mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-05-23 23:05:43 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
jak-project/game/kernel/jak3/kscheme.cpp
T
water111 452f1329dd [jak3] fix envmap texture and strength (#3704) 
Fix the envmap texture using the eye texture by default (will require a
re-extract to fix), fix envmap strength in all three games being off by
2x. (oops)

With envmap scale fix:

![image](https://github.com/user-attachments/assets/3b0ef8b7-cbdc-4402-8a12-af368538c16e)

without envmap scale fix (but with texture fix):

![image](https://github.com/user-attachments/assets/fd72d75b-f0bb-455c-a7c9-56916fbd4a67)

---------

Co-authored-by: water111 <awaterford1111445@gmail.com>
2024-10-05 12:53:57 -04:00

1991 lines
72 KiB
C++
Raw Permalink Blame History

#include "kscheme.h"
#include <unordered_map>
#include "common/common_types.h"
#include "common/goal_constants.h"
#include "common/log/log.h"
#include "common/symbols.h"
#include "game/kernel/common/Symbol4.h"
#include "game/kernel/common/fileio.h"
#include "game/kernel/common/kdsnetm.h"
#include "game/kernel/common/klink.h"
#include "game/kernel/common/kmalloc.h"
#include "game/kernel/common/kmemcard.h"
#include "game/kernel/common/kprint.h"
#include "game/kernel/common/kscheme.h"
#include "game/kernel/jak3/fileio.h"
#include "game/kernel/jak3/kdgo.h"
#include "game/kernel/jak3/klink.h"
#include "game/kernel/jak3/klisten.h"
#include "game/kernel/jak3/kmachine.h"
#include "game/kernel/jak3/kmalloc.h"
#include "game/kernel/jak3/kprint.h"
#define JAK3_HASH_TABLE
namespace jak3 {
using namespace jak3_symbols;
Ptr<u32> SymbolString;
Ptr<Symbol4<u32>> CollapseQuote;
Ptr<Symbol4<u32>> LevelTypeList;
Ptr<String> UnknownName;
bool DebugSymbols = false;
Ptr<u32> KernelDebug;
Ptr<Symbol4<u32>> SqlResult;
#ifdef JAK3_HASH_TABLE
std::unordered_map<std::string, int> g_symbol_hash_table;
#endif
void kscheme_init_globals() {
LevelTypeList.offset = 0;
SymbolString.offset = 0;
CollapseQuote.offset = 0;
UnknownName.offset = 0;
DebugSymbols = false;
KernelDebug.offset = 0;
SqlResult.offset = 0;
#ifdef JAK3_HASH_TABLE
g_symbol_hash_table.clear();
#endif
}
u32 u32_in_fixed_sym(u32 offset) {
return Ptr<Symbol4<u32>>(s7.offset + offset)->value();
}
namespace {
void fixed_sym_set(u32 offset, u32 value) {
Ptr<Symbol4<u32>>(s7.offset + offset)->value() = value;
}
} // namespace
u64 new_illegal(u32 allocation, u32 type) {
(void)allocation;
MsgErr("dkernel: illegal attempt to call new method of static object type %s\n",
sym_to_string(Ptr<Type>(type)->symbol)->data());
return s7.offset;
}
u64 alloc_from_heap(u32 heap_symbol, u32 type, s32 size, u32 pp) {
auto heap_ptr = Ptr<Symbol4<Ptr<kheapinfo>>>(heap_symbol)->value();
s32 aligned_size = ((size + 0xf) / 0x10) * 0x10;
if ((heap_symbol == s7.offset + FIX_SYM_GLOBAL_HEAP) ||
(heap_symbol == s7.offset + FIX_SYM_DEBUG) ||
(heap_symbol == s7.offset + FIX_SYM_LOADING_LEVEL) ||
(heap_symbol == s7.offset + FIX_SYM_PROCESS_LEVEL_HEAP)) {
if (!type) { // no type given, just call it a global-object
return kmalloc(heap_ptr, size, KMALLOC_MEMSET, "global-object").offset;
}
Ptr<Type> typ(type);
if (!typ->symbol.offset) { // type doesn't have a symbol, just call it a global-object
return kmalloc(heap_ptr, size, KMALLOC_MEMSET, "global-object").offset;
}
Ptr<String> gstr = sym_to_string(typ->symbol);
if (!gstr->len) { // string has nothing in it.
return kmalloc(heap_ptr, size, KMALLOC_MEMSET, "global-object").offset;
}
return kmalloc(heap_ptr, size, KMALLOC_MEMSET, gstr->data()).offset;
} else if (heap_symbol == s7.offset + FIX_SYM_PROCESS_TYPE) {
u32 start = *Ptr<u32>(pp + 0x64);
u32 heapEnd = *Ptr<u32>(pp + 0x60);
u32 allocEnd = start + aligned_size;
if (allocEnd < heapEnd) {
*Ptr<u32>(pp + 0x64) = allocEnd;
memset(Ptr<u8>(start).c(), 0, aligned_size);
return start;
} else {
MsgErr("kmalloc: !alloc mem in heap for #<process @ #x%x> (%d bytes)\n", pp, aligned_size);
return 0;
}
} else if (heap_symbol == s7.offset + FIX_SYM_SCRATCH) {
ASSERT(false); // nyi, I think unused.
return 0;
} else {
memset(Ptr<u8>(heap_symbol).c(), 0, aligned_size); // treat it as a stack address
return heap_symbol;
}
}
/*!
* Allocate untyped memory.
*/
u64 alloc_heap_memory(u32 heap, u32 size) {
// should never happen on process heap
return alloc_from_heap(heap, 0, size, UNKNOWN_PP);
}
/*!
* Allocate memory and add type tag for an object.
* For allocating basics.
* Called from GOAL.
*/
u64 alloc_heap_object(u32 heap, u32 type, u32 size, u32 pp) {
auto mem = alloc_from_heap(heap, type, size, pp);
if (!mem) {
return 0;
}
*Ptr<u32>(mem) = type;
return mem + BASIC_OFFSET;
}
/*!
* Allocate a structure and get the structure size from the type.
*/
u64 new_structure(u32 heap, u32 type) {
// should never happen on process heap
return alloc_from_heap(heap, type, Ptr<Type>(type)->allocated_size, UNKNOWN_PP);
}
/*!
* Allocate a structure with a dynamic size
*/
u64 new_dynamic_structure(u32 heap_symbol, u32 type, u32 size) {
// should never happen on process heap
return alloc_from_heap(heap_symbol, type, size, UNKNOWN_PP);
}
/*!
* Delete a structure. Not supported, as it uses kfree, which doesn't do anything.
*/
void delete_structure(u32 s) {
kfree(Ptr<u8>(s));
}
/*!
* Allocate a basic of fixed size.
*/
u64 new_basic(u32 heap, u32 type, u32 /*size*/, u32 pp) {
return alloc_heap_object(heap, type, Ptr<Type>(type)->allocated_size, pp);
}
/*!
* Delete a basic. Not supported, as it uses kfree.
*/
void delete_basic(u32 s) {
// note that the game has a bug here and has s as a uint* and does -4 which is actually a
// 16-byte offset. Luckily kfree does nothing so there's no harm done. But it's a good indication
// that the "freeing memory" feature never made it very far in development. This bug exists in
// Jak 3 as well.
kfree(Ptr<u8>(s - BASIC_OFFSET * 4)); // replicate the bug
}
/*!
* Allocate a new pair and set its car and cdr.
*/
u64 new_pair(u32 heap, u32 type, u32 car, u32 cdr) {
auto mem = alloc_from_heap(heap, type, Ptr<Type>(type)->allocated_size, UNKNOWN_PP);
if (!mem) {
return 0;
}
u32* m = Ptr<u32>(mem).c();
m[0] = car;
m[1] = cdr;
return mem + PAIR_OFFSET;
}
/*!
* Delete a pair. BUG
*/
void delete_pair(u32 s) {
// the -8 should be a -2, but s is likely a u32* in the code.
kfree(Ptr<u8>(s - 8));
}
u64 make_string(u32 size) {
using namespace jak3_symbols;
auto mem_size = size + 1; // null
if (mem_size < 8) {
mem_size = 8; // min size of string
}
// total size is mem_size (chars + null term), plus basic_offset (type tag) + 4 (string size)
auto mem =
alloc_heap_object((s7 + FIX_SYM_GLOBAL_HEAP).offset, u32_in_fixed_sym(FIX_SYM_STRING_TYPE),
mem_size + BASIC_OFFSET + sizeof(uint32_t), UNKNOWN_PP);
// set the string size field.
if (mem) {
*Ptr<u32>(mem) = size;
}
return mem;
}
/*!
* Convert a C string to a GOAL string.
* Allocates from the global heap and copies the string data.
*/
u64 make_string_from_c(const char* c_str) {
auto str_size = strlen(c_str);
auto mem_size = str_size + 1;
if (mem_size < 8) {
mem_size = 8;
}
auto mem =
alloc_heap_object((s7 + FIX_SYM_GLOBAL_HEAP).offset, u32_in_fixed_sym(FIX_SYM_STRING_TYPE),
mem_size + BASIC_OFFSET + 4, UNKNOWN_PP);
// there's no check for failed allocation here!
// string size field
*Ptr<u32>(mem) = str_size;
// rest is chars
kstrcpy(Ptr<char>(mem + 4).c(), c_str);
return mem;
}
u64 make_debug_string_from_c(const char* c_str) {
auto str_size = strlen(c_str);
auto mem_size = str_size + 1;
if (mem_size < 8) {
mem_size = 8;
}
auto mem = alloc_heap_object((s7 + FIX_SYM_DEBUG).offset, u32_in_fixed_sym(FIX_SYM_STRING_TYPE),
mem_size + BASIC_OFFSET + 4, UNKNOWN_PP);
// there's no check for failed allocation here!
// string size field
*Ptr<u32>(mem) = str_size;
// rest is chars
kstrcpy(Ptr<char>(mem + 4).c(), c_str);
return mem;
}
extern "C" {
#ifndef __aarch64__
#ifdef __APPLE__
void _arg_call_systemv() asm("_arg_call_systemv");
void _stack_call_systemv() asm("_stack_call_systemv");
void _stack_call_win32() asm("_stack_call_win32");
#else
void _arg_call_systemv();
void _stack_call_systemv();
void _stack_call_win32();
#endif
#else
#if defined(__APPLE__)
void _arg_call_arm64() asm("_arg_call_arm64");
void _stack_call_arm64() asm("_stack_call_arm64");
#else
void _arg_call_arm64();
void _stack_call_arm64();
#endif
#endif
}
/*!
* This creates an OpenGOAL function from a C++ function. Only 6 arguments can be accepted.
* But calling this function is fast. It used to be really fast but wrong.
*/
Ptr<Function> make_function_from_c_systemv(void* func, bool arg3_is_pp) {
auto mem = Ptr<u8>(alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_FUNCTION_TYPE), 0x40, UNKNOWN_PP));
auto f = (uint64_t)func;
auto target_function = (u8*)&f;
#ifndef __aarch64__
auto trampoline_function_addr = _arg_call_systemv;
#else
auto trampoline_function_addr = _arg_call_arm64;
#endif
auto trampoline = (u8*)&trampoline_function_addr;
// TODO - x86 code still being emitted below
// movabs rax, target_function
int offset = 0;
mem.c()[offset++] = 0x48;
mem.c()[offset++] = 0xb8;
for (int i = 0; i < 8; i++) {
mem.c()[offset++] = target_function[i];
}
// push rax
mem.c()[offset++] = 0x50;
// movabs rax, trampoline
mem.c()[offset++] = 0x48;
mem.c()[offset++] = 0xb8;
for (int i = 0; i < 8; i++) {
mem.c()[offset++] = trampoline[i];
}
if (arg3_is_pp) {
// mov rcx, r13. Puts pp in the third argument.
mem.c()[offset++] = 0x4c;
mem.c()[offset++] = 0x89;
mem.c()[offset++] = 0xe9;
}
// jmp rax
mem.c()[offset++] = 0xff;
mem.c()[offset++] = 0xe0;
// the asm function's ret will return to the caller of this (GOAL code) directlyz.
// CacheFlush(mem, 0x34);
return mem.cast<Function>();
}
/*!
* Create a GOAL function from a C function. This doesn't export it as a global function, it just
* creates a function object on the global heap.
*
* This creates a simple trampoline function which jumps to the C function and reorders the
* arguments to be correct for Windows.
*/
Ptr<Function> make_function_from_c_win32(void* func, bool arg3_is_pp) {
// allocate a function object on the global heap
auto mem = Ptr<u8>(alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_FUNCTION_TYPE), 0x80, UNKNOWN_PP));
auto f = (uint64_t)func;
auto fp = (u8*)&f;
int i = 0;
// we will put the function address in RAX with a movabs rax, imm8
mem.c()[i++] = 0x48;
mem.c()[i++] = 0xb8;
for (int j = 0; j < 8; j++) {
mem.c()[i++] = fp[j];
}
/*
push rdi
push rsi
push rdx
push rcx
pop r9
pop r8
pop rdx
pop rcx
push r10
push r11
sub rsp, 40
*/
for (auto x : {0x57, 0x56, 0x52, 0x51, 0x41, 0x59, 0x41, 0x58, 0x5A, 0x59, 0x41, 0x52, 0x41, 0x53,
0x48, 0x83, 0xEC, 0x28}) {
mem.c()[i++] = x;
}
if (arg3_is_pp) {
// mov r9, r13. Puts pp in the third argument.
mem.c()[i++] = 0x4d;
mem.c()[i++] = 0x89;
mem.c()[i++] = 0xe9;
}
/*
call rax
add rsp, 40
pop r11
pop r10
ret
*/
for (auto x : {0xFF, 0xD0, 0x48, 0x83, 0xC4, 0x28, 0x41, 0x5B, 0x41, 0x5A, 0xC3}) {
mem.c()[i++] = x;
}
// CacheFlush(mem, 0x34);
return mem.cast<Function>();
}
Ptr<Function> make_stack_arg_function_from_c_systemv(void* func) {
// allocate a function object on the global heap
auto mem = Ptr<u8>(alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_FUNCTION_TYPE), 0x40, UNKNOWN_PP));
auto f = (uint64_t)func;
auto target_function = (u8*)&f;
#ifndef __aarch64__
auto trampoline_function_addr = _stack_call_systemv;
#else
auto trampoline_function_addr = _stack_call_arm64;
#endif
auto trampoline = (u8*)&trampoline_function_addr;
// movabs rax, target_function
int offset = 0;
mem.c()[offset++] = 0x48;
mem.c()[offset++] = 0xb8;
for (int i = 0; i < 8; i++) {
mem.c()[offset++] = target_function[i];
}
// push rax
mem.c()[offset++] = 0x50;
// movabs rax, trampoline
mem.c()[offset++] = 0x48;
mem.c()[offset++] = 0xb8;
for (int i = 0; i < 8; i++) {
mem.c()[offset++] = trampoline[i];
}
// jmp rax
mem.c()[offset++] = 0xff;
mem.c()[offset++] = 0xe0;
// CacheFlush(mem, 0x34);
return mem.cast<Function>();
}
#ifdef _WIN32
/*!
* Create a GOAL function from a C function. This calls a windows function, but doesn't scramble
* the argument order. It's supposed to be used with _format_win32 which assumes GOAL order.
*/
Ptr<Function> make_stack_arg_function_from_c_win32(void* func) {
// allocate a function object on the global heap
auto mem = Ptr<u8>(alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_FUNCTION_TYPE), 0x80, UNKNOWN_PP));
auto f = (uint64_t)func;
auto fp = (u8*)&f;
auto trampoline_function_addr = _stack_call_win32;
auto trampoline = (u8*)&trampoline_function_addr;
int i = 0;
// we will put the function address in RAX with a movabs rax, imm8
mem.c()[i++] = 0x48;
mem.c()[i++] = 0xb8;
for (int j = 0; j < 8; j++) {
mem.c()[i++] = fp[j];
}
// push rax
mem.c()[i++] = 0x50;
// we will put the function address in RAX with a movabs rax, imm8
mem.c()[i++] = 0x48;
mem.c()[i++] = 0xb8;
for (int j = 0; j < 8; j++) {
mem.c()[i++] = trampoline[j];
}
/*
* jmp rax
*/
for (auto x : {0xFF, 0xE0}) {
mem.c()[i++] = x;
}
return mem.cast<Function>();
}
#endif
/*!
* Create a GOAL function from a C function. This doesn't export it as a global function, it just
* creates a function object on the global heap.
*
* The implementation is to create a simple trampoline function which jumps to the C function.
*/
Ptr<Function> make_function_from_c(void* func, bool arg3_is_pp = false) {
#ifdef __linux__
return make_function_from_c_systemv(func, arg3_is_pp);
#elif __APPLE__
return make_function_from_c_systemv(func, arg3_is_pp);
#elif _WIN32
return make_function_from_c_win32(func, arg3_is_pp);
#endif
}
Ptr<Function> make_stack_arg_function_from_c(void* func) {
#ifdef __linux__
return make_stack_arg_function_from_c_systemv(func);
#elif __APPLE__
return make_stack_arg_function_from_c_systemv(func);
#elif _WIN32
return make_stack_arg_function_from_c_win32(func);
#endif
}
/*!
* Create a GOAL function which does nothing and immediately returns.
*/
Ptr<Function> make_nothing_func() {
auto mem = Ptr<u8>(alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_FUNCTION_TYPE), 0x14, UNKNOWN_PP));
// a single x86-64 ret.
mem.c()[0] = 0xc3;
// CacheFlush(mem, 8);
return mem.cast<Function>();
}
/*!
* Create a GOAL function which returns 0.
*/
Ptr<Function> make_zero_func() {
auto mem = Ptr<u8>(alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_FUNCTION_TYPE), 0x14, UNKNOWN_PP));
// xor eax, eax
mem.c()[0] = 0x31;
mem.c()[1] = 0xc0;
// ret
mem.c()[2] = 0xc3;
// CacheFlush(mem, 8);
return mem.cast<Function>();
}
u64 symbol_to_string_from_c(u32 sym) {
auto name = sym_to_string(Ptr<Symbol4<u32>>(sym));
if (name.offset == UnknownName.offset ||
(kglobalheap->top_base.offset < name.offset &&
(DebugSegment == 0 || u32_in_fixed_sym(FIX_SYM_KERNEL_SYMBOL_WARNINGS) != s7.offset))) {
MsgWarn(
"dkernel: doing a symbol->string on %s (addr #x%x), but the symbol has not been marked as "
"symbol-export-string\n",
name->data(), sym);
}
return name.offset;
}
/*!
* Given a C function and a name, create a GOAL function and store it in the symbol with the given
* name. This effectively creates a global GOAL function with the given name which calls the given C
* function.
*
* This work on both Linux and Windows, but only supports up to 6 arguments.
*/
Ptr<Function> make_function_symbol_from_c(const char* name, void* f) {
auto sym = intern_from_c(-1, 0, name);
auto func = make_function_from_c(f);
sym->value() = func.offset;
return func;
}
/*!
* Like make_function_symbol_from_c, but all 8 GOAL arguments are put into an array on the stack.
* The address of this array is passed as the first and only argument to f.
*/
Ptr<Function> make_stack_arg_function_symbol_from_c(const char* name, void* f) {
auto sym = intern_from_c(-1, 0, name);
auto func = make_stack_arg_function_from_c(f);
sym->value() = func.offset;
return func;
}
u32 make_raw_function_symbol_from_c(const char* name, u32 value) {
intern_from_c(-1, 0, name)->value() = value;
return value;
}
Ptr<Symbol4<u32>> set_fixed_symbol(int offset, const char* name, u32 value) {
Ptr<Symbol4<u32>> sym(s7.offset + offset);
ASSERT((sym.offset & 3) == 1); //
sym->value() = value;
if (sym_to_string_ptr(sym).c()->offset) {
printf("setting %s\n", name);
ASSERT_NOT_REACHED(); // duplicate def
}
#ifdef JAK3_HASH_TABLE
ASSERT((offset % 4) == 0);
g_symbol_hash_table.insert(std::make_pair(name, offset / 4));
#endif
kheaplogging = true;
*sym_to_string_ptr(sym).c() = Ptr<String>(make_string_from_c(name));
NumSymbols = NumSymbols + 1;
kheaplogging = false;
return sym;
}
Ptr<Symbol4<u32>> find_symbol_in_area(const char* name, u32 start, u32 end) {
for (u32 i = start; i < end; i += 4) {
auto sym = Ptr<Symbol4<u32>>(i);
auto str = sym_to_string(sym);
if (str.offset && !strcmp(str->data(), name)) {
return sym;
}
}
// failed
return Ptr<Symbol4<u32>>(0);
}
#ifdef JAK3_HASH_TABLE
Ptr<Symbol4<u32>> find_symbol_from_c_ht(const char* name) {
const auto& it = g_symbol_hash_table.find(name);
if (it == g_symbol_hash_table.end()) {
return Ptr<Symbol4<u32>>(0);
} else {
return Ptr<Symbol4<u32>>(s7.offset + it->second * 4);
}
}
Ptr<Symbol4<u32>> find_slot_in_area(u32 start, u32 end) {
for (u32 i = start; i < end; i += 4) {
auto sym = Ptr<Symbol4<u32>>(i);
auto str = sym_to_string(sym);
if (!str.offset) {
return sym;
}
}
// failed
return Ptr<Symbol4<u32>>(0);
}
Ptr<Symbol4<u32>> intern_from_c_ht(const char* name) {
auto existing = find_symbol_from_c_ht(name);
if (existing.offset) {
return existing;
}
auto slot = find_slot_in_area(s7.offset, LastSymbol.offset);
if (!slot.offset) {
slot = find_slot_in_area(SymbolTable2.offset, s7.offset - 0x10);
}
ASSERT(slot.offset); // out of symbols!!
NumSymbols++;
*sym_to_string_ptr(slot) = Ptr<String>(make_string_from_c(name));
g_symbol_hash_table[name] = (slot.offset - s7.offset) / 4;
return slot;
}
#endif
/*!
* Get a pointer to a symbol. Can provide the symbol id, the name, or both.
*/
Ptr<Symbol4<u32>> find_symbol_from_c(uint16_t sym_id, const char* name) {
#ifdef JAK3_HASH_TABLE
if (!strcmp(name, "_empty_")) {
return (s7 + S7_OFF_FIX_SYM_EMPTY_PAIR).cast<Symbol4<u32>>();
}
return find_symbol_from_c_ht(name);
#endif
// sign extend
int extended_sym_id = (int16_t)sym_id;
if (sym_id == 0xffff) {
// the ID wasn't provided, so we have to use the name
if (!name) {
// always warn - no name or ID!
MsgErr("dkernel: attempted to find symbol with NULL name and id #x%x\n", sym_id);
return Ptr<Symbol4<u32>>(0);
} else {
// find the symbol
Ptr<Symbol4<u32>> lookup_result = find_symbol_in_area(name, s7.offset, LastSymbol.offset);
if (lookup_result.offset == 0) {
lookup_result = find_symbol_in_area(name, SymbolTable2.offset, s7.offset - 0x10);
}
// do some sanity checking, but only in retail or if we've explicitly asked for it.
if (!DebugSegment || u32_in_fixed_sym(FIX_SYM_KERNEL_SYMBOL_WARNINGS) != s7.offset) {
if (lookup_result.offset == 0) {
// lookup by the name failed.
MsgWarn("dkernel: doing a string->symbol on %s, but could not find the name\n", name);
} else {
auto sym_string = sym_to_string(lookup_result);
// not sure how you could get unknown name here...
// but the second check sees if you were only saved by having the symbol string in the
// debug heap. This would tell you that the lookup worked, but would fail in retail mode.
if ((sym_string == UnknownName) || (kglobalheap->top_base.offset < sym_string.offset)) {
MsgWarn(
"dkernel: doing a string->symbol on %s, but the symbol has not been marked "
"as symbol-export-string\n",
name);
}
}
}
return lookup_result;
}
} else {
// just use the ID. warn if there's a name conflict.
Ptr<Symbol4<u32>> sym(s7.offset + extended_sym_id - 1);
if (sym.offset != s7.offset + S7_OFF_FIX_SYM_EMPTY_PAIR) {
auto existing_name = sym_to_string(sym);
if (existing_name.offset && !strcmp(existing_name->data(), name)) {
MsgWarn(
"dkernel: WARNING: attempting to find symbol %s at id #x%x but symbol %s was "
"already there.\n",
name, sym_id, existing_name->data());
}
}
return sym;
}
}
/*!
* Find or create a symbol.
* New for Jak 3 is that there is no longer a symbol hash table. So there are some significant
* changes to how this works. Also, many symbols do not store their name, to save memory.
*
* @param sym_id The symbol ID. This _must_ be provided if the symbol does not exist yet, or if the
* symbol's name isn't known. Use -1 if the symbol ID is unknown.
*
* @param name The name. This can be used instead of the ID if the symbol's name is stored.
*
* @param flags Optional flag (0x40) can force the symbol's name to be stored. This uses memory.
*
*/
Ptr<Symbol4<u32>> intern_from_c(int sym_id, int flags, const char* name) {
#ifdef JAK3_HASH_TABLE
if (!strcmp(name, "_empty_")) {
return (s7 + S7_OFF_FIX_SYM_EMPTY_PAIR).cast<Symbol4<u32>>();
}
return intern_from_c_ht(name);
#endif
// first, look up the symbol.
Ptr<Symbol4<u32>> symbol = find_symbol_from_c(sym_id, name);
kheaplogging = true;
if (symbol.offset == 0) {
// the function above can only fail if we didn't give an ID.
MsgErr("dkernel: attempted to intern symbol %s using the name, but could not find it\n", name);
kheaplogging = false;
return Ptr<Symbol4<u32>>(0);
}
if (symbol.offset == s7.offset + S7_OFF_FIX_SYM_EMPTY_PAIR) {
// in case it's the empty pair, just return and don't worry about names.
kheaplogging = false;
return symbol;
}
// if the symbol is new, then the name pointer will be 0, and we need to set it up.
auto sptr = sym_to_string_ptr(symbol);
auto current_string = *sptr;
if (current_string.offset) { // existing symbol
if ((flags & 0x40U) == 0) { // symbol-export-string not set
// nothing to do!
kheaplogging = false;
return symbol;
}
// if the symbol-export-string flag is set, we need to make sure that there's a known name
// and the name is stored in the global heap:
if ((current_string != UnknownName) &&
(current_string.offset <= kglobalheap->top_base.offset)) {
// it is, nothing to do.
kheaplogging = false;
return symbol;
}
// "upgrade" from the debug heap to global. (this could also trigger if the name was previously
// unknown)
MsgWarn("dkernel: upgrading symbol %s (flags #x%x) from debug heap to global\n", name, flags);
*sptr = Ptr<String>(make_string_from_c(name));
kheaplogging = false;
return symbol;
}
// setting up a new symbol case:
Ptr<String> new_string;
if (DebugSymbols == 0) {
// normal mode
if ((flags & 0x40U) != 0) {
// if symbol-export-string is set, allocate it on the global heap.
new_string = Ptr<String>(make_string_from_c(name));
} else if (DebugSegment != 0) {
// if debugsegment, always load all symbols to debug heap for easy debugging.
new_string = Ptr<String>(make_debug_string_from_c(name));
} else {
// otherwise, no symbols!! save memory!
new_string = UnknownName;
}
} else {
// debug symbol mode is on - force it to the global heap no matter what.
new_string = Ptr<String>(make_string_from_c(name));
}
*sptr = new_string;
NumSymbols++;
kheaplogging = 0;
return symbol;
}
u64 intern(u32 name) {
return intern_from_c(-1, 0x40, Ptr<String>(name)->data()).offset;
}
/*!
* Configure a type.
*/
Ptr<Type> set_type_values(Ptr<Type> type, Ptr<Type> parent, u64 flags) {
type->parent = parent;
type->allocated_size = (flags & 0xffff);
type->heap_base = (flags >> 16) & 0xffff;
type->padded_size = ((type->allocated_size + 0xf) & 0xfff0);
u16 new_methods = (flags >> 32) & 0xffff; // i think this accidentally uses jak1 style flags.
if (type->num_methods < new_methods) {
type->num_methods = new_methods;
}
return type;
}
static bool in_valid_memory_for_new_type(u32 addr) {
if (SymbolTable2.offset <= addr && addr < 0x8000000) {
return true;
}
if (addr < 0x100000 && addr >= 0x84000) {
return true;
}
return false;
}
u32 size_of_type(u32 method_count) {
return (4 * method_count + 0x23) & 0xfffffff0;
}
static bool is_valid_type(u32 addr) {
if ((addr & 7) != 4) {
return false;
}
if (*Ptr<u32>(addr - 4) != u32_in_fixed_sym(FIX_SYM_TYPE_TYPE)) {
return false;
}
return true;
}
/*!
* Given a symbol for the type name, allocate memory for a type and add it to the symbol table.
* New: in Jak 2, there's a level type list
*/
Ptr<Type> alloc_and_init_type(Ptr<Symbol4<Ptr<Type>>> sym,
u32 method_count,
bool force_global_type) {
// number of bytes for this type
u32 type_size = size_of_type(method_count);
u32 type_mem = 0;
ASSERT(sym.offset & 1);
if (!force_global_type &&
u32_in_fixed_sym(FIX_SYM_LOADING_LEVEL) != u32_in_fixed_sym(FIX_SYM_GLOBAL_HEAP)) {
u32 type_list_ptr = LevelTypeList->value();
if (type_list_ptr == 0) {
// we don't have a type-list... just alloc on global
MsgErr("dkernel: trying to init loading level type \'%s\' while type-list is undefined\n",
sym_to_string(sym)->data());
type_mem = alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_TYPE_TYPE), type_size, UNKNOWN_PP);
} else {
// we do have a type list! allocate on the level heap
type_mem = alloc_heap_object(s7.offset + FIX_SYM_LOADING_LEVEL,
u32_in_fixed_sym(FIX_SYM_TYPE_TYPE), type_size, UNKNOWN_PP);
// link us!
u32 old_head = *Ptr<u32>(type_list_ptr);
*Ptr<u32>(type_list_ptr) = type_mem;
// I guess we hide this in the memusage method.
Ptr<Type>(type_mem)->memusage_method.offset = old_head;
}
} else {
// normal global type
type_mem = alloc_heap_object(s7.offset + FIX_SYM_GLOBAL_HEAP,
u32_in_fixed_sym(FIX_SYM_TYPE_TYPE), type_size, UNKNOWN_PP);
}
Ptr<Type> the_type(type_mem);
sym->value() = the_type;
the_type->allocated_size = type_size;
the_type->padded_size = ((type_size + 0xf) & 0xfff0);
return the_type;
}
/*!
* Like intern, but returns a type instead of a symbol. If the type doesn't exist, a new one is
* allocated.
*/
Ptr<Type> intern_type_from_c(int a, int b, const char* name, u64 methods) {
// there's a weird flag system used here.
// if methods is a number that's not 0 or 1, its used as the desired number of methods.
// If method is 0, and a new type needs to be created, it uses 12 methods
// If method is 1, and a new type needs to be created, it uses 44 methods
// If method is 0 or 1 and no new type needs to be created, there is no error.
// Requesting a type to have fewer methods than the existing type has is ok.
// Requesting a type to have more methods than the existing type is not ok and prints an error.
auto symbol = intern_from_c(a, b, name);
u32 sym_value = symbol->value();
if (!sym_value) {
// new type
int n_methods = methods;
if (methods == 0) {
// some stupid types like user-defined children of integers have "0" as the method count
n_methods = 0xc;
} else if (methods == 1) {
// whatever builds the v2/v4 object files (level data) doesn't actually know method counts.
// so it just puts a 1. In this case, we should put lots of methods, just in case.
// I guess 44 was the number they picked.
n_methods = 0x2c;
}
// create the type.
auto casted_sym = symbol.cast<Symbol4<Ptr<Type>>>();
auto type = alloc_and_init_type(casted_sym, n_methods, 0); // allow level types
type->symbol = casted_sym;
type->num_methods = n_methods;
return type;
} else {
// the type exists.
auto type = Ptr<Type>(sym_value);
// note - flags of 0 or 1 will pass through here without triggering the error.
if (size_of_type(type->num_methods) < size_of_type(methods)) {
MsgErr(
"dkernel: trying to redefine a type '%s' with %d methods when it had %d, try "
"restarting\n",
name, (u32)methods, type->num_methods);
ASSERT(false);
}
return type;
}
}
/*!
* Wrapper of intern_type_from_c to use with GOAL. It accepts a gstring as a name.
*/
u64 intern_type(u32 name, u64 methods) {
return intern_type_from_c(-1, 0, Ptr<String>(name)->data(), methods).offset;
}
/*!
* Setup a type which is located in a fixed spot of the symbol table.
*/
Ptr<Type> set_fixed_type(u32 offset,
const char* name,
Ptr<Symbol4<Ptr<Type>>> parent_symbol,
u64 flags,
u32 print,
u32 inspect) {
Ptr<Symbol4<Ptr<Type>>> type_symbol(s7.offset + offset);
Ptr<Type> symbol_value = type_symbol->value();
// set the symbol's name and hash
*sym_to_string_ptr(type_symbol) = Ptr<String>(make_string_from_c(name));
ASSERT(g_symbol_hash_table.count(name) == 0);
g_symbol_hash_table[name] = (type_symbol.offset - s7.offset) / 4;
NumSymbols++;
if (symbol_value.offset == 0) {
// no type memory exists, let's allocate it. force it global
// the flag logic here multiplies the method count 2, hopefully
// this will set up the symbol
symbol_value = alloc_and_init_type(type_symbol, (flags >> 0x1f) & 0xffff, 1);
}
// remember our symbol
symbol_value->symbol = type_symbol;
// make our type a type (we're a basic)
u32 type_of_type = u32_in_fixed_sym(FIX_SYM_TYPE_TYPE);
*Ptr<u32>(symbol_value.offset - 4) = type_of_type;
Ptr<Type> parent_type = parent_symbol->value();
set_type_values(symbol_value, parent_type, flags);
symbol_value->new_method = parent_type->new_method;
symbol_value->delete_method = parent_type->delete_method;
if (!print) {
symbol_value->print_method = parent_type->print_method;
} else {
symbol_value->print_method.offset = print;
}
if (!inspect) {
symbol_value->inspect_method = parent_type->inspect_method;
} else {
symbol_value->inspect_method.offset = inspect;
}
symbol_value->length_method.offset = u32_in_fixed_sym(FIX_SYM_ZERO_FUNC);
symbol_value->asize_of_method = parent_type->asize_of_method;
symbol_value->copy_method = parent_type->copy_method;
return symbol_value;
}
u64 new_type(u32 symbol, u32 parent, u64 flags) {
u32 n_methods = (flags >> 32) & 0xffff;
if (n_methods == 0) {
// 12 methods used as default, if the user has not provided us with a number
n_methods = 12;
}
auto sym_string = sym_to_string(Ptr<Symbol4<Type>>(symbol));
const char* sym_string_c = nullptr;
if (sym_string.offset) {
sym_string_c = sym_string->data();
}
u32 parent_num_methods = Ptr<Type>(parent)->num_methods;
auto new_type_obj = intern_type_from_c(((symbol - s7.offset) + 1), 0x80, sym_string_c, n_methods);
u32 original_type_list_value = new_type_obj->memusage_method.offset;
Ptr<Function>* child_slots = &(new_type_obj->new_method);
Ptr<Function>* parent_slots = &(Ptr<Type>(parent)->new_method);
for (u32 i = 0; i < n_methods; i++) {
if (i < parent_num_methods) { // bug fix from jak 1
child_slots[i] = parent_slots[i];
} else {
child_slots[i].offset = 0;
}
}
// deal with loading-level types
if (u32_in_fixed_sym(FIX_SYM_LOADING_LEVEL) == u32_in_fixed_sym(FIX_SYM_GLOBAL_HEAP)) {
// not loading a level
// we'll consider a type list if it's #f or a valid type
if (original_type_list_value && (original_type_list_value == s7.offset ||
(in_valid_memory_for_new_type(original_type_list_value) &&
is_valid_type(original_type_list_value)))) {
printf("case 1 for new_type level types\n");
new_type_obj->memusage_method.offset = original_type_list_value;
}
} else {
if (original_type_list_value == 0) {
// loading a level, but the type is global
MsgWarn("dkernel: loading-level init of type %s, but was interned global (this is okay)\n",
sym_to_string(new_type_obj->symbol)->data());
} else {
new_type_obj->memusage_method.offset = original_type_list_value;
}
}
auto ret = set_type_values(new_type_obj, Ptr<Type>(parent), flags).offset;
;
return ret;
}
/*!
* Is t1 a t2?
*/
u64 type_typep(Ptr<Type> t1, Ptr<Type> t2) {
if (t1 == t2) {
return (s7 + FIX_SYM_TRUE).offset;
}
do {
t1 = t1->parent;
if (t1 == t2) {
return (s7 + FIX_SYM_TRUE).offset;
}
} while (t1.offset && t1.offset != u32_in_fixed_sym(FIX_SYM_OBJECT_TYPE));
return s7.offset;
}
u64 method_set(u32 type_, u32 method_id, u32 method) {
Ptr<Type> type(type_);
auto existing_method = type->get_method(method_id).offset;
if (method == 1) {
method = 0;
} else if (method == 0) {
return 0;
} else if (method == 2) {
method = type->parent->get_method(method_id).offset;
printf("[Method Set] got 2, inheriting\n");
}
// do the set
type->get_method(method_id).offset = method;
// now, propagate to children
// we don't track children directly, so we end up having to iterate the whole symbol to find all
// types. This is slow, so we only do it in some cases
// the condition is either setting *enable-method-set* in GOAL, or if we're debugging without the
// disk boot. The point of doing this in debug is just to print warning messages.
if (*EnableMethodSet || (!FastLink && MasterDebug && !DiskBoot)) {
auto sym = Ptr<Symbol4<Ptr<Type>>>(s7.offset);
for (; sym.offset < LastSymbol.offset; sym.offset += 4) {
auto sym_value = sym->value();
if (in_valid_memory_for_new_type(sym_value.offset) && (sym_value.offset & 7) == 4 &&
*Ptr<u32>(sym_value.offset - 4) == u32_in_fixed_sym(FIX_SYM_TYPE_TYPE) &&
method_id < sym_value->num_methods &&
sym_value->get_method(method_id).offset == existing_method &&
type_typep(sym_value, type) != s7.offset) {
if (FastLink != 0) {
printf("************ WARNING **************\n");
printf("method %d of %s redefined - you must define class heirarchies in order now\n",
method_id, sym_to_string(sym)->data());
printf("***********************************\n");
}
sym_value->get_method(method_id).offset = method;
}
}
sym = Ptr<Symbol4<Ptr<Type>>>(SymbolTable2.offset);
for (; sym.offset < s7.offset; sym.offset += 4) {
auto sym_value = sym->value();
if (in_valid_memory_for_new_type(sym_value.offset) && (sym_value.offset & 7) == 4 &&
*Ptr<u32>(sym_value.offset - 4) == u32_in_fixed_sym(FIX_SYM_TYPE_TYPE) &&
method_id < sym_value->num_methods &&
sym_value->get_method(method_id).offset == existing_method &&
type_typep(sym_value, type) != s7.offset) {
if (FastLink != 0) {
printf("************ WARNING **************\n");
printf("method %d of %s redefined - you must define class heirarchies in order now\n",
method_id, sym_to_string(sym)->data());
printf("***********************************\n");
}
sym_value->get_method(method_id).offset = method;
}
}
}
return method;
}
/*!
* Call a GOAL method of a given type.
*/
u64 call_method_of_type(u32 arg, Ptr<Type> type, u32 method_id) {
if (((type.offset < SymbolTable2.offset || 0x7ffffff < type.offset) && // not in normal memory
(type.offset < 0x84000 || 0x100000 <= type.offset)) // not in kernel memory
|| ((type.offset & OFFSET_MASK) != BASIC_OFFSET)) { // invalid type
cprintf("#<#%x has invalid type ptr #x%x>\n", arg, type.offset);
} else {
auto type_tag = Ptr<Ptr<Type>>(type.offset - 4);
if ((*type_tag).offset == u32_in_fixed_sym(FIX_SYM_TYPE_TYPE)) {
auto f = type->get_method(method_id);
return call_goal(f, arg, 0, 0, s7.offset, g_ee_main_mem);
} else {
cprintf("#<#x%x has invalid type ptr #x%x, bad type #x%x>\n", arg, type.offset,
(*type_tag).offset);
}
}
printf("[ERROR] call_method_of_type failed!\n");
return arg;
}
/*!
* Call a GOAL function with 2 arguments.
*/
u64 call_goal_function_arg2(Ptr<Function> func, u64 a, u64 b) {
return call_goal(func, a, b, 0, s7.offset, g_ee_main_mem);
}
/*!
* Call a global GOAL function by name.
*/
u64 call_goal_function_by_name(const char* name) {
return call_goal_function(Ptr<Function>(intern_from_c(-1, 0, name)->value()));
}
u64 print_object(u32 obj);
u64 print_pair(u32 obj);
u64 print_symbol(u32 obj);
/*!
* Print an object with a newline after it to the GOAL PrintBuffer (not stdout)
*/
u64 sprint(u32 obj) {
auto rv = print_object(obj);
cprintf("\n");
return rv;
}
/*!
* Like call_method_of_type, but has two arguments. Used to "relocate" v2/s4 loads.
*/
u64 call_method_of_type_arg2(u32 arg, Ptr<Type> type, u32 method_id, u32 a1, u32 a2) {
if (((type.offset < SymbolTable2.offset || 0x7ffffff < type.offset) && // not in normal memory
(type.offset < 0x84000 || 0x100000 <= type.offset)) // not in kernel memory
|| ((type.offset & OFFSET_MASK) != BASIC_OFFSET)) { // invalid type
cprintf("#<#%x has invalid type ptr #x%x>\n", arg, type.offset);
} else {
auto type_tag = Ptr<Ptr<Type>>(type.offset - 4);
if ((*type_tag).offset == u32_in_fixed_sym(FIX_SYM_TYPE_TYPE)) {
// return type->get_method(method_id).cast<u64 (u32,u32,u32)>().c()(arg,a1,a2);
return call_goal(type->get_method(method_id), arg, a1, a2, s7.offset, g_ee_main_mem);
} else {
cprintf("#<#x%x has invalid type ptr #x%x, bad type #x%x>\n", arg, type.offset,
(*type_tag).offset);
}
}
ASSERT_MSG(false, "[ERROR] call_method_of_type_arg2 failed!");
return arg;
}
/*!
* Most generic printing method.
* Does not correctly handle 64 bit boxed integers or object64's correctly.
* It is important that no objects of type object actually exist or this will loop!
*/
u64 print_object(u32 obj) {
if ((obj & OFFSET_MASK) == BINTEGER_OFFSET) {
return print_binteger(s64(s32(obj)));
} else {
if ((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) { // not in kernel memory
cprintf("#<invalid object #x%x>", obj);
} else if ((obj & OFFSET_MASK) == PAIR_OFFSET) {
return print_pair(obj);
} else if ((obj & 1) == SYMBOL_OFFSET && obj >= SymbolTable2.offset &&
obj < LastSymbol.offset) {
return print_symbol(obj);
} else if ((obj & OFFSET_MASK) == BASIC_OFFSET) {
return call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - 4)), GOAL_PRINT_METHOD);
} else {
cprintf("#<unknown type %d @ #x%x>", obj & OFFSET_MASK, obj);
}
}
return obj;
}
/*!
* Default print method a basic.
* Confirms basic is valid and prints the type name.
*/
u64 print_basic(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & OFFSET_MASK) != BASIC_OFFSET)) {
cprintf("#<invalid basic #x%x>", obj);
} else {
cprintf("#<%s @ #x%x>", sym_to_string(Ptr<Type>(*Ptr<u32>(obj - 4))->symbol)->data(), obj);
}
return obj;
}
/*!
* Print a pair as a LISP list. Don't try to print circular lists or it will get stuck
* Can print improper lists
*/
u64 print_pair(u32 obj) {
if (obj == s7.offset + S7_OFF_FIX_SYM_EMPTY_PAIR) {
cprintf("()");
} else {
// clang-format off
// we want to treat ('quote <foo>) as just '<foo> unless
if (CollapseQuote->value() == s7.offset // CollapseQuote is enabled
|| ((obj & 7) != 2) // this object isn't a pair
|| *Ptr<u32>(obj - 2) != s7.offset + FIX_SYM_QUOTE // the car isn't 'quote
|| (*Ptr<u32>(obj + 2) & 7) != 2 // the cdr isn't a pair
|| *Ptr<u32>(*Ptr<u32>(obj + 2) + 2) != s7.offset + S7_OFF_FIX_SYM_EMPTY_PAIR // the cddr isn't '()
) {
// clang-format on
cprintf("(");
auto toPrint = obj;
for (;;) {
if ((toPrint & OFFSET_MASK) == PAIR_OFFSET) {
// print CAR
print_object(*Ptr<u32>(toPrint - 2));
// load up CDR
auto cdr = *Ptr<u32>(toPrint + 2);
toPrint = cdr;
if (cdr == s7.offset + S7_OFF_FIX_SYM_EMPTY_PAIR) { // end of proper list
cprintf(")");
return obj;
} else { // continue list
cprintf(" ");
}
} else { // improper list
cprintf(". ");
print_object(toPrint);
cprintf(")");
return obj;
}
}
} else {
cprintf("'");
print_object(*Ptr<u32>(*Ptr<u32>(obj + 2) - 2));
}
}
return obj;
}
/*!
* Print method for symbol. Just prints the name without quotes or anything fancy.
*/
u64 print_symbol(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & 1) != 1) || obj < SymbolTable2.offset || obj >= LastSymbol.offset) {
cprintf("#<invalid symbol #x%x>", obj);
} else {
char* str = sym_to_string(Ptr<Symbol4<u32>>(obj))->data();
cprintf("%s", str);
}
return obj;
}
/*!
* Print method for type. Just prints the name without quotes
*/
u64 print_type(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & OFFSET_MASK) != BASIC_OFFSET) ||
*Ptr<u32>(obj - 4) != u32_in_fixed_sym(FIX_SYM_TYPE_TYPE)) {
cprintf("#<invalid type #x%x>", obj);
} else {
cprintf("%s", sym_to_string(Ptr<Type>(obj)->symbol)->data());
}
return obj;
}
/*!
* Print method for string. Prints the string in quotes.
*/
u64 print_string(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & OFFSET_MASK) != BASIC_OFFSET) ||
*Ptr<u32>(obj - 4) != u32_in_fixed_sym(FIX_SYM_STRING_TYPE)) {
if (obj == s7.offset) {
cprintf("#f"); // new in jak 2.
} else {
cprintf("#<invalid string #x%x>", obj);
}
} else {
cprintf("\"%s\"", Ptr<String>(obj)->data());
}
return obj;
}
/*!
* Print method for function. Just prints the address because functions can't identify themselves.
*/
u64 print_function(u32 obj) {
cprintf("#<compiled %s @ #x%x>", sym_to_string(Ptr<Type>(*Ptr<u32>(obj - 4))->symbol)->data(),
obj);
return obj;
}
/*!
* Get the allocated size field of a basic. By default we grab this from the type struct.
* Dynamically sized basics should override this method.
*/
u64 asize_of_basic(u32 it) {
return Ptr<Type>(*Ptr<u32>(it - BASIC_OFFSET))->allocated_size;
}
/*!
* Create a copy of a basic. If the destination isn't identified as a symbol, treat it as an
* address. This seems a little bit unsafe to me, as it reads the 4-bytes before the given address
* and checks it against the symbol type pointer to see if its a symbol. It seems possible to have a
* false positive for this check.
*/
u64 copy_basic(u32 obj, u32 heap, u32 /*unused*/, u32 pp) {
// determine size of basic. We call a method instead of using asize_of_basic in case the type has
// overridden the default asize_of method.
u32 size = call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - BASIC_OFFSET)), GOAL_ASIZE_METHOD);
u32 result;
if ((heap & 1) == 1) {
// we think we're creating a new copy on a heap. First allocate memory...
result = alloc_heap_object(heap, *Ptr<u32>(obj - BASIC_OFFSET), size, pp);
// then copy! (minus the type tag, alloc_heap_object already did it for us)
memcpy(Ptr<u32>(result).c(), Ptr<u32>(obj).c(), size - BASIC_OFFSET);
} else {
printf("DANGER COPY BASIC!\n");
// copy directly (including type tag)
memcpy(Ptr<u32>(heap - BASIC_OFFSET).c(), Ptr<u32>(obj - BASIC_OFFSET).c(), size);
result = heap;
}
return result;
}
u64 inspect_pair(u32 obj);
u64 inspect_symbol(u32 obj);
/*!
* Highest level inspect method. Won't inspect 64-bit bintegers correctly.
*/
u64 inspect_object(u32 obj) {
if ((obj & OFFSET_MASK) == BINTEGER_OFFSET) {
return inspect_binteger(obj);
} else {
if ((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) { // not in kernel memory
cprintf("#<invalid object #x%x>", obj);
} else if ((obj & OFFSET_MASK) == PAIR_OFFSET) {
return inspect_pair(obj);
} else if ((obj & 1) == SYMBOL_OFFSET && obj >= SymbolTable2.offset &&
obj < LastSymbol.offset) {
return inspect_symbol(obj);
} else if ((obj & OFFSET_MASK) == BASIC_OFFSET) {
return call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - BASIC_OFFSET)),
GOAL_INSPECT_METHOD);
} else {
cprintf("#<unknown type %d @ #x%x>", obj & OFFSET_MASK, obj);
}
}
return obj;
}
/*!
* Inspect a pair.
*/
u64 inspect_pair(u32 obj) {
cprintf("[%8x] pair ", obj);
print_pair(obj);
cprintf("\n");
return obj;
}
/*!
* Inspect a string. There's a typo in allocated_length (has underscore instead of dash).
* This typo is fixed in later games.
*/
u64 inspect_string(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & OFFSET_MASK) != BASIC_OFFSET) ||
*Ptr<u32>(obj - 4) != u32_in_fixed_sym(FIX_SYM_STRING_TYPE)) {
cprintf("#<invalid string #x%x>\n", obj);
} else {
auto str = Ptr<String>(obj);
cprintf("[%8x] string\n\tallocated-length: %d\n\tdata: \"%s\"\n", obj, str->len, str->data());
}
return obj;
}
/*!
* Inspect a symbol.
*/
u64 inspect_symbol(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & 1) != 1) || obj < SymbolTable2.offset || obj >= LastSymbol.offset) {
cprintf("#<invalid symbol #x%x>", obj);
} else {
auto sym = Ptr<Symbol4<u32>>(obj);
cprintf("[%8x] symbol\n\tname: %s\n\tvalue: ", obj, sym_to_string(sym)->data());
print_object(sym->value());
cprintf("\n");
}
return obj;
}
/*!
* Inspect a type.
*/
u64 inspect_type(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & OFFSET_MASK) != BASIC_OFFSET) ||
*Ptr<u32>(obj - 4) != u32_in_fixed_sym(FIX_SYM_TYPE_TYPE)) {
cprintf("#<invalid type #x%x>\n", obj);
} else {
auto typ = Ptr<Type>(obj);
auto sym = typ->symbol;
cprintf("[%8x] type\n\tname: %s\n\tparent: ", obj, sym_to_string(sym)->data());
print_object(typ->parent.offset);
cprintf("\n\tsize: %d/%d\n\theap-base: %d\n\tallocated-length: %d\n\tprint: ",
typ->allocated_size, typ->padded_size, typ->heap_base, typ->num_methods);
print_object(typ->print_method.offset);
cprintf("\n\tinspect: ");
print_object(typ->inspect_method.offset);
cprintf("\n");
}
return obj;
}
/*!
* Inspect a basic. This is just a fallback for basics which don't know how to inspect themselves.
* We just use print_object.
*/
u64 inspect_basic(u32 obj) {
if (((obj < SymbolTable2.offset || 0x7ffffff < obj) && // not in normal memory
(obj < 0x84000 || 0x100000 <= obj)) // not in kernel memory
|| ((obj & OFFSET_MASK) != BASIC_OFFSET)) {
if (obj == s7.offset) {
// added in jak2 (and inlined in jak 3, but only the final version?)
return inspect_symbol(obj);
} else {
cprintf("#<invalid basic #x%x>\n", obj);
}
} else {
cprintf("[%8x] ", obj);
print_object(*Ptr<u32>(obj - 4));
cprintf("\n");
}
return obj;
}
/*!
* Inspect a link block. This link block doesn't seem to be used at all.
*/
u64 inspect_link_block(u32 ob) {
struct LinkBlock {
u32 length;
u32 version;
};
auto lb = Ptr<LinkBlock>(ob);
cprintf("[%8x] link-block\n\tallocated_length: %d\n\tversion: %d\n\tfunction: ", ob, lb->length,
lb->version);
print_object(ob + lb->length);
cprintf("\n");
return ob;
}
namespace {
Ptr<Symbol4<Ptr<Type>>> get_fixed_type_symbol(u32 offset) {
return (s7 + offset).cast<Symbol4<Ptr<Type>>>();
}
u64 pack_type_flag(u64 methods, u64 heap_base, u64 size) {
return (methods << 32) + (heap_base << 16) + (size);
}
} // namespace
int InitHeapAndSymbol() {
Ptr<u32> symbol_table =
kmalloc(kglobalheap, 4 * GOAL_MAX_SYMBOLS, KMALLOC_MEMSET, "symbol-table").cast<u32>();
SymbolString =
kmalloc(kglobalheap, 4 * GOAL_MAX_SYMBOLS, KMALLOC_MEMSET, "string-table").cast<u32>();
SymbolString.offset += 2 * GOAL_MAX_SYMBOLS; // point to the middle
LastSymbol = symbol_table + 0xff00;
SymbolTable2 = symbol_table + 5;
s7 = symbol_table + 0x8001;
NumSymbols = 0;
reset_output();
// empty pair (this is extra confusing).
*Ptr<u32>(s7.offset + FIX_SYM_EMPTY_CAR - 1) = s7.offset + S7_OFF_FIX_SYM_EMPTY_PAIR;
*Ptr<u32>(s7.offset + FIX_SYM_EMPTY_CDR - 1) = s7.offset + S7_OFF_FIX_SYM_EMPTY_PAIR;
fixed_sym_set(FIX_SYM_GLOBAL_HEAP, kglobalheap.offset);
UnknownName = Ptr<String>(make_string_from_c("*unknown-symbol-name*"));
alloc_and_init_type((s7 + FIX_SYM_TYPE_TYPE).cast<Symbol4<Ptr<Type>>>(), 9, true);
alloc_and_init_type((s7 + FIX_SYM_SYMBOL_TYPE).cast<Symbol4<Ptr<Type>>>(), 9, true);
alloc_and_init_type((s7 + FIX_SYM_STRING_TYPE).cast<Symbol4<Ptr<Type>>>(), 9, true);
alloc_and_init_type((s7 + FIX_SYM_FUNCTION_TYPE).cast<Symbol4<Ptr<Type>>>(), 9, true);
set_fixed_symbol(FIX_SYM_FALSE, "#f", s7.offset + FIX_SYM_FALSE);
set_fixed_symbol(FIX_SYM_TRUE, "#t", s7.offset + FIX_SYM_TRUE);
set_fixed_symbol(FIX_SYM_NOTHING_FUNC, "nothing", make_nothing_func().offset);
set_fixed_symbol(FIX_SYM_ZERO_FUNC, "zero-func", make_zero_func().offset);
set_fixed_symbol(FIX_SYM_ASIZE_OF_BASIC_FUNC, "asize-of-basic-func",
make_function_from_c((void*)asize_of_basic).offset);
set_fixed_symbol(FIX_SYM_COPY_BASIC_FUNC, "asize-of-basic-func", // typo in name here again.
make_function_from_c((void*)copy_basic, true).offset);
set_fixed_symbol(FIX_SYM_DELETE_BASIC, "delete-basic",
make_function_from_c((void*)delete_basic).offset);
set_fixed_symbol(FIX_SYM_GLOBAL_HEAP, "global", kglobalheap.offset);
set_fixed_symbol(FIX_SYM_DEBUG, "debug", kdebugheap.offset);
set_fixed_symbol(FIX_SYM_STATIC, "static", s7.offset + FIX_SYM_STATIC);
set_fixed_symbol(FIX_SYM_LOADING_LEVEL, "loading-level", kglobalheap.offset);
set_fixed_symbol(FIX_SYM_LOADING_PACKAGE, "loading-package", kglobalheap.offset);
set_fixed_symbol(FIX_SYM_PROCESS_LEVEL_HEAP, "process-level-heap", kglobalheap.offset);
set_fixed_symbol(FIX_SYM_STACK, "stack", s7.offset + FIX_SYM_STACK);
set_fixed_symbol(FIX_SYM_SCRATCH, "scratch", s7.offset + FIX_SYM_SCRATCH);
set_fixed_symbol(FIX_SYM_SCRATCH_TOP, "*scratch-top*", 0x70000000);
set_fixed_symbol(FIX_SYM_LEVEL, "level", 0);
set_fixed_symbol(FIX_SYM_ART_GROUP, "art-group", 0);
set_fixed_symbol(FIX_SYM_TEXTURE_PAGE_DIR, "texture-page-dir", 0);
set_fixed_symbol(FIX_SYM_TEXTURE_PAGE, "texture-page", 0);
set_fixed_symbol(FIX_SYM_SOUND, "sound", 0);
set_fixed_symbol(FIX_SYM_DGO, "dgo", 0);
set_fixed_symbol(FIX_SYM_TOP_LEVEL, "top-level", u32_in_fixed_sym(FIX_SYM_NOTHING_FUNC));
set_fixed_symbol(FIX_SYM_QUOTE, "quote", s7.offset + FIX_SYM_QUOTE);
set_fixed_symbol(FIX_SYM_LISTENER_LINK_BLOCK, "*listener-link-block*", 0);
set_fixed_symbol(FIX_SYM_LISTENER_FUNCTION, "*listener-function*", 0x0);
set_fixed_symbol(FIX_SYM_STACK_TOP, "*stack-top*", 0x0);
set_fixed_symbol(FIX_SYM_STACK_BASE, "*stack-base*", 0x0);
set_fixed_symbol(FIX_SYM_STACK_SIZE, "*stack-size*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_FUNCTION, "*kernel-function*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_PACKAGES, "*kernel-packages*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_BOOT_MESSAGE, "*kernel-boot-message*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_BOOT_MODE, "*kernel-boot-mode*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_BOOT_LEVEL, "*kernel-boot-level*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_BOOT_ART_GROUP, "*kernel-boot-art-group*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_DEBUG, "*kernel-debug*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_VERSION, "*kernel-version*", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_DISPATCHER, "kernel-dispatcher", 0x0);
set_fixed_symbol(FIX_SYM_SYNC_DISPATCHER, "sync-dispatcher", 0x0);
set_fixed_symbol(FIX_SYM_PRINT_COLLUMN, "*print-collumn*", 0x0);
set_fixed_symbol(FIX_SYM_DEBUG_SEGMENT, "*debug-segment*", 0x0);
set_fixed_symbol(FIX_SYM_ENABLE_METHOD_SET, "*enable-method-set*", 0x0);
set_fixed_symbol(FIX_SYM_SQL_RESULT, "*sql-result*", 0x0);
set_fixed_symbol(FIX_SYM_COLLAPSE_QUOTE, "*collapse-quote*", 0x0);
set_fixed_symbol(FIX_SYM_LEVEL_TYPE_LIST, "*level-type-list*", 0x0);
set_fixed_symbol(FIX_SYM_DECI_COUNT, "*deci-count*", 0x0);
set_fixed_symbol(FIX_SYM_USER, "*user*", 0x0);
set_fixed_symbol(FIX_SYM_VIDEO_MODE, "*video-mode*", 0x0);
set_fixed_symbol(FIX_SYM_BOOT_VIDEO_MODE, "*boot-video-mode*", 0x0);
set_fixed_symbol(FIX_SYM_BOOT, "boot", 0x0);
set_fixed_symbol(FIX_SYM_DEMO, "demo", 0x0);
set_fixed_symbol(FIX_SYM_DEMO_SHARED, "demo-shared", 0x0);
set_fixed_symbol(FIX_SYM_PREVIEW, "preview", 0x0);
set_fixed_symbol(FIX_SYM_KIOSK, "kiosk", 0x0);
set_fixed_symbol(FIX_SYM_PLAY_BOOT, "play-boot", 0x0);
set_fixed_symbol(FIX_SYM_SIN, "sin", 0x0);
set_fixed_symbol(FIX_SYM_COS, "cos", 0x0);
set_fixed_symbol(FIX_SYM_PUT_DISPLAY_ENV, "put-display-env", 0x0);
set_fixed_symbol(FIX_SYM_SYNCV, "syncv", 0x0);
set_fixed_symbol(FIX_SYM_SYNC_PATH, "sync-path", 0x0);
set_fixed_symbol(FIX_SYM_RESET_PATH, "reset-path", 0x0);
set_fixed_symbol(FIX_SYM_RESET_GRAPH, "reset-graph", 0x0);
set_fixed_symbol(FIX_SYM_DMA_SYNC, "dma-sync", 0x0);
set_fixed_symbol(FIX_SYM_GS_PUT_IMR, "gs-put-imr", 0x0);
set_fixed_symbol(FIX_SYM_GS_GET_IMR, "gs-get-imr", 0x0);
set_fixed_symbol(FIX_SYM_GS_STORE_IMAGE, "gs-store-image", 0x0);
set_fixed_symbol(FIX_SYM_FLUSH_CACHE, "flush-cache", 0x0);
set_fixed_symbol(FIX_SYM_CPAD_OPEN, "cpad-open", 0x0);
set_fixed_symbol(FIX_SYM_CPAD_GET_DATA, "cpad-get-data", 0x0);
set_fixed_symbol(FIX_SYM_MOUSE_GET_DATA, "mouse-get-data", 0x0);
set_fixed_symbol(FIX_SYM_KEYBD_GET_DATA, "keybd-get-data", 0x0);
set_fixed_symbol(FIX_SYM_INSTALL_HANDLER, "install-handler", 0x0);
set_fixed_symbol(FIX_SYM_INSTALL_DEBUG_HANDLER, "install-debug-handler", 0x0);
set_fixed_symbol(FIX_SYM_FILE_STREAM_OPEN, "file-stream-open", 0x0);
set_fixed_symbol(FIX_SYM_FILE_STREAM_CLOSE, "file-stream-close", 0x0);
set_fixed_symbol(FIX_SYM_FILE_STREAM_LENGTH, "file-stream-length", 0x0);
set_fixed_symbol(FIX_SYM_FILE_STREAM_SEEK, "file-stream-seek", 0x0);
set_fixed_symbol(FIX_SYM_FILE_STREAM_READ, "file-stream-read", 0x0);
set_fixed_symbol(FIX_SYM_FILE_STREAM_WRITE, "file-stream-write", 0x0);
// set_fixed_symbol(FIX_SYM_FILE_STREAM_WRITE, "file-stream-write", 0x0);
set_fixed_symbol(FIX_SYM_SCF_GET_LANGUAGE, "scf-get-language", 0x0);
set_fixed_symbol(FIX_SYM_SCF_GET_TIME, "scf-get-time", 0x0);
set_fixed_symbol(FIX_SYM_SCF_GET_ASPECT, "scf-get-aspect", 0x0);
set_fixed_symbol(FIX_SYM_SCF_GET_VOLUME, "scf-get-volume", 0x0);
set_fixed_symbol(FIX_SYM_SCF_GET_TERRITORY, "scf-get-territory", 0x0);
set_fixed_symbol(FIX_SYM_SCF_GET_TIMEOUT, "scf-get-timeout", 0x0);
set_fixed_symbol(FIX_SYM_SCF_GET_INACTIVE_TIMEOUT, "scf-get-inactive-timeout", 0x0);
set_fixed_symbol(FIX_SYM_DMA_TO_IOP, "dma-to-iop", 0x0);
set_fixed_symbol(FIX_SYM_KERNEL_SHUTDOWN, "kernel-shutdown", 0x0);
set_fixed_symbol(FIX_SYM_AYBABTU, "aybabtu", 0x0);
set_fixed_symbol(FIX_SYM_STRING_TO_SYMBOL, "string->symbol", 0x0);
set_fixed_symbol(FIX_SYM_SYMBOL_TO_STRING, "symbol->string", 0x0);
set_fixed_symbol(FIX_SYM_PRINT, "print", 0x0);
set_fixed_symbol(FIX_SYM_INSPECT, "inspect", 0x0);
set_fixed_symbol(FIX_SYM_LOAD, "load", 0x0);
set_fixed_symbol(FIX_SYM_LOADB, "loadb", 0x0);
set_fixed_symbol(FIX_SYM_LOADO, "loado", 0x0);
set_fixed_symbol(FIX_SYM_UNLOAD, "unload", 0x0);
set_fixed_symbol(FIX_SYM_FORMAT, "_format", 0x0);
set_fixed_symbol(FIX_SYM_MALLOC, "malloc", 0x0);
set_fixed_symbol(FIX_SYM_KMALLOC, "kmalloc", 0x0);
set_fixed_symbol(FIX_SYM_KMEMOPEN, "kmemopen", 0x0);
set_fixed_symbol(FIX_SYM_KMEMCLOSE, "kmemclose", 0x0);
set_fixed_symbol(FIX_SYM_NEW_DYNAMIC_STRUCTURE, "new-dynamic-structure", 0x0);
set_fixed_symbol(FIX_SYM_METHOD_SET, "method-set!", 0x0);
set_fixed_symbol(FIX_SYM_LINK, "link", 0x0);
set_fixed_symbol(FIX_SYM_LINK_BUSY, "link-busy?", 0x0);
set_fixed_symbol(FIX_SYM_LINK_RESET, "link-reset", 0x0);
set_fixed_symbol(FIX_SYM_LINK_BEGIN, "link-begin", 0x0);
set_fixed_symbol(FIX_SYM_LINK_RESUME, "link-resume", 0x0);
set_fixed_symbol(FIX_SYM_DGO_LOAD, "dgo-load", 0x0);
set_fixed_symbol(FIX_SYM_SQL_QUERY, "sql-query", 0x0);
set_fixed_symbol(FIX_SYM_MC_RUN, "mc-run", 0x0);
set_fixed_symbol(FIX_SYM_MC_FORMAT, "mc-format", 0x0);
set_fixed_symbol(FIX_SYM_MC_UNFORMAT, "mc-unformat", 0x0);
set_fixed_symbol(FIX_SYM_MC_CREATE_FILE, "mc-create-file", 0x0);
set_fixed_symbol(FIX_SYM_MC_SAVE, "mc-save", 0x0);
set_fixed_symbol(FIX_SYM_MC_LOAD, "mc-load", 0x0);
set_fixed_symbol(FIX_SYM_MC_CHECK_RESULT, "mc-check-result", 0x0);
set_fixed_symbol(FIX_SYM_MC_GET_SLOT_INFO, "mc-get-slot-info", 0x0);
set_fixed_symbol(FIX_SYM_MC_MAKEFILE, "mc-makefile", 0x0);
set_fixed_symbol(FIX_SYM_KSET_LANGUAGE, "kset-language", 0x0);
set_fixed_symbol(FIX_SYM_RPC_CALL, "rpc-call", 0x0);
set_fixed_symbol(FIX_SYM_RPC_BUSY, "rpc-busy?", 0x0);
set_fixed_symbol(FIX_SYM_TEST_LOAD_DGO_C, "test-load-dgo-c", 0x0);
set_fixed_symbol(FIX_SYM_SYMLINK2, "symlink2", 0x0);
set_fixed_symbol(FIX_SYM_SYMLINK3, "symlink3", 0x0);
set_fixed_symbol(FIX_SYM_ULTIMATE_MEMCPY, "ultimate-memcpy", 0x0);
set_fixed_symbol(FIX_SYM_PLAY, "play", 0x0);
set_fixed_symbol(FIX_SYM_SYMBOL_STRING, "*symbol-string*", SymbolString.offset);
set_fixed_symbol(FIX_SYM_KERNEL_SYMBOL_WARNINGS, "*kernel-symbol-warnings*",
s7.offset + FIX_SYM_TRUE);
set_fixed_symbol(FIX_SYM_NETWORK_BOOTSTRAP, "network-bootstrap", 0);
auto new_illegal_func = make_function_from_c((void*)new_illegal);
auto delete_illegal_func = make_function_from_c((void*)delete_illegal);
auto print_object_func = make_function_from_c((void*)print_object);
auto inspect_object_func = make_function_from_c((void*)inspect_object);
set_fixed_type(FIX_SYM_OBJECT_TYPE, "object", get_fixed_type_symbol(FIX_SYM_OBJECT_TYPE),
pack_type_flag(9, 0, 4), print_object_func.offset, inspect_object_func.offset);
auto object_type = Ptr<Type>(u32_in_fixed_sym(FIX_SYM_OBJECT_TYPE));
object_type->new_method = Ptr<Function>(u32_in_fixed_sym(FIX_SYM_NOTHING_FUNC)); // new for jak 2
object_type->delete_method = delete_illegal_func;
object_type->asize_of_method =
Ptr<Function>(u32_in_fixed_sym(FIX_SYM_ZERO_FUNC)); // changed to zero!
object_type->length_method =
Ptr<Function>(u32_in_fixed_sym(FIX_SYM_ZERO_FUNC)); // changed to zero!
object_type->copy_method = make_function_from_c((void*)copy_fixed);
auto structure_type =
set_fixed_type(FIX_SYM_STRUCTURE, "structure", get_fixed_type_symbol(FIX_SYM_OBJECT_TYPE),
pack_type_flag(9, 0, 4), make_function_from_c((void*)print_structure).offset,
make_function_from_c((void*)inspect_structure).offset);
structure_type->new_method = make_function_from_c((void*)new_structure);
structure_type->delete_method = make_function_from_c((void*)delete_structure);
auto basic_type =
set_fixed_type(FIX_SYM_BASIC, "basic", get_fixed_type_symbol(FIX_SYM_STRUCTURE),
pack_type_flag(9, 0, 4), make_function_from_c((void*)print_basic).offset,
make_function_from_c((void*)inspect_basic).offset);
basic_type->new_method = make_function_from_c((void*)new_basic, true);
basic_type->delete_method = Ptr<Function>(u32_in_fixed_sym(FIX_SYM_DELETE_BASIC));
basic_type->asize_of_method = Ptr<Function>(u32_in_fixed_sym(FIX_SYM_ASIZE_OF_BASIC_FUNC));
basic_type->copy_method = Ptr<Function>(u32_in_fixed_sym(FIX_SYM_COPY_BASIC_FUNC));
set_fixed_type(FIX_SYM_SYMBOL_TYPE, "symbol", get_fixed_type_symbol(FIX_SYM_OBJECT_TYPE),
pack_type_flag(9, 0, 4), make_function_from_c((void*)print_symbol).offset,
make_function_from_c((void*)inspect_symbol).offset);
auto sym_type = Ptr<Type>(u32_in_fixed_sym(FIX_SYM_SYMBOL_TYPE));
sym_type->new_method = new_illegal_func;
sym_type->delete_method = delete_illegal_func;
set_fixed_type(FIX_SYM_TYPE_TYPE, "type", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(9, 0, 0x38), make_function_from_c((void*)print_type).offset,
make_function_from_c((void*)inspect_type).offset);
auto type_type = Ptr<Type>(u32_in_fixed_sym(FIX_SYM_TYPE_TYPE));
type_type->new_method = make_function_from_c((void*)new_type);
type_type->delete_method = delete_illegal_func;
set_fixed_type(FIX_SYM_STRING_TYPE, "string", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(9, 0, 8), make_function_from_c((void*)print_string).offset,
make_function_from_c((void*)inspect_string).offset);
set_fixed_type(FIX_SYM_FUNCTION_TYPE, "function", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(9, 0, 4), make_function_from_c((void*)print_function).offset, 0);
auto function_type = Ptr<Type>(u32_in_fixed_sym(FIX_SYM_FUNCTION_TYPE));
function_type->new_method = new_illegal_func;
function_type->delete_method = delete_illegal_func;
set_fixed_type(FIX_SYM_VU_FUNCTION, "vu-function", get_fixed_type_symbol(FIX_SYM_STRUCTURE),
pack_type_flag(9, 0, 0x10), make_function_from_c((void*)print_vu_function).offset,
make_function_from_c((void*)inspect_vu_function).offset);
Ptr<Type>(u32_in_fixed_sym(FIX_SYM_VU_FUNCTION))->delete_method = delete_illegal_func;
set_fixed_type(FIX_SYM_LINK_BLOCK, "link-block", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(9, 0, 0xc), 0,
make_function_from_c((void*)inspect_link_block).offset);
auto link_block_type = Ptr<Type>(u32_in_fixed_sym(FIX_SYM_LINK_BLOCK));
link_block_type->new_method = new_illegal_func;
link_block_type->delete_method = delete_illegal_func;
set_fixed_type(FIX_SYM_HEAP, "kheap", get_fixed_type_symbol(FIX_SYM_STRUCTURE),
pack_type_flag(9, 0, 0x10), 0, make_function_from_c((void*)inspect_kheap).offset);
set_fixed_type(FIX_SYM_ARRAY, "array", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(9, 0, 0x10), 0, 0);
set_fixed_type(FIX_SYM_PAIR_TYPE, "pair", get_fixed_type_symbol(FIX_SYM_OBJECT_TYPE),
pack_type_flag(9, 0, 8), make_function_from_c((void*)print_pair).offset,
make_function_from_c((void*)inspect_pair).offset);
Ptr<Type>(u32_in_fixed_sym(FIX_SYM_PAIR_TYPE))->new_method =
make_function_from_c((void*)new_pair);
Ptr<Type>(u32_in_fixed_sym(FIX_SYM_PAIR_TYPE))->delete_method =
make_function_from_c((void*)delete_pair);
set_fixed_type(FIX_SYM_PROCESS_TREE, "process-tree", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(0xe, 0, 0x24), 0, 0);
set_fixed_type(FIX_SYM_PROCESS_TYPE, "process", get_fixed_type_symbol(FIX_SYM_PROCESS_TREE),
pack_type_flag(0xe, 0, 0x80), 0, 0);
set_fixed_type(FIX_SYM_THREAD, "thread", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(0xc, 0, 0x28), 0, 0);
set_fixed_type(FIX_SYM_CONNECTABLE, "connectable", get_fixed_type_symbol(FIX_SYM_STRUCTURE),
pack_type_flag(9, 0, 0x10), 0, 0);
set_fixed_type(FIX_SYM_STACK_FRAME, "stack-frame", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(9, 0, 0xc), 0, 0);
set_fixed_type(FIX_SYM_FILE_STREAM, "file-stream", get_fixed_type_symbol(FIX_SYM_BASIC),
pack_type_flag(9, 0, 0x14), 0, 0);
set_fixed_type(FIX_SYM_POINTER, "pointer", get_fixed_type_symbol(FIX_SYM_OBJECT_TYPE),
pack_type_flag(9, 0, 4), 0, 0);
Ptr<Type>(u32_in_fixed_sym(FIX_SYM_POINTER))->new_method = new_illegal_func;
set_fixed_type(FIX_SYM_NUMBER, "number", get_fixed_type_symbol(FIX_SYM_OBJECT_TYPE),
pack_type_flag(9, 0, 8), make_function_from_c((void*)print_integer).offset,
make_function_from_c((void*)inspect_integer).offset);
Ptr<Type>(u32_in_fixed_sym(FIX_SYM_NUMBER))->new_method = new_illegal_func;
set_fixed_type(FIX_SYM_FLOAT, "float", get_fixed_type_symbol(FIX_SYM_NUMBER),
pack_type_flag(9, 0, 4), make_function_from_c((void*)print_float).offset,
make_function_from_c((void*)inspect_float).offset);
set_fixed_type(FIX_SYM_INTEGER, "integer", get_fixed_type_symbol(FIX_SYM_NUMBER),
pack_type_flag(9, 0, 8), 0, 0);
set_fixed_type(FIX_SYM_BINTEGER, "binteger", get_fixed_type_symbol(FIX_SYM_INTEGER),
pack_type_flag(9, 0, 8), make_function_from_c((void*)print_binteger).offset,
make_function_from_c((void*)inspect_binteger).offset);
set_fixed_type(FIX_SYM_SINTEGER, "sinteger", get_fixed_type_symbol(FIX_SYM_INTEGER),
pack_type_flag(9, 0, 8), 0, 0);
set_fixed_type(FIX_SYM_INT8, "int8", get_fixed_type_symbol(FIX_SYM_SINTEGER),
pack_type_flag(9, 0, 1), 0, 0);
set_fixed_type(FIX_SYM_INT16, "int16", get_fixed_type_symbol(FIX_SYM_SINTEGER),
pack_type_flag(9, 0, 2), 0, 0);
set_fixed_type(FIX_SYM_INT32, "int32", get_fixed_type_symbol(FIX_SYM_SINTEGER),
pack_type_flag(9, 0, 4), 0, 0);
set_fixed_type(FIX_SYM_INT64, "int64", get_fixed_type_symbol(FIX_SYM_SINTEGER),
pack_type_flag(9, 0, 8), 0, 0);
set_fixed_type(FIX_SYM_INT128, "int128", get_fixed_type_symbol(FIX_SYM_SINTEGER),
pack_type_flag(9, 0, 16), 0, 0);
set_fixed_type(FIX_SYM_UINTEGER, "uinteger", get_fixed_type_symbol(FIX_SYM_INTEGER),
pack_type_flag(9, 0, 8), 0, 0);
set_fixed_type(FIX_SYM_UINT8, "uint8", get_fixed_type_symbol(FIX_SYM_UINTEGER),
pack_type_flag(9, 0, 1), 0, 0);
set_fixed_type(FIX_SYM_UINT16, "uint16", get_fixed_type_symbol(FIX_SYM_UINTEGER),
pack_type_flag(9, 0, 2), 0, 0);
set_fixed_type(FIX_SYM_UINT32, "uint32", get_fixed_type_symbol(FIX_SYM_UINTEGER),
pack_type_flag(9, 0, 4), 0, 0);
set_fixed_type(FIX_SYM_UINT64, "uint64", get_fixed_type_symbol(FIX_SYM_UINTEGER),
pack_type_flag(9, 0, 8), 0, 0);
set_fixed_type(FIX_SYM_UINT128, "uint128", get_fixed_type_symbol(FIX_SYM_UINTEGER),
pack_type_flag(9, 0, 16), 0, 0);
Ptr<Type>(u32_in_fixed_sym(FIX_SYM_OBJECT_TYPE))->new_method =
make_function_from_c((void*)alloc_heap_object, true);
make_function_symbol_from_c("string->symbol", (void*)intern);
make_function_symbol_from_c("symbol->string", (void*)symbol_to_string_from_c);
make_function_symbol_from_c("print", (void*)sprint);
make_function_symbol_from_c("inspect", (void*)inspect_object);
make_function_symbol_from_c("load", (void*)load);
make_function_symbol_from_c("loadb", (void*)loadb);
make_function_symbol_from_c("loado", (void*)loado);
make_function_symbol_from_c("unload", (void*)unload);
make_stack_arg_function_symbol_from_c("_format", (void*)format_impl_jak3);
make_function_symbol_from_c("malloc", (void*)alloc_heap_memory);
make_function_symbol_from_c("kmalloc", (void*)goal_malloc);
make_function_symbol_from_c("kmemopen", (void*)kmemopen);
make_function_symbol_from_c("kmemclose", (void*)kmemclose);
make_function_symbol_from_c("new-dynamic-structure", (void*)new_dynamic_structure);
make_function_symbol_from_c("method-set!", (void*)method_set);
make_stack_arg_function_symbol_from_c("link", (void*)link_and_exec_wrapper);
make_function_symbol_from_c("link-busy?", (void*)link_busy);
make_function_symbol_from_c("link-reset", (void*)link_reset);
make_function_symbol_from_c("dgo-load", (void*)load_and_link_dgo);
make_raw_function_symbol_from_c("ultimate-memcpy", 0);
make_raw_function_symbol_from_c("symlink2", 0);
make_raw_function_symbol_from_c("symlink3", 0);
make_stack_arg_function_symbol_from_c("link-begin", (void*)link_begin);
make_function_symbol_from_c("link-resume", (void*)link_resume);
make_function_symbol_from_c("sql-query", (void*)sql_query_sync);
make_function_symbol_from_c("mc-run", (void*)MC_run);
make_function_symbol_from_c("mc-format", (void*)MC_format);
make_function_symbol_from_c("mc-unformat", (void*)MC_unformat);
make_function_symbol_from_c("mc-create-file", (void*)MC_createfile);
make_function_symbol_from_c("mc-save", (void*)MC_save);
make_function_symbol_from_c("mc-load", (void*)MC_load);
make_function_symbol_from_c("mc-check-result", (void*)MC_check_result);
make_function_symbol_from_c("mc-get-slot-info", (void*)MC_get_status);
make_function_symbol_from_c("mc-makefile", (void*)MC_makefile);
make_function_symbol_from_c("kset-language", (void*)MC_set_language);
auto ds_symbol = intern_from_c(-1, 0, "*debug-segment*");
if (DebugSegment) {
ds_symbol->value() = (s7 + FIX_SYM_TRUE).offset;
} else {
ds_symbol->value() = (s7 + FIX_SYM_FALSE).offset;
}
auto method_set_symbol = intern_from_c(-1, 0, "*enable-method-set*");
EnableMethodSet = method_set_symbol.cast<u32>() - 1;
method_set_symbol->value() = 0;
KernelDebug = intern_from_c(-1, 0, "*kernel-debug*").cast<u32>() - 1;
*KernelDebug = 0;
intern_from_c(-1, 0, "*boot-video-mode*")->value() = 0;
intern_from_c(-1, 0, "*video-mode*")->value() = 0;
SqlResult = intern_from_c(-1, 0, "*sql-result*");
SqlResult->value() = s7.offset;
CollapseQuote = intern_from_c(-1, 0, "*collapse-quote*");
CollapseQuote->value() = s7.offset + FIX_SYM_TRUE;
LevelTypeList = intern_from_c(-1, 0, "*level-type-list*");
if (MasterUseKernel) {
*EnableMethodSet = *EnableMethodSet + 1;
load_and_link_dgo_from_c("kernel", kglobalheap,
LINK_FLAG_OUTPUT_LOAD | LINK_FLAG_EXECUTE | LINK_FLAG_PRINT_LOGIN,
0x400000, true);
*EnableMethodSet = *EnableMethodSet + -1;
auto kernel_version = intern_from_c(-1, 0, "*kernel-version*")->value();
if (!kernel_version || ((kernel_version >> 0x13) != KERNEL_VERSION_MAJOR)) {
lg::error(
"Kernel version mismatch! Compiled C kernel version is {}.{} but"
" the goal kernel is {}.{}",
KERNEL_VERSION_MAJOR, KERNEL_VERSION_MINOR, kernel_version >> 0x13,
(kernel_version >> 3) & 0xffff);
return -1;
} else {
lg::info("Got correct kernel version {}.{}", kernel_version >> 0x13,
(kernel_version >> 3) & 0xffff);
}
}
protoBlock.deci2count = intern_from_c(-1, 0, "*deci-count*").cast<s32>() - 1;
InitListener();
InitMachineScheme();
kmemclose();
return 0;
}
u64 load(u32 /*file_name_in*/, u32 /*heap_in*/) {
ASSERT(false);
return 0;
}
u64 loadb(u32 /*file_name_in*/, u32 /*heap_in*/, u32 /*param3*/) {
ASSERT(false);
return 0;
}
u64 loadc(const char* /*file_name*/, kheapinfo* /*heap*/, u32 /*flags*/) {
ASSERT(false);
return 0;
}
u64 loado(u32 file_name_in, u32 heap_in) {
char loadName[272];
Ptr<String> file_name(file_name_in);
Ptr<kheapinfo> heap(heap_in);
printf("****** CALL TO loado(%s) ******\n", file_name->data());
kstrcpy(loadName, MakeFileName(DATA_FILE_TYPE, file_name->data(), 0));
s32 returnValue = load_and_link(file_name->data(), loadName, heap.c(), LINK_FLAG_PRINT_LOGIN);
if (returnValue < 0) {
return s7.offset;
} else {
return returnValue;
}
}
/*!
* "Unload". Doesn't free memory, just informs listener we unloaded.
*/
u64 unload(u32 name) {
output_unload(Ptr<String>(name)->data());
return 0;
}
s64 load_and_link(const char* filename, char* decode_name, kheapinfo* heap, u32 flags) {
(void)filename;
s32 sz;
auto rv = FileLoad(decode_name, make_ptr(heap), Ptr<u8>(0), KMALLOC_ALIGN_64, &sz);
if (((s32)rv.offset) > -1) {
return (s32)link_and_exec(rv, decode_name, sz, make_ptr(heap), flags, false).offset;
}
return (s32)rv.offset;
}
} // namespace jak3
Reference in New Issue View Git Blame Copy Permalink