Allow IDO 7.1 to be used for certain files

Author: Francessco121

docs/Guide.md

@@ -355,10 +355,13 @@ The flag combinations currently known for the decomp are:
 - `-O2 -g3` - The default. Used for almost everything.
 - `-O2 -g0` - Used for compiling *modified* libultra code.
 - `-O1 -g0` - Used for compiling *unmodified* libultra code.
+- `-O1 -g2` - Used for libnaudio code.
 
 Sometimes, to get a function to match you will need to change the optimization and debugging levels that the containing file is compiled with. This can be done by adding the comment `// @DECOMP_OPT_FLAGS=<opt flags>` to the top of the file. For example, `// @DECOMP_OPT_FLAGS=-O1` would compile the file with the optimization flag `-O1` instead of the default.
 
-> Note: The build script must be re-configured for the new optimization flags to take effect (`./dino.py configure`).
+Additionally, you may need a different version of IDO. This can be set by adding the comment `// @DECOMP_IDO_VERSION=<version>` to the top of the file. Only versions `5.3` (default) and `7.1` are available currently.
+
+> Note: The build script must be re-configured for the new optimization flags/compiler to take effect (`./dino.py configure`).
 
 
 ## 6. DLL Decompilation

tools/configure.py

@@ -20,18 +20,29 @@
 SCRIPT_DIR = Path(os.path.dirname(os.path.realpath(__file__)))
 
 opt_flags_pattern = re.compile(r"@DECOMP_OPT_FLAGS\s*=\s*(.*)\s*")
+ido_version_pattern = re.compile(r"@DECOMP_IDO_VERSION\s*=\s*(.*)\s*")
+
+IDO_VAR_MAP = {
+    "5.3": "$IDO_53",
+    "7.1": "$IDO_71"
+}
+
+class BuildFileConfig:
+    def __init__(self, opt: "str | None", ido_version: "str | None"):
+        self.opt = opt
+        self.ido_version = ido_version
 
 class BuildFileType(Enum):
     C = 1
     ASM = 2
     BIN = 3
 
 class BuildFile:
-    def __init__(self, src_path: str, obj_path: str, type: BuildFileType, opt: "str | None"=None):
+    def __init__(self, src_path: str, obj_path: str, type: BuildFileType, config: BuildFileConfig | None=None):
         self.src_path = src_path
         self.obj_path = obj_path
         self.type = type
-        self.opt = opt
+        self.config = config
 
 class DLL:
     def __init__(self, number: str, dir: str, files: "list[BuildFile]"):
@@ -178,19 +189,17 @@ def __write_prelude(self):
         # Write tools
         cross = self.__detect_cross()
         exe_suffix = ".exe" if sys.platform == "win32" else ""
+        ido_recomp_platform = "windows" if sys.platform == "win32" else "linux"
 
         self.writer.comment("Tools")
         self.writer.variable("AS", f"{cross}as{exe_suffix}")
         self.writer.variable("LD", f"{cross}ld{exe_suffix}")
         self.writer.variable("OBJCOPY", f"{cross}objcopy{exe_suffix}")
-        if sys.platform == "win32":
-            self.writer.variable("CC", "tools/ido_recomp/windows/5.3/cc.exe")
-        else:
-            self.writer.variable("CC", "tools/ido_recomp/linux/5.3/cc")
+        self.writer.variable("IDO_53", f"tools/ido_recomp/{ido_recomp_platform}/5.3/cc{exe_suffix}")
+        self.writer.variable("IDO_71", f"tools/ido_recomp/{ido_recomp_platform}/7.1/cc{exe_suffix}")
+        self.writer.variable("CC", "$IDO_53")
         self.writer.variable("ASM_PROCESSOR", "python3 tools/asm_processor/build.py")
         self.writer.variable("HEADER_DEPS", "python3 tools/header_deps.py")
-        self.writer.variable("CC_PREPROCESSED", "$ASM_PROCESSOR $CC -- $AS $AS_FLAGS --")
-        self.writer.variable("CC_PREPROCESSED_DLL", "$ASM_PROCESSOR $CC -- $AS $AS_FLAGS_DLL --")
         self.writer.variable("ELF2DLL", "python3 tools/elf2dll.py")
         self.writer.variable("DINODLL", "python3 tools/dino_dll.py")
 
