auto decompile more functions

6 files changed, 191 insertions, 34 deletions

diff --git a/tools/libdol2asm/data/base.py b/tools/libdol2asm/data/base.py
index 6ceada5eb9..6878ca1341 100644
--- a/tools/libdol2asm/data/base.py
+++ b/tools/libdol2asm/data/base.py
@@ -84,6 +84,12 @@ class ArbitraryData(Symbol):
             self.size // self.element_size,
             self.padding // self.element_size)
 
+    def return_type(self):
+        array_type = self.array_type()
+        if isinstance(array_type, ArrayType) or isinstance(array_type, PaddingArrayType)  or isinstance(array_type, ZeroArrayType):
+            return PointerType(array_type.base)
+        return array_type
+
     def cpp_reference(self, accessor, addr):
         name = self.declaration_name(forward=False, c_export=False,full_qualified_name=True)
         if addr == self.addr:
@@ -92,6 +98,14 @@ class ArbitraryData(Symbol):
             offset = addr - self.addr
             return f"(((char*)&{name})+0x{offset:X})"
 
+    def cpp_load(self, accessor, addr):
+        name = self.declaration_name(forward=False, c_export=False,full_qualified_name=True)
+        if addr == self.addr:
+            return f"{name}"
+        else:
+            offset = addr - self.addr
+            return f"*(((char*)&{name})+0x{offset:X})"
+
     def declaration_name(self, forward: bool,
                          c_export: bool,
                          full_qualified_name: bool):
diff --git a/tools/libdol2asm/data/function/ret.py b/tools/libdol2asm/data/function/ret.py
index bf15e02e9b..aed96c2315 100644
--- a/tools/libdol2asm/data/function/ret.py
+++ b/tools/libdol2asm/data/function/ret.py
@@ -6,16 +6,39 @@ from .base import *
 
 @dataclass(eq=False)
 class ReturnFunction(Function):
-    return_value: str = None
-
-    def export_return_value(self):
-        return self.return_value
+    def export_return_value(self, symbol_table):
+        assert False
 
     async def export_function_body(self, exporter, builder: AsyncBuilder):
-        return_value = self.export_return_value()
+        return_value = self.export_return_value(exporter.gst)
         await builder.write(f" {{")
         if return_value:
             await builder.write(f"\treturn {return_value};")
         else:
             await builder.write(f"\t/* empty function */")
         await builder.write(f"}}")
+
+@dataclass(eq=False)
+class CustomReturnFunction(ReturnFunction):
+    return_value: str = None
+
+    def export_return_value(self, symbol_table):
+        return self.return_value
+
+@dataclass(eq=False)
+class SymbolReturnFunction(ReturnFunction):
+    symbol_addr: int = 0
+    load_or_reference: bool = True
+
+    def gather_references(self, context, valid_range):
+        self.references = set([ self.symbol_addr ])
+
+    def export_return_value(self, symbol_table):
+        symbol = symbol_table[-1, self.symbol_addr]
+        assert symbol
+        name = symbol.cpp_reference(self, self.symbol_addr)
+        type = PointerType(self.return_type)
+        dereference = ""
+        if self.load_or_reference:
+            dereference = "*"
+        return f"{dereference}({type.type()})({name})"
diff --git a/tools/libdol2asm/data/reference_array.py b/tools/libdol2asm/data/reference_array.py
index 1b05b92342..d5d5fdf918 100644
--- a/tools/libdol2asm/data/reference_array.py
+++ b/tools/libdol2asm/data/reference_array.py
@@ -33,6 +33,7 @@ class ReferenceArray(ArbitraryData):
 
     def values(self):
         return Integer.u32_from(self.data)
+        
     def gather_references(self, context, valid_range):
         self.references = [ addr for addr in self.values() if addr in valid_range ]
 
