splat64 0.36.3__py3-none-any.whl → 0.36.4__py3-none-any.whl

splat/__init__.py

@@ -1,7 +1,7 @@
 __package_name__ = __name__
 
 # Should be synced with pyproject.toml
-__version__ = "0.36.3"
+__version__ = "0.36.4"
 __author__ = "ethteck"
 
 from . import util as util

splat/scripts/create_config.py

@@ -1,15 +1,19 @@
 #! /usr/bin/env python3
 
 import argparse
-import sys
+import hashlib
 from pathlib import Path
+import subprocess
+import sys
+from typing import Optional
 
 from ..util.n64 import find_code_length, rominfo
 from ..util.psx import psxexeinfo
+from ..util.ps2 import ps2elfinfo
 from ..util import log, file_presets, conf
 
 
-def main(file_path: Path):
+def main(file_path: Path, objcopy: Optional[str]):
     if not file_path.exists():
         sys.exit(f"File {file_path} does not exist ({file_path.absolute()})")
     if file_path.is_dir():
@@ -27,6 +31,11 @@ def main(file_path: Path):
         create_psx_config(file_path, file_bytes)
         return
 
+    # Check for ELFs
+    if file_bytes[0:4] == b"\x7fELF":
+        do_elf(file_path, file_bytes, objcopy)
+        return
+
     log.error(f"create_config does not support the file format of '{file_path}'")
 
 
@@ -360,15 +369,208 @@ segments:
     file_presets.write_all_files()
 
 
+def do_elf(elf_path: Path, elf_bytes: bytes, objcopy: Optional[str]):
+    elf = ps2elfinfo.Ps2Elf.get_info(elf_path, elf_bytes)
+    if elf is None:
+        log.error(f"Unsupported elf file '{elf_path}'")
+
+    basename = elf_path.name.replace(" ", "")
+    cleaned_basename = remove_invalid_path_characters(basename)
+
+    rom_name = Path(f"{cleaned_basename}.rom")
+    # Prefer the user objcopy
+    if objcopy is None:
+        objcopy = find_objcopy()
+    objcopy_cmd = run_objcopy(objcopy, str(elf_path), str(rom_name))
+
+    sha1 = hashlib.sha1(rom_name.read_bytes()).hexdigest()
+
+    header = f"""\
+# name: Your game name here!
+sha1: {sha1}
+options:
+  basename: {basename}
+  target_path: {rom_name}
+  elf_path: build/{cleaned_basename}.elf
+  base_path: .
+  platform: ps2
+  compiler: {elf.compiler}
+"""
+
+    if elf.gp is not None:
+        header += f"""
+  gp_value: 0x{elf.gp:08X}
+"""
+        if elf.ld_gp_expression is not None:
+            header += f"  ld_gp_expression: {elf.ld_gp_expression}\n"
+        else:
+            header += "  # ld_gp_expression:\n"
+
+    header += f"""
+  # asm_path: asm
+  # src_path: src
+  # build_path: build
+
+  ld_script_path: {cleaned_basename}.ld
+  ld_dependencies: True
+  ld_wildcard_sections: True
+  ld_bss_contains_common: True
+
+  create_asm_dependencies: True
+
+  find_file_boundaries: False
+
+  o_as_suffix: True
+
+  symbol_addrs_path:
+    - symbol_addrs.txt
+  reloc_addrs_path:
+    - reloc_addrs.txt
+
+  # undefined_funcs_auto_path: undefined_funcs_auto.txt
+  # undefined_syms_auto_path: undefined_syms_auto.txt
+
+  extensions_path: tools/splat_ext
+
+  string_encoding: ASCII
+  data_string_encoding: ASCII
+  rodata_string_guesser_level: 2
+  data_string_guesser_level: 2
+
+  named_regs_for_c_funcs: False
+"""
+
+    header += "\n  section_order:\n"
+    for sect, is_valid in elf.elf_section_names:
+        comment = "" if is_valid else "# "
+        header += f"    {comment}- {sect}\n"
+
+    header += "\n  auto_link_sections:\n"
+    for sect, is_valid in elf.elf_section_names:
+        comment = "" if is_valid else "# "
+        if sect != ".text" and sect != ".vutext":
+            header += f"    {comment}- {sect}\n"
+
+    segments = "\nsegments:"
+    for seg in elf.segs:
+        segments += f"""
+  - name: {seg.name}
+    type: code
+    start: 0x{seg.start:06X}
+    vram: 0x{seg.vram:08X}
+    bss_size: 0x{seg.bss_size:X}
+    subalign: null
+    subsegments:
+"""
+        for section in seg.sections:
+            if section.is_nobits:
+                segments += f"      - {{ type: {section.splat_segment_type}, vram: 0x{section.vram:08X}, name: {seg.name}/{section.vram:08X} }} # {section.name}\n"
+            else:
+                segments += f"      - [0x{section.start:06X}, {section.splat_segment_type}, {seg.name}/{section.start:06X}] # {section.name}\n"
+
+    segments += f"""\
+  - [0x{elf.size:X}]
+"""
+
+    out_file = Path(f"{cleaned_basename}.yaml")
+    with out_file.open("w", newline="\n") as f:
+        print(f"Writing config to {out_file}")
+        f.write(header)
+        f.write(segments)
+
+    # `file_presets` requires an initialized `opts`.
+    # A simple way to do that is to simply load the yaml we just generated.
+    conf.load([out_file])
+    file_presets.write_all_files()
+
+    # Write symbol_addrs.txt file
+    symbol_addrs = []
+    symbol_addrs.append(f"_start = 0x{elf.entrypoint:08X}; // type:func")
+    if symbol_addrs:
+        symbol_addrs.append("")
+        with Path("symbol_addrs.txt").open("w", newline="\n") as f:
+            print("Writing symbol_addrs.txt")
+            f.write(
+                "// Visit https://github.com/ethteck/splat/wiki/Adding-Symbols for documentation about this file\n"
+            )
+            contents = "\n".join(symbol_addrs)
+            f.write(contents)
+
+    # Write other linker script
+    linker_script = []
+    linker_script.append("ENTRY(_start);")
+    if linker_script:
+        linker_script.append("")
+        with Path("linker_script_extra.ld").open("w", newline="\n") as f:
+            print("Writing linker_script_extra.ld")
+            f.write(
+                "/* Pass this file to the linker with the `-T linker_script_extra.ld` flag */\n"
+            )
+            contents = "\n".join(linker_script)
+            f.write(contents)
+
+    print()
+    print(
+        "The generated yaml does not use the actual ELF file as input, but instead it"
+    )
+    print(
+        'uses a "rom" generated from said ELF, which contains the game code without any'
+    )
+    print("of the elf metadata.")
+    print(
+        'Use the following command to generate this "rom". It is recommended to include'
+    )
+    print("this command into your setup/configure script.")
+    print("```")
+    print(" ".join(objcopy_cmd))
+    print("```")
+
+
+def find_objcopy() -> str:
+    # First we try to figure out if the user has objcopy on their pc, and under
+    # which name.
+    # We just try a bunch and hope for the best
+    options = [
+        "mips-linux-gnu-objcopy",
+        "mipsel-linux-gnu-objcopy",
+    ]
+
+    for name in options:
+        sub = subprocess.run([name, "--version"], capture_output=True)
+        if sub.returncode == 0:
+            return name
+
+    msg = "Unable to find objcopy.\nI tried the following list of names:\n"
+    for name in options:
+        msg += f"  - {name}\n"
+    msg += "\nTry to install one of those or use the `--objcopy` flag to pass the name to your own objcopy to me."
+    log.error(msg)
+
+
+def run_objcopy(objcopy_name: str, elf_path: str, rom: str) -> list[str]:
+    cmd = [objcopy_name, "-O", "binary", "--gap-fill=0x00", elf_path, rom]
+    print("Running:", " ".join(cmd))
+    sub = subprocess.run(cmd)
+    if sub.returncode != 0:
+        log.error("Failed to run objcopy")
+    return cmd
+
+
 def add_arguments_to_parser(parser: argparse.ArgumentParser):
     parser.add_argument(
         "file",
-        help="Path to a .z64/.n64 ROM or PSX executable",
+        help="Path to a .z64/.n64 ROM, PSX executable or PS2 ELF",
+        type=Path,
+    )
+    parser.add_argument(
+        "--objcopy",
+        help="Path to an user-provided objcopy program. Only used when processing ELF files",
+        type=str,
     )
 
 
 def process_arguments(args: argparse.Namespace):
