Flattened package hierarchy

src/elf/Constants.go

@@ -0,0 +1,55 @@
+package elf
+
+const (
+	LittleEndian      = 1
+	TypeExecutable    = 2
+	ArchitectureAMD64 = 0x3E
+)
+
+type ProgramType int32
+
+const (
+	ProgramTypeNULL    ProgramType = 0
+	ProgramTypeLOAD    ProgramType = 1
+	ProgramTypeDYNAMIC ProgramType = 2
+	ProgramTypeINTERP  ProgramType = 3
+	ProgramTypeNOTE    ProgramType = 4
+	ProgramTypeSHLIB   ProgramType = 5
+	ProgramTypePHDR    ProgramType = 6
+	ProgramTypeTLS     ProgramType = 7
+)
+
+type ProgramFlags int32
+
+const (
+	ProgramFlagsExecutable ProgramFlags = 0x1
+	ProgramFlagsWritable   ProgramFlags = 0x2
+	ProgramFlagsReadable   ProgramFlags = 0x4
+)
+
+type SectionType int32
+
+const (
+	SectionTypeNULL     SectionType = 0
+	SectionTypePROGBITS SectionType = 1
+	SectionTypeSYMTAB   SectionType = 2
+	SectionTypeSTRTAB   SectionType = 3
+	SectionTypeRELA     SectionType = 4
+	SectionTypeHASH     SectionType = 5
+	SectionTypeDYNAMIC  SectionType = 6
+	SectionTypeNOTE     SectionType = 7
+	SectionTypeNOBITS   SectionType = 8
+	SectionTypeREL      SectionType = 9
+	SectionTypeSHLIB    SectionType = 10
+	SectionTypeDYNSYM   SectionType = 11
+)
+
+type SectionFlags int64
+
+const (
+	SectionFlagsWritable   SectionFlags = 1 << 0
+	SectionFlagsAllocate   SectionFlags = 1 << 1
+	SectionFlagsExecutable SectionFlags = 1 << 2
+	SectionFlagsStrings    SectionFlags = 1 << 5
+	SectionFlagsTLS        SectionFlags = 1 << 10
+)

src/elf/ELF.go

@@ -0,0 +1,82 @@
+package elf
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"git.akyoto.dev/cli/q/src/config"
+	"git.akyoto.dev/cli/q/src/exe"
+)
+
+// ELF represents an ELF file.
+type ELF struct {
+	Header
+	CodeHeader ProgramHeader
+	DataHeader ProgramHeader
+}
+
+// Write writes the ELF64 format to the given writer.
+func Write(writer io.Writer, code []byte, data []byte) {
+	const HeaderEnd = HeaderSize + ProgramHeaderSize*2
+
+	var (
+		codeStart, codePadding = exe.Align(HeaderEnd, config.Align)
+		dataStart, dataPadding = exe.Align(codeStart+len(code), config.Align)
+	)
+
+	elf := &ELF{
+		Header: Header{
+			Magic:                       [4]byte{0x7F, 'E', 'L', 'F'},
+			Class:                       2,
+			Endianness:                  LittleEndian,
+			Version:                     1,
+			OSABI:                       0,
+			ABIVersion:                  0,
+			Type:                        TypeExecutable,
+			Architecture:                ArchitectureAMD64,
+			FileVersion:                 1,
+			EntryPointInMemory:          config.BaseAddress + config.CodeOffset,
+			ProgramHeaderOffset:         HeaderSize,
+			SectionHeaderOffset:         0,
+			Flags:                       0,
+			Size:                        HeaderSize,
+			ProgramHeaderEntrySize:      ProgramHeaderSize,
+			ProgramHeaderEntryCount:     2,
+			SectionHeaderEntrySize:      0,
+			SectionHeaderEntryCount:     0,
+			SectionNameStringTableIndex: 0,
+		},
+		CodeHeader: ProgramHeader{
+			Type:            ProgramTypeLOAD,
+			Flags:           ProgramFlagsExecutable | ProgramFlagsReadable,
+			Offset:          config.CodeOffset,
+			VirtualAddress:  config.BaseAddress + config.CodeOffset,
+			PhysicalAddress: config.BaseAddress + config.CodeOffset,
+			SizeInFile:      int64(len(code)),
+			SizeInMemory:    int64(len(code)),
+			Align:           config.Align,
+		},
+		DataHeader: ProgramHeader{
+			Type:            ProgramTypeLOAD,
+			Flags:           ProgramFlagsReadable,
+			Offset:          int64(dataStart),
+			VirtualAddress:  int64(config.BaseAddress + dataStart),
+			PhysicalAddress: int64(config.BaseAddress + dataStart),
+			SizeInFile:      int64(len(data)),
+			SizeInMemory:    int64(len(data)),
+			Align:           config.Align,
+		},
+	}
+
+	binary.Write(writer, binary.LittleEndian, &elf.Header)
+	binary.Write(writer, binary.LittleEndian, &elf.CodeHeader)
+	binary.Write(writer, binary.LittleEndian, &elf.DataHeader)
+	writer.Write(bytes.Repeat([]byte{0x00}, codePadding))
+	writer.Write(code)
+
+	if len(data) > 0 {
+		writer.Write(bytes.Repeat([]byte{0x00}, dataPadding))
+		writer.Write(data)
+	}
+}

