const std = @import("std");

const mem = std.mem;

const math = std.math;

const assert = std.debug.assert;

const ir = @import("air.zig");

const Type = @import("type.zig").Type;

const Value = @import("value.zig").Value;

const TypedValue = @import("TypedValue.zig");

const link = @import("link.zig");

const Module = @import("Module.zig");

const Compilation = @import("Compilation.zig");

const ErrorMsg = Module.ErrorMsg;

const Target = std.Target;

const Allocator = mem.Allocator;

const trace = @import("tracy.zig").trace;

const DW = std.dwarf;

const leb128 = std.leb;

const log = std.log.scoped(.codegen);

const build_options = @import("build_options");

const LazySrcLoc = Module.LazySrcLoc;

const RegisterManager = @import("register_manager.zig").RegisterManager;

const X8664Encoder = @import("codegen/x86_64.zig").Encoder;

pub const Result = union(enum) {

/// The `code` parameter passed to `generateSymbol` has the value appended.

appended: void,

/// The value is available externally, `code` is unused.

externally_managed: []const u8,

fail: *ErrorMsg,

};

pub const GenerateSymbolError = error{

OutOfMemory,

/// A Decl that this symbol depends on had a semantic analysis failure.

AnalysisFail,

};

pub const DebugInfoOutput = union(enum) {

dwarf: struct {

dbg_line: *std.ArrayList(u8),

dbg_info: *std.ArrayList(u8),

dbg_info_type_relocs: *link.File.DbgInfoTypeRelocsTable,

},

none,

};

