cli/q
Code Issues Pull Requests Activity

Improved Windows support

Browse Source
This commit is contained in:
Eduard Urbach 2024-08-13 19:34:54 +02:00
parent 7b1a293cd0
commit e818e5b907
Signed by: akyoto
GPG Key ID: C874F672B1AF20C0
16 changed files with 142 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/sys/sys_windows.q Normal file
View File

@ -0,0 +1,3 @@
write(_ Int, _ Pointer, _ Int) -> Int {
return 0
}

25
src/asm/Finalize.go
View File

@ -9,6 +9,9 @@ import (
"git.akyoto.dev/cli/q/src/arch/x64"
"git.akyoto.dev/cli/q/src/config"
"git.akyoto.dev/cli/q/src/os/common"
"git.akyoto.dev/cli/q/src/os/linux/elf"
"git.akyoto.dev/cli/q/src/os/mac/macho"
"git.akyoto.dev/cli/q/src/os/windows/pe"
"git.akyoto.dev/cli/q/src/sizeof"
)
@ -337,8 +340,26 @@ restart:
}
data, dataLabels = a.Data.Finalize()
dataStart := config.BaseAddress + config.CodeOffset + Address(len(code))
dataStart += int32(common.Padding(int64(dataStart), config.Align))
var (
codeOffset Address
align Address
)
switch config.TargetOS {
case "linux":
codeOffset = elf.CodeOffset
align = elf.Align
case "mac":
codeOffset = macho.CodeOffset
align = macho.Align
case "windows":
codeOffset = pe.CodeOffset
align = pe.Align
}
dataStart := Address(config.BaseAddress) + codeOffset + Address(len(code))
dataStart += int32(common.Padding(dataStart, align))
for _, pointer := range dataPointers {
address := dataStart + pointer.Resolve()

8
src/config/config.go
View File

@ -8,12 +8,6 @@ const (
// The base address is the virtual address for our ELF file.
BaseAddress = 0x40 * MinAddress
// The code offset is the offset of the executable machine code within the file.
CodeOffset = 64 + 56 + 56
// Align decides the alignment of the sections and it must be a multiple of the page size.
Align = 0x1000
)
var (
@ -45,3 +39,5 @@ func Reset() {
TargetOS = "mac"
}
}
//

8
src/os/linux/elf/Constants.go
View File

@ -1,5 +1,13 @@
package elf
const (
// Align decides the alignment of the sections and it must be a multiple of the page size.
Align = 0x1000
// The code offset is the offset of the executable machine code within the file.
CodeOffset = HeaderSize + ProgramHeaderSize*2
)
const (
LittleEndian = 1
TypeExecutable = 2

16
src/os/linux/elf/ELF.go
View File

@ -22,8 +22,8 @@ type ELF struct {
// New creates a new ELF binary.
func New(code []byte, data []byte) *ELF {
dataOffset := config.CodeOffset + int64(len(code))
dataPadding := common.Padding(dataOffset, config.Align)
dataOffset := CodeOffset + int64(len(code))
dataPadding := common.Padding(dataOffset, Align)
dataOffset += dataPadding
return &ELF{
@ -37,7 +37,7 @@ func New(code []byte, data []byte) *ELF {
Type: TypeExecutable,
Architecture: ArchitectureAMD64,
FileVersion: 1,
EntryPointInMemory: config.BaseAddress + config.CodeOffset,
EntryPointInMemory: config.BaseAddress + CodeOffset,
ProgramHeaderOffset: HeaderSize,
SectionHeaderOffset: 0,
Flags: 0,
@ -51,12 +51,12 @@ func New(code []byte, data []byte) *ELF {
CodeHeader: ProgramHeader{
Type: ProgramTypeLOAD,
Flags: ProgramFlagsExecutable | ProgramFlagsReadable,
Offset: config.CodeOffset,
VirtualAddress: config.BaseAddress + config.CodeOffset,
PhysicalAddress: config.BaseAddress + config.CodeOffset,
Offset: CodeOffset,
VirtualAddress: config.BaseAddress + CodeOffset,
PhysicalAddress: config.BaseAddress + CodeOffset,
SizeInFile: int64(len(code)),
SizeInMemory: int64(len(code)),
Align: config.Align,
Align: Align,
},
DataHeader: ProgramHeader{
Type: ProgramTypeLOAD,
@ -66,7 +66,7 @@ func New(code []byte, data []byte) *ELF {
PhysicalAddress: config.BaseAddress + dataOffset,
SizeInFile: int64(len(data)),
SizeInMemory: int64(len(data)),
Align: config.Align,
Align: Align,
},
CodePadding: nil,
Code: code,

8
src/os/mac/macho/Constants.go
View File

@ -1,5 +1,13 @@
package macho
const (
// Align decides the alignment of the sections and it must be a multiple of the page size.
Align = 0x1000
// The code offset is the offset of the executable machine code within the file.
CodeOffset = 32 + 0x48*3 + 184
)
type CPU uint32
const (

10
src/os/mac/macho/MachO.go
View File

@ -25,7 +25,7 @@ func New(code []byte, data []byte) *MachO {
MicroArchitecture: 3 | 0x80000000,
Type: TypeExecute,
NumCommands: 4,
SizeCommands: 0x48*3 + 184,
SizeCommands: 72*3 + 184,
Flags: FlagNoUndefs,
Reserved: 0,
},
@ -40,7 +40,7 @@ func (m *MachO) Write(writer io.Writer) {
binary.Write(writer, binary.LittleEndian, &Segment64{
LoadCommand: LcSegment64,
Length: 0x48,
Length: 72,
Name: [16]byte{'_', '_', 'P', 'A', 'G', 'E', 'Z', 'E', 'R', 'O'},
Address: 0,
SizeInMemory: config.BaseAddress,
@ -55,12 +55,12 @@ func (m *MachO) Write(writer io.Writer) {
codeStart := uint64(32 + m.Header.SizeCommands)
codeLength := uint64(len(m.Code))
codeEnd := codeStart + codeLength
dataPadding := common.Padding(codeEnd, config.Align)
dataPadding := common.Padding(codeEnd, Align)
dataStart := codeEnd + dataPadding
binary.Write(writer, binary.LittleEndian, &Segment64{
LoadCommand: LcSegment64,
Length: 0x48,
Length: 72,
Name: [16]byte{'_', '_', 'T', 'E', 'X', 'T'},
Address: config.BaseAddress + codeStart,
SizeInMemory: codeLength,
@ -74,7 +74,7 @@ func (m *MachO) Write(writer io.Writer) {
binary.Write(writer, binary.LittleEndian, &Segment64{
LoadCommand: LcSegment64,
Length: 0x48,
Length: 72,
Name: [16]byte{'_', '_', 'D', 'A', 'T', 'A'},
Address: config.BaseAddress + dataStart,
SizeInMemory: uint64(len(m.Data)),

8
src/os/windows/pe/Constants.go
View File

@ -1,5 +1,13 @@
package pe
const (
// Align decides the alignment of the sections.
Align = 0x200
// The code offset is the offset of the executable machine code within the file.
CodeOffset = Align
)
// CPU
const (
IMAGE_FILE_MACHINE_AMD64 = 0x8664

6
src/os/windows/pe/DOSHeader.go
View File

@ -1,9 +1,11 @@
package pe
const DOSHeaderSize = 64
// DOSHeader is at the beginning of each EXE file and nowadays just points
// to the NTHeader using an absolute file offset.
// to the PEHeader using an absolute file offset.
type DOSHeader struct {
Magic [4]byte
_ [56]byte
NTHeaderOffset uint32
PEHeaderOffset uint32
}

84
src/os/windows/pe/EXE.go
View File

@ -1,6 +1,7 @@
package pe
import (
"bytes"
"encoding/binary"
"io"
@ -8,53 +9,58 @@ import (
"git.akyoto.dev/cli/q/src/os/common"
)
const NumSections = 2
// EXE is the portable executable format used on Windows.
type EXE struct {
DOSHeader
NTHeader
PEHeader
OptionalHeader64
CodeHeader SectionHeader
Code []byte
Data []byte
Sections [NumSections]SectionHeader
CodePadding []byte
Code []byte
DataPadding []byte
Data []byte
}
// New creates a new EXE file.
func New(code []byte, data []byte) *EXE {
const codeStart = 0x170
const optHeaderSize = 0xF0
codeStart := uint32(DOSHeaderSize + PEHeaderSize + OptionalHeader64Size + SectionHeaderSize*NumSections)
codePadding := common.Padding(codeStart, Align)
codeStart += codePadding
codeSize := uint32(len(code))
headerSize := uint32(codeStart)
sectionAlign := uint32(0x10)
fileAlign := uint32(0x10)
imageSize := uint32(codeStart + len(code))
imageSize += common.Padding(imageSize, sectionAlign)
dataStart := codeStart + uint32(len(code))
dataPadding := common.Padding(dataStart, Align)
dataStart += dataPadding
imageSize := uint32(dataStart + uint32(len(data)))
imageSize += common.Padding(imageSize, Align)
return &EXE{
DOSHeader: DOSHeader{
Magic: [4]byte{'M', 'Z', 0, 0},
NTHeaderOffset: 0x40,
PEHeaderOffset: 0x40,
},
NTHeader: NTHeader{
PEHeader: PEHeader{
Signature: [4]byte{'P', 'E', 0, 0},
Machine: IMAGE_FILE_MACHINE_AMD64,
NumberOfSections: 1,
SizeOfOptionalHeader: optHeaderSize,
NumberOfSections: NumSections,
SizeOfOptionalHeader: OptionalHeader64Size,
Characteristics: IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_LARGE_ADDRESS_AWARE,
},
OptionalHeader64: OptionalHeader64{
Magic: 0x020B, // PE32+ executable
MajorLinkerVersion: 0x0E,
MinorLinkerVersion: 0x16,
SizeOfCode: codeSize,
SizeOfCode: uint32(len(code)),
AddressOfEntryPoint: codeStart,
ImageBase: config.BaseAddress,
SectionAlignment: sectionAlign, // power of 2, must be greater than or equal to FileAlignment
FileAlignment: fileAlign, // power of 2
SectionAlignment: Align, // power of 2, must be greater than or equal to FileAlignment
FileAlignment: Align, // power of 2
MajorOperatingSystemVersion: 0x06,
MajorSubsystemVersion: 0x06,
SizeOfImage: imageSize,
SizeOfHeaders: headerSize,
SizeOfHeaders: codeStart, // section bodies begin here
Subsystem: IMAGE_SUBSYSTEM_WINDOWS_GUI,
DllCharacteristics: IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA | IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE | IMAGE_DLLCHARACTERISTICS_NX_COMPAT | IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE,
SizeOfStackReserve: 0x100000,
@ -81,25 +87,39 @@ func New(code []byte, data []byte) *EXE {
{VirtualAddress: 0, Size: 0},
},
},
CodeHeader: SectionHeader{
Name: [8]byte{'.', 't', 'e', 'x', 't'},
VirtualSize: uint32(len(code)),
VirtualAddress: codeStart,
RawSize: uint32(len(code)), // must be a multiple of FileAlignment
RawAddress: codeStart, // must be a multiple of FileAlignment
Characteristics: IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ,
Sections: [NumSections]SectionHeader{
{
Name: [8]byte{'.', 'c', 'o', 'd', 'e'},
VirtualSize: uint32(len(code)),
VirtualAddress: codeStart,
RawSize: uint32(len(code)), // must be a multiple of FileAlignment
RawAddress: codeStart, // must be a multiple of FileAlignment
Characteristics: IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ,
},
{
Name: [8]byte{'.', 'd', 'a', 't', 'a'},
VirtualSize: uint32(len(data)),
VirtualAddress: dataStart,
RawSize: uint32(len(data)), // must be a multiple of FileAlignment
RawAddress: dataStart, // must be a multiple of FileAlignment
Characteristics: IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ,
},
},
Code: code,
// Data: data,
CodePadding: bytes.Repeat([]byte{0}, int(codePadding)),
Code: code,
DataPadding: bytes.Repeat([]byte{0}, int(dataPadding)),
Data: data,
}
}
// Write writes the EXE file to the given writer.
func (pe *EXE) Write(writer io.Writer) {
binary.Write(writer, binary.LittleEndian, &pe.DOSHeader)
binary.Write(writer, binary.LittleEndian, &pe.NTHeader)
binary.Write(writer, binary.LittleEndian, &pe.PEHeader)
binary.Write(writer, binary.LittleEndian, &pe.OptionalHeader64)
binary.Write(writer, binary.LittleEndian, &pe.CodeHeader)
binary.Write(writer, binary.LittleEndian, &pe.Sections)
binary.Write(writer, binary.LittleEndian, &pe.CodePadding)
binary.Write(writer, binary.LittleEndian, &pe.Code)
// binary.Write(writer, binary.LittleEndian, &pe.Data)
binary.Write(writer, binary.LittleEndian, &pe.DataPadding)
binary.Write(writer, binary.LittleEndian, &pe.Data)
}

9
src/os/windows/pe/ImportDirectory.go Normal file
View File

@ -0,0 +1,9 @@
package pe
type ImportDirectory struct {
OriginalFirstThunk uint32
TimeDateStamp uint32
ForwarderChain uint32
Name uint32
FirstThunk uint32
}

2
src/os/windows/pe/OptionalHeader64.go
View File

@ -1,5 +1,7 @@
package pe
const OptionalHeader64Size = 240
type OptionalHeader64 struct {
Magic uint16
MajorLinkerVersion uint8

4
src/os/windows/pe/NTHeader.go → src/os/windows/pe/PEHeader.go
View File

@ -1,6 +1,8 @@
package pe
type NTHeader struct {
const PEHeaderSize = 24
type PEHeader struct {
Signature [4]byte
Machine uint16
NumberOfSections uint16

2
src/os/windows/pe/SectionHeader.go
View File

@ -1,5 +1,7 @@
package pe
const SectionHeaderSize = 40
type SectionHeader struct {
Name [8]byte
VirtualSize uint32

4
src/scanner/queueDirectory.go
View File

@ -29,6 +29,10 @@ func (s *Scanner) queueDirectory(directory string, pkg string) {
return
}
if strings.HasSuffix(name, "_windows.q") && config.TargetOS != "windows" {
return
}
fullPath := filepath.Join(directory, name)
s.queueFile(fullPath, pkg)
})

2
src/scanner/scanFile.go
View File

@ -249,7 +249,7 @@ func (s *Scanner) scanFile(path string, pkg string) error {
register := x64.InputRegisters[count]
uses := token.Count(function.Body, contents, token.Identifier, name)
if uses == 0 {
if uses == 0 && name != "_" {
return errors.New(&errors.UnusedVariable{Name: name}, file, tokens[0].Position)
}