splat64 0.36.2__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.2"
+__version__ = "0.36.4"
 __author__ = "ethteck"
 
 from . import util as util

splat/disassembler/__init__.py

@@ -1,4 +1,3 @@
 from . import disassembler as disassembler
 from . import spimdisasm_disassembler as spimdisasm_disassembler
 from . import disassembler_section as disassembler_section
-from . import disassembler_section as disassembler_section

splat/disassembler/null_disassembler.py

@@ -1,5 +1,4 @@
 from . import disassembler
-from ..util.options import SplatOpts
 from typing import Set
 
 

splat/disassembler/spimdisasm_disassembler.py

@@ -7,7 +7,7 @@ from typing import Set
 
 class SpimdisasmDisassembler(disassembler.Disassembler):
     # This value should be kept in sync with the version listed on requirements.txt and pyproject.toml
-    SPIMDISASM_MIN = (1, 36, 1)
+    SPIMDISASM_MIN = (1, 38, 0)
 
     def configure(self):
         # Configure spimdisasm

splat/platforms/ps2.py

@@ -1,8 +1,6 @@
 import spimdisasm
 import rabbitizer
 
-from ..util import compiler, options
-
 
 def init(target_bytes: bytes):
     rabbitizer.config.toolchainTweaks_treatJAsUnconditionalBranch = False

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}'")
 
 
@@ -223,7 +232,7 @@ segments:
             f"// The address of the end of the stack is 0x{rom.entrypoint_info.stack_top.value:08X}."
         )
         reloc_addrs.append(
-            f"// A common size for this stack is 0x2000, so try checking for the address 0x{rom.entrypoint_info.stack_top.value-0x2000:08X}. Note the stack may have a different size."
+            f"// A common size for this stack is 0x2000, so try checking for the address 0x{rom.entrypoint_info.stack_top.value - 0x2000:08X}. Note the stack may have a different size."
         )
         reloc_addrs.append(
             f"// rom:0x{rom.entrypoint_info.stack_top.rom_hi:06X} reloc:MIPS_HI16 symbol:main_stack addend:0xXXXX"
@@ -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/scripts/split.py

@@ -138,12 +138,12 @@ def initialize_segments(config_segments: Union[dict, list]) -> List[Segment]:
                             )
 
                         # Not user error, hopefully...
-                        assert (
-                            seg.paired_segment is None
-                        ), f"Somehow '{seg.name}' was already paired so something else? It is paired to '{seg.paired_segment.name}' instead of {other_seg.name}"
-                        assert (
-                            other_seg.paired_segment is None
-                        ), f"Somehow '{other_seg.name}' was already paired so something else? It is paired to '{other_seg.paired_segment.name}' instead of {seg.name}"
+                        assert seg.paired_segment is None, (
+                            f"Somehow '{seg.name}' was already paired so something else? It is paired to '{seg.paired_segment.name}' instead of {other_seg.name}"
+                        )
+                        assert other_seg.paired_segment is None, (
+                            f"Somehow '{other_seg.name}' was already paired so something else? It is paired to '{other_seg.paired_segment.name}' instead of {seg.name}"
+                        )
 
                         found = True
                         # Pair them