-    main(Path(args.file))
+    main(args.file, args.objcopy)
 
 
 script_description = "Create a splat config from an N64 ROM or PSX executable."

splat/segtypes/common/bss.py

@@ -88,7 +88,7 @@ class CommonSegBss(CommonSegData):
 
         for spim_sym in self.spim_section.get_section().symbolList:
             symbols.create_symbol_from_spim_symbol(
-                self.get_most_parent(), spim_sym.contextSym
+                self.get_most_parent(), spim_sym.contextSym, force_in_segment=True
             )
 
     def should_scan(self) -> bool:

splat/segtypes/common/c.py

@@ -283,7 +283,24 @@ class CommonSegC(CommonSegCodeSubsegment):
                 section = self.spim_section.get_section()
                 old_value = section.getGpRelHack()
                 section.setGpRelHack(False)
+
+                if options.opts.platform == "ps2":
+                    # Modern gas requires `$` on the special r5900 registers.
+                    from rabbitizer import TrinaryValue
+
+                    for func in section.symbolList:
+                        assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction)
+                        for inst in func.instructions:
+                            inst.flag_r5900UseDollar = TrinaryValue.TRUE
+
                 self.split_as_asmtu_file(self.asm_out_path())
+
+                if options.opts.platform == "ps2":
+                    for func in section.symbolList:
+                        assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction)
+                        for inst in func.instructions:
+                            inst.flag_r5900UseDollar = TrinaryValue.FALSE
+
                 section.setGpRelHack(old_value)
 
     def get_c_preamble(self):

splat/segtypes/common/codesubsegment.py

@@ -119,7 +119,7 @@ class CommonSegCodeSubsegment(Segment):
         self.parent: CommonSegCode = self.parent
 
         symbols.create_symbol_from_spim_symbol(
-            self.get_most_parent(), func_spim.contextSym
+            self.get_most_parent(), func_spim.contextSym, force_in_segment=False
         )
 
         # Gather symbols found by spimdisasm and create those symbols in splat's side
@@ -129,7 +129,7 @@ class CommonSegCodeSubsegment(Segment):
             )
             if context_sym is not None:
                 symbols.create_symbol_from_spim_symbol(
-                    self.get_most_parent(), context_sym
+                    self.get_most_parent(), context_sym, force_in_segment=False
                 )
 
         # Main loop
