From 2d78a20141fe2636a1c43785cca27f690365028f Mon Sep 17 00:00:00 2001
From: kotcrab <4594081+kotcrab@users.noreply.github.com>
Date: Thu, 27 Feb 2025 20:27:50 +0100
Subject: [PATCH] Add initial relocatable kernel object exporter

---
 CHANGES.md                                    |   1 +
 README.md                                     |   9 +-
 src/main/kotlin/allegrex/export/ExportElf.kt  | 253 +++++++
 .../export/RelocatableKernelObjectExporter.kt | 638 ++++++++++++++++++
 .../allegrex/util/LeRandomAccessFile.kt       | 228 +++++++
 5 files changed, 1128 insertions(+), 1 deletion(-)
 create mode 100644 src/main/kotlin/allegrex/export/ExportElf.kt
 create mode 100644 src/main/kotlin/allegrex/export/RelocatableKernelObjectExporter.kt
 create mode 100644 src/main/kotlin/allegrex/util/LeRandomAccessFile.kt

diff --git a/CHANGES.md b/CHANGES.md
index 673d3bd..875d182 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,7 @@
 #### Version 21.1
 - Added build for Ghidra 11.3.1
 - Added missing implementation for `eret` instruction
+- Added exporter for relocatable kernel objects
 
 #### Version 21
 - Added build for Ghidra 11.3
diff --git a/README.md b/README.md
index 8e3b9a6..f02604e 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ your Ghidra version. Then depending on the version you're installing:
 ### Version 19 or newer
 
 In main Ghidra window:
+
 1. Select `File -> Install Extensions`.
 2. Press the green plus button.
 3. Select downloaded ZIP.
@@ -55,9 +56,15 @@ file in PPSSPP.
 ### Kernel modules
 
 Usage is very similar as when importing games though kernel modules are usually loaded starting from address `88000000`.
-Note that for some files (e.g. `sysmem`, `loadcore`) you will need to click `Options...` during import and select checkbox to 
+Note that for some files (e.g. `sysmem`, `loadcore`) you will need to click `Options...` during import and select checkbox to
 use `reboot.bin` type B relocation mapping.
 