src/elf/ELF_test.go

@@ -0,0 +1,12 @@
+package elf_test
+
+import (
+	"io"
+	"testing"
+
+	"git.akyoto.dev/cli/q/src/elf"
+)
+
+func TestWrite(t *testing.T) {
+	elf.Write(io.Discard, nil, nil)
+}

src/elf/Header.go

@@ -0,0 +1,28 @@
+package elf
+
+// HeaderSize is equal to the size of a header in bytes.
+const HeaderSize = 64
+
+// Header contains general information.
+type Header struct {
+	Magic                       [4]byte
+	Class                       byte
+	Endianness                  byte
+	Version                     byte
+	OSABI                       byte
+	ABIVersion                  byte
+	_                           [7]byte
+	Type                        int16
+	Architecture                int16
+	FileVersion                 int32
+	EntryPointInMemory          int64
+	ProgramHeaderOffset         int64
+	SectionHeaderOffset         int64
+	Flags                       int32
+	Size                        int16
+	ProgramHeaderEntrySize      int16
+	ProgramHeaderEntryCount     int16
+	SectionHeaderEntrySize      int16
+	SectionHeaderEntryCount     int16
+	SectionNameStringTableIndex int16
+}

src/elf/ProgramHeader.go

@@ -0,0 +1,16 @@
+package elf
+
+// ProgramHeaderSize is equal to the size of a program header in bytes.
+const ProgramHeaderSize = 56
+
+// ProgramHeader points to the executable part of our program.
+type ProgramHeader struct {
+	Type            ProgramType
+	Flags           ProgramFlags
+	Offset          int64
+	VirtualAddress  int64
+	PhysicalAddress int64
+	SizeInFile      int64
+	SizeInMemory    int64
+	Align           int64
+}

src/elf/SectionHeader.go

@@ -0,0 +1,18 @@
+package elf
+
+// SectionHeaderSize is equal to the size of a section header in bytes.
+const SectionHeaderSize = 64
+
+// SectionHeader points to the data sections of our program.
+type SectionHeader struct {
+	NameIndex      int32
+	Type           SectionType
+	Flags          SectionFlags
+	VirtualAddress int64
+	Offset         int64
+	SizeInFile     int64
+	Link           int32
+	Info           int32
+	Align          int64
+	EntrySize      int64
+}

src/elf/elf.md

@@ -0,0 +1,38 @@
+# ELF
+
+## Basic structure
+
+1. ELF header (0x00 - 0x40)
+2. Program header (0x40 - 0x78)
+3. Padding
+4. Machine code
+
+## Entry point
+
+The entry point is defined in the first 64 bytes (ELF header).
+
+## Base address
+
+The minimum base address is controlled by the `mmap` settings:
+
+```shell
+sysctl vm.mmap_min_addr
+```
+
+Usually, this value is 65536 (0x1000).
+
+## Initialization in Linux
+
+ELF loader:
+https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/binfmt_elf.c
+
+ELF register definitions:
+https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/elf.h
+
+## Links
+
+- https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/elf.h
+- https://lwn.net/Articles/631631/
+- https://en.wikipedia.org/wiki/Executable_and_Linkable_Format
+- https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html
+- https://nathanotterness.com/2021/10/tiny_elf_modernized.html