@@ -216,9 +216,9 @@ def calc_segment_dependences(
 
             for follows_class in vram_class.follows_classes:
                 if follows_class in vram_class_to_segments:
-                    vram_class_to_follows_segments[
-                        vram_class
-                    ] += vram_class_to_segments[follows_class]
+                    vram_class_to_follows_segments[vram_class] += (
+                        vram_class_to_segments[follows_class]
+                    )
     return vram_class_to_follows_segments
 
 

splat/segtypes/common/asm.py

@@ -1,7 +1,5 @@
-from pathlib import Path
-from typing import Optional, List
+from typing import Optional
 
-from ...util import options
 
 from .codesubsegment import CommonSegCodeSubsegment
 

splat/segtypes/common/bin.py

@@ -3,7 +3,8 @@ from typing import Optional
 
 from ...util import log, options
 
-from .segment import CommonSegment, SegmentType
+from .segment import CommonSegment
+from ..segment import SegmentType
 
 
 class CommonSegBin(CommonSegment):

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

@@ -177,9 +177,9 @@ class CommonSegC(CommonSegCodeSubsegment):
                     if rodata_sibling.is_generated:
                         continue
 
-                    assert isinstance(
-                        rodata_sibling, CommonSegRodata
-                    ), f"{rodata_sibling}, {rodata_sibling.type}"
+                    assert isinstance(rodata_sibling, CommonSegRodata), (
+                        f"{rodata_sibling}, {rodata_sibling.type}"
+                    )
 
                     if not rodata_sibling.type.startswith("."):
                         # Emit an error if we try to migrate the rodata symbols to functions if the rodata section is not prefixed with a dot
@@ -237,7 +237,7 @@ class CommonSegC(CommonSegCodeSubsegment):
                 entry.sectionRodata = rodata_section_type
                 if entry.function is not None:
                     if (
-                        entry.function.getName() in self.global_asm_funcs
+                        entry.function.getNameUnquoted() in self.global_asm_funcs
                         or is_new_c_file
                         or options.opts.disassemble_all
                     ):
@@ -250,7 +250,8 @@ class CommonSegC(CommonSegCodeSubsegment):
                         assert func_sym is not None
 
                         if (
-                            entry.function.getName() not in self.global_asm_funcs
+                            entry.function.getNameUnquoted()
+                            not in self.global_asm_funcs
                             and options.opts.disassemble_all
                             and not is_new_c_file
                         ):
@@ -263,7 +264,8 @@ class CommonSegC(CommonSegCodeSubsegment):
                 else:
                     for spim_rodata_sym in entry.rodataSyms:
                         if (
-                            spim_rodata_sym.getName() in self.global_asm_rodata_syms
+                            spim_rodata_sym.getNameUnquoted()
+                            in self.global_asm_rodata_syms
                             or is_new_c_file
                             or options.opts.disassemble_all
                         ):
@@ -281,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):
@@ -307,7 +326,7 @@ class CommonSegC(CommonSegCodeSubsegment):
                     "\nA gap was detected in migrated rodata symbols!", status="warn"
                 )
                 log.write(
-                    f"\t In function '{func.getName()}' (0x{func.vram:08X}), gap detected between '{rodata_sym.getName()}' (0x{rodata_sym.vram:08X}) and '{next_rodata_sym.getName()}' (0x{next_rodata_sym.vram:08X})"
+                    f"\t In function '{func.getNameUnquoted()}' (0x{func.vram:08X}), gap detected between '{rodata_sym.getNameUnquoted()}' (0x{rodata_sym.vram:08X}) and '{next_rodata_sym.getNameUnquoted()}' (0x{next_rodata_sym.vram:08X})"
                 )
                 log.write(
                     f"\t The address of the missing rodata symbol is 0x{rodata_sym.vramEnd:08X}"
@@ -414,7 +433,7 @@ class CommonSegC(CommonSegCodeSubsegment):
             and spim_sym.instructions[0].isReturn()
             and spim_sym.instructions[1].isNop()
         ):
-            c_lines.append(f"void {spim_sym.getName()}(void) {{")
+            c_lines.append(f"void {spim_sym.getNameUnquoted()}(void) {{")
             c_lines.append("}")
         else:
             c_lines.append(
@@ -492,7 +511,7 @@ class CommonSegC(CommonSegCodeSubsegment):
             depend_list = []
             for entry in symbols_entries:
                 if entry.function is not None:
-                    func_name = entry.function.getName()
+                    func_name = entry.function.getNameUnquoted()
 
                     if func_name in self.global_asm_funcs or is_new_c_file:
                         outpath = asm_out_dir / self.name / (func_name + ".s")
@@ -502,7 +521,7 @@ class CommonSegC(CommonSegCodeSubsegment):
                         f.write(f" \\\n    {outpath.as_posix()}")
                 else:
                     for rodata_sym in entry.rodataSyms:
-                        rodata_name = rodata_sym.getName()
+                        rodata_name = rodata_sym.getNameUnquoted()
 
                         if rodata_name in self.global_asm_rodata_syms or is_new_c_file:
                             outpath = asm_out_dir / self.name / (rodata_name + ".s")

splat/segtypes/common/code.py

@@ -1,5 +1,5 @@
 from collections import OrderedDict
-from typing import OrderedDict, List, Optional, Type, Tuple
+from typing import List, Optional, Type, Tuple
 
 from ...util import log, options, utils
 

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):
@@ -182,7 +182,7 @@ class CommonSegCodeSubsegment(Segment):
                 print(
                     "File split suggestions for this segment will follow in config yaml format:"
                 )