@@ -199,11 +208,11 @@ def __write_prelude(self):
         # Write rules
         self.writer.comment("Rules")
         self.writer.rule("cc", 
-            "$HEADER_DEPS $CC_PREPROCESSED -c $CC_FLAGS $OPT_FLAGS -o $out $in", 
+            "$HEADER_DEPS $ASM_PROCESSOR $CC -- $AS $AS_FLAGS -- -c $CC_FLAGS $OPT_FLAGS -o $out $in", 
             "Compiling $in...",
             depfile="$out.d")
         self.writer.rule("cc_dll", 
-            "$HEADER_DEPS $CC_PREPROCESSED_DLL -c $CC_FLAGS_DLL $OPT_FLAGS -o $out $in", 
+            "$HEADER_DEPS $ASM_PROCESSOR $CC -- $AS $AS_FLAGS_DLL -- -c $CC_FLAGS_DLL $OPT_FLAGS -o $out $in", 
             "Compiling $in...",
             depfile="$out.d")
         self.writer.rule("as", "$AS $AS_FLAGS -o $out $in", "Assembling $in...")
@@ -231,10 +240,7 @@ def __write_file_builds(self):
 
         for file in self.input.files:
             # Determine variables
-            variables: dict[str, str] = {}
-            opt = file.opt
-            if opt is not None and opt != self.config.default_opt_flags:
-                variables["OPT_FLAGS"] = opt
+            variables: dict[str, str] = self.__file_config_to_variables(file.config)
 
             # Determine command
             command: str
@@ -267,10 +273,7 @@ def __write_dll_builds(self):
             dll_link_deps: "list[str]" = []
             for file in dll.files:
                 # Determine variables
-                variables: dict[str, str] = {}
-                opt = file.opt
-                if opt is not None and opt != self.config.default_opt_flags:
-                    variables["OPT_FLAGS"] = opt
+                variables: dict[str, str] = self.__file_config_to_variables(file.config)
 
                 # Determine command
                 command: str
@@ -392,6 +395,17 @@ def __detect_cross(self) -> str:
         else:
             return "mips-linux-gnu-"
 
+    def __file_config_to_variables(self, file_config: BuildFileConfig | None):
+        variables: dict[str, str] = {}
+        
+        if file_config != None:
+            if file_config.opt != None:
+                variables["OPT_FLAGS"] = file_config.opt
+            if file_config.ido_version != None:
+                variables["CC"] = IDO_VAR_MAP[file_config.ido_version]
+        
+        return variables
+
 class ObjDiffConfigWriter:
     def __init__(self, output_file: TextIO, input: BuildFiles, config: BuildConfig):
         self.output_file = output_file
@@ -462,8 +476,8 @@ def __scan_c_files(self):
         paths = [Path(path) for path in glob.glob("src/**/*.c", recursive=True) if not Path(path).is_relative_to(Path("src/dlls"))]
         for src_path in paths:
             obj_path = self.__make_obj_path(src_path)
-            opt = self.__get_optimization_level(src_path)
-            self.files.append(BuildFile(str(src_path), str(obj_path), BuildFileType.C, opt))
+            file_config = self.__get_file_config(src_path)
+            self.files.append(BuildFile(str(src_path), str(obj_path), BuildFileType.C, file_config))
 
     def __scan_asm_files(self):
         # Exclude splat nonmatchings, those are compiled in with their respective C file
@@ -510,8 +524,8 @@ def __scan_dlls(self):
 
             for src_path in c_paths:
                 obj_path = self.__make_obj_path(src_path)
-                opt = self.__get_optimization_level(src_path)
-                files.append(BuildFile(str(src_path), str(obj_path), BuildFileType.C, opt))
+                file_config = self.__get_file_config(src_path)
+                files.append(BuildFile(str(src_path), str(obj_path), BuildFileType.C, file_config))
 
             for src_path in asm_paths:
                 obj_path = self.__make_obj_path(src_path)
@@ -533,18 +547,35 @@ def __scan_dlls(self):
     def __make_obj_path(self, path: Path) -> str:
         return path.with_suffix('.o')
 
-    def __get_optimization_level(self, path: Path) -> str:
+    def __get_file_config(self, path: Path) -> BuildFileConfig:
+        opt_flags: "str | None" = None
+        ido_version: "str | None" = None
+
         with open(path, "r", encoding="utf-8") as file:
+            found_comments = False
             while True:
                 line = file.readline().strip()
-                if len(line) == 0:
+                if len(line) == 0 and found_comments:
+                    # End on empty line after comment block
                     break
                 if line.startswith("//"):
+                    found_comments = True
+
                     opt_match = opt_flags_pattern.search(line)
                     if opt_match != None:
-                        return opt_match.group(1)
+                        opt_flags = opt_match.group(1)
+                        continue
+                    ido_match = ido_version_pattern.search(line)
+                    if ido_match != None:
+                        ido_version = ido_match.group(1)
+                        continue
+                else:
+                    # End on non-empty non-comment line
+                    break
 
-        return self.config.default_opt_flags
+        return BuildFileConfig(
+            opt=opt_flags, 
+            ido_version=ido_version)
 
     def __get_dll_config(self, dll_dir: Path, number: int) -> DLLBuildConfig | None:
         yaml_path = dll_dir.joinpath("dll.yaml")