@@ -153,7 +153,7 @@ class CommonSegCodeSubsegment(Segment):
                 context_sym = self.spim_section.get_section().getSymbol(sym_address)
                 if context_sym is not None:
                     symbols.create_symbol_from_spim_symbol(
-                        self.get_most_parent(), context_sym
+                        self.get_most_parent(), context_sym, force_in_segment=False
                     )
 
     def print_file_boundaries(self):

splat/segtypes/common/data.py

@@ -130,7 +130,7 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
 
         for symbol in self.spim_section.get_section().symbolList:
             symbols.create_symbol_from_spim_symbol(
-                self.get_most_parent(), symbol.contextSym
+                self.get_most_parent(), symbol.contextSym, force_in_segment=True
             )
 
             # Gather symbols found by spimdisasm and create those symbols in splat's side
@@ -140,7 +140,7 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
                 )
                 if context_sym is not None:
                     symbols.create_symbol_from_spim_symbol(
-                        self.get_most_parent(), context_sym
+                        self.get_most_parent(), context_sym, force_in_segment=False
                     )
 
             # Hint to the user that we are now in the .rodata section and no longer in the .data section (assuming rodata follows data)

splat/segtypes/common/rodata.py

@@ -108,7 +108,7 @@ class CommonSegRodata(CommonSegData):
 
         for symbol in self.spim_section.get_section().symbolList:
             generated_symbol = symbols.create_symbol_from_spim_symbol(
-                self.get_most_parent(), symbol.contextSym
+                self.get_most_parent(), symbol.contextSym, force_in_segment=True
             )
             generated_symbol.linker_section = self.get_linker_section_linksection()
 
@@ -119,7 +119,7 @@ class CommonSegRodata(CommonSegData):
                 )
                 if context_sym is not None:
                     symbols.create_symbol_from_spim_symbol(
-                        self.get_most_parent(), context_sym
+                        self.get_most_parent(), context_sym, force_in_segment=False
                     )
 
             possible_text = self.get_possible_text_subsegment_for_symbol(symbol)

splat/segtypes/n64/ci.py

@@ -48,6 +48,8 @@ class N64SegCi(N64SegImg):
         return options.opts.asset_path / self.dir / f"{out_name}{type_extension}.png"
 
     def split(self, rom_bytes):
+        self.check_len()
+
         assert self.palettes is not None
         if len(self.palettes) == 0:
             # TODO: output with blank palette

splat/segtypes/n64/img.py

@@ -64,6 +64,10 @@ class N64SegImg(Segment):
             log.error(
                 f"Error: {self.name} should end at 0x{self.rom_start + expected_len:X}, but it ends at 0x{self.rom_end:X}\n(hint: add a 'bin' segment after it)"
             )
+        elif actual_len < expected_len:
+            log.error(
+                f"Error: {self.name} should end at 0x{self.rom_start + expected_len:X}, but it ends at 0x{self.rom_end:X}"
+            )
 
     def out_path(self) -> Path:
         type_extension = f".{self.type}" if self.image_type_in_extension else ""

splat/segtypes/n64/palette.py

@@ -23,7 +23,21 @@ class N64SegPalette(Segment):
                     f"segment {self.name} needs to know where it ends; add a position marker [0xDEADBEEF] after it"
                 )
 
-            if not isinstance(self.yaml, dict) or "size" not in self.yaml:
+            if isinstance(self.yaml, dict) and "size" in self.yaml:
+                yaml_size: int = self.yaml["size"]
+                if isinstance(self.rom_start, int) and isinstance(self.rom_end, int):
+                    rom_len = self.rom_end - self.rom_start
+                    if rom_len < yaml_size:
+                        log.error(
+                            f"Error: {self.name} has a `size` value of 0x{yaml_size:X}, but this is smaller than the actual rom size of the palette (0x{rom_len:X}, start: 0x{self.rom_start:X}, end: 0x{self.rom_end:X})"
+                        )
+                    elif rom_len > yaml_size:
+                        log.error(
+                            f"Warning: {self.name} has a `size` value of 0x{yaml_size:X}, but this is larger than the end of the palette (0x{rom_len:X}, start: 0x{self.rom_start:X}, end: 0x{self.rom_end:X})\n(hint add a 'bin' segment after this palette with address 0x{self.rom_end:X})",
+                        )
+
+                size = yaml_size
+            else:
                 assert self.rom_end is not None
                 assert self.rom_start is not None
                 actual_len = self.rom_end - self.rom_start
@@ -39,7 +53,11 @@ class N64SegPalette(Segment):
                     log.error(
                         f"Error: {self.name} (0x{actual_len:X} bytes) is not a valid palette size ({', '.join(hex(s) for s in VALID_SIZES)})\n{hint_msg}"
                     )
+                size = actual_len
+        else:
+            size = 0
 
+        self.palette_size: int = size
         self.global_id: Optional[str] = (
             self.yaml.get("global_id") if isinstance(self.yaml, dict) else None
         )
@@ -61,7 +79,8 @@ class N64SegPalette(Segment):
         return palette
 
     def parse_palette(self, rom_bytes) -> List[Tuple[int, int, int, int]]:
-        data = rom_bytes[self.rom_start : self.rom_end]
+        assert self.rom_start is not None
+        data = rom_bytes[self.rom_start : self.rom_start + self.palette_size]
 
         return N64SegPalette.parse_palette_bytes(data)
 

splat/segtypes/segment.py