diff --git a/tools/libdol2asm/data/symbol.py b/tools/libdol2asm/data/symbol.py
index 5a708fb361..9a75d16bb6 100644
--- a/tools/libdol2asm/data/symbol.py
+++ b/tools/libdol2asm/data/symbol.py
@@ -139,6 +139,12 @@ class Symbol:
                 f"invalid reference addr 0x{addr:08X} for {type(self).__name__}\n{self}")
         return f"&{self.identifier.label}"
 
+    def cpp_load(self, accessor, addr):
+        if addr != self.addr:
+            raise Dol2ZelException(
+                f"invalid reference addr 0x{addr:08X} for {type(self).__name__}\n{self}")
+        return f"{self.identifier.label}"
+
     def asm_reference(self, addr):
         if addr != self.addr:
             return None
@@ -147,6 +153,9 @@ class Symbol:
     def gather_references(self, context, valid_range):
         pass
 
+    def get_reference_information(self, context, symbol_table):
+        pass
+
     def types(self):
         return set()
 
diff --git a/tools/libdol2asm/generate_functions.py b/tools/libdol2asm/generate_functions.py
index 8df6a6c8e9..90fd2354e7 100644
--- a/tools/libdol2asm/generate_functions.py
+++ b/tools/libdol2asm/generate_functions.py
@@ -1,6 +1,10 @@
 import struct

 

+from capstone import *

+from capstone.ppc import *

+

 from . import linker_map

+from . import disassemble

 from .types import *

 from .data import *

 

@@ -159,6 +163,61 @@ def is_load_global_function(data: bytearray) -> Tuple[bool, int, str, int]:
 

     return False, None, None, None

 

+# TODO: @!game move

+R2_ADDR = 0x80459A00

+R13_ADDR = 0x80458580

+

+RETURN_SYMBOL_LOAD_INSTS = {

+    PPC_INS_LWZ,

+    PPC_INS_LHZ,

+    PPC_INS_LBZ,

+}

+

+RETURN_SYMBOL_TYPE = {

+    PPC_INS_LWZ: U32,

+    PPC_INS_LHZ: U16,

+    PPC_INS_LBZ: U8,

+}

+

+def decompile_return_symbol_function(symbol, block, insts, symbol_table) -> Function:

+    if len(insts) != 2:

+        return None

+

+    load = insts[0]

+    ret = insts[1]

+

+    if ret.id != PPC_INS_BLR:

+        return None

+    if not load.id in RETURN_SYMBOL_LOAD_INSTS:

+        return None

+    

+    address = 0

+    mem_base = load.operands[1].mem.base

+    mem_disp = load.operands[1].mem.disp

+    if mem_base == PPC_REG_R2:

+        address = R2_ADDR + disassemble.sign_extend_16(mem_disp)

+    elif mem_base == PPC_REG_R13:

+        address = R13_ADDR + disassemble.sign_extend_16(mem_disp)

+    else:

+        return None

+

+    return_symbol = symbol_table[-1, address]

+    if not return_symbol:

+        return None

+

+    # structure does not work :(

+    if isinstance(return_symbol, Structure):

+        return None

+

+    return SymbolReturnFunction(

+        symbol.identifier,

+        addr=symbol.addr,

+        size=symbol.size,

+        padding=symbol.padding,

+        alignment=0,

+        return_type=RETURN_SYMBOL_TYPE[load.id],

+        symbol_addr=address)

