1357 lines
68 KiB
Zig
1357 lines
68 KiB
Zig
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const assert = std.debug.assert;
|
|
const equal = std.mem.eql;
|
|
|
|
const Compilation = @import("../Compilation.zig");
|
|
const logln = Compilation.logln;
|
|
const Module = Compilation.Module;
|
|
const data_structures = @import("../data_structures.zig");
|
|
const ArrayList = data_structures.ArrayList;
|
|
const AutoArrayHashMap = data_structures.AutoArrayHashMap;
|
|
const StringArrayHashMap = data_structures.StringArrayHashMap;
|
|
|
|
pub const Logger = enum {
|
|
g,
|
|
|
|
pub var bitset = std.EnumSet(Logger).initMany(&.{
|
|
.g,
|
|
});
|
|
};
|
|
|
|
const margin_width = 4;
|
|
|
|
pub const TranslationUnit = struct {
|
|
string_literals: ArrayList(u8) = .{},
|
|
primitive_type_declarations: ArrayList(u8) = .{},
|
|
type_forward_declarations: ArrayList(u8) = .{},
|
|
type_declarations: ArrayList(u8) = .{},
|
|
function_declarations: ArrayList(u8) = .{},
|
|
global_variable_declarations: ArrayList(u8) = .{},
|
|
function_definitions: ArrayList(u8) = .{},
|
|
syscall_bitset: SyscallBitset = SyscallBitset.initEmpty(),
|
|
struct_type_set: AutoArrayHashMap(Compilation.Type.Index, []const u8) = .{},
|
|
optional_type_set: AutoArrayHashMap(Compilation.Type.Index, []const u8) = .{},
|
|
function_set: AutoArrayHashMap(Compilation.Function.Index, []const u8) = .{},
|
|
slice_type_set: AutoArrayHashMap(Compilation.Type.Index, []const u8) = .{},
|
|
array_type_set: AutoArrayHashMap(Compilation.Type.Index, []const u8) = .{},
|
|
declaration_set: AutoArrayHashMap(Compilation.Declaration.Index, []const u8) = .{},
|
|
|
|
const SyscallBitset = std.StaticBitSet(6);
|
|
|
|
fn create(module: *Module, allocator: Allocator) !*TranslationUnit {
|
|
var unit = try allocator.create(TranslationUnit);
|
|
unit.* = .{};
|
|
try unit.primitive_type_declarations.appendSlice(allocator,
|
|
\\typedef unsigned char u8;
|
|
\\typedef unsigned short u16;
|
|
\\typedef unsigned int u32;
|
|
\\typedef unsigned long u64;
|
|
\\typedef u64 usize;
|
|
\\static_assert(sizeof(u8) == 1);
|
|
\\static_assert(sizeof(u16) == 2);
|
|
\\static_assert(sizeof(u32) == 4);
|
|
\\static_assert(sizeof(u64) == 8);
|
|
\\typedef signed char s8;
|
|
\\typedef signed short s16;
|
|
\\typedef signed int s32;
|
|
\\typedef signed long s64;
|
|
\\typedef s64 ssize;
|
|
\\static_assert(sizeof(s8) == 1);
|
|
\\static_assert(sizeof(s16) == 2);
|
|
\\static_assert(sizeof(s32) == 4);
|
|
\\static_assert(sizeof(s64) == 8);
|
|
\\
|
|
\\
|
|
);
|
|
|
|
{
|
|
var function_definitions = module.types.function_definitions.iterator();
|
|
while (function_definitions.nextIndex()) |function_definition_index| {
|
|
_ = try unit.writeFunctionDefinition(module, allocator, function_definition_index);
|
|
}
|
|
}
|
|
|
|
return unit;
|
|
}
|
|
|
|
fn writeFunctionDefinition(unit: *TranslationUnit, module: *Module, allocator: Allocator, function_definition_index: Compilation.Function.Index) ![]const u8 {
|
|
const gop = try unit.function_set.getOrPut(allocator, function_definition_index);
|
|
|
|
if (!gop.found_existing) {
|
|
const function_definition = module.types.function_definitions.get(function_definition_index);
|
|
const function_prototype_type = function_definition.prototype;
|
|
const function_prototype = module.types.function_prototypes.get(module.types.array.get(function_prototype_type).function);
|
|
|
|
const function_name = try unit.writeFunctionHeader(module, &unit.function_declarations, allocator, function_definition_index);
|
|
gop.value_ptr.* = function_name;
|
|
|
|
_ = try unit.writeFunctionHeader(module, &unit.function_definitions, allocator, function_definition_index);
|
|
try unit.function_declarations.appendSlice(allocator, ";\n\n");
|
|
|
|
try unit.function_definitions.append(allocator, ' ');
|
|
try unit.writeBlock(module, &unit.function_definitions, allocator, function_definition.body, function_prototype.return_type, 0);
|
|
try unit.function_definitions.append(allocator, '\n');
|
|
}
|
|
|
|
return gop.value_ptr.*;
|
|
}
|
|
|
|
fn writeDeclaration(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, declaration_index: Compilation.Declaration.Index, indentation: usize) !void {
|
|
const declaration = module.values.declarations.get(declaration_index);
|
|
const mangle = false;
|
|
const name = try unit.renderDeclarationName(module, allocator, declaration_index, mangle);
|
|
|
|
if (declaration.mutability == .@"const") {
|
|
switch (module.types.array.get(declaration.type).*) {
|
|
.optional => |optional| switch (module.types.array.get(optional.element_type).*) {
|
|
.pointer => {},
|
|
else => try list.appendSlice(allocator, "const "),
|
|
},
|
|
.pointer => {},
|
|
.integer,
|
|
.@"struct",
|
|
.slice,
|
|
.bool,
|
|
=> try list.appendSlice(allocator, "const "),
|
|
else => |t| @panic(@tagName(t)),
|
|
//else => try list.appendSlice(allocator, "const "),
|
|
}
|
|
}
|
|
|
|
try unit.writeType(module, list, allocator, declaration.type);
|
|
|
|
try list.append(allocator, ' ');
|
|
|
|
try list.appendSlice(allocator, name);
|
|
|
|
try list.appendSlice(allocator, " = ");
|
|
|
|
try unit.writeValue(module, list, allocator, Compilation.Type.Index.invalid, indentation, .{
|
|
.value_index = declaration.init_value,
|
|
.type_index = declaration.type,
|
|
});
|
|
}
|
|
|
|
fn writeAssignment(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, assignment_index: Compilation.Assignment.Index, function_return_type: Compilation.Type.Index, indentation: usize) !void {
|
|
const assignment = module.values.assignments.get(assignment_index);
|
|
const left_type = module.values.array.get(assignment.source).getType(module);
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = assignment.destination,
|
|
.type_index = left_type,
|
|
});
|
|
try list.append(allocator, ' ');
|
|
switch (assignment.operation) {
|
|
.none => {},
|
|
.add => try list.append(allocator, '+'),
|
|
}
|
|
try list.appendSlice(allocator, "= ");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = assignment.source,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
}
|
|
|
|
fn writeBlock(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, block_index: Compilation.Block.Index, function_return_type: Compilation.Type.Index, old_indentation: usize) !void {
|
|
try list.appendSlice(allocator, "{\n");
|
|
const block = module.values.blocks.get(block_index);
|
|
|
|
const indentation = old_indentation + 1;
|
|
|
|
for (block.statements.items) |statement_index| {
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
|
|
const statement = module.values.array.get(statement_index);
|
|
switch (statement.*) {
|
|
.declaration => |declaration_index| {
|
|
try unit.writeDeclaration(module, list, allocator, declaration_index, indentation);
|
|
try list.append(allocator, ';');
|
|
},
|
|
.assign => |assignment_index| {
|
|
try unit.writeAssignment(module, list, allocator, assignment_index, function_return_type, indentation);
|
|
try list.append(allocator, ';');
|
|
},
|
|
.@"return" => |return_index| {
|
|
const return_expr = module.values.returns.get(return_index);
|
|
try list.appendSlice(allocator, "return ");
|
|
const return_value = module.values.array.get(return_expr.value);
|
|
const return_value_type_index = return_value.getType(module);
|
|
// _ = return_value_type_index;
|
|
switch (module.types.array.get(function_return_type).*) {
|
|
.optional => switch (module.types.array.get(return_value_type_index).*) {
|
|
.optional => try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = return_expr.value,
|
|
.type_index = function_return_type,
|
|
}),
|
|
else => {
|
|
try list.append(allocator, '(');
|
|
try unit.writeType(module, list, allocator, function_return_type);
|
|
try list.appendSlice(allocator, ") {\n");
|
|
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.appendSlice(allocator, ".value = ");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = return_expr.value,
|
|
.type_index = return_value_type_index,
|
|
});
|
|
try list.appendSlice(allocator, ",\n");
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.appendSlice(allocator, ".is_null = false,\n");
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.append(allocator, '}');
|
|
},
|
|
},
|
|
else => try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = return_expr.value,
|
|
.type_index = function_return_type,
|
|
}),
|
|
}
|
|
|
|
try list.append(allocator, ';');
|
|
},
|
|
.syscall => |syscall_index| {
|
|
try unit.writeSyscall(module, list, allocator, syscall_index, function_return_type, indentation);
|
|
try list.append(allocator, ';');
|
|
},
|
|
.@"unreachable" => {
|
|
try writeUnreachable(list, allocator);
|
|
try list.append(allocator, ';');
|
|
},
|
|
.call => |call_index| {
|
|
try unit.writeCall(module, list, allocator, call_index, function_return_type, indentation);
|
|
try list.append(allocator, ';');
|
|
},
|
|
.branch => |branch_index| {
|
|
const branch = module.values.branches.get(branch_index);
|
|
try list.appendSlice(allocator, "if (");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = branch.expression,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ") ");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = branch.taken_expression,
|
|
.type_index = function_return_type,
|
|
});
|
|
|
|
if (!branch.not_taken_expression.invalid) {
|
|
if (module.values.array.get(branch.taken_expression).* == .block) {
|
|
_ = list.pop();
|
|
try list.appendSlice(allocator, " else ");
|
|
} else {
|
|
unreachable;
|
|
}
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = branch.not_taken_expression,
|
|
.type_index = function_return_type,
|
|
});
|
|
|
|
if (module.values.array.get(branch.not_taken_expression).* == .block) {
|
|
continue;
|
|
}
|
|
}
|
|
},
|
|
.assembly_block => |assembly_block_index| {
|
|
try unit.writeAssembly(module, list, allocator, assembly_block_index, indentation);
|
|
try list.append(allocator, ';');
|
|
},
|
|
.loop => |loop_index| {
|
|
const loop = module.values.loops.get(loop_index);
|
|
try list.appendSlice(allocator, "for (");
|
|
if (!loop.pre.invalid) {
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = loop.pre,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
}
|
|
try list.appendSlice(allocator, "; ");
|
|
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = loop.condition,
|
|
.type_index = Compilation.Type.boolean,
|
|
});
|
|
|
|
try list.appendSlice(allocator, "; ");
|
|
|
|
if (!loop.post.invalid) {
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = loop.post,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
}
|
|
|
|
try list.appendSlice(allocator, ") ");
|
|
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = loop.body,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
},
|
|
.block => |new_block_index| {
|
|
try unit.writeBlock(module, list, allocator, new_block_index, function_return_type, indentation);
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
|
|
try list.append(allocator, '\n');
|
|
}
|
|
|
|
try list.appendNTimes(allocator, ' ', old_indentation * margin_width);
|
|
try list.appendSlice(allocator, "}\n");
|
|
}
|
|
|
|
const FunctionHeaderType = enum {
|
|
pointer,
|
|
header,
|
|
};
|
|
|
|
fn renderTypeName(unit: *TranslationUnit, module: *Module, allocator: Allocator, type_index: Compilation.Type.Index) ![]const u8 {
|
|
const declaration_index = module.map.types.get(type_index).?;
|
|
const mangle = true;
|
|
const result = try unit.renderDeclarationName(module, allocator, declaration_index, mangle);
|
|
return result;
|
|
}
|
|
|
|
fn renderFunctionName(unit: *TranslationUnit, module: *Module, allocator: Allocator, function_index: Compilation.Function.Index) ![]const u8 {
|
|
const function_definition = module.types.function_definitions.get(function_index);
|
|
const function_prototype_type = module.types.array.get(function_definition.prototype);
|
|
const function_prototype_index = function_prototype_type.function;
|
|
const function_prototype = module.types.function_prototypes.get(function_prototype_index);
|
|
const mangle = !(function_prototype.attributes.@"export" or function_prototype.attributes.@"extern");
|
|
const function_declaration_index = module.map.functions.get(function_index).?;
|
|
const name = try unit.renderDeclarationName(module, allocator, function_declaration_index, mangle);
|
|
return name;
|
|
}
|
|
|
|
fn renderDeclarationName(unit: *TranslationUnit, module: *Module, allocator: Allocator, declaration_index: Compilation.Declaration.Index, mangle: bool) anyerror![]const u8 {
|
|
const gop = try unit.declaration_set.getOrPut(allocator, declaration_index);
|
|
|
|
if (!gop.found_existing) {
|
|
const declaration = module.values.declarations.get(declaration_index);
|
|
const base_declaration_name = module.getName(declaration.name).?;
|
|
var list = ArrayList(u8){};
|
|
|
|
try list.insertSlice(allocator, 0, base_declaration_name);
|
|
|
|
if (mangle) {
|
|
var scope_index = declaration.scope;
|
|
|
|
var iterations: usize = 0;
|
|
switch (declaration.scope_type) {
|
|
.global => {
|
|
while (!scope_index.invalid) {
|
|
const scope = module.values.scopes.get(scope_index);
|
|
|
|
if (module.map.types.get(scope.type)) |type_declaration| {
|
|
const scope_type_declaration = module.values.declarations.get(type_declaration);
|
|
const scope_type_declaration_name = module.getName(scope_type_declaration.name).?;
|
|
try list.insert(allocator, 0, '_');
|
|
try list.insertSlice(allocator, 0, scope_type_declaration_name);
|
|
|
|
scope_index = scope.parent;
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
iterations += 1;
|
|
}
|
|
},
|
|
.local => {},
|
|
}
|
|
}
|
|
|
|
// TODO: enhance declaration name rendering with file scope name
|
|
// const scope = declaration.scope;
|
|
gop.value_ptr.* = list.items;
|
|
|
|
switch (declaration.scope_type) {
|
|
.global => switch (module.types.array.get(declaration.type).*) {
|
|
.function,
|
|
.type,
|
|
=> {},
|
|
.@"struct" => {
|
|
try unit.writeDeclaration(module, &unit.global_variable_declarations, allocator, declaration_index, 0);
|
|
try unit.global_variable_declarations.append(allocator, ';');
|
|
try unit.global_variable_declarations.appendNTimes(allocator, '\n', 2);
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
},
|
|
.local => {},
|
|
}
|
|
}
|
|
|
|
assert(@intFromPtr(gop.value_ptr.*.ptr) != 0xaaaa_aaaa_aaaa_aaaa);
|
|
logln(.c, .g, "Rendering name: {s}", .{gop.value_ptr.*});
|
|
|
|
return gop.value_ptr.*;
|
|
}
|
|
|
|
fn writeFunctionPrototype(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, function_prototype_index: Compilation.Function.Prototype.Index, name: []const u8) !void {
|
|
const function_prototype = module.types.function_prototypes.get(function_prototype_index);
|
|
switch (function_prototype.attributes.calling_convention) {
|
|
.system_v => {},
|
|
.naked => try list.appendSlice(allocator, "[[gnu::naked]] "),
|
|
}
|
|
|
|
try unit.writeType(module, list, allocator, function_prototype.return_type);
|
|
|
|
try list.append(allocator, ' ');
|
|
|
|
try list.appendSlice(allocator, name);
|
|
|
|
try list.append(allocator, '(');
|
|
|
|
if (function_prototype.arguments) |function_arguments| {
|
|
for (function_arguments) |argument_index| {
|
|
const arg_declaration = module.values.declarations.get(argument_index);
|
|
try unit.writeType(module, list, allocator, arg_declaration.type);
|
|
try list.append(allocator, ' ');
|
|
const arg_name = module.getName(arg_declaration.name).?;
|
|
try list.appendSlice(allocator, arg_name);
|
|
try list.appendSlice(allocator, ", ");
|
|
}
|
|
_ = list.pop();
|
|
_ = list.pop();
|
|
}
|
|
|
|
try list.appendSlice(allocator, ")");
|
|
}
|
|
|
|
fn writeFunctionHeader(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, function_index: Compilation.Function.Index) ![]const u8 {
|
|
const name = try unit.renderFunctionName(module, allocator, function_index);
|
|
const function_definition = module.types.function_definitions.get(function_index);
|
|
const function_prototype_type = module.types.array.get(function_definition.prototype);
|
|
const function_prototype_index = function_prototype_type.function;
|
|
try unit.writeFunctionPrototype(module, list, allocator, function_prototype_index, name);
|
|
|
|
return name;
|
|
}
|
|
|
|
fn writeType(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, type_index: Compilation.Type.Index) anyerror!void {
|
|
const sema_type = module.types.array.get(type_index);
|
|
|
|
switch (sema_type.*) {
|
|
.void => try list.appendSlice(allocator, "void"),
|
|
.noreturn => try list.appendSlice(allocator, "[[noreturn]] void"),
|
|
.bool => try list.appendSlice(allocator, "bool"),
|
|
.integer => |integer| {
|
|
try list.append(allocator, switch (integer.signedness) {
|
|
.signed => 's',
|
|
.unsigned => 'u',
|
|
});
|
|
try list.writer(allocator).print("{}", .{integer.bit_count});
|
|
},
|
|
.pointer => |pointer| {
|
|
switch (module.types.array.get(pointer.element_type).*) {
|
|
.function => {
|
|
@panic("This should be unreachable");
|
|
},
|
|
else => {
|
|
if (pointer.@"const") {
|
|
try list.appendSlice(allocator, "const ");
|
|
}
|
|
try unit.writeType(module, list, allocator, pointer.element_type);
|
|
try list.append(allocator, '*');
|
|
},
|
|
}
|
|
},
|
|
.@"struct" => {
|
|
const name = try unit.cacheStructType(module, allocator, type_index);
|
|
try list.appendSlice(allocator, name);
|
|
},
|
|
.optional => {
|
|
const name = try unit.cacheOptionalType(module, allocator, type_index);
|
|
try list.appendSlice(allocator, name);
|
|
},
|
|
.slice => {
|
|
const name = try unit.cacheSliceType(module, allocator, type_index);
|
|
try list.appendSlice(allocator, name);
|
|
},
|
|
.array => {
|
|
const name = try unit.cacheArrayType(module, allocator, type_index);
|
|
try list.appendSlice(allocator, name);
|
|
},
|
|
.any => @panic("Internal compiler error: 'any' made it to the backend"),
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
}
|
|
|
|
fn writeCDeclaration(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, name: []const u8, type_index: Compilation.Type.Index) !void {
|
|
const declaration_type = module.types.array.get(type_index);
|
|
switch (declaration_type.*) {
|
|
.pointer => |pointer| {
|
|
switch (module.types.array.get(pointer.element_type).*) {
|
|
.function => |function| return try unit.writeFunctionPrototype(module, list, allocator, function, try std.mem.concat(allocator, u8, &.{ "(*", name, ")" })),
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
},
|
|
else => {},
|
|
}
|
|
|
|
try unit.writeType(module, list, allocator, type_index);
|
|
try list.append(allocator, ' ');
|
|
try list.appendSlice(allocator, name);
|
|
}
|
|
|
|
fn writeAssembly(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, assembly_block_index: Compilation.Assembly.Block.Index, indentation: usize) !void {
|
|
const assembly_block = module.values.assembly_blocks.get(assembly_block_index);
|
|
try list.appendSlice(allocator, "__asm__ __volatile__(\n");
|
|
for (assembly_block.instructions) |instruction_index| {
|
|
const generic_instruction = module.values.assembly_instructions.get(instruction_index);
|
|
try list.appendNTimes(allocator, ' ', (indentation + 1) * margin_width);
|
|
try list.append(allocator, '"');
|
|
switch (module.descriptor.target.cpu.arch) {
|
|
.x86_64 => {
|
|
const architecture = @field(Compilation.Assembly, "x86_64");
|
|
|
|
const instruction: architecture.Instruction = @enumFromInt(generic_instruction.id);
|
|
const instruction_name = switch (instruction) {
|
|
.@"and" => "andq",
|
|
.xor => @tagName(instruction),
|
|
.call => "callq",
|
|
};
|
|
try list.appendSlice(allocator, instruction_name);
|
|
|
|
assert(generic_instruction.operands.len <= 2);
|
|
if (generic_instruction.operands.len > 0) {
|
|
try list.append(allocator, ' ');
|
|
var operand_i: usize = generic_instruction.operands.len;
|
|
|
|
while (operand_i > 0) {
|
|
operand_i -= 1;
|
|
|
|
const operand = generic_instruction.operands[operand_i];
|
|
switch (operand) {
|
|
.register => |generic_register| {
|
|
const register: architecture.Register = @enumFromInt(generic_register);
|
|
try list.append(allocator, '%');
|
|
try list.appendSlice(allocator, @tagName(register));
|
|
},
|
|
.number_literal => |number_literal| {
|
|
try list.writer(allocator).print("$0x{x}", .{number_literal});
|
|
},
|
|
.value_index => |value_index| {
|
|
try unit.writeValue(module, list, allocator, Compilation.Type.Index.invalid, indentation + 1, .{
|
|
.value_index = value_index,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
},
|
|
}
|
|
|
|
try list.appendSlice(allocator, ", ");
|
|
}
|
|
|
|
_ = list.pop();
|
|
_ = list.pop();
|
|
}
|
|
},
|
|
else => unreachable,
|
|
}
|
|
try list.appendSlice(allocator, "\\n\\t\"\n");
|
|
}
|
|
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.append(allocator, ')');
|
|
}
|
|
|
|
fn cacheStructType(unit: *TranslationUnit, module: *Module, allocator: Allocator, type_index: Compilation.Type.Index) ![]const u8 {
|
|
const t = module.types.array.get(type_index);
|
|
assert(t.* == .@"struct");
|
|
const gop = try unit.struct_type_set.getOrPut(allocator, type_index);
|
|
|
|
if (!gop.found_existing) {
|
|
const struct_type = module.types.structs.get(t.@"struct");
|
|
const type_name = try unit.renderTypeName(module, allocator, type_index);
|
|
gop.value_ptr.* = type_name;
|
|
// Forward declare the struct
|
|
{
|
|
try unit.type_forward_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name);
|
|
try unit.type_forward_declarations.append(allocator, ' ');
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name);
|
|
try unit.type_forward_declarations.appendSlice(allocator, ";\n");
|
|
}
|
|
|
|
// Actually declare the struct
|
|
{
|
|
try unit.type_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name);
|
|
try unit.type_declarations.appendSlice(allocator, " {\n");
|
|
|
|
for (struct_type.fields.items) |struct_field_index| {
|
|
try unit.type_declarations.appendNTimes(allocator, ' ', margin_width);
|
|
|
|
const struct_field = module.types.container_fields.get(struct_field_index);
|
|
const struct_field_name = module.getName(struct_field.name).?;
|
|
|
|
switch (struct_type.backing_type.invalid) {
|
|
false => {
|
|
try unit.writeType(module, &unit.type_declarations, allocator, struct_type.backing_type);
|
|
try unit.type_declarations.append(allocator, ' ');
|
|
try unit.type_declarations.appendSlice(allocator, struct_field_name);
|
|
try unit.type_declarations.appendSlice(allocator, " : ");
|
|
try unit.type_declarations.writer(allocator).print("{}", .{module.types.array.get(struct_field.type).getBitSize()});
|
|
},
|
|
true => try unit.writeCDeclaration(module, &unit.type_declarations, allocator, struct_field_name, struct_field.type),
|
|
}
|
|
|
|
try unit.type_declarations.appendSlice(allocator, ";\n");
|
|
}
|
|
|
|
try unit.type_declarations.appendSlice(allocator, "} ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name);
|
|
try unit.type_declarations.appendSlice(allocator, ";\n\n");
|
|
}
|
|
}
|
|
|
|
assert(@intFromPtr(gop.value_ptr.*.ptr) != 0xaaaa_aaaa_aaaa_aaaa);
|
|
|
|
return gop.value_ptr.*;
|
|
}
|
|
|
|
fn cacheOptionalType(unit: *TranslationUnit, module: *Module, allocator: Allocator, type_index: Compilation.Type.Index) ![]const u8 {
|
|
const optional_type = module.types.array.get(type_index);
|
|
assert(optional_type.* == .optional);
|
|
const optional = optional_type.optional;
|
|
|
|
const gop = try unit.optional_type_set.getOrPut(allocator, optional.element_type);
|
|
|
|
if (!gop.found_existing) {
|
|
var type_name = ArrayList(u8){};
|
|
const optional_element_type = module.types.array.get(optional.element_type);
|
|
|
|
switch (optional_element_type.*) {
|
|
.pointer => {
|
|
try unit.writeType(module, &type_name, allocator, optional.element_type);
|
|
},
|
|
else => {
|
|
try type_name.appendSlice(allocator, "Optional_");
|
|
try unit.writeType(module, &type_name, allocator, optional.element_type);
|
|
|
|
if (!gop.found_existing) {
|
|
try unit.type_forward_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_forward_declarations.append(allocator, ' ');
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_forward_declarations.appendSlice(allocator, ";\n");
|
|
|
|
try unit.type_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_declarations.appendSlice(allocator, " {\n");
|
|
|
|
try unit.type_declarations.appendNTimes(allocator, ' ', margin_width);
|
|
try unit.writeCDeclaration(module, &unit.type_declarations, allocator, "value", optional.element_type);
|
|
try unit.type_declarations.appendSlice(allocator, ";\n");
|
|
|
|
try unit.type_declarations.appendNTimes(allocator, ' ', margin_width);
|
|
try unit.writeCDeclaration(module, &unit.type_declarations, allocator, "is_null", Compilation.Type.boolean);
|
|
try unit.type_declarations.appendSlice(allocator, ";\n");
|
|
|
|
try unit.type_declarations.appendSlice(allocator, "} ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_declarations.appendSlice(allocator, ";\n\n");
|
|
}
|
|
},
|
|
}
|
|
gop.value_ptr.* = type_name.items;
|
|
}
|
|
|
|
return gop.value_ptr.*;
|
|
}
|
|
|
|
fn cacheSliceType(unit: *TranslationUnit, module: *Module, allocator: Allocator, type_index: Compilation.Type.Index) ![]const u8 {
|
|
const slice = module.types.array.get(type_index).slice;
|
|
|
|
const gop = try unit.slice_type_set.getOrPut(allocator, slice.element_type);
|
|
|
|
if (!gop.found_existing) {
|
|
var type_name = ArrayList(u8){};
|
|
try type_name.appendSlice(allocator, "Slice_");
|
|
try unit.writeType(module, &type_name, allocator, slice.element_type);
|
|
gop.value_ptr.* = type_name.items;
|
|
|
|
try unit.type_forward_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_forward_declarations.append(allocator, ' ');
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_forward_declarations.appendSlice(allocator, ";\n");
|
|
|
|
try unit.type_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_declarations.appendSlice(allocator, " {\n");
|
|
|
|
try unit.type_declarations.appendNTimes(allocator, ' ', margin_width);
|
|
try unit.writeType(module, &unit.type_declarations, allocator, slice.element_type);
|
|
try unit.type_declarations.appendSlice(allocator, "* ptr;\n");
|
|
|
|
try unit.type_declarations.appendNTimes(allocator, ' ', margin_width);
|
|
try unit.type_declarations.appendSlice(allocator, "usize len;\n");
|
|
|
|
try unit.type_declarations.appendSlice(allocator, "} ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_declarations.appendSlice(allocator, ";\n\n");
|
|
}
|
|
|
|
return gop.value_ptr.*;
|
|
}
|
|
|
|
fn cacheArrayType(unit: *TranslationUnit, module: *Module, allocator: Allocator, type_index: Compilation.Type.Index) ![]const u8 {
|
|
const array = module.types.array.get(type_index).array;
|
|
|
|
const gop = try unit.array_type_set.getOrPut(allocator, array.element_type);
|
|
|
|
if (!gop.found_existing) {
|
|
var type_name = ArrayList(u8){};
|
|
try type_name.appendSlice(allocator, "Array_");
|
|
try unit.writeType(module, &type_name, allocator, array.element_type);
|
|
try type_name.writer(allocator).print("_{}", .{array.element_count});
|
|
gop.value_ptr.* = type_name.items;
|
|
|
|
try unit.type_forward_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_forward_declarations.append(allocator, ' ');
|
|
try unit.type_forward_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_forward_declarations.appendSlice(allocator, ";\n");
|
|
|
|
try unit.type_declarations.appendSlice(allocator, "typedef struct ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_declarations.appendSlice(allocator, " {\n");
|
|
|
|
try unit.type_declarations.appendNTimes(allocator, ' ', margin_width);
|
|
try unit.writeType(module, &unit.type_declarations, allocator, array.element_type);
|
|
try unit.type_declarations.appendSlice(allocator, " value\n");
|
|
|
|
try unit.type_declarations.writer(allocator).print("[{}];\n", .{array.element_count});
|
|
|
|
try unit.type_declarations.appendSlice(allocator, "} ");
|
|
try unit.type_declarations.appendSlice(allocator, type_name.items);
|
|
try unit.type_declarations.appendSlice(allocator, ";\n\n");
|
|
}
|
|
|
|
return gop.value_ptr.*;
|
|
}
|
|
|
|
fn writeSyscall(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, syscall_index: Compilation.Syscall.Index, function_return_type: Compilation.Type.Index, indentation: usize) !void {
|
|
const syscall = module.values.syscalls.get(syscall_index);
|
|
const arguments = syscall.getArguments();
|
|
|
|
if (!unit.syscall_bitset.isSet(arguments.len - 1)) {
|
|
try unit.function_declarations.appendSlice(allocator, "static __inline u64 syscall");
|
|
try unit.function_declarations.writer(allocator).print("{}(", .{arguments.len});
|
|
try unit.function_declarations.appendSlice(allocator, "u64 n, ");
|
|
for (0..arguments.len) |arg_i| {
|
|
try unit.function_declarations.writer(allocator).print("u64 arg{}, ", .{arg_i});
|
|
}
|
|
_ = unit.function_declarations.pop();
|
|
_ = unit.function_declarations.pop();
|
|
try unit.function_declarations.appendSlice(allocator,
|
|
\\) {
|
|
\\
|
|
);
|
|
|
|
const simple_register_argument_count = @min(arguments.len, 3);
|
|
const complex_register_argument_count = arguments.len - simple_register_argument_count;
|
|
const simple_argument_registers = [_]u8{ 'D', 'S', 'd' };
|
|
const complex_argument_registers = [_]u8{ 10, 8, 9 };
|
|
|
|
for (0..complex_register_argument_count) |i| {
|
|
try unit.function_declarations.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try unit.function_declarations.writer(allocator).print("register unsigned long r{} __asm__(\"r{}\") = arg{};\n", .{ complex_argument_registers[i], complex_argument_registers[i], 3 + i });
|
|
}
|
|
|
|
try unit.function_declarations.appendSlice(allocator,
|
|
\\ unsigned long ret;
|
|
\\
|
|
\\ __asm__ __volatile__("syscall"
|
|
\\ : "=a"(ret)
|
|
\\ : "a"(n),
|
|
);
|
|
|
|
for (0..simple_register_argument_count, simple_argument_registers[0..simple_register_argument_count]) |arg_i, arg_register| {
|
|
try unit.function_declarations.writer(allocator).print("\"{c}\"(arg{}), ", .{ arg_register, arg_i });
|
|
}
|
|
|
|
for (complex_argument_registers[0..complex_register_argument_count]) |arg_register| {
|
|
try unit.function_declarations.writer(allocator).print("\"r\"(r{}), ", .{arg_register});
|
|
}
|
|
|
|
_ = unit.function_declarations.pop();
|
|
_ = unit.function_declarations.pop();
|
|
|
|
try unit.function_declarations.appendSlice(allocator,
|
|
\\
|
|
\\ : "rcx", "r11", "memory"
|
|
\\ );
|
|
\\
|
|
\\ return ret;
|
|
\\}
|
|
\\
|
|
\\
|
|
);
|
|
|
|
unit.syscall_bitset.set(arguments.len - 1);
|
|
}
|
|
|
|
try list.writer(allocator).print("syscall{}(", .{arguments.len});
|
|
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = syscall.number,
|
|
.type_index = function_return_type,
|
|
});
|
|
try list.appendSlice(allocator, ", ");
|
|
|
|
for (arguments) |argument_index| {
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = argument_index,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ", ");
|
|
}
|
|
|
|
_ = list.pop();
|
|
_ = list.pop();
|
|
try list.append(allocator, ')');
|
|
}
|
|
|
|
fn writeUnreachable(list: *ArrayList(u8), allocator: Allocator) !void {
|
|
try list.appendSlice(allocator, "__builtin_unreachable()");
|
|
}
|
|
|
|
fn writeCall(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, call_index: Compilation.Call.Index, function_return_type: Compilation.Type.Index, indentation: usize) !void {
|
|
const call = module.values.calls.get(call_index);
|
|
const call_value = module.values.array.get(call.value);
|
|
switch (call_value.*) {
|
|
.function_definition => |function_definition_index| {
|
|
const name = try unit.renderFunctionName(module, allocator, function_definition_index);
|
|
try list.appendSlice(allocator, name);
|
|
try list.append(allocator, '(');
|
|
},
|
|
.field_access => |field_access_index| {
|
|
const field_access = module.values.field_accesses.get(field_access_index);
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = field_access.declaration_reference,
|
|
.type_index = function_return_type,
|
|
});
|
|
|
|
const left_type = module.types.array.get(module.values.array.get(field_access.declaration_reference).declaration_reference.type);
|
|
const is_pointer = switch (left_type.*) {
|
|
.pointer => true,
|
|
else => false,
|
|
};
|
|
|
|
if (is_pointer) {
|
|
try list.appendSlice(allocator, "->");
|
|
} else {
|
|
try list.append(allocator, '.');
|
|
}
|
|
|
|
const field = module.types.container_fields.get(field_access.field);
|
|
const field_name = module.getName(field.name).?;
|
|
try list.appendSlice(allocator, field_name);
|
|
try list.append(allocator, '(');
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
|
|
if (!call.arguments.invalid) {
|
|
const argument_list = module.values.argument_lists.get(call.arguments);
|
|
|
|
if (argument_list.array.items.len > 0) {
|
|
for (argument_list.array.items) |argument_index| {
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = argument_index,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ", ");
|
|
}
|
|
|
|
_ = list.pop();
|
|
_ = list.pop();
|
|
}
|
|
}
|
|
|
|
try list.append(allocator, ')');
|
|
}
|
|
|
|
const ValueArguments = struct {
|
|
value_index: Compilation.Value.Index,
|
|
type_index: Compilation.Type.Index,
|
|
};
|
|
|
|
fn writeValue(unit: *TranslationUnit, module: *Module, list: *ArrayList(u8), allocator: Allocator, function_return_type: Compilation.Type.Index, indentation: usize, arguments: ValueArguments) anyerror!void {
|
|
const value_index = arguments.value_index;
|
|
const type_index = arguments.type_index;
|
|
_ = type_index;
|
|
const value = module.values.array.get(value_index);
|
|
switch (value.*) {
|
|
.declaration => |declaration_index| {
|
|
try unit.writeDeclaration(module, list, allocator, declaration_index, indentation);
|
|
},
|
|
.assign => |assignment_index| {
|
|
try unit.writeAssignment(module, list, allocator, assignment_index, function_return_type, indentation);
|
|
},
|
|
.integer => |integer| {
|
|
try list.writer(allocator).print("{}", .{integer.value});
|
|
},
|
|
.declaration_reference => |declaration_reference| {
|
|
const mangle = true;
|
|
const name = try unit.renderDeclarationName(module, allocator, declaration_reference.value, mangle);
|
|
try list.appendSlice(allocator, name);
|
|
},
|
|
.binary_operation => |binary_operation_index| {
|
|
const binary_operation = module.values.binary_operations.get(binary_operation_index);
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = binary_operation.left,
|
|
.type_index = binary_operation.type,
|
|
});
|
|
try list.append(allocator, ' ');
|
|
|
|
switch (binary_operation.id) {
|
|
.add => try list.append(allocator, '+'),
|
|
.sub => try list.append(allocator, '-'),
|
|
.bit_and => try list.append(allocator, '&'),
|
|
.bit_or => try list.append(allocator, '|'),
|
|
.bit_xor => try list.append(allocator, '^'),
|
|
.multiply => try list.append(allocator, '*'),
|
|
.divide => try list.append(allocator, '/'),
|
|
.compare_greater_than => try list.append(allocator, '>'),
|
|
.compare_less_than => try list.append(allocator, '<'),
|
|
.shift_left => try list.appendSlice(allocator, "<<"),
|
|
.shift_right => try list.appendSlice(allocator, ">>"),
|
|
.compare_equal => try list.appendSlice(allocator, "=="),
|
|
.compare_greater_or_equal => try list.appendSlice(allocator, ">="),
|
|
.compare_less_or_equal => try list.appendSlice(allocator, "<="),
|
|
}
|
|
|
|
try list.append(allocator, ' ');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = binary_operation.right,
|
|
.type_index = binary_operation.type,
|
|
});
|
|
},
|
|
.sign_extend => |cast_index| {
|
|
const sign_extend = module.values.casts.get(cast_index);
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = sign_extend.value,
|
|
.type_index = sign_extend.type,
|
|
});
|
|
},
|
|
.cast => |cast_index| {
|
|
const cast = module.values.casts.get(cast_index);
|
|
try list.append(allocator, '(');
|
|
try unit.writeType(module, list, allocator, cast.type);
|
|
try list.append(allocator, ')');
|
|
const cast_value = module.values.array.get(cast.value);
|
|
const cast_value_type = module.types.array.get(cast_value.getType(module));
|
|
|
|
switch (cast_value_type.*) {
|
|
.@"struct" => |struct_index| {
|
|
const struct_type = module.types.structs.get(struct_index);
|
|
switch (struct_type.backing_type.invalid) {
|
|
false => {
|
|
try list.appendSlice(allocator, "*(");
|
|
try unit.writeType(module, list, allocator, struct_type.backing_type);
|
|
try list.appendSlice(allocator, "*)&(");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = cast.value,
|
|
.type_index = function_return_type,
|
|
});
|
|
try list.append(allocator, ')');
|
|
},
|
|
true => @panic("Unable to bitcast non-packed struct"),
|
|
}
|
|
},
|
|
else => try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = cast.value,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
}),
|
|
}
|
|
},
|
|
.string_literal => |string_literal_descriptor| {
|
|
try list.appendSlice(allocator, "(const u8*)");
|
|
const string_literal = module.getName(string_literal_descriptor.hash) orelse unreachable;
|
|
try list.append(allocator, '"');
|
|
try list.appendSlice(allocator, string_literal);
|
|
try list.append(allocator, '"');
|
|
},
|
|
.@"unreachable" => {
|
|
try writeUnreachable(list, allocator);
|
|
},
|
|
.call => |call_index| try unit.writeCall(module, list, allocator, call_index, function_return_type, indentation),
|
|
.syscall => |syscall_index| try unit.writeSyscall(module, list, allocator, syscall_index, function_return_type, indentation),
|
|
.bool => |boolean| try list.appendSlice(allocator, if (boolean) "true" else "false"),
|
|
.block => |block_index| try unit.writeBlock(module, list, allocator, block_index, function_return_type, indentation),
|
|
.unary_operation => |unary_operation_index| {
|
|
const unary_operation = module.values.unary_operations.get(unary_operation_index);
|
|
const expression_character: u8 = switch (unary_operation.id) {
|
|
.boolean_not => '!',
|
|
.negation => '-',
|
|
.address_of => '&',
|
|
.pointer_dereference => '*',
|
|
};
|
|
|
|
try list.append(allocator, expression_character);
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = unary_operation.value,
|
|
.type_index = unary_operation.type,
|
|
});
|
|
try list.append(allocator, ')');
|
|
},
|
|
.container_initialization => |container_initialization_index| {
|
|
const container_initialization = module.values.container_initializations.get(container_initialization_index);
|
|
try list.append(allocator, '(');
|
|
try unit.writeType(module, list, allocator, container_initialization.type);
|
|
try list.appendSlice(allocator, ") {\n");
|
|
|
|
const container_type = module.types.array.get(container_initialization.type);
|
|
const container_fields = switch (container_type.*) {
|
|
.@"struct" => module.types.structs.get(container_type.@"struct").fields,
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
|
|
for (container_initialization.field_initializations.items, container_fields.items) |field_initialization_index, container_field_index| {
|
|
try list.appendNTimes(allocator, ' ', (indentation + 1) * margin_width);
|
|
try list.append(allocator, '.');
|
|
const container_field = module.types.container_fields.get(container_field_index);
|
|
const field_name = module.getName(container_field.name).?;
|
|
try list.appendSlice(allocator, field_name);
|
|
try list.appendSlice(allocator, " = ");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = field_initialization_index,
|
|
.type_index = container_field.type,
|
|
});
|
|
try list.appendSlice(allocator, ",\n");
|
|
}
|
|
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.append(allocator, '}');
|
|
},
|
|
.field_access => |field_access_index| {
|
|
const field_access = module.values.field_accesses.get(field_access_index);
|
|
const left = module.values.array.get(field_access.declaration_reference);
|
|
const left_type = module.types.array.get(left.getType(module));
|
|
const right_field = module.types.container_fields.get(field_access.field);
|
|
const right_field_name = module.getName(right_field.name).?;
|
|
const is_pointer = switch (left_type.*) {
|
|
.@"struct" => false,
|
|
.pointer => true,
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = field_access.declaration_reference,
|
|
.type_index = right_field.type,
|
|
});
|
|
|
|
if (is_pointer) {
|
|
try list.appendSlice(allocator, "->");
|
|
} else {
|
|
try list.append(allocator, '.');
|
|
}
|
|
|
|
try list.appendSlice(allocator, right_field_name);
|
|
},
|
|
.pointer_null_literal => try list.appendSlice(allocator, "nullptr"),
|
|
.optional_null_literal => {
|
|
assert(!arguments.type_index.invalid);
|
|
try list.append(allocator, '(');
|
|
try unit.writeType(module, list, allocator, arguments.type_index);
|
|
try list.appendSlice(allocator, ") { .is_null = true }");
|
|
},
|
|
.slice => |slice_index| {
|
|
const slice = module.values.slices.get(slice_index);
|
|
const sliceable = module.values.array.get(slice.sliceable);
|
|
|
|
const sliceable_type_index = switch (sliceable.*) {
|
|
.declaration_reference => |declaration_reference| declaration_reference.type,
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
const sliceable_type = module.types.array.get(sliceable_type_index);
|
|
const sliceable_element_type = switch (sliceable_type.*) {
|
|
.pointer => |pointer| pointer.element_type,
|
|
.slice => |slice_type| slice_type.element_type,
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
|
|
try list.appendSlice(allocator, "(Slice_");
|
|
try unit.writeType(module, list, allocator, sliceable_element_type);
|
|
try list.appendSlice(allocator, ") {\n");
|
|
|
|
try list.appendNTimes(allocator, ' ', (indentation + 1) * margin_width);
|
|
try list.appendSlice(allocator, ".ptr = ");
|
|
|
|
switch (sliceable_type.*) {
|
|
.pointer => {
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.sliceable,
|
|
.type_index = sliceable_type_index,
|
|
});
|
|
try list.appendSlice(allocator, ") + (");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.range.start,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, "),\n");
|
|
},
|
|
.slice => {
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.sliceable,
|
|
.type_index = sliceable_type_index,
|
|
});
|
|
try list.appendSlice(allocator, ").ptr + (");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.range.start,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, "),\n");
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
|
|
try list.appendNTimes(allocator, ' ', (indentation + 1) * margin_width);
|
|
try list.appendSlice(allocator, ".len = ");
|
|
|
|
switch (sliceable_type.*) {
|
|
.pointer => {
|
|
switch (slice.range.end.invalid) {
|
|
false => {
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.range.end,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ") - (");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.range.start,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ")\n");
|
|
},
|
|
true => {
|
|
unreachable;
|
|
},
|
|
}
|
|
},
|
|
.slice => {
|
|
switch (slice.range.end.invalid) {
|
|
false => {
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.range.end,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ") - (");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation + 1, .{
|
|
.value_index = slice.range.start,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ")\n");
|
|
},
|
|
true => {
|
|
unreachable;
|
|
},
|
|
}
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.append(allocator, '}');
|
|
},
|
|
.function_definition => |function_definition_index| {
|
|
const function_name = try unit.writeFunctionDefinition(module, allocator, function_definition_index);
|
|
try list.appendSlice(allocator, function_name);
|
|
},
|
|
.optional_check => |optional_check_index| {
|
|
const optional_check = module.values.optional_checks.get(optional_check_index);
|
|
const optional_type = module.types.array.get(module.values.array.get(optional_check.value).getType(module));
|
|
assert(optional_type.* == .optional);
|
|
const optional_element_type = module.types.array.get(optional_type.optional.element_type);
|
|
const is_null_suffix_expression = switch (optional_element_type.*) {
|
|
.pointer => false,
|
|
else => true,
|
|
};
|
|
if (is_null_suffix_expression) {
|
|
try list.append(allocator, '!');
|
|
}
|
|
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = optional_check.value,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.append(allocator, ')');
|
|
|
|
if (is_null_suffix_expression) {
|
|
try list.appendSlice(allocator, ".is_null");
|
|
}
|
|
},
|
|
.optional_unwrap => |optional_unwrap_index| {
|
|
const optional_unwrap = module.values.optional_unwraps.get(optional_unwrap_index);
|
|
const optional_value = module.values.array.get(optional_unwrap.value);
|
|
const optional_type = module.types.array.get(optional_value.getType(module));
|
|
assert(optional_type.* == .optional);
|
|
const optional_element_type_index = optional_type.optional.element_type;
|
|
const optional_element_type = module.types.array.get(optional_element_type_index);
|
|
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = optional_unwrap.value,
|
|
.type_index = optional_element_type_index,
|
|
});
|
|
try list.append(allocator, ')');
|
|
|
|
switch (optional_element_type.*) {
|
|
.pointer => {},
|
|
else => try list.appendSlice(allocator, ".value"),
|
|
}
|
|
},
|
|
.slice_access => |slice_access_index| {
|
|
const slice_access = module.values.slice_accesses.get(slice_access_index);
|
|
try list.append(allocator, '(');
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = slice_access.value,
|
|
.type_index = slice_access.type,
|
|
});
|
|
try list.appendSlice(allocator, ").");
|
|
try list.appendSlice(allocator, @tagName(slice_access.field));
|
|
},
|
|
.indexed_access => |indexed_access_index| {
|
|
const indexed_access = module.values.indexed_accesses.get(indexed_access_index);
|
|
try list.append(allocator, '(');
|
|
const indexed_expression_index = indexed_access.indexed_expression;
|
|
const indexed_expression = module.values.array.get(indexed_expression_index);
|
|
const indexed_expression_type_index = indexed_expression.getType(module);
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = indexed_expression_index,
|
|
.type_index = indexed_expression_type_index,
|
|
});
|
|
|
|
const indexed_expression_type = module.types.array.get(indexed_expression_type_index);
|
|
switch (indexed_expression_type.*) {
|
|
.slice => {
|
|
try list.appendSlice(allocator, ".ptr");
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
|
|
try list.appendSlice(allocator, ")[");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = indexed_access.index_expression,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.append(allocator, ']');
|
|
},
|
|
.optional_cast => |cast_index| {
|
|
const optional_cast = module.values.casts.get(cast_index);
|
|
const optional_type = module.types.array.get(optional_cast.type);
|
|
switch (optional_type.*) {
|
|
.optional => |optional| {
|
|
const optional_element_type = module.types.array.get(optional.element_type);
|
|
switch (optional_element_type.*) {
|
|
.pointer => try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = optional_cast.value,
|
|
.type_index = optional.element_type,
|
|
}),
|
|
else => {
|
|
try list.append(allocator, '(');
|
|
try unit.writeType(module, list, allocator, optional_cast.type);
|
|
try list.appendSlice(allocator, ") {\n");
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.appendSlice(allocator, ".value = ");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = optional_cast.value,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ",\n");
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.appendSlice(allocator, ".is_null = false,\n");
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.append(allocator, '}');
|
|
},
|
|
}
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
},
|
|
.undefined => try list.appendSlice(allocator, "{}"),
|
|
.array_coerce_to_slice => |cast_index| {
|
|
const array_coerce_to_slice = module.values.casts.get(cast_index);
|
|
try list.append(allocator, '(');
|
|
try unit.writeType(module, list, allocator, array_coerce_to_slice.type);
|
|
try list.appendSlice(allocator, ") {\n");
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.appendSlice(allocator, ".ptr = ");
|
|
try unit.writeValue(module, list, allocator, function_return_type, indentation, .{
|
|
.value_index = array_coerce_to_slice.value,
|
|
.type_index = Compilation.Type.Index.invalid,
|
|
});
|
|
try list.appendSlice(allocator, ".value,\n");
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
const array_value = module.values.array.get(array_coerce_to_slice.value);
|
|
const array_type = module.types.array.get(array_value.getType(module));
|
|
const array_length = switch (array_type.*) {
|
|
.array => |array| array.element_count,
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
try list.writer(allocator).print(".len = {},\n", .{array_length});
|
|
try list.appendNTimes(allocator, ' ', indentation * margin_width);
|
|
try list.append(allocator, '}');
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
}
|
|
};
|
|
|
|
pub fn initialize(compilation: *Compilation, module: *Module, descriptor: Compilation.Module.Descriptor) !void {
|
|
const allocator = compilation.base_allocator;
|
|
var unit = try TranslationUnit.create(module, allocator);
|
|
const c_source_file_path = try std.mem.concat(allocator, u8, &.{ descriptor.executable_path, ".c" });
|
|
const c_source_file = try std.fs.cwd().createFile(c_source_file_path, .{});
|
|
|
|
try unit.type_forward_declarations.append(allocator, '\n');
|
|
|
|
var offset: u64 = 0;
|
|
const slices = [_][]const u8{ unit.primitive_type_declarations.items, unit.type_forward_declarations.items, unit.type_declarations.items, unit.function_declarations.items, unit.global_variable_declarations.items, unit.string_literals.items, unit.function_definitions.items };
|
|
for (slices) |slice| {
|
|
try c_source_file.pwriteAll(slice, offset);
|
|
offset += slice.len;
|
|
}
|
|
|
|
c_source_file.close();
|
|
const c_source_file_realpath = try std.fs.cwd().realpathAlloc(allocator, c_source_file_path);
|
|
const c_flags = [_][]const u8{
|
|
"-std=c2x",
|
|
"-g",
|
|
};
|
|
|
|
var zig_command_line = ArrayList([]const u8){};
|
|
try zig_command_line.append(allocator, "zig");
|
|
try zig_command_line.append(allocator, "build-exe");
|
|
try zig_command_line.append(allocator, try std.mem.concat(allocator, u8, &.{ "-femit-bin=", descriptor.executable_path }));
|
|
try zig_command_line.append(allocator, "-cflags");
|
|
for (c_flags) |c_flag| {
|
|
try zig_command_line.append(allocator, c_flag);
|
|
}
|
|
try zig_command_line.append(allocator, "--");
|
|
try zig_command_line.append(allocator, c_source_file_realpath);
|
|
|
|
const run_result = try std.ChildProcess.run(.{
|
|
.allocator = allocator,
|
|
.argv = zig_command_line.items,
|
|
});
|
|
switch (run_result.term) {
|
|
.Exited => |exit_code| {
|
|
if (exit_code != 0) {
|
|
for (zig_command_line.items) |arg| {
|
|
std.debug.print("{s} ", .{arg});
|
|
}
|
|
std.debug.panic("\nZig command exited with code {}:\n{s}", .{ exit_code, run_result.stderr });
|
|
}
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
}
|
|
}
|