+#### Exporting relocatable kernel objects
+
+Kernel modules can be exported as object files (`.o`).
+To learn more about this feature see
+[here](https://github.com/kotcrab/ghidra-allegrex/wiki/Exporting-relocatable-kernel-objects).
+
 ### Raw binaries
 
 Raw binaries are also supported. In that case you will need to manually select Allegrex as the processor and set image base.
diff --git a/src/main/kotlin/allegrex/export/ExportElf.kt b/src/main/kotlin/allegrex/export/ExportElf.kt
new file mode 100644
index 0000000..1551fa3
--- /dev/null
+++ b/src/main/kotlin/allegrex/export/ExportElf.kt
@@ -0,0 +1,253 @@
+package allegrex.export
+
+import allegrex.export.ExportElf.SectionName.COMBINED_0
+import allegrex.export.ExportElf.SectionName.COMBINED_1
+import allegrex.export.ExportElf.SectionName.REL_COMBINED_0
+import allegrex.export.ExportElf.SectionName.REL_COMBINED_1
+import allegrex.export.ExportElf.SectionName.SHSTRTAB
+import allegrex.export.ExportElf.SectionName.STRTAB
+import allegrex.export.ExportElf.SectionName.SYMTAB
+import allegrex.util.LeRandomAccessFile
+import allegrex.util.align
+import allegrex.util.writeString
+import java.io.ByteArrayOutputStream
+import java.io.File
+
+object ExportElf {
+  fun writeElf(
+    outFile: File,
+    sections: List<Section>,
+    shStrTab: StringAllocator,
+    symbols: List<Symbol>,
+    strTab: StringAllocator,
+    programBytes: List<ByteArray>,
+    programRelocations: List<List<AllegrexRelocation>>,
+  ) {
+    LeRandomAccessFile(outFile).use {
+      it.setLength(0)
+      // 0x00
+      it.writeByte(0x7F) // magic number
+      it.writeString("ELF")
+      it.write(byteArrayOf(0x01, 0x01, 0x01, 0x00)) // 32-bit, little-endian, version 1, ABI none
+      it.writeInt(0)
+      it.writeInt(0)
+
+      // 0x10
+      it.writeShort(0x01) // ET_REL
+      it.writeShort(0x08) // MIPS
+      it.writeInt(1) // version 1
+      it.writeInt(0) // entry point offset
+      it.writeInt(0) // program headers offset
+
+      // 0x20
+      val sectionHeaderOffset = it.filePointer
+      it.writeInt(0) // section header offset (written later)
+      it.writeInt(0x10A23001) // flags
+      it.writeShort(0x34) // header size
+      it.writeShort(0) // program header size
+      it.writeShort(0) // program header count
+      it.writeShort(0x28) // section header size
+
+      // 0x30
+      it.writeShort(sections.size)
+      it.writeShort(sections.indexOfFirst { e -> shStrTab.lookupOrNull(e.name) == ".shstrtab" })
+
+      // 0x34
+      // Write program bytes
+      val programBytesOffsets = programBytes.map { bytes ->
+        val start = it.filePointer
+        it.write(bytes)
+        it.align(4)
+        start
+      }
+
+      // Write relocations
+      val programRelocationsOffsets = programRelocations.map { relocations ->
+        val start = it.filePointer
+        relocations.forEach { relocation ->
+          it.writeRelocation(relocation)
+        }
+        it.align(4)
+        start
+      }
+
+      // Write symbols
+      val symTabStart = it.filePointer
+      symbols.forEach { symbol ->
+        it.writeSymbol(symbol)
+      }
+      it.align(4)
+
+      // Write strtab
+      val strTabStart = it.filePointer
+      val strTabBytes = strTab.toByteArray()
+      it.write(strTabBytes)
+      it.align(4)
+
+      // Write shstrtab
+      val shStrTabStart = it.filePointer
+      val shStrTabBytes = shStrTab.toByteArray()
+      it.write(shStrTabBytes)
+      it.align(4)
+
+      // Write sections
+      val sectionsStart = it.filePointer
+
+      it.seek(sectionHeaderOffset)
+      it.writeInt(sectionsStart.toInt())
+      it.seek(sectionsStart)
+
+      sections.forEach { section ->
+        it.writeInt(section.name)
+        it.writeInt(section.type)
+        it.writeInt(section.flags)
+        it.writeInt(section.address)
+
+        if (section.offset == -1) {
+          it.writeInt(
+            when (shStrTab.lookupOrNull(section.name)) {
+              COMBINED_0 -> programBytesOffsets[0]
+              COMBINED_1 -> programBytesOffsets[1]
+              REL_COMBINED_0 -> programRelocationsOffsets[0]
+              REL_COMBINED_1 -> programRelocationsOffsets[1]
+              SYMTAB -> symTabStart
+              STRTAB -> strTabStart
+              SHSTRTAB -> shStrTabStart
+              else -> error("Unknown section: ${section.name}")
+            }.toInt()
+          )
+        } else {
+          it.writeInt(section.offset)
+        }
+
+        if (section.size == -1) {
+          it.writeInt(
+            when (shStrTab.lookupOrNull(section.name)) {
+              COMBINED_0 -> programBytes[0].size
+              COMBINED_1 -> programBytes[1].size
+              REL_COMBINED_0 -> programRelocations[0].size * 8
+              REL_COMBINED_1 -> programRelocations[1].size * 8
+              SYMTAB -> symbols.size * 0x10
+              STRTAB -> strTabBytes.size
+              SHSTRTAB -> shStrTabBytes.size
+              else -> error("Unknown section: ${section.name}")
+            }.toInt()
+          )
+        } else {
+          it.writeInt(section.size)
+        }
+
+        it.writeInt(section.link)
+        it.writeInt(section.info)
+        it.writeInt(section.addressAlign)
+        it.writeInt(section.entrySize)
+      }
+    }
+  }
+
+  private fun LeRandomAccessFile.writeRelocation(relocation: AllegrexRelocation) {
+    writeInt(relocation.offset)
+    writeByte(relocation.type)
+    writeByte(relocation.symbol)
+    writeByte(relocation.symbol shr 8)
+    writeByte(relocation.symbol shr 16)
+  }
+
+  private fun LeRandomAccessFile.writeSymbol(symbol: Symbol) {
+    writeInt(symbol.name)
+    writeInt(symbol.value)
+    writeInt(symbol.size)
+    writeByte(symbol.info.toInt())
+    writeByte(symbol.other.toInt())
+    writeShort(symbol.sectionIndex)
+  }
+
+  object SectionName {
+    const val COMBINED_0 = ".combined0"
+    const val REL_COMBINED_0 = ".rel.combined0"
+    const val COMBINED_1 = ".combined1"
+    const val REL_COMBINED_1 = ".rel.combined1"
+    const val SYMTAB = ".symtab"
+    const val STRTAB = ".strtab"
+    const val SHSTRTAB = ".shstrtab"
+  }
+
+  object Const {
+    const val SHT_PROGBITS = 0x1
+    const val SHT_SYMTAB = 0x2
+    const val SHT_STRTAB = 0x3
+    const val SHT_REL = 0x9
+
+    const val SHF_WRITE = 0x1
+    const val SHF_ALLOC = 0x2
+    const val SHF_EXECINSTR = 0x4
+    const val SHF_INFO_LINK = 0x40
+
+    const val STB_LOCAL = 0x0 shl 4
+    const val STB_GLOBAL = 0x1 shl 4
+    const val STB_WEAK = 0x2 shl 4
+
+    const val STT_NOTYPE = 0x0
+    const val STT_FUNC = 0x2
+    const val STT_SECTION = 0x3
+  }
+
+  class StringAllocator {
+    private val cache = mutableMapOf<String, Int>()
+    private val bytes = ByteArrayOutputStream()
+
+    init {
+      getOrPut("")
+    }
+
+    fun getOrPut(text: String): Int {
+      return cache.getOrPut(text) {
+        val pos = bytes.size()
+        bytes.write(text.toByteArray(Charsets.US_ASCII))
+        bytes.write(byteArrayOf(0))
+        pos
+      }
+    }
+
+    fun lookup(offset: Int): String {
+      return lookupOrNull(offset)
+        ?: error("Can't find string in table for offset: $offset")
+    }
+
+    fun lookupOrNull(offset: Int): String? {
+      return cache.entries.firstOrNull { it.value == offset }?.key
+    }
+
+    fun toByteArray(): ByteArray {
+      return bytes.toByteArray()
+    }
+  }
+
+  data class AllegrexRelocation(
+    val offset: Int,
+    val type: Int,
+    val symbol: Int,
+  )
+
+  data class Symbol(
+    val name: Int,
+    val value: Int,
+    val size: Int,
+    val info: Byte,
+    val other: Byte,
+    val sectionIndex: Int
+  )
+
+  data class Section(
+    val name: Int,
+    val type: Int,
+    val flags: Int,
+    val address: Int,
+    val offset: Int,
+    val size: Int,
+    val link: Int,
+    val info: Int,
+    val addressAlign: Int,
+    val entrySize: Int,
+  )
+}
diff --git a/src/main/kotlin/allegrex/export/RelocatableKernelObjectExporter.kt b/src/main/kotlin/allegrex/export/RelocatableKernelObjectExporter.kt
new file mode 100644
index 0000000..24f5db8
--- /dev/null
+++ b/src/main/kotlin/allegrex/export/RelocatableKernelObjectExporter.kt
@@ -0,0 +1,638 @@
+package allegrex.export
+
+import allegrex.export.ExportElf.Const.SHF_ALLOC
+import allegrex.export.ExportElf.Const.SHF_EXECINSTR
+import allegrex.export.ExportElf.Const.SHF_INFO_LINK
+import allegrex.export.ExportElf.Const.SHF_WRITE
+import allegrex.export.ExportElf.Const.SHT_PROGBITS
+import allegrex.export.ExportElf.Const.SHT_REL
+import allegrex.export.ExportElf.Const.SHT_STRTAB
+import allegrex.export.ExportElf.Const.SHT_SYMTAB
+import allegrex.export.ExportElf.Const.STB_GLOBAL
+import allegrex.export.ExportElf.Const.STB_LOCAL
+import allegrex.export.ExportElf.Const.STB_WEAK
+import allegrex.export.ExportElf.Const.STT_FUNC
+import allegrex.export.ExportElf.Const.STT_NOTYPE
+import allegrex.export.ExportElf.Const.STT_SECTION
+import allegrex.export.ExportElf.SectionName.COMBINED_0
+import allegrex.export.ExportElf.SectionName.COMBINED_1
+import allegrex.export.ExportElf.SectionName.REL_COMBINED_0
+import allegrex.export.ExportElf.SectionName.REL_COMBINED_1
+import allegrex.export.ExportElf.SectionName.SHSTRTAB
+import allegrex.export.ExportElf.SectionName.STRTAB
+import allegrex.export.ExportElf.SectionName.SYMTAB
+import allegrex.format.elf.relocation.AllegrexElfRelocationConstants
+import allegrex.format.elf.relocation.AllegrexRelocation
+import ghidra.app.decompiler.DecompInterface
+import ghidra.app.decompiler.component.DecompilerUtils
+import ghidra.app.util.DomainObjectService
+import ghidra.app.util.Option
+import ghidra.app.util.OptionException
+import ghidra.app.util.OptionUtils
+import ghidra.app.util.exporter.Exporter
+import ghidra.app.util.exporter.ExporterException
+import ghidra.framework.model.DomainObject
+import ghidra.program.model.address.Address
+import ghidra.program.model.address.AddressRange
+import ghidra.program.model.address.AddressSetView
+import ghidra.program.model.listing.Function
+import ghidra.program.model.listing.Program
+import ghidra.program.model.mem.Memory
+import ghidra.program.model.mem.MemoryBlock
+import ghidra.program.model.pcode.PcodeOp
+import ghidra.program.model.pcode.PcodeOpAST
+import ghidra.program.model.pcode.Varnode
+import ghidra.program.model.reloc.Relocation
+import ghidra.program.model.reloc.RelocationTable
+import ghidra.program.model.symbol.SymbolType
+import ghidra.util.task.TaskMonitor
+import java.io.File
+import java.io.IOException
+
+@Suppress("unused")
+class RelocatableKernelObjectExporter : Exporter(
+  "Relocatable PSP kernel object", "o", null
+) {
+  companion object {
+    private object Options {
+      object GlobalDataSymbolsPattern {
+        private const val NAME = "Global data symbols names (regex)"
+        const val DEFAULT = "^g_.+\$"
+
+        fun toOption() = Option(NAME, DEFAULT)
+
+        fun getValue(options: List<Option>): String = OptionUtils.getOption(NAME, options, DEFAULT)
+      }
+    }
+
+    private val importStubBytes = byteArrayOf(0x08, 0x00, 0xe0.toByte(), 0x03, 0x00, 0x00, 0x00, 0x00) // jr ra / nop
+    private val kernelRelocationsSectionTypeBytes = byteArrayOf(0xa1.toByte(), 0x00, 0x00, 0x70) // SHT_PSP_REL_TYPE_B
+
+    // Section list for getting section indexes, they must appear in this order in output
+    private val sectionNames = listOf(
+      "", // UNDEF
+      COMBINED_0,
+      REL_COMBINED_0,
+      COMBINED_1,
+      REL_COMBINED_1,
+      SYMTAB,
+      STRTAB,
+      SHSTRTAB,
+    )
+  }
+
+  private var globalDataSymbolsRegex = Regex(Options.GlobalDataSymbolsPattern.DEFAULT)
+
+  override fun getOptions(domainObjectService: DomainObjectService): List<Option> {
+    return listOf(
+      Options.GlobalDataSymbolsPattern.toOption(),
+    )
+  }
+
+  @Throws(OptionException::class)
+  override fun setOptions(options: List<Option>) {
+    runCatching {
+      globalDataSymbolsRegex = Regex(Options.GlobalDataSymbolsPattern.getValue(options))
+    }
+      .getOrElse { throw OptionException(it.message) }
+  }
+
+  override fun supportsAddressRestrictedExport(): Boolean {
+    return false
+  }
+
+  @Throws(ExporterException::class, IOException::class)
+  override fun export(file: File, domainObj: DomainObject, addrSet: AddressSetView?, monitor: TaskMonitor): Boolean {
+    if (domainObj !is Program) {
+      log.appendMsg("Unsupported type: " + domainObj.javaClass.name)
+      return false
+    }
+    try {
+      return exportProgram(file, domainObj, monitor)
+    } catch (e: ProcessingException) {
+      log.appendMsg("ERROR: ${e.message}")
+      return false
+    } catch (e: Exception) {
+      throw ExporterException(e)
+    }
+  }
+
+  private fun exportProgram(file: File, program: Program, monitor: TaskMonitor): Boolean {
+    val validationMessage = validateKernelModule(program)
+    if (validationMessage != null) {
+      log.appendMsg("This file doesn't appear to be a PSP kernel module. $validationMessage")
+      return false
+    }
+    val blocks = resolveMemoryBlocks(program)
+    val programBytes = blocks.map { block ->
+      ByteArray(block.size.toInt())
+        .also { block.getBytes(block.start, it) }
+    }
+    val resolvedLoRelocations = resolveHiLoRelocations(program, monitor)
+    monitor.message = "Creating output file"
+    unapplyRelocations(program.relocationTable, blocks, programBytes)
+    val symbols = collectSymbols(program)
+    val functions = collectFunctions(program)
+    val strTab = ExportElf.StringAllocator()
+    val elfSymbols = createElfSymbols(strTab, symbols, functions)
+    checkElfSymbolsDuplicates(strTab, elfSymbols)
+    val (shStrTab, elfSections) = createElfSections()
+    val elfRelocations = createElfRelocations(program, symbols, programBytes, resolvedLoRelocations, strTab, elfSymbols)
+    ExportElf.writeElf(file, elfSections, shStrTab, elfSymbols, strTab, programBytes, elfRelocations)
+    return true
+  }
+
+  private fun validateKernelModule(program: Program): String? {
+    val programHeaders = program.memory.getBlock("_elfProgramHeaders")
+      ?: return "Section _elfProgramHeaders is missing"
+    if (programHeaders.size != 0x20L * 3) {
+      return "Program doesn't have 3 program headers"
+    }
+    val lastType = ByteArray(4)
+      .also { programHeaders.getBytes(programHeaders.start.add(0x20L * 2), it) }
+    if (!lastType.contentEquals(kernelRelocationsSectionTypeBytes)) {
+      return "Kernel relocations program header not found as the last header"
+    }
+    return null
+  }
+
+  private fun resolveMemoryBlocks(program: Program): List<MemoryBlock> {
+    val firstBlock = program.memory.blocks.firstOrNull { it.start == program.imageBase }
+      ?: throw ProcessingException("There must be memory block that start at image base")
+    val secondBlock = program.memory.blocks.sortedBy { it.start }
+      .firstOrNull { it.start > firstBlock.start }
+      ?: throw ProcessingException("There must be memory block that starts after the first block")
+    return listOf(firstBlock, secondBlock)
+  }
+
+  private fun resolveHiLoRelocations(program: Program, monitor: TaskMonitor): List<ResolvedLoRelocation> {
+    val (loRelocations, hiRelocations) = program.relocationTable.relocations.asSequence()
+      .filter { it.type == AllegrexElfRelocationConstants.R_MIPS_LO16 || it.type == AllegrexElfRelocationConstants.R_MIPS_X_HI16 }
+      .partition { it.type == AllegrexElfRelocationConstants.R_MIPS_LO16 }
+
+    var missingFunctions = false
+    val functions = loRelocations.map { relocation ->
+      program.functionManager.getFunctionContaining(relocation.address)
+        .also {
+          if (it == null) {
+            log.appendMsg("Could not find function for HI relocation at address ${relocation.address}, is the function defined?")
+            missingFunctions = true
+          }
+        }
+    }
+      .distinct()
+    if (missingFunctions) {
+      throw ProcessingException("Some functions containing HI relocations are not defined. Create them before exporting object file.")
+    }
+
+    val decompiler = createDecompiler(program)
+    val decompiledFunctions = try {
+      functions.associateWith { function ->
+        monitor.message = "Decompiling ${function.name}"
+        decompiler.decompileFunction(function, decompiler.options.defaultTimeout, monitor).also {
+          if (!it.decompileCompleted()) {
+            throw ProcessingException("Failed to decompile ${function.name}")
+          }
+        }
+      }
+    } finally {
+      decompiler.dispose()
+    }
+
+    monitor.message = "Processing HI/LO relocations"
+    val remainingHiRelocations = hiRelocations.toMutableList()
+    val hiRelocationToTargetAddresses = mutableMapOf<Address, MutableSet<Int>>()
+    val resolvedLoRelocations = loRelocations.map { loRelocation ->
+      val lowFunction = program.functionManager.getFunctionContaining(loRelocation.address)
+      val highFunction = decompiledFunctions[lowFunction]?.highFunction
+        ?: error("Missing decompilation result for relocation ${loRelocation.address}")
+      val instruction = program.listing.getInstructionAt(loRelocation.address)
+      val writtenRegister = instruction.getRegister(0).address
+      val lastLowPcode = instruction.pcode.last()
+      val pcodeAddress = when {
+        instruction.isInDelaySlot -> loRelocation.address.subtract(4)
+        else -> loRelocation.address
+      }
+      val pcodeOps = highFunction.getPcodeOps(pcodeAddress).asSequence().toList()
+      val registerWritePcode = pcodeOps
+        .filter { pcode ->
+          pcode.opcode == lastLowPcode.opcode
+        }
+        .lastOrNull { pcode ->
+          when (lastLowPcode.opcode) {
+            PcodeOp.LOAD, PcodeOp.INT_ADD, PcodeOp.INT_OR -> pcode.output.isRegister && pcode.output.address == writtenRegister
+            PcodeOp.STORE -> pcode.inputs[2].isRegister && pcode.inputs[2].address == writtenRegister
+            else -> false
+          }
+        }
+        ?: throw ProcessingException("Could not find pcode write for instruction at ${loRelocation.address}")
+
+      val sourceAddresses = mutableSetOf<Address>()
+      val targetAddress = when (registerWritePcode.opcode) {
+        PcodeOp.LOAD, PcodeOp.STORE -> backtraceVarnode(program, sourceAddresses, registerWritePcode.inputs[1])
+        else -> backtrackPcode(program, sourceAddresses, registerWritePcode)
+      }
+      val relatedHiRelocations = remainingHiRelocations
+        .filter { it.address in sourceAddresses }
+      remainingHiRelocations.removeAll(relatedHiRelocations)
+      hiRelocations // To spot duplicates can't use relatedHiRelocations here
+        .filter { it.address in sourceAddresses }
+        .forEach { hiRelocation ->
+          hiRelocationToTargetAddresses.getOrPut(hiRelocation.address) { mutableSetOf() }
+            .add(targetAddress)
+        }
+
+      ResolvedLoRelocation(
+        loRelocation = loRelocation,
+        relatedHiRelocations = relatedHiRelocations,
+        targetAddress = targetAddress - program.imageBase.offset.toInt()
+      )
+    }
+
+    if (remainingHiRelocations.isNotEmpty()) {
+      log.appendMsg("WARN: There are unaccounted HI relocations at addresses: ${remainingHiRelocations.map { it.address }}")
+    }
+    hiRelocationToTargetAddresses
+      .filterValues { it.size > 1 }
+      .forEach { (hiRelocationAddress, resolvedAddresses) ->
+        log.appendMsg(
+          "WARN: HI relocations at addresses: $hiRelocationAddress resolved to multiple addresses: " +
+            "${resolvedAddresses.map { Integer.toHexString(it) }}"
+        )
+      }
+
+    return resolvedLoRelocations
+  }
+
+  private fun backtrackPcode(program: Program, sourceAddresses: MutableSet<Address>, pcode: PcodeOpAST): Int {
+    return when (pcode.opcode) {
+      PcodeOp.INT_ADD -> backtraceVarnode(program, sourceAddresses, pcode.inputs[0]) + backtraceVarnode(program, sourceAddresses, pcode.inputs[1])
+      PcodeOp.INT_SUB -> backtraceVarnode(program, sourceAddresses, pcode.inputs[0]) - backtraceVarnode(program, sourceAddresses, pcode.inputs[1])
+      PcodeOp.INT_OR -> backtraceVarnode(program, sourceAddresses, pcode.inputs[0]) or backtraceVarnode(program, sourceAddresses, pcode.inputs[1])
+      PcodeOp.INT_LEFT -> backtraceVarnode(program, sourceAddresses, pcode.inputs[0]) shl backtraceVarnode(program, sourceAddresses, pcode.inputs[1])
+      PcodeOp.COPY, PcodeOp.INDIRECT -> backtraceVarnode(program, sourceAddresses, pcode.inputs[0])
+      else -> throw ProcessingException("Too complex data flow or unhandled pcode op ${pcode.opcode} in $pcode")
+    }
+  }
+
+  private fun backtraceVarnode(program: Program, sourceAddresses: MutableSet<Address>, varnode: Varnode): Int {
+    if (varnode.isConstant) {
+      return varnode.offset.toInt()
+    }
+    val def = varnode.def
+      ?: throw ProcessingException("Varnode $varnode is missing definition")
+    val instruction = program.listing.getInstructionAt(def.seqnum.target)
+    if (instruction.delaySlotDepth > 0) {
+      // this is a branch or jump instruction, the instruction which actually affects the relocation must be in the delay slot
+      sourceAddresses.add(def.seqnum.target.add(4))
+    } else {
+      sourceAddresses.add(def.seqnum.target)
+    }
+    return backtrackPcode(program, sourceAddresses, def as PcodeOpAST)
+  }
+
+  private fun createDecompiler(program: Program): DecompInterface {
+    val decompiler = DecompInterface()
+    decompiler.setOptions(DecompilerUtils.getDecompileOptions(this.provider, program))
+    decompiler.toggleCCode(false)
+    decompiler.toggleSyntaxTree(true)
+    decompiler.setSimplificationStyle("firstpass")
+    decompiler.openProgram(program)
+    return decompiler
+  }
+
+  private fun unapplyRelocations(relocationTable: RelocationTable, blocks: List<MemoryBlock>, programBytes: List<ByteArray>) {
+    relocationTable.relocations.forEach { relocation ->
+      val sectionIndex = blocks.indexOfFirst { it.addressRange.contains(relocation.address) }
+      if (sectionIndex == -1) {
+        throw ProcessingException("Can't find source memory block for relocation at ${relocation.address}")
+      }
+      val offset = relocation.address.subtract(blocks[sectionIndex].start).toInt()
+      System.arraycopy(relocation.bytes, 0, programBytes[sectionIndex], offset, relocation.bytes.size)
+    }
+  }
+
+  private fun collectSymbols(program: Program): List<ModuleSymbol> {
+    return program.symbolTable.symbolIterator
+      .mapNotNull map@{ symbol ->
+        val dataType = program.listing.getDataAt(symbol.address)?.dataType
+        ModuleSymbol(
+          name = symbol.name,
+          address = symbol.address.subtract(program.imageBase).toInt(),
+          dataLength = (dataType?.length ?: -1).takeIf { it > 0 },
+          global = symbol.name.matches(globalDataSymbolsRegex),
+          data = symbol.symbolType == SymbolType.LABEL
+        )
+      }
+  }
+
+  private fun collectFunctions(program: Program): List<ModuleFunction> {
+    val implementationTag = program.functionManager.functionTagManager.getFunctionTag("IMPLEMENTATION")
+    return program.functionManager.getFunctions(true)
+      .map {
+        ModuleFunction(
+          name = it.name,
+          entryPoint = it.entryPoint.subtract(program.imageBase).toInt(),
+          length = it.body.addressRanges.first().length.toInt(),
+          import = !it.tags.contains(implementationTag) && isFunctionLikelyImport(program.memory, it)
+        )
+      }
+  }
+
+  private fun isFunctionLikelyImport(memory: Memory, function: Function): Boolean {
+    val ranges = function.body.addressRanges.toList()
+    return ranges.size == 1 && isRangeLikelyImportStub(memory, ranges.first())
+  }
+
+  private fun isRangeLikelyImportStub(memory: Memory, range: AddressRange): Boolean {
+    val length = range.length.toInt()
+    if (length != 8) {
+      return false
+    }
+    val bytes = ByteArray(length)
+      .also { memory.getBytes(range.minAddress, it) }
+    return bytes.contentEquals(importStubBytes)
+  }
+
+  private fun createElfSymbols(
+    strTab: ExportElf.StringAllocator,
+    symbols: List<ModuleSymbol>,
+    functions: List<ModuleFunction>
+  ): List<ExportElf.Symbol> {
+    val combinedSectionSymbols =
+      listOf(
+        ExportElf.Symbol(strTab.getOrPut(COMBINED_0), 0, 0, (STB_LOCAL or STT_SECTION).toByte(), 0, sectionNames.indexOf(COMBINED_0)),
+        ExportElf.Symbol(strTab.getOrPut(COMBINED_1), 0, 0, (STB_LOCAL or STT_SECTION).toByte(), 0, sectionNames.indexOf(COMBINED_1)),
+      )
+    val weakFunctionSymbols = functions
+      .filter { it.import }
+      .map {
+        ExportElf.Symbol(
+          strTab.getOrPut(it.name),
+          it.entryPoint,
+          it.length,
+          (STB_WEAK or STT_FUNC).toByte(),
+          0,
+          sectionNames.indexOf(COMBINED_0)
+        )
+      }
+    val externFunctionSymbols = functions
+      .filter { !it.import }
+      .map { ExportElf.Symbol(strTab.getOrPut(it.name), 0, 0, (STB_GLOBAL or STT_NOTYPE).toByte(), 0, 0) }
+    val externDataSymbols = symbols
+      .filter { it.global && it.data }
+      .map { ExportElf.Symbol(strTab.getOrPut(it.name), 0, 0, (STB_GLOBAL or STT_NOTYPE).toByte(), 0, 0) }
+
+    return listOf(ExportElf.Symbol(strTab.getOrPut(""), 0, 0, 0, 0, 0)) +
+      combinedSectionSymbols +
+      weakFunctionSymbols +
+      externFunctionSymbols +
+      externDataSymbols
+  }
+
+  private fun checkElfSymbolsDuplicates(strTab: ExportElf.StringAllocator, elfSymbols: List<ExportElf.Symbol>) {
+    elfSymbols.groupBy { it.name }
+      .filter { it.value.size > 1 }
+      .forEach { (name, _) ->
+        log.appendMsg("WARN: Symbol ${strTab.lookup(name)} occurs multiple times in the symbol table")
+      }
+  }
+
+  private fun createElfSections(): Pair<ExportElf.StringAllocator, List<ExportElf.Section>> {
+    val shStrTab = ExportElf.StringAllocator()
+    val sections = sectionNames.map { sectionName ->
+      val nameOffset = shStrTab.getOrPut(sectionName)
+      when (sectionName) {
+        "" -> ExportElf.Section(nameOffset, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+        COMBINED_0 -> ExportElf.Section(nameOffset, SHT_PROGBITS, SHF_ALLOC or SHF_EXECINSTR, 0, -1, -1, 0, 0, 4, 0)
+        REL_COMBINED_0 -> {
+          // link: symbol table index, info: section index for applying relocations
+          ExportElf.Section(nameOffset, SHT_REL, SHF_INFO_LINK, 0, -1, -1, sectionNames.indexOf(SYMTAB), sectionNames.indexOf(COMBINED_0), 4, 8)
+        }
+        COMBINED_1 -> ExportElf.Section(nameOffset, SHT_PROGBITS, SHF_WRITE or SHF_ALLOC, 0, -1, -1, 0, 0, 4, 0)
+        REL_COMBINED_1 -> {
+          // link: symbol table index, info: section index for applying relocations
+          ExportElf.Section(nameOffset, SHT_REL, SHF_INFO_LINK, 0, -1, -1, sectionNames.indexOf(SYMTAB), sectionNames.indexOf(COMBINED_1), 4, 8)
+        }
+        SYMTAB -> {
+          // link: string table index, info: last local symbol index + 1 (in this case we only have local symbols for .combined0 and .combined1)
+          ExportElf.Section(nameOffset, SHT_SYMTAB, 0, 0, -1, -1, sectionNames.indexOf(STRTAB), 0x3, 4, 0x10)
+        }
+        STRTAB -> ExportElf.Section(nameOffset, SHT_STRTAB, 0, 0, -1, -1, 0, 0, 1, 0)
+        SHSTRTAB -> ExportElf.Section(nameOffset, SHT_STRTAB, 0, 0, -1, -1, 0, 0, 1, 0)
+        else -> error("Missing setup for section $sectionName")
+      }
+    }
+    return Pair(shStrTab, sections)
+  }
+
+  private fun createElfRelocations(
+    program: Program,
+    symbols: List<ModuleSymbol>,
+    programBytes: List<ByteArray>,
+    resolvedLoRelocations: List<ResolvedLoRelocation>,
+    strTab: ExportElf.StringAllocator,
+    elfSymbols: List<ExportElf.Symbol>,
+  ): List<List<ExportElf.AllegrexRelocation>> {
+    val elfRelocations: List<MutableList<ExportElf.AllegrexRelocation>> = listOf(mutableListOf(), mutableListOf())
+    program.relocationTable.relocations.forEach { relocation ->
+      val reloc = AllegrexRelocation.fromLongArray(relocation.values)
+      if (reloc !is AllegrexRelocation.TypeB) {
+        throw ProcessingException(
+          "Type A relocation in kernel module is not supported, " +
+            "relocation type ${relocation.type}, address ${relocation.address}"
+        )
+      }
+      when (relocation.type) {
+        AllegrexElfRelocationConstants.R_MIPS_32 -> {
+          val targetAddress = program.memory.getInt(relocation.address) - program.imageBase.offset.toInt()
+          val symbolOffsetInfo = getSymbolForAddress(program.imageBase, symbols, relocation, targetAddress)
+          val elfSymbolIndex = symbolOffsetInfo?.let { (moduleSymbol, _) ->
+            elfSymbols.indexOfFirst { elfSymbol -> elfSymbol.name == strTab.getOrPut(moduleSymbol.name) }
+              .takeIf { it != -1 }
+          }
+          if (symbolOffsetInfo != null && elfSymbolIndex != null) {
+            // TODO need to test this
+            programBytes[reloc.offsetBaseIndex][reloc.offset] = 0
+            programBytes[reloc.offsetBaseIndex][reloc.offset + 1] = 0
+            programBytes[reloc.offsetBaseIndex][reloc.offset + 2] = 0
+            programBytes[reloc.offsetBaseIndex][reloc.offset + 3] = 0
+            elfRelocations[reloc.offsetBaseIndex].add(
+              ExportElf.AllegrexRelocation(
+                reloc.offset,
+                AllegrexElfRelocationConstants.R_MIPS_32,
+                elfSymbolIndex,
+              )
+            )
+          } else {
+            elfRelocations[reloc.offsetBaseIndex].add(
+              ExportElf.AllegrexRelocation(
+                reloc.offset,
+                AllegrexElfRelocationConstants.R_MIPS_32,
+                reloc.addressBaseIndex + 1,
+              )
+            )
+          }
+        }
+        AllegrexElfRelocationConstants.R_MIPS_LO16, AllegrexElfRelocationConstants.R_MIPS_X_HI16 -> {
+          // Processed below using resolvedLoRelocations
+        }
+        AllegrexElfRelocationConstants.R_MIPS_X_J26 -> {
+          if (reloc.offsetBase != 0L || reloc.addressBase != 0L) {
+            throw ProcessingException("Not supported, jump is to or inside a non-zero section. $reloc")
+          }
+          elfRelocations[reloc.offsetBaseIndex].add(
+            ExportElf.AllegrexRelocation(
+              reloc.offset,
+              AllegrexElfRelocationConstants.R_MIPS_26,
+              reloc.addressBaseIndex + 1,
+            )
+          )
+        }
+        AllegrexElfRelocationConstants.R_MIPS_X_JAL26 -> {
+          if (reloc.offsetBase != 0L || reloc.addressBase != 0L) {
+            throw ProcessingException("Not supported, jal is to or inside a non-zero section. $reloc")
+          }
+          programBytes[reloc.offsetBaseIndex][reloc.offset] = 0
+          programBytes[reloc.offsetBaseIndex][reloc.offset + 1] = 0
+          programBytes[reloc.offsetBaseIndex][reloc.offset + 2] = 0
+          programBytes[reloc.offsetBaseIndex][reloc.offset + 3] = 0xC
+          val origInstr = program.listing.getInstructionAt(relocation.address)
+          val targetAddress = origInstr.getAddress(0)
+          val targetSymbol = program.symbolTable.symbolIterator.firstOrNull { it.address == targetAddress }
+            ?: throw ProcessingException("Unknown symbol for JAL relocation address ${relocation.address}, is the target function defined?")
+          val symbolIndex = elfSymbols.indexOfFirst { it.name == strTab.getOrPut(targetSymbol.name) }.takeIf { it != -1 }
+            ?: throw ProcessingException("No symbol in ELF symbol table for ${targetSymbol.name}, relocation address ${relocation.address}")
+          elfRelocations[reloc.offsetBaseIndex].add(
+            ExportElf.AllegrexRelocation(
+              reloc.offset,
+              AllegrexElfRelocationConstants.R_MIPS_26,
+              symbolIndex
+            )
+          )
+        }
+      }
+    }
+
+    val exportedGlobalDataSymbols = mutableSetOf<String>()
+    resolvedLoRelocations.forEach { resolvedLoRelocation ->
+      val targetAddress = resolvedLoRelocation.targetAddress
+      val symbolOffsetInfo = getSymbolForAddress(program.imageBase, symbols, resolvedLoRelocation.loRelocation, targetAddress)
+      val elfSymbolIndex = symbolOffsetInfo?.let { (moduleSymbol, _) ->
+        elfSymbols.indexOfFirst { elfSymbol -> elfSymbol.name == strTab.getOrPut(moduleSymbol.name) }
+          .takeIf { it != -1 }
+      }
+
+      resolvedLoRelocation.relatedHiRelocations.forEach { hiRelocation ->
+        val hiReloc = AllegrexRelocation.fromLongArray(hiRelocation.values)
+        if (hiReloc !is AllegrexRelocation.TypeB) {
+          throw ProcessingException("Type A relocation in kernel module is not supported, at address ${hiRelocation.address}")
+        }
+        if (symbolOffsetInfo != null && elfSymbolIndex != null) {
+          val (targetSymbol, symbolInnerOffset) = symbolOffsetInfo
+          exportedGlobalDataSymbols.add(targetSymbol.name)
+          programBytes[hiReloc.offsetBaseIndex][hiReloc.offset] = (symbolInnerOffset ushr 16).toByte() // TODO is this ok?
+          programBytes[hiReloc.offsetBaseIndex][hiReloc.offset + 1] = (symbolInnerOffset ushr 24).toByte()
+          elfRelocations[hiReloc.offsetBaseIndex].add(
+            ExportElf.AllegrexRelocation(
+              hiReloc.offset,
+              AllegrexElfRelocationConstants.R_MIPS_HI16,
+              elfSymbolIndex
+            )
+          )
+        } else {
+          // local symbol
+          val targetHi = targetAddress - targetAddress.toShort().toInt()
+          programBytes[hiReloc.offsetBaseIndex][hiReloc.offset] = (targetHi ushr 16).toByte() // TODO is this ok?
+          programBytes[hiReloc.offsetBaseIndex][hiReloc.offset + 1] = (targetHi ushr 24).toByte()
+          elfRelocations[hiReloc.offsetBaseIndex].add(
+            ExportElf.AllegrexRelocation(
+              hiReloc.offset,
+              AllegrexElfRelocationConstants.R_MIPS_HI16,
+              hiReloc.addressBaseIndex + 1,
+            )
+          )
+        }
+      }
+
+      val loReloc = AllegrexRelocation.fromLongArray(resolvedLoRelocation.loRelocation.values)
+      if (loReloc !is AllegrexRelocation.TypeB) {
+        throw ProcessingException("Type A relocation in kernel module is not supported, at address ${resolvedLoRelocation.loRelocation.address}")
+      }
+      if (symbolOffsetInfo != null && elfSymbolIndex != null) {
+        // remap to global symbol so need to set immediate value to the inner symbol offset
+        val (_, symbolInnerOffset) = symbolOffsetInfo
+        programBytes[loReloc.offsetBaseIndex][loReloc.offset] = symbolInnerOffset.toByte()
+        programBytes[loReloc.offsetBaseIndex][loReloc.offset + 1] = (symbolInnerOffset ushr 8).toByte()
+        elfRelocations[loReloc.offsetBaseIndex].add(
+          ExportElf.AllegrexRelocation(
+            loReloc.offset,
+            AllegrexElfRelocationConstants.R_MIPS_LO16,
+            elfSymbolIndex
+          )
+        )
+      } else {
+        // local symbol
+        val targetLo = targetAddress.toShort().toInt()
+        programBytes[loReloc.offsetBaseIndex][loReloc.offset] = targetLo.toByte()
+        programBytes[loReloc.offsetBaseIndex][loReloc.offset + 1] = (targetLo ushr 8).toByte()
+        elfRelocations[loReloc.offsetBaseIndex].add(
+          ExportElf.AllegrexRelocation(
+            loReloc.offset,
+            AllegrexElfRelocationConstants.R_MIPS_LO16,
+            loReloc.addressBaseIndex + 1,
+          )
+        )
+      }
+    }
+    log.appendMsg("\nGlobal data symbols:\n${exportedGlobalDataSymbols.joinToString("\n").ifEmpty { "(none)" }}")
+    return elfRelocations
+  }
+
+  private fun getSymbolForAddress(
+    imageBase: Address,
+    symbols: List<ModuleSymbol>,
+    relocation: Relocation,
+    targetAddress: Int
+  ): Pair<ModuleSymbol, Int>? {
+    symbols.forEach { sym ->
+      if (sym.dataLength != null) {
+        if (targetAddress >= sym.address && targetAddress < sym.address + sym.dataLength) {
+          return sym to (targetAddress - sym.address)
+        }
+      } else {
+        if (targetAddress == sym.address) {
+          return sym to 0
+        }
+      }
+    }
+    log.appendMsg(
+      "WARN: No symbol for offset ${imageBase.add(targetAddress.toLong() and 0xFFFFFFFF)}. " +
+        "Relocation type ${relocation.type}, address ${relocation.address}"
+    )
+    return null
+  }
+
+  private data class ModuleSymbol(
+    val name: String,
+    val address: Int,
+    val dataLength: Int?,
+    val global: Boolean,
+    val data: Boolean,
+  )
+
+  private data class ModuleFunction(
+    val name: String,
+    val entryPoint: Int,
+    val length: Int,
+    val import: Boolean,
+  )
+
+  private data class ResolvedLoRelocation(
+    val loRelocation: Relocation,
+    val relatedHiRelocations: List<Relocation>,
+    val targetAddress: Int,
+  )
+}
+
+private class ProcessingException(message: String) : Exception(message)
diff --git a/src/main/kotlin/allegrex/util/LeRandomAccessFile.kt b/src/main/kotlin/allegrex/util/LeRandomAccessFile.kt
new file mode 100644
index 0000000..8aed7fb
--- /dev/null
+++ b/src/main/kotlin/allegrex/util/LeRandomAccessFile.kt
@@ -0,0 +1,228 @@
+package allegrex.util
+
+import java.io.Closeable
+import java.io.DataInput
+import java.io.DataOutput
+import java.io.File
+import java.io.FileDescriptor
+import java.io.RandomAccessFile
+import java.nio.charset.Charset
+
+fun LeRandomAccessFile.align(pad: Long) = align(pad, length(), ::write)
+
+private inline fun align(pad: Long, length: Long, write: (ByteArray) -> Unit) {
+  if (length % pad == 0L) {
+    return
+  }
+  val targetCount = (length / pad + 1) * pad
+  val writeBytes = targetCount - length
+  if (writeBytes > Int.MAX_VALUE) {
+    error("Too big write size")
+  }
+  write(ByteArray(writeBytes.toInt()))
+}
+
+fun LeRandomAccessFile.readString(size: Int, charset: Charset = Charsets.UTF_8): String {
+  return readBytes(size).toString(charset)
+}
+
+fun LeRandomAccessFile.writeString(string: String, charset: Charset = Charsets.UTF_8) {
+  write(string.toByteArray(charset))
+}
+
+fun LeRandomAccessFile.readBytes(n: Int): ByteArray {
+  val bytes = ByteArray(n)
+  read(bytes)
+  return bytes
+}
+
+class LeRandomAccessFile(file: File, mode: String) : DataInput, DataOutput, Closeable {
+  constructor(file: File) : this(file, "rw")
+  constructor(path: String) : this(File(path), "rw")
+  constructor(path: String, mode: String) : this(File(path), mode)
+
+  private var raf = RandomAccessFile(file, mode)
+
+  val fd: FileDescriptor
+    get() = raf.fd
+
+  val filePointer
+    get() = raf.filePointer
+
+  fun length(): Long {
+    return raf.length()
+  }
+
+  fun setLength(newLength: Long) {
+    raf.setLength(newLength)
+  }
+
+  override fun close() {
+    raf.close()
+  }
+
+  fun seek(pos: Long) {
+    raf.seek(pos)
+  }
+
+  override fun skipBytes(n: Int): Int {
+    return raf.skipBytes(n)
+  }
+
+  fun read(): Int {
+    return raf.read()
+  }
+
+  fun read(b: ByteArray): Int {
+    return raf.read(b)
+  }
+
+  fun read(b: ByteArray, off: Int, len: Int): Int {
+    return raf.read(b, off, len)
+  }
+
+  override fun readFully(b: ByteArray) {
+    raf.readFully(b, 0, b.size)
+  }
+
+  override fun readFully(b: ByteArray, off: Int, len: Int) {
+    raf.readFully(b, off, len)
+  }
+
+  override fun readByte(): Byte {
+    return raf.readByte()
+  }
+
+  override fun readBoolean(): Boolean {
+    return raf.readBoolean()
+  }
+
+  override fun readUnsignedByte(): Int {
+    return raf.readUnsignedByte()
+  }
+
+  override fun readShort(): Short {
+    val b0 = read()
+    val b1 = read()
+    return ((b1 shl 8) or b0).toShort()
+  }
+
+  override fun readUnsignedShort(): Int {
+    val b0 = read()
+    val b1 = read()
+    return (b1 shl 8) or b0
+  }
+
+  override fun readChar(): Char {
+    val b0 = read()
+    val b1 = read()
+    return ((b1 shl 8) or b0).toChar()
+  }
+
+  override fun readInt(): Int {
+    val b0 = read()
+    val b1 = read()
+    val b2 = read()
+    val b3 = read()
+    return (b3 shl 24) or (b2 shl 16) or (b1 shl 8) or b0
+  }
+
+  override fun readLong(): Long {
+    val b0 = read()
+    val b1 = read()
+    val b2 = read()
+    val b3 = read()
+    val b4 = read()
+    val b5 = read()
+    val b6 = read()
+    val b7 = read()
+    return (b7.toLong() shl 56) or (b6.toLong() shl 48) or (b5.toLong() shl 40) or (b4.toLong() shl 32) or
+      (b3.toLong() shl 24) or (b2.toLong() shl 16) or (b1.toLong() shl 8) or b0.toLong()
+  }
+
+  override fun readFloat(): Float {
+    return Float.fromBits(readInt())
+  }
+
+  override fun readDouble(): Double {
+    return Double.fromBits(readLong())
+  }
+
+  override fun readLine(): String {
+    return raf.readLine()
+  }
+
+  @Deprecated("Use some other method for reading strings", level = DeprecationLevel.ERROR)
+  override fun readUTF(): String {
+    return raf.readUTF()
+  }
+
+  override fun write(b: Int) {
+    raf.write(b)
+  }
+
+  override fun write(b: ByteArray) {
+    raf.write(b)
+  }
+
+  override fun write(b: ByteArray, off: Int, len: Int) {
+    raf.write(b, off, len)
+  }
+
+  override fun writeBoolean(v: Boolean) {
+    raf.writeBoolean(v)
+  }
+
+  override fun writeByte(v: Int) {
+    raf.writeByte(v)
+  }
+
+  override fun writeShort(v: Int) {
+    raf.writeByte(v)
+    raf.writeByte(v shr 8)
+  }
+
+  override fun writeChar(v: Int) {
+    raf.writeByte(v)
+    raf.writeByte(v shr 8)
+  }
+
+  override fun writeInt(v: Int) {
+    raf.writeByte(v)
+    raf.writeByte(v shr 8)
+    raf.writeByte(v shr 16)
+    raf.writeByte(v shr 24)
+  }
+
+  override fun writeLong(v: Long) {
+    raf.writeByte((v and 0xFF).toInt())
+    raf.writeByte((v shr 8 and 0xFF).toInt())
+    raf.writeByte((v shr 16 and 0xFF).toInt())
+    raf.writeByte((v shr 24 and 0xFF).toInt())
+    raf.writeByte((v shr 32 and 0xFF).toInt())
+    raf.writeByte((v shr 40 and 0xFF).toInt())
+    raf.writeByte((v shr 48 and 0xFF).toInt())
+    raf.writeByte((v shr 56 and 0xFF).toInt())
+  }
+
+  override fun writeFloat(v: Float) {
+    writeInt(v.toBits())
+  }
+
+  override fun writeDouble(v: Double) {
+    writeLong(v.toBits())
+  }
+
+  override fun writeBytes(s: String) {
+    raf.writeBytes(s)
+  }
+
+  override fun writeChars(s: String) {
+    s.toCharArray().forEach { writeChar(it.code) }
+  }
+
+  @Deprecated("Use some other method for writing strings", level = DeprecationLevel.ERROR)
+  override fun writeUTF(s: String) {
+    raf.writeUTF(s)
+  }
+}