@aptre/v86 0.5.0

package/src/elf.ts

@@ -0,0 +1,251 @@
+declare let DEBUG: boolean
+
+import { dbg_log, LOG_LEVEL } from './log.js'
+
+// A minimal elf parser for loading 32 bit, x86, little endian, executable elf files
+
+const ELF_MAGIC = 0x464c457f
+
+interface FieldType {
+    size: number
+    get: (offset: number, littleEndian?: boolean) => number
+    set?: (offset: number, value: number, littleEndian?: boolean) => void
+}
+
+interface StructEntry {
+    name: string
+    type: FieldType
+    size: number
+    get: (offset: number, littleEndian?: boolean) => number
+    set:
+        | ((offset: number, value: number, littleEndian?: boolean) => void)
+        | undefined
+}
+
+type StructRecord = Record<string, number>
+
+export interface ElfResult {
+    header: StructRecord
+    program_headers: StructRecord[]
+    sections_headers: StructRecord[]
+}
+
+const types = DataView.prototype
+const U8: FieldType = { size: 1, get: types.getUint8, set: types.setUint8 }
+const U16: FieldType = { size: 2, get: types.getUint16, set: types.setUint16 }
+const U32: FieldType = { size: 4, get: types.getUint32, set: types.setUint32 }
+const pad = function (size: number): FieldType {
+    return {
+        size,
+        get: (_offset: number): number => -1,
+    }
+}
+
+const Header: StructEntry[] = create_struct([
+    { magic: U32 },
+
+    { class: U8 },
+    { data: U8 },
+    { version0: U8 },
+    { osabi: U8 },
+
+    { abiversion: U8 },
+    { pad0: pad(7) },
+
+    { type: U16 },
+    { machine: U16 },
+
+    { version1: U32 },
+    { entry: U32 },
+    { phoff: U32 },
+    { shoff: U32 },
+    { flags: U32 },
+
+    { ehsize: U16 },
+    { phentsize: U16 },
+    { phnum: U16 },
+    { shentsize: U16 },
+    { shnum: U16 },
+    { shstrndx: U16 },
+])
+console.assert(
+    Header.reduce((a: number, entry: StructEntry) => a + entry.size, 0) === 52,
+)
+
+const ProgramHeader: StructEntry[] = create_struct([
+    { type: U32 },
+    { offset: U32 },
+    { vaddr: U32 },
+    { paddr: U32 },
+    { filesz: U32 },
+    { memsz: U32 },
+    { flags: U32 },
+    { align: U32 },
+])
+console.assert(
+    ProgramHeader.reduce(
+        (a: number, entry: StructEntry) => a + entry.size,
+        0,
+    ) === 32,
+)
+
+const SectionHeader: StructEntry[] = create_struct([
+    { name: U32 },
+    { type: U32 },
+    { flags: U32 },
+    { addr: U32 },
+    { offset: U32 },
+    { size: U32 },
+    { link: U32 },
+    { info: U32 },
+    { addralign: U32 },
+    { entsize: U32 },
+])
+console.assert(
+    SectionHeader.reduce(
+        (a: number, entry: StructEntry) => a + entry.size,
+        0,
+    ) === 40,
+)
+
+// From [{ name: type }, ...] to [{ name, type, size, get, set }, ...]
+function create_struct(struct: Record<string, FieldType>[]): StructEntry[] {
+    return struct.map(function (entry: Record<string, FieldType>): StructEntry {
+        const keys = Object.keys(entry)
+        console.assert(keys.length === 1)
+        const name = keys[0]
+        const type = entry[name]
+
+        console.assert(type.size > 0)
+
+        return {
+            name,
+            type,
+            size: type.size,
+            get: type.get,
+            set: type.set,
+        }
+    })
+}
+
+export function read_elf(buffer: ArrayBuffer): ElfResult {
+    const view = new DataView(buffer)
+
+    const [header, offset] = read_struct(view, Header)
+    console.assert(offset === 52)
+
+    if (DEBUG) {
+        for (const key of Object.keys(header)) {
+            dbg_log(key + ': 0x' + (Number(header[key].toString(16)) >>> 0))
+        }
+    }
+
+    console.assert(header.magic === ELF_MAGIC, 'Bad magic')
+    console.assert(header.class === 1, 'Unimplemented: 64 bit elf')
+    console.assert(header.data === 1, 'Unimplemented: big endian')
+    console.assert(header.version0 === 1, 'Bad version0')
+
+    // 1, 2, 3, 4 specify whether the object is relocatable, executable,
+    // shared, or core, respectively.
+    console.assert(header.type === 2, 'Unimplemented type')
+
+    console.assert(header.version1 === 1, 'Bad version1')
+
+    // these are different in 64 bit
+    console.assert(header.ehsize === 52, 'Bad header size')
+    console.assert(header.phentsize === 32, 'Bad program header size')
+    console.assert(header.shentsize === 40, 'Bad section header size')
+
+    const [program_headers, _ph_offset] = read_structs(
+        view_slice(view, header.phoff, header.phentsize * header.phnum),
+        ProgramHeader,
+        header.phnum,
+    )
+
+    const [sections_headers, _sh_offset] = read_structs(
+        view_slice(view, header.shoff, header.shentsize * header.shnum),
+        SectionHeader,
+        header.shnum,
+    )
+
+    if (DEBUG && LOG_LEVEL) {
+        console.log('%d program headers:', program_headers.length)
+        for (const program of program_headers) {
+            console.log(
+                'type=%s offset=%s vaddr=%s paddr=%s ' +
+                    'filesz=%s memsz=%s flags=%s align=%s',
+                program.type.toString(16),
+                program.offset.toString(16),
+                program.vaddr.toString(16),
+                program.paddr.toString(16),
+                program.filesz.toString(16),
+                program.memsz.toString(16),
+                program.flags.toString(16),
+                program.align.toString(16),
+            )
+        }
+
+        console.log('%d section headers:', sections_headers.length)
+        for (const section of sections_headers) {
+            console.log(
+                'name=%s type=%s flags=%s addr=%s offset=%s ' +
+                    'size=%s link=%s info=%s addralign=%s entsize=%s',
+                section.name.toString(16),
+                section.type.toString(16),
+                section.flags.toString(16),
+                section.addr.toString(16),
+                section.offset.toString(16),
+                section.size.toString(16),
+                section.link.toString(16),
+                section.info.toString(16),
+                section.addralign.toString(16),
+                section.entsize.toString(16),
+            )
+        }
+    }
+
+    return {
+        header,
+        program_headers,
+        sections_headers,
+    }
+}
+
+function read_struct(
+    view: DataView,
+    Struct: StructEntry[],
+): [StructRecord, number] {
+    const result: StructRecord = {}
+    let offset = 0
+    const LITTLE_ENDIAN = true // big endian not supported yet
+
+    for (const entry of Struct) {
+        const value = entry.get.call(view, offset, LITTLE_ENDIAN)
+        console.assert(result[entry.name] === undefined)
+        result[entry.name] = value
+        offset += entry.size
+    }
+
+    return [result, offset]
+}
+
+function read_structs(
+    view: DataView,
+    Struct: StructEntry[],
+    count: number,
+): [StructRecord[], number] {
+    const result: StructRecord[] = []
+    let offset = 0
+
+    for (let i = 0; i < count; i++) {
+        const [s, size] = read_struct(view_slice(view, offset), Struct)
+        result.push(s)
+        offset += size
+    }
+
+    return [result, offset]
+}
+
+function view_slice(view: DataView, offset: number, length?: number): DataView {
+    return new DataView(view.buffer, view.byteOffset + offset, length)
+}