397 lines
18 KiB
Plaintext
397 lines
18 KiB
Plaintext
import "@std/mem"
|
|
import "@std/io"
|
|
import "@std/enummap"
|
|
import "@std/arraylist"
|
|
import "@source/ir"
|
|
import "@source/diagnostics"
|
|
|
|
@hide
|
|
Type :: struct {
|
|
kind ir.Type = .void
|
|
shape ir.ArrayId = ir.no_array
|
|
}
|
|
|
|
@hide
|
|
State :: struct {
|
|
output io.Writer
|
|
module @ir.Module
|
|
line_starts []usize
|
|
values []mut Type
|
|
next_register usize = 0
|
|
}
|
|
|
|
#! writes a standalone native LLVM module; all temporary emitter storage is released before returning.
|
|
emit proc(
|
|
allocator mem.Allocator,
|
|
output io.Writer,
|
|
module @ir.Module,
|
|
diagnostic_store @diagnostics.Store,
|
|
source []u8,
|
|
path []u8,
|
|
) void ! (mem.AllocError | io.WriteError) {
|
|
line_starts := arraylist.init(usize, allocator)
|
|
defer arraylist.deinit(&line_starts)
|
|
try arraylist.append(&line_starts, usize(0))
|
|
for (source) |byte, index| {
|
|
if (byte == '\n') try arraylist.append(&line_starts, index + 1)
|
|
}
|
|
try io.write_all(output, runtime)
|
|
try io.write_all(output, "\n@path = private constant ")
|
|
try bytes_constant(output, path)
|
|
try io.write_all(output, "\n")
|
|
for (module.strings.items) |_, index| {
|
|
try io.print("@s{} = private constant ", output, {index})
|
|
try bytes_constant(output, ir.string_bytes(module, ir.StringId(index)))
|
|
try io.write_all(output, "\n")
|
|
}
|
|
for (diagnostic_store.list.items) |diagnostic, index| {
|
|
try io.print("@d{} = private constant ", output, {index})
|
|
try bytes_constant(output, enummap.get(diagnostics.Code, []u8, &diagnostics.messages, diagnostic.code)?)
|
|
try io.write_all(output, "\n")
|
|
}
|
|
try emit_reporting(output, diagnostic_store, line_starts.items, path.len)
|
|
for (module.globals.items) |global, index| {
|
|
try io.print("@g{} = internal global ", output, {index})
|
|
storage_kind :: if (global.type == .void) ir.Type.invalid else global.type
|
|
try write_type(output, module, Type{ kind = storage_kind, shape = global.array_type })
|
|
try io.print(" zeroinitializer\n@gs{} = internal global i8 0\n", output, {index})
|
|
try emit_global(output, module, global, index)
|
|
}
|
|
for (module.arrays.items) |_, index| try emit_array_printer(output, module, ir.ArrayId(index))
|
|
for (module.functions.items) |function, index| {
|
|
values :: try mem.alloc(Type, allocator, function.value_count)
|
|
defer mem.free(allocator, values)
|
|
mem.set(values, Type{})
|
|
for (function.blocks.items) |block| {
|
|
for (block.instructions.items) |instruction| {
|
|
if (instruction.destination != ir.no_value) {
|
|
values[usize(instruction.destination)] = Type{ kind = instruction.type, shape = instruction.array_type }
|
|
}
|
|
}
|
|
}
|
|
state := State{ output = output, module = module, line_starts = line_starts.items, values = values }
|
|
try emit_function(&state, &function, index)
|
|
}
|
|
try io.write_all(output, "define i32 @main() {\nentry:\n")
|
|
if (module.entry) |entry| {
|
|
function :: module.functions.items[usize(entry)]
|
|
result :: Type{ kind = function.result, shape = function.result_array_type }
|
|
if (result.kind != .void) try io.write_all(output, " %result = ")
|
|
else try io.write_all(output, " ")
|
|
try io.write_all(output, "call ")
|
|
try write_type(output, module, result)
|
|
try io.print(" @f{}()\n", output, {u32(entry)})
|
|
if (result.kind != .void and result.kind != .invalid) {
|
|
try print_call(output, module, result, "%result")
|
|
try io.write_all(output, " call void @out(i32 1, ptr @newline, i64 1)\n")
|
|
}
|
|
try io.write_all(output, " call void @report(i64 -1)\n")
|
|
status i32 :: if (diagnostics.count(diagnostic_store) == 0) 0 else 1
|
|
try io.print(" ret i32 {}\n", output, {status})
|
|
} else {
|
|
try io.print(" call void @trap(i64 {}, i64 0, i64 0, ptr null, i64 0)\n unreachable\n", output, {u32(module.entry_diagnostic)})
|
|
}
|
|
try io.write_all(output, "}\n")
|
|
}
|
|
|
|
@hide:file
|
|
bytes_constant proc(output io.Writer, bytes []u8) void ! io.WriteError {
|
|
try io.print("[{} x i8] c\"", output, {bytes.len})
|
|
digits :: "0123456789ABCDEF"
|
|
for (bytes) |byte| {
|
|
escaped [3]u8 :: ['\\', digits[usize(divtrunc!(byte, 16))], digits[usize(rem!(byte, 16))]]
|
|
try io.write_all(output, (&escaped)[..])
|
|
}
|
|
try io.write_all(output, "\"")
|
|
}
|
|
|
|
@hide
|
|
write_type proc(output io.Writer, module @ir.Module, type Type) void ! io.WriteError {
|
|
match type.kind {
|
|
.int, .usize: try io.write_all(output, "i64")
|
|
.float: try io.write_all(output, "double")
|
|
.bool: try io.write_all(output, "i1")
|
|
.string: try io.write_all(output, "%string")
|
|
.function: try io.write_all(output, "ptr")
|
|
.address: try io.write_all(output, "%address")
|
|
.array: {
|
|
shape :: module.arrays.items[usize(type.shape)]
|
|
try io.print("[{} x ", output, {shape.len})
|
|
try write_type(output, module, Type{ kind = shape.element, shape = shape.element_array })
|
|
try io.write_all(output, "]")
|
|
}
|
|
.void: try io.write_all(output, "void")
|
|
# invalid storage only belongs to recovery paths that trap before reading it.
|
|
.invalid: try io.write_all(output, "i8")
|
|
}
|
|
}
|
|
|
|
@hide:file
|
|
local_type proc(function @ir.Function, index usize) Type {
|
|
type := Type{ kind = function.locals.items[index] }
|
|
if (type.kind == .void) type.kind = .invalid
|
|
if (type.kind == .array) {
|
|
for (function.array_storage.items) |storage| {
|
|
if (storage.local and usize(storage.index) == index) {
|
|
type.shape = storage.array_type
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return type
|
|
}
|
|
|
|
@hide
|
|
Location :: struct {
|
|
line usize = 1
|
|
column usize = 1
|
|
}
|
|
|
|
@hide
|
|
location proc(line_starts []usize, span diagnostics.Span) Location {
|
|
offset :: usize(span.start)
|
|
line := usize(0)
|
|
end := line_starts.len
|
|
while (line + 1 < end) {
|
|
middle :: line + divtrunc!(end - line, 2)
|
|
if (line_starts[middle] <= offset) line = middle
|
|
else end = middle
|
|
}
|
|
return Location{ line = line + 1, column = offset - line_starts[line] + 1 }
|
|
}
|
|
|
|
@hide:file
|
|
emit_reporting proc(output io.Writer, diagnostic_store @diagnostics.Store, line_starts []usize, path_length usize) void ! io.WriteError {
|
|
try io.write_all(output, "define internal void @io_failure() noreturn {\nentry:\n")
|
|
try io.print(" %path_result = call i64 @write(i32 2, ptr @path, i64 {})\n", output, {path_length})
|
|
try io.write_all(output, " %message_result = call i64 @write(i32 2, ptr @write_error, i64 44)\n call void @exit(i32 2)\n unreachable\n}\n")
|
|
try io.write_all(output, "define internal void @diagnose(i64 %line, i64 %column, ptr %message, i64 %length, i1 %trap) {\nentry:\n")
|
|
try io.print(" call void @out(i32 2, ptr @path, i64 {})\n", output, {path_length})
|
|
try io.write_all(output,
|
|
` call void @out(i32 2, ptr @colon, i64 1)
|
|
` call void @print_integer(i32 2, i64 %line, i1 true)
|
|
` call void @out(i32 2, ptr @colon, i64 1)
|
|
` call void @print_integer(i32 2, i64 %column, i1 true)
|
|
` %label = select i1 %trap, ptr @runtime_trap, ptr @error
|
|
` %label_length = select i1 %trap, i64 16, i64 9
|
|
` call void @out(i32 2, ptr %label, i64 %label_length)
|
|
` call void @out(i32 2, ptr %message, i64 %length)
|
|
` call void @out(i32 2, ptr @newline, i64 1)
|
|
` ret void
|
|
`}
|
|
)
|
|
try io.write_all(output, "define internal void @report(i64 %trap) {\nentry:\n")
|
|
for (diagnostic_store.list.items) |diagnostic, index| {
|
|
position :: location(line_starts, diagnostic.span)
|
|
message :: enummap.get(diagnostics.Code, []u8, &diagnostics.messages, diagnostic.code)?
|
|
try io.print(" %t{} = icmp eq i64 %trap, {}\n", output, {index, index})
|
|
try io.print(" call void @diagnose(i64 {}, i64 {}, ptr @d{}, i64 {}, i1 %t{})\n", output, {
|
|
position.line, position.column, index, message.len, index,
|
|
})
|
|
}
|
|
try io.write_all(output, " ret void\n}\n")
|
|
}
|
|
|
|
@hide:file
|
|
emit_global proc(output io.Writer, module @ir.Module, global ir.Global, index usize) void ! io.WriteError {
|
|
type :: Type{ kind = global.type, shape = global.array_type }
|
|
try io.print("define internal ptr @global{}(i64 %line, i64 %column) {{\nentry:\n", output, {index})
|
|
try io.print(" %state = load i8, ptr @gs{}\n", output, {index})
|
|
try io.write_all(output,
|
|
` switch i8 %state, label %initialize [ i8 1, label %cycle i8 2, label %ready ]
|
|
`cycle:
|
|
` call void @trap(i64 -1, i64 %line, i64 %column, ptr @cycle, i64 27)
|
|
` unreachable
|
|
`initialize:
|
|
)
|
|
try io.print(" store i8 1, ptr @gs{}\n", output, {index})
|
|
if (type.kind == .void) {
|
|
try io.print(" call void @f{}()\n", output, {u32(global.initializer)})
|
|
} else {
|
|
try io.write_all(output, " %value = call ")
|
|
try write_type(output, module, type)
|
|
try io.print(" @f{}()\n store ", output, {u32(global.initializer)})
|
|
try write_type(output, module, type)
|
|
try io.print(" %value, ptr @g{}\n", output, {index})
|
|
}
|
|
try io.print(" store i8 2, ptr @gs{}\n br label %ready\nready:\n ret ptr @g{}\n}}\n", output, {index, index})
|
|
}
|
|
|
|
@hide:file
|
|
print_call proc(output io.Writer, module @ir.Module, type Type, operand []u8) void ! io.WriteError {
|
|
match type.kind {
|
|
.int, .usize: try io.print(" call void @print_integer(i32 1, i64 {s}, i1 {})\n", output, {operand, type.kind == .usize})
|
|
.float: try io.print(" call void @print_float(double {s})\n", output, {operand})
|
|
.bool: try io.print(" call void @print_bool(i1 {s})\n", output, {operand})
|
|
.string: try io.print(" call void @print_string(%string {s})\n", output, {operand})
|
|
.array: {
|
|
try io.print(" call void @print_array{}(", output, {u32(type.shape)})
|
|
try write_type(output, module, type)
|
|
try io.print(" {s})\n", output, {operand})
|
|
}
|
|
else: unreachable
|
|
}
|
|
}
|
|
|
|
@hide:file
|
|
emit_array_printer proc(output io.Writer, module @ir.Module, id ir.ArrayId) void ! io.WriteError {
|
|
shape :: module.arrays.items[usize(id)]
|
|
type :: Type{ kind = .array, shape = id }
|
|
element :: Type{ kind = shape.element, shape = shape.element_array }
|
|
try io.print("define internal void @print_array{}(", output, {u32(id)})
|
|
try write_type(output, module, type)
|
|
try io.write_all(output, " %value) {\nentry:\n %storage = alloca ")
|
|
try write_type(output, module, type)
|
|
try io.write_all(output, "\n store ")
|
|
try write_type(output, module, type)
|
|
try io.write_all(output, " %value, ptr %storage\n call void @out(i32 1, ptr @open, i64 1)\n br label %loop\nloop:\n %index = phi i64 [ 0, %entry ], [ %next, %element ]\n")
|
|
try io.print(" %done = icmp eq i64 %index, {}\n", output, {shape.len})
|
|
try io.write_all(output, " br i1 %done, label %end, label %separator\nseparator:\n %first = icmp eq i64 %index, 0\n br i1 %first, label %element, label %comma\ncomma:\n call void @out(i32 1, ptr @separator, i64 2)\n br label %element\nelement:\n %pointer = getelementptr ")
|
|
try write_type(output, module, type)
|
|
try io.write_all(output, ", ptr %storage, i64 0, i64 %index\n %item = load ")
|
|
try write_type(output, module, element)
|
|
try io.write_all(output, ", ptr %pointer\n")
|
|
# functions may occur inside arrays without being printable source results.
|
|
if (element.kind != .function) try print_call(output, module, element, "%item")
|
|
else try io.write_all(output, " call void @exit(i32 2)\n")
|
|
try io.write_all(output, " %next = add i64 %index, 1\n br label %loop\nend:\n call void @out(i32 1, ptr @close, i64 1)\n ret void\n}\n")
|
|
}
|
|
|
|
@hide
|
|
fresh proc(state @mut State) usize {
|
|
value :: state.next_register
|
|
state.next_register += 1
|
|
return value
|
|
}
|
|
|
|
@hide
|
|
load proc(state @mut State, value ir.ValueId) usize ! io.WriteError {
|
|
result :: fresh(state)
|
|
try io.print(" %r{} = load ", state.output, {result})
|
|
try write_type(state.output, state.module, state.values[usize(value)])
|
|
try io.print(", ptr %v{}\n", state.output, {u32(value)})
|
|
return result
|
|
}
|
|
|
|
@hide
|
|
store proc(state @State, destination ir.ValueId, register usize) void ! io.WriteError {
|
|
if (destination == ir.no_value or state.values[usize(destination)].kind == .void) return
|
|
try io.write_all(state.output, " store ")
|
|
try write_type(state.output, state.module, state.values[usize(destination)])
|
|
try io.print(" %r{}, ptr %v{}\n", state.output, {register, u32(destination)})
|
|
}
|
|
|
|
@hide
|
|
check_local proc(state @State, slot u32, read bool, span diagnostics.Span) void ! io.WriteError {
|
|
position :: location(state.line_starts, span)
|
|
try io.print(" call void @check_init(ptr %i{}, i1 {}, i64 {}, i64 {})\n", state.output, {slot, read, position.line, position.column})
|
|
}
|
|
|
|
@hide:file
|
|
trap proc(state @State, code diagnostics.Code, span diagnostics.Span) void ! io.WriteError {
|
|
position :: location(state.line_starts, span)
|
|
symbol []u8 :: match code {
|
|
.integer_overflow: "overflow"
|
|
.index_out_of_bounds: "bounds"
|
|
else: unreachable
|
|
}
|
|
message :: enummap.get(diagnostics.Code, []u8, &diagnostics.messages, code)?
|
|
length :: message.len
|
|
try io.print(" call void @trap(i64 -1, i64 {}, i64 {}, ptr @{s}, i64 {})\n unreachable\n", state.output, {position.line, position.column, symbol, length})
|
|
}
|
|
|
|
@hide
|
|
check_failure proc(state @mut State, condition usize, code diagnostics.Code, span diagnostics.Span) void ! io.WriteError {
|
|
label :: fresh(state)
|
|
try io.print(" br i1 %r{}, label %fail{}, label %ok{}\nfail{}:\n", state.output, {condition, label, label, label})
|
|
try trap(state, code, span)
|
|
try io.print("ok{}:\n", state.output, {label})
|
|
}
|
|
|
|
@hide
|
|
write_constant proc(output io.Writer, module @ir.Module, value ir.Value) void ! io.WriteError {
|
|
match value.type {
|
|
.int: try io.print("{}", output, {value.data.integer})
|
|
.usize: try io.print("{}", output, {value.data.unsigned})
|
|
.float: {
|
|
bits :: ptrcast!(@u64, &value.data.real)^
|
|
try io.print("bitcast (i64 {} to double)", output, {bits})
|
|
}
|
|
.bool: try io.print("{}", output, {value.data.boolean})
|
|
.string: try io.print("{{ ptr @s{}, i64 {} }}", output, {u32(value.data.string), ir.string_bytes(module, value.data.string).len})
|
|
.function: try io.print("@f{}", output, {u32(value.data.function)})
|
|
.array: {
|
|
shape :: module.arrays.items[usize(value.array_type)]
|
|
width :: if (shape.element == .array) module.arrays.items[usize(shape.element_array)].cells else 1
|
|
try io.write_all(output, "[")
|
|
for (0..shape.len) |index| {
|
|
if (index != 0) try io.write_all(output, ", ")
|
|
element := ir.Value{}
|
|
if (shape.element == .array) {
|
|
element = ir.Value{ type = .array, array_type = shape.element_array, data = ir.ValueData{ elements = value.data.elements[index * width..(index + 1) * width] } }
|
|
} else element = value.data.elements[index]
|
|
try write_type(output, module, Type{ kind = element.type, shape = element.array_type })
|
|
try io.write_all(output, " ")
|
|
try write_constant(output, module, element)
|
|
}
|
|
try io.write_all(output, "]")
|
|
}
|
|
else: unreachable
|
|
}
|
|
}
|
|
|
|
@hide:file
|
|
emit_function proc(state @mut State, function @ir.Function, id usize) void ! io.WriteError {
|
|
output :: state.output
|
|
try io.write_all(output, "define internal ")
|
|
try write_type(output, state.module, Type{ kind = function.result, shape = function.result_array_type })
|
|
try io.print(" @f{}(", output, {id})
|
|
for (function.parameters.items) |_, index| {
|
|
if (index != 0) try io.write_all(output, ", ")
|
|
try write_type(output, state.module, local_type(function, index))
|
|
try io.print(" %p{}", output, {index})
|
|
}
|
|
try io.write_all(output, ") {\nentry:\n")
|
|
for (function.locals.items) |_, index| {
|
|
type :: local_type(function, index)
|
|
try io.print(" %l{} = alloca ", output, {index})
|
|
try write_type(output, state.module, type)
|
|
try io.print("\n %i{} = alloca i1\n store i1 {}, ptr %i{}\n", output, {index, index < function.parameters.items.len, index})
|
|
if (index < function.parameters.items.len) {
|
|
try io.write_all(output, " store ")
|
|
try write_type(output, state.module, type)
|
|
try io.print(" %p{}, ptr %l{}\n", output, {index, index})
|
|
}
|
|
}
|
|
for (state.values) |type, index| {
|
|
if (type.kind == .void) continue
|
|
try io.print(" %v{} = alloca ", output, {index})
|
|
try write_type(output, state.module, type)
|
|
try io.write_all(output, "\n")
|
|
}
|
|
try io.print(" br label %b{}\n", output, {u32(function.entry)})
|
|
for (function.blocks.items) |block, index| {
|
|
try io.print("b{}:\n", output, {index})
|
|
for (block.instructions.items) |instruction| try emit_instruction(state, &block, instruction)
|
|
terminator :: block.terminator
|
|
match terminator.kind {
|
|
.return_value: {
|
|
if (terminator.value == ir.no_value or state.values[usize(terminator.value)].kind == .void) try io.write_all(output, " ret void\n")
|
|
else {
|
|
result :: try load(state, terminator.value)
|
|
try io.write_all(output, " ret ")
|
|
try write_type(output, state.module, state.values[usize(terminator.value)])
|
|
try io.print(" %r{}\n", output, {result})
|
|
}
|
|
}
|
|
.trap: try io.print(" call void @trap(i64 {}, i64 0, i64 0, ptr null, i64 0)\n unreachable\n", output, {u32(terminator.diagnostic)})
|
|
.jump: try io.print(" br label %b{}\n", output, {u32(terminator.target)})
|
|
.branch: {
|
|
condition :: try load(state, terminator.value)
|
|
try io.print(" br i1 %r{}, label %b{}, label %b{}\n", output, {condition, u32(terminator.target), u32(terminator.alternative)})
|
|
}
|
|
}
|
|
}
|
|
try io.write_all(output, "}\n")
|
|
}
|