`elf_writer.nx` source

↩ module page · 247 lines · 9296 B
1// elf_writer.nx -- emit a minimal RV64 Linux ELF executable.
2//
3// Library form: `write_elf(code, code_len, fd)` produces a statically-
4// loadable ELF64 on `fd` that executes `code` when run.  No linker,
5// no libc, no gcc `as`.  With this + nxasm + nxc2.nx we have the full
6// binary-up chain in pure NishiLang.
7//
8// Layout:
9//   [0..64)            ELF header (e_ehsize = 64)
10//   [64..120)          Program header (PT_LOAD, 56 bytes)
11//   [120..120+N)       Code -- N bytes of RV64 machine code
12//
13// Virtual address base = 0x10000 (standard for statically-linked
14// Linux RV64).  Entry point = 0x10000 + 120 so execution starts at
15// the first code byte.
16
17import "../runtime/nx_syscalls.nx"
18
19// Encode a 64-bit little-endian value into `dst[off..off+8]`.
20func put_u64_le(dst: *u8, off: i64, v: i64) -> i64 {
  dst[off + 0] = (v        ) & 0xFF
  dst[off + 1] = (v >>  8  ) & 0xFF
  dst[off + 2] = (v >> 16  ) & 0xFF
  dst[off + 3] = (v >> 24  ) & 0xFF
  dst[off + 4] = (v >> 32  ) & 0xFF
  dst[off + 5] = (v >> 40  ) & 0xFF
  dst[off + 6] = (v >> 48  ) & 0xFF
  dst[off + 7] = (v >> 56  ) & 0xFF
  return 0
30}
31
32// Parameterised variant: build an ELF with custom base vaddr.  The
33// kernel needs vaddr = 0x80000000 (bare-metal RV64 M-mode convention);
34// Linux userspace uses 0x10000.  Same layout otherwise.
35//
36// Returns total byte count (120 + code_len).
37func build_elf_image_at(out: *u8, code: *u8, code_len: i64,
                      base_vaddr: i64) -> i64 {
  let entry_vaddr: i64 = base_vaddr + 120
  // ---- ELF header (64 bytes) ----
  out[0]  = 0x7F
  out[1]  = 0x45
  out[2]  = 0x4C
  out[3]  = 0x46
  out[4]  = 2
  out[5]  = 1
  out[6]  = 1
  out[7]  = 0
  out[8]  = 0;  out[9]  = 0;  out[10] = 0;  out[11] = 0
  out[12] = 0;  out[13] = 0;  out[14] = 0;  out[15] = 0
  out[16] = 2;  out[17] = 0                   // e_type = ET_EXEC
  out[18] = 0xF3; out[19] = 0                 // e_machine = EM_RISCV
  out[20] = 1;  out[21] = 0;  out[22] = 0;  out[23] = 0
  put_u64_le(out, 24, entry_vaddr)
  put_u64_le(out, 32, 64)                     // e_phoff
  put_u64_le(out, 40, 0)                      // e_shoff
  out[48] = 0;  out[49] = 0;  out[50] = 0;  out[51] = 0
  out[52] = 64; out[53] = 0                   // e_ehsize
  out[54] = 56; out[55] = 0                   // e_phentsize
  out[56] = 1;  out[57] = 0                   // e_phnum
  out[58] = 0;  out[59] = 0                   // e_shentsize
  out[60] = 0;  out[61] = 0                   // e_shnum
  out[62] = 0;  out[63] = 0                   // e_shstrndx
  // ---- Program header (56 bytes, offset 64) ----
  out[64] = 1;  out[65] = 0;  out[66] = 0;  out[67] = 0    // PT_LOAD
  out[68] = 5;  out[69] = 0;  out[70] = 0;  out[71] = 0    // PF_R|PF_X
  put_u64_le(out, 72, 0)                      // p_offset
  put_u64_le(out, 80, base_vaddr)             // p_vaddr
  put_u64_le(out, 88, base_vaddr)             // p_paddr
  put_u64_le(out, 96, 120 + code_len)         // p_filesz
  put_u64_le(out, 104, 120 + code_len)        // p_memsz
  put_u64_le(out, 112, 0x1000)                // p_align
  // ---- Code ----
  var i: i64 = 0
  while i < code_len {
      out[120 + i] = code[i]
      i = i + 1
  }
  return 120 + code_len
80}
81
82// Write ELF at a custom base vaddr to fd.
83func write_elf_at(code: *u8, code_len: i64, base_vaddr: i64,
                fd: i64) -> i64 {
  let total: i64 = 120 + code_len
  let img: *u8 = sys_mmap(total + 64)
  build_elf_image_at(img, code, code_len, base_vaddr)
  return sys_write(fd, img, total)
89}
90
91// Kernel-mode ELF: page-aligned code at file offset 0x1000.
92//
93// Bare-metal RV64 (QEMU `virt` -bios none -kernel ELF) puts the CPU's
94// reset vector at vaddr 0x80000000 via a fixed mask ROM that ignores
95// e_entry.  So vaddr 0x80000000 MUST be the first byte of executable
96// code, not the ELF magic.  The userspace layout (file_offset=0 ->
97// vaddr=base) puts the ELF header at 0x80000000 -- silent garbage
98// execution.
99//
100// This layout matches what GNU `ld` produces for the same kernel:
101//   File [0..0x40)     ELF header
102//   File [0x40..0x78)  Program header (PT_LOAD, 56 bytes)
103//   File [0x78..0x1000) Zero padding (page-alignment fill)
104//   File [0x1000..)    Code (loaded at p_vaddr = base_vaddr)
105//
106// Entry point = base_vaddr (= start of code in memory).
107//
108// Returns total byte count (0x1000 + code_len).
109func build_elf_kernel_at(out: *u8, code: *u8, code_len: i64,
                       base_vaddr: i64) -> i64 {
  // Zero the header + padding region [0..0x1000).
  var z: i64 = 0
  while z < 0x1000 {
      out[z] = 0
      z = z + 1
  }
  // ---- ELF header (64 bytes) ----
  out[0]  = 0x7F
  out[1]  = 0x45
  out[2]  = 0x4C
  out[3]  = 0x46
  out[4]  = 2
  out[5]  = 1
  out[6]  = 1
  out[7]  = 0
  out[16] = 2;  out[17] = 0                   // e_type = ET_EXEC
  out[18] = 0xF3; out[19] = 0                 // e_machine = EM_RISCV
  out[20] = 1;  out[21] = 0;  out[22] = 0;  out[23] = 0
  put_u64_le(out, 24, base_vaddr)             // e_entry = base (first code byte)
  put_u64_le(out, 32, 64)                     // e_phoff
  put_u64_le(out, 40, 0)                      // e_shoff = 0
  out[52] = 64; out[53] = 0                   // e_ehsize
  out[54] = 56; out[55] = 0                   // e_phentsize
  out[56] = 1;  out[57] = 0                   // e_phnum
  // ---- Program header (56 bytes, offset 64) ----
  out[64] = 1;  out[65] = 0;  out[66] = 0;  out[67] = 0    // PT_LOAD
  out[68] = 7;  out[69] = 0;  out[70] = 0;  out[71] = 0    // PF_R|PF_W|PF_X
  put_u64_le(out, 72, 0x1000)                 // p_offset (page-aligned)
  put_u64_le(out, 80, base_vaddr)             // p_vaddr
  put_u64_le(out, 88, base_vaddr)             // p_paddr
  put_u64_le(out, 96, code_len)               // p_filesz (code only)
  put_u64_le(out, 104, code_len)              // p_memsz
  put_u64_le(out, 112, 0x1000)                // p_align
  // ---- Code at file offset 0x1000 ----
  var i: i64 = 0
  while i < code_len {
      out[0x1000 + i] = code[i]
      i = i + 1
  }
  return 0x1000 + code_len
151}
152
153// Write a kernel-mode ELF (page-aligned code at file offset 0x1000) to fd.
154func write_elf_kernel_at(code: *u8, code_len: i64, base_vaddr: i64,
                       fd: i64) -> i64 {
  let total: i64 = 0x1000 + code_len
  let img: *u8 = sys_mmap(total + 0x1000)
  build_elf_kernel_at(img, code, code_len, base_vaddr)
  return sys_write(fd, img, total)
160}
161
162// Build the full ELF image (header + phdr + code) into `out`, return
163// the total byte count.  Caller sizes `out` to at least code_len +
164// 120 bytes.
165func build_elf_image(out: *u8, code: *u8, code_len: i64) -> i64 {
  // ---- ELF header (64 bytes) ----
  // e_ident[16]: magic + class64 + data2lsb + version1 + osabi=sysv
  out[0]  = 0x7F
  out[1]  = 0x45  // 'E'
  out[2]  = 0x4C  // 'L'
  out[3]  = 0x46  // 'F'
  out[4]  = 2     // ELFCLASS64
  out[5]  = 1     // ELFDATA2LSB
  out[6]  = 1     // EV_CURRENT
  out[7]  = 0     // ELFOSABI_SYSV
  out[8]  = 0     // abiversion
  out[9]  = 0
  out[10] = 0
  out[11] = 0
  out[12] = 0
  out[13] = 0
  out[14] = 0
  out[15] = 0
  // e_type (2) = ET_EXEC (2)
  out[16] = 2; out[17] = 0
  // e_machine (2) = EM_RISCV (243 = 0xF3)
  out[18] = 0xF3; out[19] = 0
  // e_version (4) = 1
  out[20] = 1; out[21] = 0; out[22] = 0; out[23] = 0
  // e_entry (8) = 0x10000 + 120 = 0x10078
  put_u64_le(out, 24, 0x10078)
  // e_phoff (8) = 64
  put_u64_le(out, 32, 64)
  // e_shoff (8) = 0
  put_u64_le(out, 40, 0)
  // e_flags (4) = 0
  out[48] = 0; out[49] = 0; out[50] = 0; out[51] = 0
  // e_ehsize (2) = 64
  out[52] = 64; out[53] = 0
  // e_phentsize (2) = 56
  out[54] = 56; out[55] = 0
  // e_phnum (2) = 1
  out[56] = 1; out[57] = 0
  // e_shentsize (2) = 0
  out[58] = 0; out[59] = 0
  // e_shnum (2) = 0
  out[60] = 0; out[61] = 0
  // e_shstrndx (2) = 0
  out[62] = 0; out[63] = 0
210
  // ---- Program header (56 bytes, offset 64) ----
  // p_type (4) = PT_LOAD (1)
  out[64] = 1; out[65] = 0; out[66] = 0; out[67] = 0
  // p_flags (4) = PF_R | PF_X = 5
  out[68] = 5; out[69] = 0; out[70] = 0; out[71] = 0
  // p_offset (8) = 0
  put_u64_le(out, 72, 0)
  // p_vaddr (8) = 0x10000
  put_u64_le(out, 80, 0x10000)
  // p_paddr (8) = 0x10000
  put_u64_le(out, 88, 0x10000)
  // p_filesz (8) = 120 + code_len
  put_u64_le(out, 96, 120 + code_len)
  // p_memsz (8) = 120 + code_len
  put_u64_le(out, 104, 120 + code_len)
  // p_align (8) = 0x1000
  put_u64_le(out, 112, 0x1000)
228
  // ---- Code (120 onwards) ----
  var i: i64 = 0
  while i < code_len {
      out[120 + i] = code[i]
      i = i + 1
  }
  return 120 + code_len
236}
237
238// Write an ELF wrapping `code` to fd.  Returns the byte count
239// written, or a negative errno on failure.
240func write_elf(code: *u8, code_len: i64, fd: i64) -> i64 {
  let total: i64 = 120 + code_len
  let img: *u8 = sys_mmap(total + 64)
  build_elf_image(img, code, code_len)
  return sys_write(fd, img, total)
245}
246
247// Library only; self-test + exit(42) demo lives in elf_writer_test.nx.
elf_writer.nx source

`elf_writer.nx` source