@@ -811,8 +811,7 @@ class Segment:
         items = [
             i
             for i in items
-            if i.segment is None
-            or Segment.visible_ram(self, i.segment)
+            if (i.segment is None or Segment.visible_ram(self, i.segment))
             and (type == i.type)
         ]
 

splat/util/__init__.py

@@ -7,6 +7,7 @@ from . import n64 as n64
 from . import options as options
 from . import palettes as palettes
 from . import progress_bar as progress_bar
+from . import ps2 as ps2
 from . import psx as psx
 from . import relocs as relocs
 from . import statistics as statistics

splat/util/ps2/__init__.py

@@ -0,0 +1 @@
+from . import ps2elfinfo as ps2elfinfo

splat/util/ps2/ps2elfinfo.py

@@ -0,0 +1,249 @@
+#! /usr/bin/env python3
+
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+import spimdisasm
+from spimdisasm.elf32 import (
+    Elf32File,
+    Elf32Constants,
+    Elf32SectionHeaderFlag,
+    Elf32ObjectFileType,
+)
+from typing import Optional
+
+from .. import log
+
+
+ELF_SECTION_MAPPING: dict[str, str] = {
+    ".text": "asm",
+    ".data": "data",
+    ".rodata": "rodata",
+    ".bss": "bss",
+    ".sdata": "sdata",
+    ".sbss": "sbss",
+    ".gcc_except_table": "gcc_except_table",
+    ".lit4": "lit4",
+    ".lit8": "lit8",
+    ".ctor": "ctor",
+    ".vtables": "vtables",
+    ".vutext": "textbin",  # No "proper" support yet
+    ".vudata": "databin",  # No "proper" support yet
+}
+
+# Section to not put into the elf_section_names list, because splat doesn't
+# know have support for them yet.
+ELF_SECTIONS_IGNORE: set[str] = {
+    ".vutext",
+    ".vudata",
+    ".vubss",
+}
+
+ELF_SMALL_SECTIONS: set[str] = {
+    ".lit4",
+    ".lit8",
+    ".sdata",
+    ".srdata",
+    ".sbss",
+}
+
+
+@dataclasses.dataclass
+class Ps2Elf:
+    entrypoint: int
+    segs: list[FakeSegment]
+    size: int
+    compiler: str
+    elf_section_names: list[tuple[str, bool]]
+    gp: Optional[int]
+    ld_gp_expression: Optional[str]
+
+    @staticmethod
+    def get_info(elf_path: Path, elf_bytes: bytes) -> Optional[Ps2Elf]:
+        # Avoid spimdisasm from complaining about unknown sections.
+        spimdisasm.common.GlobalConfig.QUIET = True
+
+        elf = Elf32File(elf_bytes)
+        if elf.header.type != Elf32ObjectFileType.EXEC.value:
+            log.write("Elf file is not an EXEC type.", status="warn")
+            return None
+        if elf.header.machine != 8:
+            # 8 corresponds to EM_MIPS
+            # We only care about mips binaries.
+            log.write("Elf file is not a MIPS binary.", status="warn")
+            return None
+        if Elf32Constants.Elf32HeaderFlag._5900 not in elf.elfFlags:
+            log.write("Missing 5900 flag", status="warn")
+            return None
+
+        if elf.reginfo is not None and elf.reginfo.gpValue != 0:
+            gp = elf.reginfo.gpValue
+        else:
+            gp = None
+        first_small_section_info: Optional[tuple[str, int]] = None
+
+        first_segment_name = "cod"
+        segs = [FakeSegment(first_segment_name, 0, 0, [])]
+
+        # TODO: check `.comment` section for any compiler info
+        compiler = "EEGCC"
+
+        elf_section_names: list[tuple[str, bool]] = []
+
+        first_offset: Optional[int] = None
+        rom_size = 0
+
+        previous_type = Elf32Constants.Elf32SectionHeaderType.PROGBITS
+        do_new_segs = False
+
+        # Loop over all the sections.
+        # Treat every normal elf section as part as the "main" segment.
+        # If we see a PROGBITS after a NOBITS then we shift the behavior into
+        # putting every new elf section into their own segment, this can happen
+        # when the elf contains a few special sections like `.mfifo`.
+        section_headers = sorted(elf.sectionHeaders, key=lambda x: x.offset)
+        for section in section_headers:
+            if section.size == 0:
+                # Skip over empty sections
+                continue
+
+            name = elf.shstrtab[section.name]
+            if name == ".mwcats":
+                compiler = "MWCCPS2"
+                continue
+
+            flags, _unknown_flags = Elf32SectionHeaderFlag.parseFlags(section.flags)
+            # if _unknown_flags != 0:
+            #     print(name, f"0x{_unknown_flags:08X}")
+            if Elf32SectionHeaderFlag.ALLOC not in flags:
+                # We don't care about non-alloc sections
+                continue
+
+            # We want PROGBITS (actual data) and NOBITS (bss and similar)
+            typ = Elf32Constants.Elf32SectionHeaderType.fromValue(section.type)
+            is_nobits = typ == Elf32Constants.Elf32SectionHeaderType.NOBITS
+            if typ == Elf32Constants.Elf32SectionHeaderType.PROGBITS:
+                if previous_type == Elf32Constants.Elf32SectionHeaderType.NOBITS:
+                    do_new_segs = True
+                pass
+            elif typ == Elf32Constants.Elf32SectionHeaderType.NOBITS:
+                pass
+            elif typ == Elf32Constants.Elf32SectionHeaderType.MIPS_REGINFO:
+                continue
+            else:
+                log.write(
+                    f"Unknown section type '{typ}' ({name}) found in the elf",
+                    status="warn",
+                )
+                return None
+
+            if first_offset is None:
+                first_offset = section.offset
+
+            if first_small_section_info is None and name in ELF_SMALL_SECTIONS:
+                first_small_section_info = (name, section.addr)
+
+            start = section.offset - first_offset
+            size = section.size
+
+            if do_new_segs:
+                segs.append(FakeSegment(name.lstrip("."), 0, start, []))
+
+            # Try to map this section to something splat can understand.
+            splat_segment_type = ELF_SECTION_MAPPING.get(name)
+            if splat_segment_type is None:
+                # Let's infer based on the section's flags
+                if is_nobits:
+                    splat_segment_type = "bss"
+                elif Elf32SectionHeaderFlag.EXECINSTR in flags:
+                    splat_segment_type = "asm"
+                elif Elf32SectionHeaderFlag.WRITE in flags:
+                    splat_segment_type = "data"
+                else:
+                    # Whatever...
+                    splat_segment_type = "rodata"
+
+            if name.startswith("."):
+                valid_for_splat = (
+                    name in ELF_SECTION_MAPPING
+                    and name not in ELF_SECTIONS_IGNORE
+                    and not do_new_segs
+                )
+                elf_section_names.append((name, valid_for_splat))
+
+            new_section = ElfSection(
+                name,
+                splat_segment_type,
+                section.addr,
+                start,
+                size,
+                is_nobits,
+            )
+            segs[-1].sections.append(new_section)
+            if is_nobits:
+                segs[-1].bss_size += size
+            else:
+                rom_size = start + size
+
+            previous_type = typ
+
+        # There are some games where they just squashed most sections into a
+        # single one, making the elf_section_names list pretty useless.
+        # We try to detect this and provide a default list if that's the case,
+        # hoping for the best.
+        if len(elf_section_names) < 4:
+            elf_section_names = [
+                (".text", True),
+                (".vutext", False),
+                (".data", True),
+                (".vudata", False),
+                (".rodata", True),
+                (".gcc_except_table", True),
+                (".lit8", True),
+                (".lit4", True),
+                (".sdata", True),
+                (".sbss", True),
+                (".bss", True),
+                (".vubss", False),
+            ]
+
+        # Fixup vram address of segments
+        for seg in segs:
+            seg.vram = seg.sections[0].vram
+
+        ld_gp_expression = None
+        if gp is not None and first_small_section_info is not None:
+            section_name, section_address = first_small_section_info
+            if gp > section_address:
+                diff = gp - section_address
+                ld_gp_expression = f"{first_segment_name}_{section_name.strip('.').upper()}_START + 0x{diff:04X}"
+
+        return Ps2Elf(
+            elf.header.entry,
+            segs,
+            rom_size,
+            compiler,
+            elf_section_names,
+            gp,
+            ld_gp_expression,
+        )
+
+
+@dataclasses.dataclass
+class FakeSegment:
+    name: str
+    vram: int
+    start: int
+    sections: list[ElfSection]
+    bss_size: int = 0
+
+
+@dataclasses.dataclass
+class ElfSection:
+    name: str
+    splat_segment_type: str
+    vram: int
+    start: int
+    size: int
+    is_nobits: bool