-            print(f"      - [0x{self.rom_start+in_file_offset:X}, {self.type}]")
+            print(f"      - [0x{self.rom_start + in_file_offset:X}, {self.type}]")
 
     def should_scan(self) -> bool:
         return (

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/databin.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Optional
 
 from ...util import log, options

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)
@@ -130,7 +130,7 @@ class CommonSegRodata(CommonSegData):
                         f"\nRodata segment '{self.name}' may belong to the text segment '{text_segment.name}'"
                     )
                     print(
-                        f"    Based on the usage from the function {refenceeFunction.getName()} to the symbol {symbol.getName()}"
+                        f"    Based on the usage from the function {refenceeFunction.getNameUnquoted()} to the symbol {symbol.getNameUnquoted()}"
                     )
                     possible_text_segments.add(text_segment)
 

splat/segtypes/common/rodatabin.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Optional
 
 from ...util import log, options

splat/segtypes/common/segment.py

@@ -1,4 +1,4 @@
-from ...segtypes.segment import Segment, SegmentType
+from ...segtypes.segment import Segment
 
 
 class CommonSegment(Segment):

splat/segtypes/linker_entry.py

@@ -162,9 +162,9 @@ class LinkerEntry:
             linker_writer._write_symbol(path_cname, ".")
 
     def emit_path(self, linker_writer: "LinkerWriter"):
-        assert (
-            self.object_path is not None
-        ), f"{self.segment.name}, {self.segment.rom_start}"
+        assert self.object_path is not None, (
+            f"{self.segment.name}, {self.segment.rom_start}"
+        )
 
         if self.noload and self.bss_contains_common:
             linker_writer._write_object_path_section(
@@ -237,9 +237,9 @@ class LinkerWriter:
             return
 
         section_entries: OrderedDict[str, List[LinkerEntry]] = OrderedDict()
-        for l in segment.section_order:
-            if l in options.opts.section_order:
-                section_entries[l] = []
+        for section_name in segment.section_order:
+            if section_name in options.opts.section_order:
+                section_entries[section_name] = []
 
         # Add all entries to section_entries
         prev_entry = None
@@ -301,7 +301,7 @@ class LinkerWriter:
 
         # To keep track which sections has been started
         started_sections: Dict[str, bool] = {
-            l: False for l in options.opts.section_order
+            section_name: False for section_name in options.opts.section_order
         }
 
         # Find where sections are last seen
@@ -389,14 +389,19 @@ class LinkerWriter:
 
             self._begin_segment(segment, seg_name, noload=False, is_first=is_first)
 
-            for l in segment.section_order:
-                if l not in options.opts.section_order:
+            for section_name in segment.section_order:
+                if section_name not in options.opts.section_order:
                     continue
-                if l == ".bss":
+                if section_name == ".bss":
                     continue
 
                 entry = LinkerEntry(
-                    segment, [], segments_path / f"{seg_name}.o", l, l, noload=False
+                    segment,
+                    [],
+                    segments_path / f"{seg_name}.o",
+                    section_name,
+                    section_name,
+                    noload=False,
                 )
                 self.dependencies_entries.append(entry)
                 entry.emit_entry(self)
@@ -439,9 +444,9 @@ class LinkerWriter:
         seg_name = segment.get_cname()
 
         section_entries: OrderedDict[str, List[LinkerEntry]] = OrderedDict()
-        for l in segment.section_order:
-            if l in options.opts.section_order:
-                section_entries[l] = []
+        for section_name in segment.section_order:
+            if section_name in options.opts.section_order:
+                section_entries[section_name] = []
 
         # Add all entries to section_entries
         prev_entry = None

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/gfx.py

@@ -36,7 +36,6 @@ from pygfxd import (
     gfxd_f3dexb,
     gfxd_f3dex2,
 )
-from ..segment import Segment
 
 from ...util import log, options
 from ...util.log import error