+    

 

 def from_group(section: Section, group: List[linker_map.Symbol]) -> Function:

     """

@@ -169,35 +228,38 @@ def from_group(section: Section, group: List[linker_map.Symbol]) -> Function:
     if len(group) == 1:

         block = group[0]

         data = section.get_data(block.start, block.end)

-        if is_return_function(data):

-            return [ReturnFunction(

-                Identifier("func", block.start, block.name),

-                addr=block.addr,

-                size=block.size,

-                padding=block.padding,

-                alignment=0,

-                return_type=VOID)]

-

-        if is_return_integer_function(data):

-            integer_value = get_short_value(data)

-            if integer_value == 0:

-                value = "false"

-                type = BOOL

-            elif integer_value == 1:

-                value = "true"

-                type = BOOL

-            else:

-                value = f"{integer_value}"

-                type = S32

-

-            return [ReturnFunction(

-                Identifier("func", block.start, block.name),

-                addr=block.addr,

-                size=block.size,

-                padding=block.padding,

-                alignment=0,

-                return_type=type,

-                return_value=value)]

+        if len(data) >= 4 and len(data) < 16:   

+            insts = list(disassemble.cs.disasm(data, block.start))

+

+            if is_return_function(data):

+                return [CustomReturnFunction(

+                    Identifier("func", block.start, block.name),

+                    addr=block.addr,

+                    size=block.size,

+                    padding=block.padding,

+                    alignment=0,

+                    return_type=VOID)]

+

+            if is_return_integer_function(data):

+                integer_value = get_short_value(data)

+                if integer_value == 0:

+                    value = "false"

+                    type = BOOL

+                elif integer_value == 1:

+                    value = "true"

+                    type = BOOL

+                else:

+                    value = f"{integer_value}"

+                    type = S32

+

+                return [CustomReturnFunction(

+                    Identifier("func", block.start, block.name),

+                    addr=block.addr,

+                    size=block.size,

+                    padding=block.padding,

+                    alignment=0,

+                    return_type=type,

+                    return_value=value)]

 

     first = group[0]

     if first.size <= 0:

@@ -208,3 +270,44 @@ def from_group(section: Section, group: List[linker_map.Symbol]) -> Function:
 

     # the function was not decompilable

     return [ASMFunction.create(section, group)]

+

+def decompile_symbol(context, section, symbol, symbol_table, add_list, remove_list):

+    if not isinstance(symbol, ASMFunction):

+        return symbol

+    if len(symbol.blocks) > 1:

+        return symbol

+

+    block = symbol.blocks[0]

+    data = symbol.data[block.start-symbol.start:block.end-symbol.start]

+    if len(data) <= 0 or len(data) > 16:

+        return symbol

+

+    insts = list(disassemble.cs.disasm(data, block.start))

+    function = decompile_return_symbol_function(symbol, block, insts, symbol_table)

+    if function:

+        function.set_mlts(symbol._module, symbol._library, symbol._translation_unit, symbol._section)

+        assert function.addr == symbol.addr

+        assert function.size == symbol.size

+        add_list.add(function)

+        remove_list.discard(symbol)

+        return function

+

+    #if symbol.size == 8:

+    #    context.debug(f"{symbol.addr:08X} {symbol.name}")

+

+    return symbol

+

+def decompile(context, libraries, symbol_table):

+    remove_list = set()

+    add_list = set()

+    for lib in libraries:

+        for tu in lib.translation_units.values():

+            for section in tu.sections.values():

+                if section.name != ".text" and section.name != ".init":

+                    continue

+                symbols = []

+                for symbol in section.symbols:

+                    symbols.append(decompile_symbol(context, section, symbol, symbol_table, add_list, remove_list))

+                section.symbols = symbols

+    return add_list, remove_list

+        
\ No newline at end of file
diff --git a/tools/libdol2asm/split_asm.py b/tools/libdol2asm/split_asm.py
index 3b09ca3a9e..48621034b5 100644
--- a/tools/libdol2asm/split_asm.py
+++ b/tools/libdol2asm/split_asm.py
@@ -300,6 +300,12 @@ class Dol2AsmSplitter:
             for symbol in add_list:
                 self.symbol_table.add_symbol(symbol)
 
+            add_list, remove_list = generate_functions.decompile(self.context, libs, self.symbol_table)
+            for symbol in remove_list:
+                self.symbol_table.remove_symbol(symbol)
+            for symbol in add_list:
+                self.symbol_table.add_symbol(symbol)
+
     def name_symbols(self):
         print(f"{self.step_count:2} Naming")
         self.step_count += 1
@@ -658,6 +664,7 @@ class Dol2AsmSplitter:
 
         self.search_binary(cache)
 
+        cache = True
         start_time = time.time()
         cache_path = Path("build/full_cache_xx.dump")
         if cache and cache_path.exists():