splat/util/symbols.py

@@ -600,8 +600,13 @@ def add_symbol_to_spim_section(
     return context_sym
 
 
+# force_in_segment=True when the symbol belongs to this specific segment.
+# force_in_segment=False when this symbol is just a reference.
 def create_symbol_from_spim_symbol(
-    segment: "Segment", context_sym: spimdisasm.common.ContextSymbol
+    segment: "Segment",
+    context_sym: spimdisasm.common.ContextSymbol,
+    *,
+    force_in_segment: bool,
 ) -> "Symbol":
     in_segment = False
 
@@ -631,7 +636,7 @@ def create_symbol_from_spim_symbol(
                 in_segment = segment.contains_vram(context_sym.vram)
 
     sym = segment.create_symbol(
-        context_sym.vram, in_segment, type=sym_type, reference=True
+        context_sym.vram, force_in_segment or in_segment, type=sym_type, reference=True
     )
 
     if sym.given_name is None and context_sym.name is not None:

{splat64-0.36.3.dist-info → splat64-0.36.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splat64
-Version: 0.36.3
+Version: 0.36.4
 Summary: A binary splitting tool to assist with decompilation and modding projects
 Project-URL: Repository, https://github.com/ethteck/splat
 Project-URL: Issues, https://github.com/ethteck/splat/issues
@@ -30,16 +30,16 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-Requires-Dist: colorama
-Requires-Dist: intervaltree
-Requires-Dist: pylibyaml
-Requires-Dist: pyyaml
-Requires-Dist: tqdm
+Requires-Dist: colorama==0.4.6
+Requires-Dist: intervaltree==3.1.0
+Requires-Dist: pylibyaml==0.1.0
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: tqdm==4.67.1
 Provides-Extra: dev
 Requires-Dist: crunch64<1.0.0,>=0.5.1; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: n64img>=0.3.3; extra == 'dev'
-Requires-Dist: pygfxd; extra == 'dev'
+Requires-Dist: pygfxd>=1.0.5; extra == 'dev'
 Requires-Dist: rabbitizer<2.0.0,>=1.12.0; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Requires-Dist: spimdisasm<2.0.0,>=1.38.0; extra == 'dev'
@@ -48,7 +48,7 @@ Requires-Dist: types-pyyaml; extra == 'dev'
 Provides-Extra: mips
 Requires-Dist: crunch64<1.0.0,>=0.5.1; extra == 'mips'
 Requires-Dist: n64img>=0.3.3; extra == 'mips'
-Requires-Dist: pygfxd; extra == 'mips'
+Requires-Dist: pygfxd>=1.0.5; extra == 'mips'
 Requires-Dist: rabbitizer<2.0.0,>=1.12.0; extra == 'mips'
 Requires-Dist: spimdisasm<2.0.0,>=1.38.0; extra == 'mips'
 Description-Content-Type: text/markdown
@@ -76,7 +76,7 @@ The brackets corresponds to the optional dependencies to install while installin
 If you use a `requirements.txt` file in your repository, then you can add this library with the following line:
 
 ```txt
-splat64[mips]>=0.36.3,<1.0.0
+splat64[mips]>=0.36.4,<1.0.0
 ```
 
 ### Optional dependencies

{splat64-0.36.3.dist-info → splat64-0.36.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-splat/__init__.py,sha256=Jd0jequ-9rFyGBhXTci1H5cne5ZAVFvapdlzAM-y-4o,291
+splat/__init__.py,sha256=K7V_4INbs5mtgBs_XECCUNEhSPHURCOviws3SKjutbc,291
 splat/__main__.py,sha256=T333dHDgr-2HYYhtARnYMEjdECnYiNIKfcXDD99o22A,732
 splat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 splat/disassembler/__init__.py,sha256=LXuCElHxOvbb9xuSSeswT8W_v78chwtqjKq_9nxFVzQ,167
@@ -14,21 +14,21 @@ splat/platforms/psp.py,sha256=rCr_uf1SuHNaMUXjIC0GyoA_463OQZv0se2KMarWry0,125
 splat/platforms/psx.py,sha256=YxQERdOBr4p3ab9Wk80FNhVYi-uvmh7p_jeykSFp23M,40
 splat/scripts/__init__.py,sha256=OY0nHg6a7JB437Sb96qLbZ_7ByVsal1gStj35wJAI_Y,101
 splat/scripts/capy.py,sha256=svbOfLO34-QN3xLiBy9vk2RGs_To8TWMWEKBw6yx2xQ,3674
-splat/scripts/create_config.py,sha256=WU_4jZQZ1Y9uLITWARgsYMl1J1YaKuPaX-bsPhqDsa4,11785
+splat/scripts/create_config.py,sha256=Xt0BgS9ql5GfLrNKWQRMuKWea0sXUygRV1_wCYGrrPE,17949
 splat/scripts/split.py,sha256=wWib2lDdedzjcNLH-Ay48gM2XGZ9JCUsrriamuHzkOU,21935
 splat/segtypes/__init__.py,sha256=-upUw_4JGQtvyp6IfTMzOq_CK3xvVaT_0K0_EipHyOo,208
 splat/segtypes/linker_entry.py,sha256=WHFdVFC_NW6_ub-LJbfwze-FZGCTRtjEZHz_bhIkX-M,25160
-splat/segtypes/segment.py,sha256=wo4QCdDAmR1TZRgk0DgTZ0RJGuhdZGuJy20L_Fgz_Ss,30629
+splat/segtypes/segment.py,sha256=IcmF7FxDrJ1ZP5AKFO-skNrGfYhGIYwawyepKzeTF3A,30619
 splat/segtypes/common/__init__.py,sha256=mnq0acScilSCCo6q2PvkDk0Or3V8qitA7I8QMVw8haI,631
 splat/segtypes/common/asm.py,sha256=gpR4uZ57l4Q9G0XTOeO1JIk9P5d8xXBxRfkrPIN-M1A,644
 splat/segtypes/common/asmtu.py,sha256=C52kKh-8YeDHu0EucEfQ-tQMtDgfKfwAJ6wwiW6nOBU,354
 splat/segtypes/common/bin.py,sha256=qZeuvHNSrRuxdk-8V0xW0tcFhtzPk6doyf43E_t7D9Q,1250
-splat/segtypes/common/bss.py,sha256=nktRbKrDivweyLdsUQkL5guSayqpwn7NK5j3gq3arKc,3084
-splat/segtypes/common/c.py,sha256=nIcnBOraSxSLcg6kn2fwkV3WMS-Tx7zfzbi7YXMdr7A,20549
+splat/segtypes/common/bss.py,sha256=cX0RO7LRcBRO6t463AUSSV8sGdlxZTcd5_McZjjqfFo,3107
+splat/segtypes/common/c.py,sha256=RkevmqKXK9RKQ_yPClFFur1Uq4jGGdVtL1BnScbHhok,21327
 splat/segtypes/common/code.py,sha256=FfBuy6x8fQXoJYX2Ul80uOs-CzlVslUaveD-hBmvKXM,10693
-splat/segtypes/common/codesubsegment.py,sha256=n6mtHMpwjxNoTSh3aMT5Y19xvriAaaBP_r8AhVW52uU,10648
+splat/segtypes/common/codesubsegment.py,sha256=XpPzNwGSNL4HE7Qgi7-tSVXlYtfdXug9PrzQIJu3yDI,10720
 splat/segtypes/common/cpp.py,sha256=p-duowCt4czrmaWgj1LuFw5LGfdyB_uaeLTKVmH80Cg,180
-splat/segtypes/common/data.py,sha256=r9G_vYieNlRze-5wGOKFazvFjpuodfSLad6iCNsBOAU,5665
+splat/segtypes/common/data.py,sha256=l3CCa95vHH8XwiksamaxuZuSF_rOGqcozGlZj0bt9Yw,5712
 splat/segtypes/common/databin.py,sha256=nDI1ciAv0QLt2xDYjEtGJHSoONZzJZKyST-BuSKML2Q,1169
 splat/segtypes/common/eh_frame.py,sha256=MzL373ej2E38leM47py3T5beLq2IolsYszLZM8PYS2Y,913
 splat/segtypes/common/gcc_except_table.py,sha256=-ZrQL5dCcRu7EPFFPgL8lIJwWL5FsEeeQoSUVfTkyIg,2112
@@ -39,14 +39,14 @@ splat/segtypes/common/lib.py,sha256=WaJH0DH0B8iJvhYQWYBjThbNeEXz3Yh7E8ZyONe5JtQ,
 splat/segtypes/common/linker_offset.py,sha256=IaEXMXq62BS2g95I4lS0wax5Ehjfi3O3C-uSDUbMjvI,767
 splat/segtypes/common/pad.py,sha256=-7SaRgXrmGeOINKVV9v1c3e9jn8aVQknD8EVaEPcPrw,758
 splat/segtypes/common/rdata.py,sha256=ab2MFZVjlnD2p5nDVNroo3W9blaVJND2jN2PJPy6a_Y,142
-splat/segtypes/common/rodata.py,sha256=Y8ugWuHDfdU6vQSXdfLF9YKdfvuaoVcRcyk3cFeo_iA,6191
+splat/segtypes/common/rodata.py,sha256=ZUqXPw119EewNr9_pUL9QeoVML5XwPTo1THz9OjB86k,6238
 splat/segtypes/common/rodatabin.py,sha256=RsvhGxY9iX1QHSyMfuWLaFrqdBvDEtL4j13-jPpvyvk,1174
 splat/segtypes/common/sbss.py,sha256=blIEuVYie4qNEOYMmlSdltn5f4MvgJu3AV8vqVD8Nh4,131
 splat/segtypes/common/sdata.py,sha256=dnLzNSNtSyclLZiNUmFTv0e0BWN8glxB1km1MSRq6xY,136
 splat/segtypes/common/segment.py,sha256=gFPzEi0Jq0NGtL4xlblIlNZus7dHkxebLKkr6jhOkxs,81
 splat/segtypes/common/textbin.py,sha256=PXEb1JQB2NEqVDLg5KW2vI0NLSqrROJvCOifxB0NUms,5994
 splat/segtypes/n64/__init__.py,sha256=tf2yWlijeKmOp1OhEEL-aW88mU-mWQRC2lSjQ5Ww1eI,569
-splat/segtypes/n64/ci.py,sha256=An7wIHcoZ89KiGCKpCRbM7IrmDNYBidXT-6kjKn2vH0,2400
+splat/segtypes/n64/ci.py,sha256=i2axvnNtteezMg18gLcgggaI14Ez0I5DuGuNah9z4DU,2426
 splat/segtypes/n64/ci4.py,sha256=ZP8e12CpV8U7r8oLnb9uHc-MkmBbxjXBbJxROFvOjiM,184
 splat/segtypes/n64/ci8.py,sha256=tS4USmp0LuJnP-UlgaOYoxvYxBKgE67wYCz-KeRLlFk,184
 splat/segtypes/n64/decompressor.py,sha256=YuKo-PS_S2-Ow1Zw8QTO70NWlSYTY79JZN0kUQB7T0U,1779
@@ -58,10 +58,10 @@ splat/segtypes/n64/i8.py,sha256=5zqYmpmuXprEzwidVQTknSKqMuu0C1Izk4t5ILoTPf4,204
 splat/segtypes/n64/ia16.py,sha256=y1uLVuh72HTmyAEK90R67vftp-X4LDgRxgJyU8EAnH0,208
 splat/segtypes/n64/ia4.py,sha256=YdBtqx1LUHFXCPOUJUqutSHnD3YTIov6JKSZjXNKuVY,206
 splat/segtypes/n64/ia8.py,sha256=TxTqD-4mx7eF81IxThkPn54aJkEtGALGvGudmejBM0w,206
-splat/segtypes/n64/img.py,sha256=MtxMPSbMIDDnRhIjOte9-Kk3smzP5XybqKkifv6EhTE,3083
+splat/segtypes/n64/img.py,sha256=xbpgJlg8tiok4CaFvkWTXRcxvNZGK_i3GAnN5jtY8kA,3283
 splat/segtypes/n64/ipl3.py,sha256=HKPXIaKr6XAQGwm3YKQedmijGqXNebzIS9LjiPxl2Q0,200
 splat/segtypes/n64/mio0.py,sha256=jYTq0Iz1NkWSFLDnFPdLYu3HG2adyRZEVlzevFNdn0U,379
-splat/segtypes/n64/palette.py,sha256=IwHVwByoRahTGOL3F1c_6hmgvGK63p3Da086dxSqBok,3132
+splat/segtypes/n64/palette.py,sha256=y--D6EfBPvzahfcLA_ahFR9MHslcPpu2JLNBuNpK-B4,4264
 splat/segtypes/n64/rgba16.py,sha256=ddWJARv5SKFFuCUIFeI-MQFqa52fa3d0srZMVbCXOSw,212
 splat/segtypes/n64/rgba32.py,sha256=LbYDZ4b95axIYKc06HDyAYMUm-cTJLOsRCKGlE_Hlmw,227
 splat/segtypes/n64/rsp.py,sha256=8t9ZnhuF2KrxG1FTRC7R0zgciu-4C9SMcFcFzBP4rfI,236
@@ -75,7 +75,7 @@ splat/segtypes/ps2/vtables.py,sha256=c8weQcbQ0-KkjkLHUXViTWkEaJ6LNR8jBUMV-0t0m4o
 splat/segtypes/psp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 splat/segtypes/psx/__init__.py,sha256=tn0oDYUPtF0PfC8I4G23nPvH_JAcuLGxOCvYN1SE3Dc,31
 splat/segtypes/psx/header.py,sha256=2S8XG_6zfLGzmEA0XpFqs0-4nf52YD9Erk6SbMUlVzo,2639
-splat/util/__init__.py,sha256=rsnoPNjNVbu9j_yxoubyq8Pf-clIbOHk2vQyuKSmxyI,513
+splat/util/__init__.py,sha256=vejj8R_nldFOlIOEoG492Lycg1zUCTQewoPF9c3P6fw,538
 splat/util/cache_handler.py,sha256=BrTWo8U4bj8TBcZfIRwiAYmogc3YUlBz9P-34Y0aIrg,1851
 splat/util/color.py,sha256=FSmy0dAQJ9FzRBc99Yt4kBEyB62MC_YiVkqoWgPMsRU,371
 splat/util/compiler.py,sha256=uXShMm49380ENecSFlsi75LWI45yakWkExZX8NT5pOU,1778
@@ -87,16 +87,18 @@ splat/util/palettes.py,sha256=d3KoZnwt-zunI9eNwb3txysXg4DY3xnF0O5aQRxM4so,2920
 splat/util/progress_bar.py,sha256=41VehpIFK1cphENaXV_Aq6_3mFx25eQ8V7Z51SKFPeM,166
 splat/util/relocs.py,sha256=j8fzM9u0ZQwZa1b1Dd26ho9GwIooBXt8mE0jAN7wqV0,4153
 splat/util/statistics.py,sha256=8C88vLW8q4Xd4i1Crz8X24NLoraLyKd0lw3ebbeonSo,1906
-splat/util/symbols.py,sha256=xYPbLTSlPrxsDvRw3aOTbN0wRZG6Ob4ZXD35cqC7YkE,31322
+splat/util/symbols.py,sha256=wqznzi0-ZQ0pID1qWLShSPHL3eD7M5jjMwmO4LyWxIc,31519
 splat/util/utils.py,sha256=kAC0DAjaGa0Kq2k86RfQtFkheV87XuyeOgZIVIk3CHE,208
 splat/util/vram_classes.py,sha256=UH4rkugEwoec_-alJ4smNOcnU51G-V5OG7Pfsj47eaM,3491
 splat/util/n64/__init__.py,sha256=hsBkPh6NUz-bW7HVspcNZ0mCxBhdfcPC07_7gbga95o,84
 splat/util/n64/find_code_length.py,sha256=uUoPoUORAjsAvH8oGqwnGvw6j8I_NnSrZtA-x9h9h7E,1414
 splat/util/n64/rominfo.py,sha256=Ms9P-MuuOSyEF4QNB3wBuC-U9OdrfByqR0VPAHqTBQI,16976
+splat/util/ps2/__init__.py,sha256=hAU12HtQLOc_sxc8_rzxOERBT5wjg3DhQ8XRN9hBXfA,39
+splat/util/ps2/ps2elfinfo.py,sha256=v6nTPabzXpG1N-MhhkbVeLoGjgsjBEpHL1DoPv26-Hs,7982
 splat/util/psx/__init__.py,sha256=kCCaR-KB1mNlIcXB4OuuSQ2zVLbWg_SnIZIUeyjeBBI,39
 splat/util/psx/psxexeinfo.py,sha256=Oxd5Lt8HTNHuUzw3cVujdyJRqEG-yo0XT78wEISUXms,5705
-splat64-0.36.3.dist-info/METADATA,sha256=Ugzp2ibo0F22MBBZwQKte5jm-Kv6-9sJFda1lTcugUw,3829
-splat64-0.36.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-splat64-0.36.3.dist-info/entry_points.txt,sha256=O7Xy-qNOHcI87-OQrWJ-OhRDws74SuwVb_4rtnp0eLo,52
-splat64-0.36.3.dist-info/licenses/LICENSE,sha256=97VMVzjG8yQvsf8NG2M9IFSbh7R8cifJnc6QK1cZqj8,1070
-splat64-0.36.3.dist-info/RECORD,,
+splat64-0.36.4.dist-info/METADATA,sha256=sQtM6Sc89JJYxes3KqZRDfIKyDRLqzFuXUbiD82IXR4,3879
+splat64-0.36.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+splat64-0.36.4.dist-info/entry_points.txt,sha256=O7Xy-qNOHcI87-OQrWJ-OhRDws74SuwVb_4rtnp0eLo,52
+splat64-0.36.4.dist-info/licenses/LICENSE,sha256=97VMVzjG8yQvsf8NG2M9IFSbh7R8cifJnc6QK1cZqj8,1070
+splat64-0.36.4.dist-info/RECORD,,

{splat64-0.36.3.dist-info → splat64-0.36.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any