pub fn generateSymbol(

bin_file: *link.File,

src_loc: Module.SrcLoc,

typed_value: TypedValue,

code: *std.ArrayList(u8),

debug_output: DebugInfoOutput,

) GenerateSymbolError!Result {

const tracy = trace(@src());

defer tracy.end();

switch (typed_value.ty.zigTypeTag()) {

.Fn => {

switch (bin_file.options.target.cpu.arch) {

.wasm32 => unreachable, // has its own code path

.wasm64 => unreachable, // has its own code path

.arm => return Function(.arm).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

.armeb => return Function(.armeb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

.aarch64 => return Function(.aarch64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

.aarch64_be => return Function(.aarch64_be).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

.aarch64_32 => return Function(.aarch64_32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.arc => return Function(.arc).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.avr => return Function(.avr).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.bpfel => return Function(.bpfel).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.bpfeb => return Function(.bpfeb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.hexagon => return Function(.hexagon).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.mips => return Function(.mips).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.mipsel => return Function(.mipsel).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.mips64 => return Function(.mips64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.mips64el => return Function(.mips64el).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.msp430 => return Function(.msp430).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.powerpc => return Function(.powerpc).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.powerpc64 => return Function(.powerpc64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.powerpc64le => return Function(.powerpc64le).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.r600 => return Function(.r600).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.amdgcn => return Function(.amdgcn).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.riscv32 => return Function(.riscv32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

.riscv64 => return Function(.riscv64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.sparc => return Function(.sparc).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.sparcv9 => return Function(.sparcv9).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.sparcel => return Function(.sparcel).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.s390x => return Function(.s390x).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.tce => return Function(.tce).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.tcele => return Function(.tcele).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.thumb => return Function(.thumb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.thumbeb => return Function(.thumbeb).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.i386 => return Function(.i386).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

.x86_64 => return Function(.x86_64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.xcore => return Function(.xcore).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.nvptx => return Function(.nvptx).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.nvptx64 => return Function(.nvptx64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.le32 => return Function(.le32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.le64 => return Function(.le64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.amdil => return Function(.amdil).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.amdil64 => return Function(.amdil64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.hsail => return Function(.hsail).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.hsail64 => return Function(.hsail64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.spir => return Function(.spir).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.spir64 => return Function(.spir64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.kalimba => return Function(.kalimba).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.shave => return Function(.shave).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.lanai => return Function(.lanai).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.renderscript32 => return Function(.renderscript32).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.renderscript64 => return Function(.renderscript64).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

//.ve => return Function(.ve).generateSymbol(bin_file, src_loc, typed_value, code, debug_output),

else => @panic("Backend architectures that don't have good support yet are commented out, to improve compilation performance. If you are interested in one of these other backends feel free to uncomment them. Eventually these will be completed, but stage1 is slow and a memory hog."),

}

},

.Array => {

// TODO populate .debug_info for the array

if (typed_value.val.castTag(.bytes)) |payload| {

if (typed_value.ty.sentinel()) |sentinel| {

try code.ensureCapacity(code.items.len + payload.data.len + 1);

code.appendSliceAssumeCapacity(payload.data);

const prev_len = code.items.len;

switch (try generateSymbol(bin_file, src_loc, .{

.ty = typed_value.ty.elemType(),

.val = sentinel,

}, code, debug_output)) {

.appended => return Result{ .appended = {} },

.externally_managed => |slice| {

code.appendSliceAssumeCapacity(slice);

return Result{ .appended = {} };

},

.fail => |em| return Result{ .fail = em },

}

} else {

return Result{ .externally_managed = payload.data };

}

}

return Result{

.fail = try ErrorMsg.create(

bin_file.allocator,

src_loc,

"TODO implement generateSymbol for more kinds of arrays",

.{},

),

};

},

.Pointer => {

// TODO populate .debug_info for the pointer

if (typed_value.val.castTag(.decl_ref)) |payload| {

const decl = payload.data;

if (decl.analysis != .complete) return error.AnalysisFail;

// TODO handle the dependency of this symbol on the decl's vaddr.

// If the decl changes vaddr, then this symbol needs to get regenerated.

const vaddr = bin_file.getDeclVAddr(decl);

const endian = bin_file.options.target.cpu.arch.endian();

switch (bin_file.options.target.cpu.arch.ptrBitWidth()) {

16 => {

try code.resize(2);

mem.writeInt(u16, code.items[0..2], @intCast(u16, vaddr), endian);

},

32 => {

try code.resize(4);

mem.writeInt(u32, code.items[0..4], @intCast(u32, vaddr), endian);

},

64 => {

try code.resize(8);

mem.writeInt(u64, code.items[0..8], vaddr, endian);

},

else => unreachable,

}

return Result{ .appended = {} };

}

return Result{

.fail = try ErrorMsg.create(

bin_file.allocator,

src_loc,

"TODO implement generateSymbol for pointer {}",

.{typed_value.val},

),

};

},

.Int => {

// TODO populate .debug_info for the integer

const endian = bin_file.options.target.cpu.arch.endian();

const info = typed_value.ty.intInfo(bin_file.options.target);

if (info.bits <= 8) {

const x = @intCast(u8, typed_value.val.toUnsignedInt());

try code.append(x);

return Result{ .appended = {} };

}

if (info.bits > 64) {

return Result{

.fail = try ErrorMsg.create(

bin_file.allocator,

src_loc,

"TODO implement generateSymbol for big ints ('{}')",

.{typed_value.ty},

),

};

}

switch (info.signedness) {

.unsigned => {

if (info.bits <= 16) {

const x = @intCast(u16, typed_value.val.toUnsignedInt());

mem.writeInt(u16, try code.addManyAsArray(2), x, endian);

} else if (info.bits <= 32) {

const x = @intCast(u32, typed_value.val.toUnsignedInt());

mem.writeInt(u32, try code.addManyAsArray(4), x, endian);

} else {

const x = typed_value.val.toUnsignedInt();

mem.writeInt(u64, try code.addManyAsArray(8), x, endian);

}

},

.signed => {

if (info.bits <= 16) {

const x = @intCast(i16, typed_value.val.toSignedInt());

mem.writeInt(i16, try code.addManyAsArray(2), x, endian);

} else if (info.bits <= 32) {

const x = @intCast(i32, typed_value.val.toSignedInt());

mem.writeInt(i32, try code.addManyAsArray(4), x, endian);

} else {

const x = typed_value.val.toSignedInt();

mem.writeInt(i64, try code.addManyAsArray(8), x, endian);

}

},

}

return Result{ .appended = {} };

},

else => |t| {

return Result{

.fail = try ErrorMsg.create(

bin_file.allocator,

src_loc,

"TODO implement generateSymbol for type '{s}'",

.{@tagName(t)},

),

};

},

}

}

const InnerError = error{

OutOfMemory,

CodegenFail,

};

fn Function(comptime arch: std.Target.Cpu.Arch) type {

const writeInt = switch (arch.endian()) {

.Little => mem.writeIntLittle,

.Big => mem.writeIntBig,

};

return struct {

gpa: *Allocator,

bin_file: *link.File,

target: *const std.Target,

mod_fn: *const Module.Fn,

code: *std.ArrayList(u8),

debug_output: DebugInfoOutput,

err_msg: ?*ErrorMsg,

args: []MCValue,

ret_mcv: MCValue,

fn_type: Type,

arg_index: usize,

src_loc: Module.SrcLoc,

stack_align: u32,

prev_di_line: u32,

prev_di_column: u32,

/// Byte offset within the source file of the ending curly.

end_di_line: u32,

end_di_column: u32,

/// Relative to the beginning of `code`.

prev_di_pc: usize,

/// The value is an offset into the `Function` `code` from the beginning.

/// To perform the reloc, write 32-bit signed little-endian integer

/// which is a relative jump, based on the address following the reloc.

exitlude_jump_relocs: std.ArrayListUnmanaged(usize) = .{},

/// Whenever there is a runtime branch, we push a Branch onto this stack,

/// and pop it off when the runtime branch joins. This provides an "overlay"

/// of the table of mappings from instructions to `MCValue` from within the branch.

/// This way we can modify the `MCValue` for an instruction in different ways

/// within different branches. Special consideration is needed when a branch

/// joins with its parent, to make sure all instructions have the same MCValue

/// across each runtime branch upon joining.

branch_stack: *std.ArrayList(Branch),

blocks: std.AutoHashMapUnmanaged(*ir.Inst.Block, BlockData) = .{},

register_manager: RegisterManager(Self, Register, &callee_preserved_regs) = .{},

/// Maps offset to what is stored there.

stack: std.AutoHashMapUnmanaged(u32, StackAllocation) = .{},

/// Offset from the stack base, representing the end of the stack frame.

max_end_stack: u32 = 0,

/// Represents the current end stack offset. If there is no existing slot

/// to place a new stack allocation, it goes here, and then bumps `max_end_stack`.

next_stack_offset: u32 = 0,

const MCValue = union(enum) {

/// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc.

/// TODO Look into deleting this tag and using `dead` instead, since every use

/// of MCValue.none should be instead looking at the type and noticing it is 0 bits.

none,

/// Control flow will not allow this value to be observed.

unreach,

/// No more references to this value remain.

dead,

/// The value is undefined.

undef,

/// A pointer-sized integer that fits in a register.

/// If the type is a pointer, this is the pointer address in virtual address space.

immediate: u64,

/// The constant was emitted into the code, at this offset.

/// If the type is a pointer, it means the pointer address is embedded in the code.

embedded_in_code: usize,

/// The value is a pointer to a constant which was emitted into the code, at this offset.

ptr_embedded_in_code: usize,

/// The value is in a target-specific register.

register: Register,

/// The value is in memory at a hard-coded address.

/// If the type is a pointer, it means the pointer address is at this memory location.

memory: u64,

/// The value is one of the stack variables.

/// If the type is a pointer, it means the pointer address is in the stack at this offset.

stack_offset: u32,

/// The value is a pointer to one of the stack variables (payload is stack offset).

ptr_stack_offset: u32,

/// The value is in the compare flags assuming an unsigned operation,

/// with this operator applied on top of it.

compare_flags_unsigned: math.CompareOperator,

/// The value is in the compare flags assuming a signed operation,

/// with this operator applied on top of it.

compare_flags_signed: math.CompareOperator,

fn isMemory(mcv: MCValue) bool {

return switch (mcv) {

.embedded_in_code, .memory, .stack_offset => true,

else => false,

};

}

fn isImmediate(mcv: MCValue) bool {

return switch (mcv) {

.immediate => true,

else => false,

};

}

fn isMutable(mcv: MCValue) bool {

return switch (mcv) {

.none => unreachable,

.unreach => unreachable,

.dead => unreachable,

.immediate,

.embedded_in_code,

.memory,

.compare_flags_unsigned,

.compare_flags_signed,

.ptr_stack_offset,

.ptr_embedded_in_code,

.undef,

=> false,

.register,

.stack_offset,

=> true,

};

}

};

const Branch = struct {

inst_table: std.AutoArrayHashMapUnmanaged(*ir.Inst, MCValue) = .{},

fn deinit(self: *Branch, gpa: *Allocator) void {

self.inst_table.deinit(gpa);

self.* = undefined;

}

};

const StackAllocation = struct {

inst: *ir.Inst,

/// TODO do we need size? should be determined by inst.ty.abiSize()

size: u32,

};

const BlockData = struct {

relocs: std.ArrayListUnmanaged(Reloc),

/// The first break instruction encounters `null` here and chooses a

/// machine code value for the block result, populating this field.

/// Following break instructions encounter that value and use it for

/// the location to store their block results.

mcv: MCValue,

};

const Reloc = union(enum) {

/// The value is an offset into the `Function` `code` from the beginning.

/// To perform the reloc, write 32-bit signed little-endian integer

/// which is a relative jump, based on the address following the reloc.

rel32: usize,

/// A branch in the ARM instruction set

arm_branch: struct {

pos: usize,

cond: @import("codegen/arm.zig").Condition,

},

};

const Self = @This();

fn generateSymbol(

bin_file: *link.File,

src_loc: Module.SrcLoc,

typed_value: TypedValue,

code: *std.ArrayList(u8),

debug_output: DebugInfoOutput,

) GenerateSymbolError!Result {

if (build_options.skip_non_native and std.Target.current.cpu.arch != arch) {

@panic("Attempted to compile for architecture that was disabled by build configuration");

}

const module_fn = typed_value.val.castTag(.function).?.data;

assert(module_fn.owner_decl.has_tv);

const fn_type = module_fn.owner_decl.ty;

var branch_stack = std.ArrayList(Branch).init(bin_file.allocator);

defer {

assert(branch_stack.items.len == 1);

branch_stack.items[0].deinit(bin_file.allocator);

branch_stack.deinit();

}

try branch_stack.append(.{});

var function = Self{

.gpa = bin_file.allocator,

.target = &bin_file.options.target,

.bin_file = bin_file,

.mod_fn = module_fn,

.code = code,

.debug_output = debug_output,

.err_msg = null,

.args = undefined, // populated after `resolveCallingConventionValues`

.ret_mcv = undefined, // populated after `resolveCallingConventionValues`

.fn_type = fn_type,

.arg_index = 0,

.branch_stack = &branch_stack,

.src_loc = src_loc,

.stack_align = undefined,

.prev_di_pc = 0,

.prev_di_line = module_fn.lbrace_line,

.prev_di_column = module_fn.lbrace_column,

.end_di_line = module_fn.rbrace_line,

.end_di_column = module_fn.rbrace_column,

};

defer function.stack.deinit(bin_file.allocator);

defer function.blocks.deinit(bin_file.allocator);

defer function.exitlude_jump_relocs.deinit(bin_file.allocator);

var call_info = function.resolveCallingConventionValues(src_loc.lazy, fn_type) catch |err| switch (err) {

error.CodegenFail => return Result{ .fail = function.err_msg.? },

else => |e| return e,

};

defer call_info.deinit(&function);

function.args = call_info.args;

function.ret_mcv = call_info.return_value;

function.stack_align = call_info.stack_align;

function.max_end_stack = call_info.stack_byte_count;

function.gen() catch |err| switch (err) {

error.CodegenFail => return Result{ .fail = function.err_msg.? },

else => |e| return e,

};

if (function.err_msg) |em| {

return Result{ .fail = em };

} else {

return Result{ .appended = {} };

}

}

fn gen(self: *Self) !void {

switch (arch) {

.x86_64 => {

try self.code.ensureCapacity(self.code.items.len + 11);

const cc = self.fn_type.fnCallingConvention();

if (cc != .Naked) {

// We want to subtract the aligned stack frame size from rsp here, but we don't

// yet know how big it will be, so we leave room for a 4-byte stack size.

// TODO During semantic analysis, check if there are no function calls. If there

// are none, here we can omit the part where we subtract and then add rsp.

self.code.appendSliceAssumeCapacity(&[_]u8{

0x55, // push rbp

0x48, 0x89, 0xe5, // mov rbp, rsp

0x48, 0x81, 0xec, // sub rsp, imm32 (with reloc)

});

const reloc_index = self.code.items.len;

self.code.items.len += 4;

try self.dbgSetPrologueEnd();

try self.genBody(self.mod_fn.body);

const stack_end = self.max_end_stack;

if (stack_end > math.maxInt(i32))

return self.failSymbol("too much stack used in call parameters", .{});

const aligned_stack_end = mem.alignForward(stack_end, self.stack_align);

mem.writeIntLittle(u32, self.code.items[reloc_index..][0..4], @intCast(u32, aligned_stack_end));

if (self.code.items.len >= math.maxInt(i32)) {

return self.failSymbol("unable to perform relocation: jump too far", .{});

}

if (self.exitlude_jump_relocs.items.len == 1) {

self.code.items.len -= 5;

} else for (self.exitlude_jump_relocs.items) |jmp_reloc| {

const amt = self.code.items.len - (jmp_reloc + 4);

const s32_amt = @intCast(i32, amt);

mem.writeIntLittle(i32, self.code.items[jmp_reloc..][0..4], s32_amt);

}

// Important to be after the possible self.code.items.len -= 5 above.

try self.dbgSetEpilogueBegin();

try self.code.ensureCapacity(self.code.items.len + 9);

// add rsp, x

if (aligned_stack_end > math.maxInt(i8)) {

// example: 48 81 c4 ff ff ff 7f add rsp,0x7fffffff

self.code.appendSliceAssumeCapacity(&[_]u8{ 0x48, 0x81, 0xc4 });

const x = @intCast(u32, aligned_stack_end);

mem.writeIntLittle(u32, self.code.addManyAsArrayAssumeCapacity(4), x);

} else if (aligned_stack_end != 0) {

// example: 48 83 c4 7f add rsp,0x7f

const x = @intCast(u8, aligned_stack_end);

self.code.appendSliceAssumeCapacity(&[_]u8{ 0x48, 0x83, 0xc4, x });

}

self.code.appendSliceAssumeCapacity(&[_]u8{

0x5d, // pop rbp

0xc3, // ret

});

} else {

try self.dbgSetPrologueEnd();

try self.genBody(self.mod_fn.body);

try self.dbgSetEpilogueBegin();

}

},

.arm, .armeb => {

const cc = self.fn_type.fnCallingConvention();

if (cc != .Naked) {

// push {fp, lr}

// mov fp, sp

// sub sp, sp, #reloc

const prologue_reloc = self.code.items.len;

try self.code.resize(prologue_reloc + 12);

writeInt(u32, self.code.items[prologue_reloc + 4 ..][0..4], Instruction.mov(.al, .fp, Instruction.Operand.reg(.sp, Instruction.Operand.Shift.none)).toU32());

try self.dbgSetPrologueEnd();

try self.genBody(self.mod_fn.body);

// Backpatch push callee saved regs

var saved_regs = Instruction.RegisterList{

.r11 = true, // fp

.r14 = true, // lr

};

inline for (callee_preserved_regs) |reg, i| {

if (self.register_manager.isRegAllocated(reg)) {

@field(saved_regs, @tagName(reg)) = true;

}

}

writeInt(u32, self.code.items[prologue_reloc..][0..4], Instruction.stmdb(.al, .sp, true, saved_regs).toU32());

// Backpatch stack offset

const stack_end = self.max_end_stack;

const aligned_stack_end = mem.alignForward(stack_end, self.stack_align);

if (Instruction.Operand.fromU32(@intCast(u32, aligned_stack_end))) |op| {

writeInt(u32, self.code.items[prologue_reloc + 8 ..][0..4], Instruction.sub(.al, .sp, .sp, op).toU32());

} else {

return self.failSymbol("TODO ARM: allow larger stacks", .{});

}

try self.dbgSetEpilogueBegin();

// exitlude jumps

if (self.exitlude_jump_relocs.items.len == 1) {

// There is only one relocation. Hence,

// this relocation must be at the end of

// the code. Therefore, we can just delete

// the space initially reserved for the

// jump

self.code.items.len -= 4;

} else for (self.exitlude_jump_relocs.items) |jmp_reloc| {

const amt = @intCast(i32, self.code.items.len) - @intCast(i32, jmp_reloc + 8);

if (amt == -4) {

// This return is at the end of the

// code block. We can't just delete

// the space because there may be

// other jumps we already relocated to

// the address. Instead, insert a nop

writeInt(u32, self.code.items[jmp_reloc..][0..4], Instruction.nop().toU32());

} else {

if (math.cast(i26, amt)) |offset| {

writeInt(u32, self.code.items[jmp_reloc..][0..4], Instruction.b(.al, offset).toU32());

} else |err| {

return self.failSymbol("exitlude jump is too large", .{});

}

}

}

// Epilogue: pop callee saved registers (swap lr with pc in saved_regs)

saved_regs.r14 = false; // lr

saved_regs.r15 = true; // pc

// mov sp, fp

// pop {fp, pc}

writeInt(u32, try self.code.addManyAsArray(4), Instruction.mov(.al, .sp, Instruction.Operand.reg(.fp, Instruction.Operand.Shift.none)).toU32());

writeInt(u32, try self.code.addManyAsArray(4), Instruction.ldm(.al, .sp, true, saved_regs).toU32());

} else {

try self.dbgSetPrologueEnd();

try self.genBody(self.mod_fn.body);

try self.dbgSetEpilogueBegin();

}

},

.aarch64, .aarch64_be, .aarch64_32 => {

const cc = self.fn_type.fnCallingConvention();

if (cc != .Naked) {

// TODO Finish function prologue and epilogue for aarch64.

// stp fp, lr, [sp, #-16]!

// mov fp, sp

// sub sp, sp, #reloc

writeInt(u32, try self.code.addManyAsArray(4), Instruction.stp(

.x29,

.x30,

Register.sp,

Instruction.LoadStorePairOffset.pre_index(-16),

).toU32());

writeInt(u32, try self.code.addManyAsArray(4), Instruction.add(.x29, .xzr, 0, false).toU32());

const backpatch_reloc = self.code.items.len;

try self.code.resize(backpatch_reloc + 4);

try self.dbgSetPrologueEnd();

try self.genBody(self.mod_fn.body);

// Backpatch stack offset

const stack_end = self.max_end_stack;

const aligned_stack_end = mem.alignForward(stack_end, self.stack_align);

if (math.cast(u12, aligned_stack_end)) |size| {

writeInt(u32, self.code.items[backpatch_reloc..][0..4], Instruction.sub(.xzr, .xzr, size, false).toU32());

} else |_| {

return self.failSymbol("TODO AArch64: allow larger stacks", .{});

}

try self.dbgSetEpilogueBegin();

// exitlude jumps

if (self.exitlude_jump_relocs.items.len == 1) {

// There is only one relocation. Hence,

// this relocation must be at the end of

// the code. Therefore, we can just delete

// the space initially reserved for the

// jump

self.code.items.len -= 4;

} else for (self.exitlude_jump_relocs.items) |jmp_reloc| {

const amt = @intCast(i32, self.code.items.len) - @intCast(i32, jmp_reloc + 8);

if (amt == -4) {

// This return is at the end of the

// code block. We can't just delete

// the space because there may be

// other jumps we already relocated to

// the address. Instead, insert a nop

writeInt(u32, self.code.items[jmp_reloc..][0..4], Instruction.nop().toU32());

} else {

if (math.cast(i28, amt)) |offset| {

writeInt(u32, self.code.items[jmp_reloc..][0..4], Instruction.b(offset).toU32());

} else |err| {

return self.failSymbol("exitlude jump is too large", .{});

}

}

}

// ldp fp, lr, [sp], #16

writeInt(u32, try self.code.addManyAsArray(4), Instruction.ldp(

.x29,

.x30,

Register.sp,

Instruction.LoadStorePairOffset.post_index(16),

).toU32());

// add sp, sp, #stack_size

writeInt(u32, try self.code.addManyAsArray(4), Instruction.add(.xzr, .xzr, @intCast(u12, aligned_stack_end), false).toU32());

// ret lr

writeInt(u32, try self.code.addManyAsArray(4), Instruction.ret(null).toU32());

} else {

try self.dbgSetPrologueEnd();

try self.genBody(self.mod_fn.body);

try self.dbgSetEpilogueBegin();

}

},

else => {

try self.dbgSetPrologueEnd();

try self.genBody(self.mod_fn.body);

try self.dbgSetEpilogueBegin();

},

}

// Drop them off at the rbrace.

try self.dbgAdvancePCAndLine(self.end_di_line, self.end_di_column);

}

fn genBody(self: *Self, body: ir.Body) InnerError!void {

for (body.instructions) |inst| {

try self.ensureProcessDeathCapacity(@popCount(@TypeOf(inst.deaths), inst.deaths));

const mcv = try self.genFuncInst(inst);

if (!inst.isUnused()) {

log.debug("{*} => {}", .{ inst, mcv });

const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];

try branch.inst_table.putNoClobber(self.gpa, inst, mcv);

}

var i: ir.Inst.DeathsBitIndex = 0;

while (inst.getOperand(i)) |operand| : (i += 1) {

if (inst.operandDies(i))

self.processDeath(operand);

}

}

}

fn dbgSetPrologueEnd(self: *Self) InnerError!void {

switch (self.debug_output) {

.dwarf => |dbg_out| {

try dbg_out.dbg_line.append(DW.LNS_set_prologue_end);

try self.dbgAdvancePCAndLine(self.prev_di_line, self.prev_di_column);

},

.none => {},

}

}

fn dbgSetEpilogueBegin(self: *Self) InnerError!void {

switch (self.debug_output) {

.dwarf => |dbg_out| {

try dbg_out.dbg_line.append(DW.LNS_set_epilogue_begin);

try self.dbgAdvancePCAndLine(self.prev_di_line, self.prev_di_column);

},

.none => {},

}

}

fn dbgAdvancePCAndLine(self: *Self, line: u32, column: u32) InnerError!void {

switch (self.debug_output) {

.dwarf => |dbg_out| {

const delta_line = @intCast(i32, line) - @intCast(i32, self.prev_di_line);

const delta_pc = self.code.items.len - self.prev_di_pc;

// TODO Look into using the DWARF special opcodes to compress this data.

// It lets you emit single-byte opcodes that add different numbers to

// both the PC and the line number at the same time.

try dbg_out.dbg_line.ensureUnusedCapacity(11);

dbg_out.dbg_line.appendAssumeCapacity(DW.LNS_advance_pc);

leb128.writeULEB128(dbg_out.dbg_line.writer(), delta_pc) catch unreachable;

if (delta_line != 0) {

dbg_out.dbg_line.appendAssumeCapacity(DW.LNS_advance_line);

leb128.writeILEB128(dbg_out.dbg_line.writer(), delta_line) catch unreachable;

}

dbg_out.dbg_line.appendAssumeCapacity(DW.LNS_copy);

},

.none => {},

}

self.prev_di_line = line;

self.prev_di_column = column;

self.prev_di_pc = self.code.items.len;

}

/// Asserts there is already capacity to insert into top branch inst_table.

fn processDeath(self: *Self, inst: *ir.Inst) void {

if (inst.tag == .constant) return; // Constants are immortal.

// When editing this function, note that the logic must synchronize with `reuseOperand`.

const prev_value = self.getResolvedInstValue(inst);

const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];

branch.inst_table.putAssumeCapacity(inst, .dead);

switch (prev_value) {

.register => |reg| {

const canon_reg = toCanonicalReg(reg);

self.register_manager.freeReg(canon_reg);

},

else => {}, // TODO process stack allocation death

}

}

fn ensureProcessDeathCapacity(self: *Self, additional_count: usize) !void {

const table = &self.branch_stack.items[self.branch_stack.items.len - 1].inst_table;

try table.ensureCapacity(self.gpa, table.count() + additional_count);

}

/// Adds a Type to the .debug_info at the current position. The bytes will be populated later,

/// after codegen for this symbol is done.

fn addDbgInfoTypeReloc(self: *Self, ty: Type) !void {

switch (self.debug_output) {

.dwarf => |dbg_out| {

assert(ty.hasCodeGenBits());

const index = dbg_out.dbg_info.items.len;

try dbg_out.dbg_info.resize(index + 4); // DW.AT_type, DW.FORM_ref4

const gop = try dbg_out.dbg_info_type_relocs.getOrPut(self.gpa, ty);

if (!gop.found_existing) {

gop.value_ptr.* = .{

.off = undefined,

.relocs = .{},

};

}

try gop.value_ptr.relocs.append(self.gpa, @intCast(u32, index));

},

.none => {},

}

}

fn genFuncInst(self: *Self, inst: *ir.Inst) !MCValue {

switch (inst.tag) {

.add => return self.genAdd(inst.castTag(.add).?),

.addwrap => return self.genAddWrap(inst.castTag(.addwrap).?),

.alloc => return self.genAlloc(inst.castTag(.alloc).?),

.arg => return self.genArg(inst.castTag(.arg).?),

.assembly => return self.genAsm(inst.castTag(.assembly).?),

.bitcast => return self.genBitCast(inst.castTag(.bitcast).?),

.bit_and => return self.genBitAnd(inst.castTag(.bit_and).?),

.bit_or => return self.genBitOr(inst.castTag(.bit_or).?),

.block => return self.genBlock(inst.castTag(.block).?),

.br => return self.genBr(inst.castTag(.br).?),

.br_block_flat => return self.genBrBlockFlat(inst.castTag(.br_block_flat).?),

.breakpoint => return self.genBreakpoint(inst.src),

.br_void => return self.genBrVoid(inst.castTag(.br_void).?),

.bool_and => return self.genBoolOp(inst.castTag(.bool_and).?),

.bool_or => return self.genBoolOp(inst.castTag(.bool_or).?),

.call => return self.genCall(inst.castTag(.call).?),

.cmp_lt => return self.genCmp(inst.castTag(.cmp_lt).?, .lt),

.cmp_lte => return self.genCmp(inst.castTag(.cmp_lte).?, .lte),

.cmp_eq => return self.genCmp(inst.castTag(.cmp_eq).?, .eq),

.cmp_gte => return self.genCmp(inst.castTag(.cmp_gte).?, .gte),

.cmp_gt => return self.genCmp(inst.castTag(.cmp_gt).?, .gt),

.cmp_neq => return self.genCmp(inst.castTag(.cmp_neq).?, .neq),

.condbr => return self.genCondBr(inst.castTag(.condbr).?),

.constant => unreachable, // excluded from function bodies

.dbg_stmt => return self.genDbgStmt(inst.castTag(.dbg_stmt).?),

.floatcast => return self.genFloatCast(inst.castTag(.floatcast).?),

.intcast => return self.genIntCast(inst.castTag(.intcast).?),

.is_non_null => return self.genIsNonNull(inst.castTag(.is_non_null).?),

.is_non_null_ptr => return self.genIsNonNullPtr(inst.castTag(.is_non_null_ptr).?),

.is_null => return self.genIsNull(inst.castTag(.is_null).?),

.is_null_ptr => return self.genIsNullPtr(inst.castTag(.is_null_ptr).?),

.is_err => return self.genIsErr(inst.castTag(.is_err).?),

.is_err_ptr => return self.genIsErrPtr(inst.castTag(.is_err_ptr).?),

.error_to_int => return self.genErrorToInt(inst.castTag(.error_to_int).?),

.int_to_error => return self.genIntToError(inst.castTag(.int_to_error).?),

.load => return self.genLoad(inst.castTag(.load).?),

.loop => return self.genLoop(inst.castTag(.loop).?),

.not => return self.genNot(inst.castTag(.not).?),

.mul => return self.genMul(inst.castTag(.mul).?),

.mulwrap => return self.genMulWrap(inst.castTag(.mulwrap).?),

.div => return self.genDiv(inst.castTag(.div).?),

.ptrtoint => return self.genPtrToInt(inst.castTag(.ptrtoint).?),

.ref => return self.genRef(inst.castTag(.ref).?),

.ret => return self.genRet(inst.castTag(.ret).?),

.retvoid => return self.genRetVoid(inst.castTag(.retvoid).?),

.store => return self.genStore(inst.castTag(.store).?),

.struct_field_ptr => return self.genStructFieldPtr(inst.castTag(.struct_field_ptr).?),

.sub => return self.genSub(inst.castTag(.sub).?),

.subwrap => return self.genSubWrap(inst.castTag(.subwrap).?),

.switchbr => return self.genSwitch(inst.castTag(.switchbr).?),

.unreach => return MCValue{ .unreach = {} },

.optional_payload => return self.genOptionalPayload(inst.castTag(.optional_payload).?),

.optional_payload_ptr => return self.genOptionalPayloadPtr(inst.castTag(.optional_payload_ptr).?),

.unwrap_errunion_err => return self.genUnwrapErrErr(inst.castTag(.unwrap_errunion_err).?),

.unwrap_errunion_payload => return self.genUnwrapErrPayload(inst.castTag(.unwrap_errunion_payload).?),

.unwrap_errunion_err_ptr => return self.genUnwrapErrErrPtr(inst.castTag(.unwrap_errunion_err_ptr).?),

.unwrap_errunion_payload_ptr => return self.genUnwrapErrPayloadPtr(inst.castTag(.unwrap_errunion_payload_ptr).?),

.wrap_optional => return self.genWrapOptional(inst.castTag(.wrap_optional).?),

.wrap_errunion_payload => return self.genWrapErrUnionPayload(inst.castTag(.wrap_errunion_payload).?),

.wrap_errunion_err => return self.genWrapErrUnionErr(inst.castTag(.wrap_errunion_err).?),

.varptr => return self.genVarPtr(inst.castTag(.varptr).?),

.xor => return self.genXor(inst.castTag(.xor).?),

}

}

fn allocMem(self: *Self, inst: *ir.Inst, abi_size: u32, abi_align: u32) !u32 {

if (abi_align > self.stack_align)

self.stack_align = abi_align;

// TODO find a free slot instead of always appending

const offset = mem.alignForwardGeneric(u32, self.next_stack_offset, abi_align);

self.next_stack_offset = offset + abi_size;

if (self.next_stack_offset > self.max_end_stack)

self.max_end_stack = self.next_stack_offset;

try self.stack.putNoClobber(self.gpa, offset, .{

.inst = inst,

.size = abi_size,

});

return offset;

}

/// Use a pointer instruction as the basis for allocating stack memory.

fn allocMemPtr(self: *Self, inst: *ir.Inst) !u32 {

const elem_ty = inst.ty.elemType();

const abi_size = math.cast(u32, elem_ty.abiSize(self.target.*)) catch {

return self.fail(inst.src, "type '{}' too big to fit into stack frame", .{elem_ty});

};

// TODO swap this for inst.ty.ptrAlign

const abi_align = elem_ty.abiAlignment(self.target.*);

return self.allocMem(inst, abi_size, abi_align);

}

fn allocRegOrMem(self: *Self, inst: *ir.Inst, reg_ok: bool) !MCValue {

const elem_ty = inst.ty;

const abi_size = math.cast(u32, elem_ty.abiSize(self.target.*)) catch {

return self.fail(inst.src, "type '{}' too big to fit into stack frame", .{elem_ty});

};

const abi_align = elem_ty.abiAlignment(self.target.*);

if (abi_align > self.stack_align)

self.stack_align = abi_align;

if (reg_ok) {

// Make sure the type can fit in a register before we try to allocate one.

const ptr_bits = arch.ptrBitWidth();

const ptr_bytes: u64 = @divExact(ptr_bits, 8);

if (abi_size <= ptr_bytes) {

if (self.register_manager.tryAllocReg(inst, &.{})) |reg| {

return MCValue{ .register = registerAlias(reg, abi_size) };

}

}

}

const stack_offset = try self.allocMem(inst, abi_size, abi_align);

return MCValue{ .stack_offset = stack_offset };

}

pub fn spillInstruction(self: *Self, src: LazySrcLoc, reg: Register, inst: *ir.Inst) !void {

const stack_mcv = try self.allocRegOrMem(inst, false);

log.debug("spilling {*} to stack mcv {any}", .{ inst, stack_mcv });

const reg_mcv = self.getResolvedInstValue(inst);

assert(reg == toCanonicalReg(reg_mcv.register));

const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];

try branch.inst_table.put(self.gpa, inst, stack_mcv);

try self.genSetStack(src, inst.ty, stack_mcv.stack_offset, reg_mcv);

}

/// Copies a value to a register without tracking the register. The register is not considered

/// allocated. A second call to `copyToTmpRegister` may return the same register.

/// This can have a side effect of spilling instructions to the stack to free up a register.

fn copyToTmpRegister(self: *Self, src: LazySrcLoc, ty: Type, mcv: MCValue) !Register {

const reg = try self.register_manager.allocReg(null, &.{});

try self.genSetReg(src, ty, reg, mcv);

return reg;

}

/// Allocates a new register and copies `mcv` into it.

/// `reg_owner` is the instruction that gets associated with the register in the register table.

/// This can have a side effect of spilling instructions to the stack to free up a register.

fn copyToNewRegister(self: *Self, reg_owner: *ir.Inst, mcv: MCValue) !MCValue {

const reg = try self.register_manager.allocReg(reg_owner, &.{});

try self.genSetReg(reg_owner.src, reg_owner.ty, reg, mcv);

return MCValue{ .register = reg };

}

fn genAlloc(self: *Self, inst: *ir.Inst.NoOp) !MCValue {

const stack_offset = try self.allocMemPtr(&inst.base);

return MCValue{ .ptr_stack_offset = stack_offset };

}

fn genFloatCast(self: *Self, inst: *ir.Inst.UnOp) !MCValue {

// No side effects, so if it's unreferenced, do nothing.

if (inst.base.isUnused())

return MCValue.dead;

switch (arch) {

else => return self.fail(inst.base.src, "TODO implement floatCast for {}", .{self.target.cpu.arch}),

}

}

fn genIntCast(self: *Self, inst: *ir.Inst.UnOp) !MCValue {

// No side effects, so if it's unreferenced, do nothing.

if (inst.base.isUnused())

return MCValue.dead;

const operand = try self.resolveInst(inst.operand);

const info_a = inst.operand.ty.intInfo(self.target.*);

const info_b = inst.base.ty.intInfo(self.target.*);

if (info_a.signedness != info_b.signedness)

return self.fail(inst.base.src, "TODO gen intcast sign safety in semantic analysis", .{});

if (info_a.bits == info_b.bits)

return operand;

switch (arch) {

else => return self.fail(inst.base.src, "TODO implement intCast for {}", .{self.target.cpu.arch}),

}

}

fn genNot(self: *Self, inst: *ir.Inst.UnOp) !MCValue {