mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 11:26:18 -04:00
4f537d4a71
This sets up the C Kernel for Jak 3, and makes it possible to build and load code built with `goalc --jak3`. There's not too much interesting here, other than they switched to a system where symbol IDs (unique numbers less than 2^14) are generated at compile time, and those get included in the object file itself. This is kind of annoying, since it means all tools that produce a GOAL object file need to work together to assign unique symbol IDs. And since the symbol IDs can't conflict, and are only a number between 0 and 2^14, you can't just hash and hope for no collisions. We work around this by ignoring the IDs and re-assigning our own. I think this is very similar to what the C Kernel did on early builds of Jak 3 which supported loading old format level files, which didn't have the IDs included. As far as I can tell, this shouldn't cause any problems. It defeats all of their fancy tricks to save memory by not storing the symbol string, but we don't care.
851 lines
29 KiB
C++
851 lines
29 KiB
C++
/*!
|
|
* @file LinkedObjectFileCreation.cpp
|
|
* Create a LinkedObjectFile from raw object file data.
|
|
* This implements a decoder for the GOAL linking format.
|
|
*/
|
|
|
|
#include "LinkedObjectFileCreation.h"
|
|
|
|
#include <cstring>
|
|
|
|
#include "common/link_types.h"
|
|
#include "common/log/log.h"
|
|
#include "common/util/Assert.h"
|
|
#include "common/util/BitUtils.h"
|
|
|
|
#include "decompiler/config.h"
|
|
#include "decompiler/util/DecompilerTypeSystem.h"
|
|
|
|
namespace decompiler {
|
|
// There are three link versions:
|
|
// V2 - not really in use anymore, but V4 will resue logic from it (and the game didn't rename the
|
|
// functions) V3 - optimized for code and small stuff. Supports segments (main, debug, top-level) V4
|
|
// - optimized for data (never code) and big stuff, special optimization possible for large V4
|
|
// objects at the end of DGO.
|
|
// internally V4 is really just a V2, but with the link data coming after the object data.
|
|
// there's a V4 header at the beginning, the object data, and then a V2 header and V2 link data.
|
|
|
|
// Header for link data used for V2, V3, V4 objects. For V3/V4, this is found at the beginning of
|
|
// the object data.
|
|
struct LinkHeaderCommon {
|
|
uint32_t type_tag; // for the basic offset, is 0 or -1 depending on version
|
|
uint32_t length; // different exact meanings, but length of the link data.
|
|
uint16_t version; // what version (2, 3, 4)
|
|
};
|
|
|
|
// Per-segment info for V3 and V5 link data
|
|
struct SegmentInfo {
|
|
uint32_t relocs; // offset of relocation table
|
|
uint32_t data; // offset of segment data
|
|
uint32_t size; // segment data size (0 if segment doesn't exist)
|
|
uint32_t magic; // always 0
|
|
};
|
|
|
|
struct LinkHeaderV3 {
|
|
uint32_t type_tag; // always 0
|
|
uint32_t length; // length of link data
|
|
uint32_t version; // always 3
|
|
uint32_t segments; // always 3
|
|
char name[64]; // name of object file
|
|
SegmentInfo segment_info[3];
|
|
};
|
|
|
|
struct LinkHeaderV5 {
|
|
uint32_t type_tag; // 0 always 0?
|
|
uint32_t length_to_get_to_code; // 4 length.. of link data?
|
|
uint16_t version; // 8
|
|
uint16_t unknown; // 10
|
|
uint32_t length_to_get_to_link; // 12
|
|
uint32_t link_length; // 16
|
|
uint8_t n_segments; // 20
|
|
char name[59]; // 21 (really??)
|
|
};
|
|
|
|
// The types of symbol links
|
|
enum class SymbolLinkKind {
|
|
EMPTY_LIST, // link to the empty list
|
|
TYPE, // link to a type
|
|
SYMBOL // link to a symbol
|
|
};
|
|
|
|
/*!
|
|
* Handle symbol links for a single symbol in a V2/V4 object file.
|
|
*/
|
|
static uint32_t c_symlink2(LinkedObjectFile& f,
|
|
const std::vector<uint8_t>& data,
|
|
uint32_t code_ptr_offset,
|
|
uint32_t link_ptr_offset,
|
|
SymbolLinkKind kind,
|
|
const char* name,
|
|
int seg_id,
|
|
DecompilerTypeSystem& dts) {
|
|
dts.add_symbol(name);
|
|
auto initial_offset = code_ptr_offset;
|
|
do {
|
|
auto table_value = data.at(link_ptr_offset);
|
|
const uint8_t* relocPtr = &data.at(link_ptr_offset);
|
|
|
|
// link table has a series of variable-length-encoded integers indicating the seek amount to hit
|
|
// each reference to the symbol. It ends when the seek is 0, and all references to this symbol
|
|
// have been patched.
|
|
uint32_t seek = table_value;
|
|
uint32_t next_reloc = link_ptr_offset + 1;
|
|
|
|
if (seek & 3) {
|
|
// 0b01, 0b10
|
|
seek = (relocPtr[1] << 8) | table_value;
|
|
next_reloc = link_ptr_offset + 2;
|
|
if (seek & 2) {
|
|
// 0b10
|
|
seek = (relocPtr[2] << 16) | seek;
|
|
next_reloc = link_ptr_offset + 3;
|
|
if (seek & 1) {
|
|
// 0b11
|
|
seek = (relocPtr[3] << 24) | seek;
|
|
next_reloc = link_ptr_offset + 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
f.stats.total_v2_symbol_links++;
|
|
link_ptr_offset = next_reloc;
|
|
|
|
code_ptr_offset += (seek & 0xfffffffc);
|
|
|
|
// the value of the code gives us more information
|
|
uint32_t code_value = *(const uint32_t*)(&data.at(code_ptr_offset));
|
|
if (code_value == 0xffffffff) {
|
|
// absolute link - replace entire word with a pointer.
|
|
LinkedWord::Kind word_kind;
|
|
switch (kind) {
|
|
case SymbolLinkKind::SYMBOL:
|
|
word_kind = LinkedWord::SYM_PTR;
|
|
break;
|
|
case SymbolLinkKind::EMPTY_LIST:
|
|
word_kind = LinkedWord::EMPTY_PTR;
|
|
break;
|
|
case SymbolLinkKind::TYPE:
|
|
// hack for jak 2: this symbol is used as a type in village 1 and also the oracle level
|
|
// level info. We'll just leave it out, as we don't really need these definitions.
|
|
if (std::string(name) != "oracle") {
|
|
dts.add_symbol(name, "type", {});
|
|
}
|
|
word_kind = LinkedWord::TYPE_PTR;
|
|
break;
|
|
default:
|
|
throw std::runtime_error("unhandled SymbolLinkKind");
|
|
}
|
|
|
|
f.symbol_link_word(seg_id, code_ptr_offset - initial_offset, name, word_kind);
|
|
} else {
|
|
// offset link - replace lower 16 bits with symbol table offset.
|
|
|
|
ASSERT((code_value & 0xffff) == 0 || (code_value & 0xffff) == 0xffff);
|
|
ASSERT(kind == SymbolLinkKind::SYMBOL);
|
|
f.symbol_link_offset(seg_id, code_ptr_offset - initial_offset, name,
|
|
(code_value & 0xffff) == 0xffff);
|
|
}
|
|
|
|
} while (data.at(link_ptr_offset));
|
|
|
|
// seek past terminating 0.
|
|
return link_ptr_offset + 1;
|
|
}
|
|
|
|
/*!
|
|
* Handle symbol links for a single symbol in a V3 object file.
|
|
*/
|
|
static uint32_t c_symlink3(LinkedObjectFile& f,
|
|
const std::vector<uint8_t>& data,
|
|
uint32_t code_ptr,
|
|
uint32_t link_ptr,
|
|
SymbolLinkKind kind,
|
|
const char* name,
|
|
int seg,
|
|
DecompilerTypeSystem& dts) {
|
|
dts.add_symbol(name);
|
|
auto initial_offset = code_ptr;
|
|
do {
|
|
// seek, with a variable length encoding that sucks.
|
|
uint8_t c;
|
|
do {
|
|
c = data.at(link_ptr);
|
|
link_ptr++;
|
|
code_ptr += c * 4;
|
|
} while (c == 0xff);
|
|
|
|
// identical logic to symlink 2
|
|
uint32_t code_value = *(const uint32_t*)(&data.at(code_ptr));
|
|
if (code_value == 0xffffffff) {
|
|
f.stats.v3_symbol_link_word++;
|
|
LinkedWord::Kind word_kind;
|
|
switch (kind) {
|
|
case SymbolLinkKind::SYMBOL:
|
|
word_kind = LinkedWord::SYM_PTR;
|
|
break;
|
|
case SymbolLinkKind::EMPTY_LIST:
|
|
word_kind = LinkedWord::EMPTY_PTR;
|
|
break;
|
|
case SymbolLinkKind::TYPE:
|
|
dts.add_symbol(name, "type", {});
|
|
word_kind = LinkedWord::TYPE_PTR;
|
|
break;
|
|
default:
|
|
throw std::runtime_error("unhandled SymbolLinkKind");
|
|
}
|
|
|
|
f.symbol_link_word(seg, code_ptr - initial_offset, name, word_kind);
|
|
} else {
|
|
u16 lower = code_value & 0xffff;
|
|
ASSERT(lower == 0 || lower == 0xffff);
|
|
f.stats.v3_symbol_link_offset++;
|
|
ASSERT(kind == SymbolLinkKind::SYMBOL);
|
|
f.symbol_link_offset(seg, code_ptr - initial_offset, name, lower == 0xffff);
|
|
}
|
|
|
|
} while (data.at(link_ptr));
|
|
return link_ptr + 1;
|
|
}
|
|
|
|
/*!
|
|
* Process link data for a "V4" or "V2" object file.
|
|
* In reality a V4 seems to be just a V2 object, but with the link data after the real data.
|
|
* There's a V4 header at the very beginning, but another V2 header/link data at the end
|
|
* -----------------------------------------------
|
|
* | V4 header | data | V2 header | V2 link data |
|
|
* -----------------------------------------------
|
|
*
|
|
* V2
|
|
* -----------------------------------
|
|
* | V2 header | V2 link data | data |
|
|
* -----------------------------------
|
|
* The V4 format avoids having to copy the data to the left once the V2 link data is discarded.
|
|
* Presumably once they decided that data could never be relocated after being loaded in,
|
|
* it became worth it to throw away the link data, and avoid the memcpy of the data.
|
|
* The memcpy is surprisingly expensive, when you consider the linker ran for ~3% of a frame each
|
|
* frame and level data is ~10 MB.
|
|
*/
|
|
static void link_v2_or_v4(LinkedObjectFile& f,
|
|
const std::vector<uint8_t>& data,
|
|
const std::string& name,
|
|
DecompilerTypeSystem& dts,
|
|
GameVersion version) {
|
|
(void)name;
|
|
const auto* header = (const LinkHeaderV4*)&data.at(0);
|
|
ASSERT(header->version == 4 || header->version == 2);
|
|
|
|
// these are different depending on the version.
|
|
uint32_t code_offset, link_data_offset, code_size;
|
|
|
|
if (header->version == 4) {
|
|
// code starts immediately after the V4 header
|
|
code_offset = sizeof(LinkHeaderV4);
|
|
// link_data_offset points to a V2 header
|
|
link_data_offset = header->code_size + sizeof(LinkHeaderV4);
|
|
// code size is specified!
|
|
code_size = header->code_size;
|
|
} else {
|
|
// link data starts immediately
|
|
link_data_offset = 0;
|
|
|
|
// code is after all the link data
|
|
code_offset = header->length;
|
|
// we have to compute the code size ourself
|
|
code_size = data.size() - code_offset;
|
|
ASSERT(header->type_tag == 0xffffffff);
|
|
}
|
|
|
|
f.stats.total_code_bytes += code_size;
|
|
f.stats.total_v2_code_bytes += code_size;
|
|
|
|
// add all code
|
|
const uint8_t* code_start = &data.at(code_offset);
|
|
const uint8_t* code_end =
|
|
&data.at(code_offset + code_size - 1) + 1; // get the pointer to one past the end.
|
|
|
|
if (version >= GameVersion::Jak2) {
|
|
while (((code_end - code_start) % 4)) {
|
|
code_end++;
|
|
}
|
|
}
|
|
|
|
ASSERT(((code_end - code_start) % 4) == 0);
|
|
f.set_segment_count(1);
|
|
for (auto x = code_start; x < code_end; x += 4) {
|
|
f.push_back_word_to_segment(*((const uint32_t*)x), 0);
|
|
}
|
|
|
|
// read v2 header after the code
|
|
const uint8_t* link_data = &data.at(link_data_offset);
|
|
uint32_t link_ptr_offset = link_data_offset;
|
|
link_ptr_offset += sizeof(LinkHeaderV2);
|
|
auto* link_header_v2 = (const LinkHeaderV2*)(link_data);
|
|
ASSERT(link_header_v2->type_tag == 0xffffffff);
|
|
ASSERT(link_header_v2->version == 2);
|
|
ASSERT(link_header_v2->length == header->length);
|
|
f.stats.total_v2_link_bytes += link_header_v2->length;
|
|
|
|
// first "section" of link data is a list of where all the pointer are.
|
|
if (data.at(link_ptr_offset) == 0) {
|
|
// there are no pointers.
|
|
link_ptr_offset++;
|
|
} else {
|
|
// there are pointers.
|
|
// there are a series of variable-length coded integers, indicating where the pointers are, in
|
|
// the form: seek_amount, number_of_consecutive_pointers, seek_amount,
|
|
// number_of_consecutive_pointers, ... , 0
|
|
|
|
uint32_t code_ptr_offset = code_offset;
|
|
bool fixing = false; // either seeking or fixing
|
|
|
|
while (true) { // loop over entire table
|
|
while (true) { // loop over current mode (fixing/seeking)
|
|
// get count from table
|
|
auto count = data.at(link_ptr_offset);
|
|
link_ptr_offset++;
|
|
|
|
if (!fixing) {
|
|
// then we are seeking
|
|
code_ptr_offset += 4 * count;
|
|
f.stats.total_v2_pointer_seeks++;
|
|
} else {
|
|
// then we are fixing consecutive pointers
|
|
for (uint8_t i = 0; i < count; i++) {
|
|
if (!f.pointer_link_word(0, code_ptr_offset - code_offset, 0,
|
|
*((const uint32_t*)(&data.at(code_ptr_offset))))) {
|
|
// was this just a bug in the linker??
|
|
// lg::error("Skipping link in {} because it is out of range!", name.c_str());
|
|
}
|
|
f.stats.total_v2_pointers++;
|
|
code_ptr_offset += 4;
|
|
}
|
|
}
|
|
|
|
// check if we are done with the current integer
|
|
if (count != 0xff)
|
|
break;
|
|
|
|
// when we "end" an encoded integer on an 0xff, we need an explicit zero byte to change
|
|
// modes. this handles this special case.
|
|
if (data.at(link_ptr_offset) == 0) {
|
|
link_ptr_offset++;
|
|
fixing = !fixing;
|
|
}
|
|
}
|
|
|
|
// mode ended, switch
|
|
fixing = !fixing;
|
|
|
|
// we got a zero, that means we're done with pointer fixing.
|
|
if (data.at(link_ptr_offset) == 0)
|
|
break;
|
|
}
|
|
link_ptr_offset++;
|
|
}
|
|
|
|
// second "section" of link data is a list of symbols to fix up.
|
|
if (data.at(link_ptr_offset) == 0) {
|
|
// no symbols
|
|
} else {
|
|
while (true) {
|
|
uint32_t reloc = data.at(link_ptr_offset);
|
|
link_ptr_offset++;
|
|
|
|
const char* s_name;
|
|
SymbolLinkKind kind;
|
|
|
|
if ((reloc & 0x80) == 0) {
|
|
// it's a symbol
|
|
if (reloc > 9) {
|
|
// always happens.
|
|
link_ptr_offset--;
|
|
} else {
|
|
ASSERT(false);
|
|
}
|
|
|
|
s_name = (const char*)(&data.at(link_ptr_offset));
|
|
kind = SymbolLinkKind::SYMBOL;
|
|
|
|
} else {
|
|
// it's a type
|
|
kind = SymbolLinkKind::TYPE;
|
|
uint8_t method_count = reloc & 0x7f;
|
|
s_name = (const char*)(&data.at(link_ptr_offset));
|
|
if (method_count == 0) {
|
|
method_count = 1;
|
|
// hack which will add 44 methods to _newly created_ types
|
|
// I assume the thing generating V2 objects didn't know about method counts.
|
|
// so this was a "safe" backup - if linking a V2 object requires allocating a type.
|
|
// just be on the safe side.
|
|
// (see the !symbolValue case in intern_type_from_c)
|
|
} else {
|
|
ASSERT(false);
|
|
}
|
|
}
|
|
|
|
if (std::string("_empty_") == s_name) {
|
|
ASSERT(kind == SymbolLinkKind::SYMBOL);
|
|
kind = SymbolLinkKind::EMPTY_LIST;
|
|
}
|
|
|
|
link_ptr_offset += strlen(s_name) + 1;
|
|
f.stats.total_v2_symbol_count++;
|
|
link_ptr_offset = c_symlink2(f, data, code_offset, link_ptr_offset, kind, s_name, 0, dts);
|
|
if (data.at(link_ptr_offset) == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
// check length
|
|
ASSERT(link_header_v2->length == align64(link_ptr_offset - link_data_offset + 1));
|
|
size_t expected_end = header->version == 4 ? data.size() : link_header_v2->length;
|
|
while (link_ptr_offset < expected_end) {
|
|
ASSERT(data.at(link_ptr_offset) == 0);
|
|
link_ptr_offset++;
|
|
}
|
|
}
|
|
|
|
static void assert_string_empty_after(const char* str, int size) {
|
|
auto ptr = str;
|
|
while (*ptr)
|
|
ptr++;
|
|
while (ptr - str < size) {
|
|
ASSERT(!*ptr);
|
|
ptr++;
|
|
}
|
|
}
|
|
|
|
static void link_v5(LinkedObjectFile& f,
|
|
const std::vector<uint8_t>& data,
|
|
const std::string& name,
|
|
DecompilerTypeSystem& dts) {
|
|
auto header = (const LinkHeaderV5*)(&data.at(0));
|
|
|
|
// for jak 3, both code and data use a "v5" format for linking.
|
|
// code has 3 segments (top-level, main, debug), and data has just 1.
|
|
// they appear to be generated by different programs, so there's some hard-coded checks for
|
|
// each.
|
|
|
|
// the "v5" format allows for multiple segments (like v3), "split-pointer" linking to support
|
|
// splitting a pointer link between a lui/ori instruction (needed for code), but uses "v2"
|
|
// symbol linking. For a reason that I don't understand, "v3" symlinks uses a less-space efficient
|
|
// encoding of large integers.
|
|
|
|
static_assert(0x50 == sizeof(LinkHeaderV5));
|
|
|
|
if (header->n_segments == 3) {
|
|
ASSERT(header->type_tag == 0);
|
|
ASSERT(name == header->name);
|
|
// the linker for code placed the link data at the beginning.
|
|
// but we expect the link data to start just after the object file header
|
|
ASSERT(header->length_to_get_to_link == sizeof(LinkHeaderV5));
|
|
// and then the code sould come after that
|
|
ASSERT(header->length_to_get_to_code == sizeof(LinkHeaderV5) + header->link_length);
|
|
} else if (header->n_segments == 1) {
|
|
ASSERT(header->type_tag == UINT32_MAX);
|
|
// name is inconsistent, so don't check is
|
|
// data files have the data first, which is good, as the last object in a DGO gets loaded
|
|
// directly to the heap, and putting the data first means that we can "free" the link data just
|
|
// by bumping the heap pointer back, rather than memcpy the code back to cover the hole if link
|
|
// data came first.
|
|
// the offset is always 0x80, which is bigger than the header, but is needed to make data
|
|
// aligned with the PS2's cache line size (64 bytes), which makes sense.
|
|
ASSERT(header->length_to_get_to_code == 0x80);
|
|
} else {
|
|
lg::die("bad segment count {}", header->n_segments);
|
|
}
|
|
f.set_segment_count(header->n_segments);
|
|
|
|
// todo - check this against the code size we actually got.
|
|
// size_t expected_code_size = data.size() - (header->link_length + 0x50);
|
|
|
|
const int n_segs = header->n_segments;
|
|
|
|
// the first think in the link data is the segment info array, which we need to find stuff.
|
|
const SegmentInfo* seg_info_array =
|
|
(const SegmentInfo*)(data.data() + header->length_to_get_to_link);
|
|
|
|
// for convenience, we'll find the data/link offsets for each segment.
|
|
uint32_t segment_data_offsets[3];
|
|
uint32_t segment_link_offsets[3];
|
|
uint32_t segment_link_ends[3]; // set in linking, once we get to the end.
|
|
for (int i = 0; i < n_segs; i++) {
|
|
segment_data_offsets[i] = header->length_to_get_to_code + seg_info_array[i].data;
|
|
segment_link_offsets[i] = header->length_to_get_to_link + seg_info_array[i].relocs;
|
|
ASSERT(seg_info_array[i].magic == 1); // if set, always use symlink2.
|
|
}
|
|
|
|
// check that the data region is filled
|
|
for (int i = 0; i < n_segs - 1; i++) {
|
|
ASSERT(align16(segment_data_offsets[i] + seg_info_array[i].size) ==
|
|
segment_data_offsets[i + 1]);
|
|
}
|
|
if (n_segs == 3) {
|
|
ASSERT(align16(segment_data_offsets[2] + seg_info_array[2].size) == data.size());
|
|
}
|
|
|
|
// loop over segments
|
|
for (int seg_id = n_segs; seg_id-- > 0;) {
|
|
int segment_size = seg_info_array[seg_id].size;
|
|
if (segment_size == 0) {
|
|
continue;
|
|
}
|
|
|
|
// the decompiler uses 4-byte words, so pad to 4-bytes.
|
|
while (segment_size % 4) {
|
|
segment_size++;
|
|
}
|
|
|
|
// set up pointers for linker.
|
|
auto base_ptr = segment_data_offsets[seg_id];
|
|
auto data_ptr = base_ptr - 4;
|
|
auto link_ptr = segment_link_offsets[seg_id];
|
|
|
|
ASSERT((data_ptr % 4) == 0);
|
|
ASSERT((segment_size % 4) == 0);
|
|
|
|
// add data to the decompiler.
|
|
auto code_start = (const uint32_t*)(&data.at(data_ptr + 4));
|
|
auto code_end = ((const uint32_t*)(&data.at(data_ptr + segment_size))) + 1;
|
|
for (auto x = code_start; x < code_end; x++) {
|
|
f.push_back_word_to_segment(*((const uint32_t*)x), seg_id);
|
|
}
|
|
|
|
// pointer linking.
|
|
bool fixing = false;
|
|
if (data.at(link_ptr)) {
|
|
// we have pointers
|
|
while (true) {
|
|
while (true) {
|
|
if (!fixing) {
|
|
// seeking
|
|
data_ptr += 4 * data.at(link_ptr);
|
|
f.stats.v3_pointer_seeks++;
|
|
} else {
|
|
// fixing.
|
|
for (uint32_t i = 0; i < data.at(link_ptr); i++) {
|
|
f.stats.v3_pointers++;
|
|
uint32_t old_code = *(const uint32_t*)(&data.at(data_ptr));
|
|
if ((old_code >> 24) == 0) {
|
|
f.stats.v3_word_pointers++;
|
|
if (!f.pointer_link_word(seg_id, data_ptr - base_ptr, seg_id, old_code)) {
|
|
// the art groups just have bogus links. we ignored them in jak 2, so do the same
|
|
// here. The joint-anim-compressed-control's have a few bogus frames at the end.
|
|
}
|
|
} else {
|
|
f.stats.v3_split_pointers++;
|
|
auto dest_seg = (old_code >> 8) & 0xf;
|
|
auto lo_hi_offset = (old_code >> 12) & 0xf;
|
|
ASSERT(lo_hi_offset);
|
|
ASSERT(dest_seg < 3);
|
|
auto offset_upper = old_code & 0xff;
|
|
uint32_t low_code = *(const uint32_t*)(&data.at(data_ptr + 4 * lo_hi_offset));
|
|
uint32_t offset = low_code & 0xffff;
|
|
if (offset_upper) {
|
|
offset += (offset_upper << 16);
|
|
}
|
|
f.pointer_link_split_word(seg_id, data_ptr - base_ptr,
|
|
data_ptr + 4 * lo_hi_offset - base_ptr, dest_seg, offset);
|
|
}
|
|
data_ptr += 4;
|
|
}
|
|
}
|
|
|
|
if (data.at(link_ptr) != 0xff)
|
|
break;
|
|
link_ptr++;
|
|
if (data.at(link_ptr) == 0) {
|
|
link_ptr++;
|
|
fixing = !fixing;
|
|
}
|
|
}
|
|
|
|
link_ptr++;
|
|
fixing = !fixing;
|
|
if (data.at(link_ptr) == 0)
|
|
break;
|
|
}
|
|
}
|
|
link_ptr++;
|
|
|
|
// symbol linking.
|
|
if (data.at(link_ptr)) {
|
|
auto sub_link_ptr = link_ptr;
|
|
|
|
while (true) {
|
|
auto reloc = data.at(sub_link_ptr);
|
|
auto next_link_ptr = sub_link_ptr + 1;
|
|
link_ptr = next_link_ptr;
|
|
|
|
if ((reloc & 0x80) == 0) {
|
|
link_ptr = sub_link_ptr + 3; //
|
|
const char* sname = (const char*)(&data.at(link_ptr));
|
|
link_ptr += strlen(sname) + 1;
|
|
// todo segment data offsets...
|
|
|
|
if (std::string("_empty_") == sname) {
|
|
link_ptr = c_symlink2(f, data, segment_data_offsets[seg_id], link_ptr,
|
|
SymbolLinkKind::EMPTY_LIST, sname, seg_id, dts);
|
|
} else {
|
|
link_ptr = c_symlink2(f, data, segment_data_offsets[seg_id], link_ptr,
|
|
SymbolLinkKind::SYMBOL, sname, seg_id, dts);
|
|
}
|
|
} else if ((reloc & 0x3f) == 0x3f) {
|
|
ASSERT(false); // todo, does this ever get hit?
|
|
} else {
|
|
/*
|
|
int n_methods_base = reloc & 0x3f;
|
|
int n_methods = n_methods_base * 4;
|
|
if (n_methods_base) {
|
|
n_methods += 3;
|
|
}
|
|
*/
|
|
link_ptr += 2; // ghidra misses some aliasing here and would have you think this is +1!
|
|
const char* sname = (const char*)(&data.at(link_ptr));
|
|
link_ptr += strlen(sname) + 1;
|
|
link_ptr = c_symlink2(f, data, segment_data_offsets[seg_id], link_ptr,
|
|
SymbolLinkKind::TYPE, sname, seg_id, dts);
|
|
}
|
|
|
|
sub_link_ptr = link_ptr;
|
|
if (!data.at(sub_link_ptr))
|
|
break;
|
|
}
|
|
}
|
|
segment_link_ends[seg_id] = link_ptr;
|
|
}
|
|
|
|
if (n_segs == 3) {
|
|
ASSERT(segment_link_offsets[0] == 128);
|
|
|
|
if (seg_info_array[0].size) {
|
|
ASSERT(segment_link_ends[0] + 1 == segment_link_offsets[1]);
|
|
} else {
|
|
ASSERT(segment_link_offsets[0] + 2 == segment_link_offsets[1]);
|
|
}
|
|
|
|
if (seg_info_array[1].size) {
|
|
ASSERT(segment_link_ends[1] + 1 == segment_link_offsets[2]);
|
|
} else {
|
|
ASSERT(segment_link_offsets[1] + 2 == segment_link_offsets[2]);
|
|
}
|
|
|
|
ASSERT(align16(segment_link_ends[2] + 2) == segment_data_offsets[0]);
|
|
}
|
|
}
|
|
|
|
static void link_v3(LinkedObjectFile& f,
|
|
const std::vector<uint8_t>& data,
|
|
const std::string& name,
|
|
DecompilerTypeSystem& dts,
|
|
GameVersion game_version) {
|
|
auto header = (const LinkHeaderV3*)(&data.at(0));
|
|
ASSERT(name == header->name);
|
|
ASSERT(header->segments == 3);
|
|
|
|
f.set_segment_count(3);
|
|
assert_string_empty_after(header->name, 64);
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
ASSERT(header->segment_info[i].magic == 0);
|
|
// printf(" [%d] %d %d %d %d\n", i, header->segment_info[i].size,
|
|
// header->segment_info[i].data, header->segment_info[i].magic,
|
|
// header->segment_info[i].relocs);
|
|
}
|
|
|
|
f.stats.v3_link_bytes += header->length;
|
|
uint32_t data_ptr_offset = header->length;
|
|
|
|
uint32_t segment_data_offsets[3];
|
|
uint32_t segment_link_offsets[3];
|
|
uint32_t segment_link_ends[3];
|
|
for (int i = 0; i < 3; i++) {
|
|
segment_data_offsets[i] = data_ptr_offset + header->segment_info[i].data;
|
|
segment_link_offsets[i] = header->segment_info[i].relocs;
|
|
}
|
|
|
|
// check that the data region is filled
|
|
for (int i = 0; i < 2; i++) {
|
|
ASSERT(align16(segment_data_offsets[i] + header->segment_info[i].size) ==
|
|
segment_data_offsets[i + 1]);
|
|
}
|
|
ASSERT(align16(segment_data_offsets[2] + header->segment_info[2].size) == data.size());
|
|
|
|
// todo - check link region is filled.
|
|
|
|
// loop over segments (reverse order for now)
|
|
for (int seg_id = 3; seg_id-- > 0;) {
|
|
// ?? is this right?
|
|
if (header->segment_info[seg_id].size == 0)
|
|
continue;
|
|
|
|
auto segment_size = header->segment_info[seg_id].size;
|
|
f.stats.v3_code_bytes += segment_size;
|
|
|
|
// HACK!
|
|
// why is this a thing?
|
|
// HACK!
|
|
if (game_version == GameVersion::Jak1 && name == "level-h" && seg_id == 0) {
|
|
segment_size++;
|
|
}
|
|
|
|
if (game_version >= GameVersion::Jak2) {
|
|
while (segment_size % 4) {
|
|
segment_size++;
|
|
}
|
|
}
|
|
|
|
auto base_ptr = segment_data_offsets[seg_id];
|
|
auto data_ptr = base_ptr - 4;
|
|
auto link_ptr = segment_link_offsets[seg_id];
|
|
|
|
ASSERT((data_ptr % 4) == 0);
|
|
ASSERT((segment_size % 4) == 0);
|
|
|
|
auto code_start = (const uint32_t*)(&data.at(data_ptr + 4));
|
|
auto code_end = ((const uint32_t*)(&data.at(data_ptr + segment_size))) + 1;
|
|
for (auto x = code_start; x < code_end; x++) {
|
|
f.push_back_word_to_segment(*((const uint32_t*)x), seg_id);
|
|
}
|
|
bool fixing = false;
|
|
|
|
if (data.at(link_ptr)) {
|
|
// we have pointers
|
|
while (true) {
|
|
while (true) {
|
|
if (!fixing) {
|
|
// seeking
|
|
data_ptr += 4 * data.at(link_ptr);
|
|
f.stats.v3_pointer_seeks++;
|
|
} else {
|
|
// fixing.
|
|
for (uint32_t i = 0; i < data.at(link_ptr); i++) {
|
|
f.stats.v3_pointers++;
|
|
uint32_t old_code = *(const uint32_t*)(&data.at(data_ptr));
|
|
if ((old_code >> 24) == 0) {
|
|
f.stats.v3_word_pointers++;
|
|
if (!f.pointer_link_word(seg_id, data_ptr - base_ptr, seg_id, old_code)) {
|
|
printf("WARNING bad pointer_link_word (2) in %s\n", name.c_str());
|
|
}
|
|
} else {
|
|
f.stats.v3_split_pointers++;
|
|
auto dest_seg = (old_code >> 8) & 0xf;
|
|
auto lo_hi_offset = (old_code >> 12) & 0xf;
|
|
ASSERT(lo_hi_offset);
|
|
ASSERT(dest_seg < 3);
|
|
auto offset_upper = old_code & 0xff;
|
|
// ASSERT(offset_upper == 0);
|
|
uint32_t low_code = *(const uint32_t*)(&data.at(data_ptr + 4 * lo_hi_offset));
|
|
uint32_t offset = low_code & 0xffff;
|
|
if (offset_upper) {
|
|
// seems to work fine, no need to warn.
|
|
// printf("WARNING - offset upper is set in %s\n", name.c_str());
|
|
offset += (offset_upper << 16);
|
|
}
|
|
f.pointer_link_split_word(seg_id, data_ptr - base_ptr,
|
|
data_ptr + 4 * lo_hi_offset - base_ptr, dest_seg, offset);
|
|
}
|
|
data_ptr += 4;
|
|
}
|
|
}
|
|
|
|
if (data.at(link_ptr) != 0xff)
|
|
break;
|
|
link_ptr++;
|
|
if (data.at(link_ptr) == 0) {
|
|
link_ptr++;
|
|
fixing = !fixing;
|
|
}
|
|
}
|
|
|
|
link_ptr++;
|
|
fixing = !fixing;
|
|
if (data.at(link_ptr) == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
link_ptr++;
|
|
|
|
while (data.at(link_ptr)) {
|
|
auto reloc = data.at(link_ptr);
|
|
SymbolLinkKind kind;
|
|
link_ptr++;
|
|
|
|
const char* s_name = nullptr;
|
|
if ((reloc & 0x80) == 0) {
|
|
// it's a symbol
|
|
kind = SymbolLinkKind::SYMBOL;
|
|
link_ptr--;
|
|
s_name = (const char*)(&data.at(link_ptr));
|
|
} else {
|
|
s_name = (const char*)(&data.at(link_ptr));
|
|
switch (game_version) {
|
|
case GameVersion::Jak1:
|
|
dts.ts.forward_declare_type_method_count(s_name, (reloc & 0x7f));
|
|
break;
|
|
case GameVersion::Jak2:
|
|
dts.ts.forward_declare_type_method_count_multiple_of_4(s_name, (reloc & 0x7f) * 4 + 3);
|
|
break;
|
|
default:
|
|
ASSERT(false);
|
|
}
|
|
kind = SymbolLinkKind::TYPE;
|
|
}
|
|
|
|
if (std::string("_empty_") == s_name) {
|
|
ASSERT(kind == SymbolLinkKind::SYMBOL);
|
|
kind = SymbolLinkKind::EMPTY_LIST;
|
|
}
|
|
|
|
link_ptr += strlen(s_name) + 1;
|
|
f.stats.v3_symbol_count++;
|
|
link_ptr = c_symlink3(f, data, base_ptr, link_ptr, kind, s_name, seg_id, dts);
|
|
}
|
|
segment_link_ends[seg_id] = link_ptr;
|
|
}
|
|
|
|
ASSERT(segment_link_offsets[0] == 128);
|
|
|
|
if (header->segment_info[0].size) {
|
|
ASSERT(segment_link_ends[0] + 1 == segment_link_offsets[1]);
|
|
} else {
|
|
ASSERT(segment_link_offsets[0] + 2 == segment_link_offsets[1]);
|
|
}
|
|
|
|
if (header->segment_info[1].size) {
|
|
ASSERT(segment_link_ends[1] + 1 == segment_link_offsets[2]);
|
|
} else {
|
|
ASSERT(segment_link_offsets[1] + 2 == segment_link_offsets[2]);
|
|
}
|
|
|
|
ASSERT(align16(segment_link_ends[2] + 2) == segment_data_offsets[0]);
|
|
}
|
|
|
|
/*!
|
|
* Main function to generate LinkedObjectFiles from raw object data.
|
|
*/
|
|
LinkedObjectFile to_linked_object_file(const std::vector<uint8_t>& data,
|
|
const std::string& name,
|
|
DecompilerTypeSystem& dts,
|
|
GameVersion game_version) {
|
|
LinkedObjectFile result(game_version);
|
|
const auto* header = (const LinkHeaderCommon*)&data.at(0);
|
|
|
|
// use appropriate linker
|
|
if (header->version == 3) {
|
|
ASSERT(header->type_tag == 0);
|
|
link_v3(result, data, name, dts, game_version);
|
|
} else if (header->version == 4 || header->version == 2) {
|
|
ASSERT(header->type_tag == 0xffffffff);
|
|
link_v2_or_v4(result, data, name, dts, game_version);
|
|
} else if (header->version == 5) {
|
|
link_v5(result, data, name, dts);
|
|
} else {
|
|
ASSERT_MSG(false, fmt::format("Unsupported version {}", header->version));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
} // namespace decompiler
|