birth-software/nativity
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

bitcode split

Browse Source
This commit is contained in:
David Gonzalez Martin 2024-05-11 11:50:03 -06:00
parent 1f945a8877
commit aade460a50
3 changed files with 719 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

481
bootstrap/compiler.zig
View File

@ -49,8 +49,8 @@ fn is_decimal_digit(ch: u8) bool {
} }
fn is_alphabetic(ch: u8) bool { fn is_alphabetic(ch: u8) bool {
const lower = is_lower(ch); const lower = is_lower(ch);
const upper = is_upper(ch); const upper = is_upper(ch);
return lower or upper; return lower or upper;
} }
@ -66,14 +66,14 @@ fn is_identifier_char(ch: u8) bool {
return is_identifier_start_ch or is_digit; return is_identifier_start_ch or is_digit;
} }
const GlobalSymbol = struct{ const GlobalSymbol = struct {
attributes: Attributes = .{}, attributes: Attributes = .{},
name: u32, name: u32,
const Attributes = struct{ const Attributes = struct {
@"export": bool = false, @"export": bool = false,
@"extern": bool = false, @"extern": bool = false,
}; };
const Attribute = enum{ const Attribute = enum {
@"export", @"export",
@"extern", @"extern",
@ -81,7 +81,7 @@ const GlobalSymbol = struct{
}; };
}; };
const Parser = struct{ const Parser = struct {
i: u64 = 0, i: u64 = 0,
current_line: u32 = 0, current_line: u32 = 0,
line_offset: u32 = 0, line_offset: u32 = 0,
@ -172,7 +172,7 @@ const Parser = struct{
fn parse_non_escaped_string_literal_content(parser: *Parser, src: []const u8) []const u8 { fn parse_non_escaped_string_literal_content(parser: *Parser, src: []const u8) []const u8 {
const string_literal = parser.parse_non_escaped_string_literal(src); const string_literal = parser.parse_non_escaped_string_literal(src);
return string_literal[1..][0..string_literal.len - 2]; return string_literal[1..][0 .. string_literal.len - 2];
} }
fn expect_character(parser: *Parser, file: []const u8, expected: u8) void { fn expect_character(parser: *Parser, file: []const u8, expected: u8) void {
@ -263,7 +263,7 @@ const Parser = struct{
const follow_up_alpha = is_alphabetic(follow_up_character); const follow_up_alpha = is_alphabetic(follow_up_character);
const follow_up_digit = is_decimal_digit(follow_up_character); const follow_up_digit = is_decimal_digit(follow_up_character);
const is_valid_after_zero = is_space(follow_up_character) or (!follow_up_digit and !follow_up_alpha); const is_valid_after_zero = is_space(follow_up_character) or (!follow_up_digit and !follow_up_alpha);
// //
if (is_prefixed_start) { if (is_prefixed_start) {
exit(1); exit(1);
} else if (is_valid_after_zero) { } else if (is_valid_after_zero) {
@ -366,7 +366,7 @@ const Parser = struct{
}; };
const LazyExpression = union(enum) { const LazyExpression = union(enum) {
dynamic: struct{ dynamic: struct {
names: PinnedArray(u32) = .{}, names: PinnedArray(u32) = .{},
outsider: *GlobalSymbolReference, outsider: *GlobalSymbolReference,
}, },
@ -395,7 +395,7 @@ const LazyExpression = union(enum) {
fn names(lazy_expression: *LazyExpression) []const u32 { fn names(lazy_expression: *LazyExpression) []const u32 {
return switch (lazy_expression.*) { return switch (lazy_expression.*) {
.dynamic => |*d| d.names.slice(), .dynamic => |*d| d.names.slice(),
.static => |*s| s.names[0.. for (s.names, 0..) |n, i| { .static => |*s| s.names[0..for (s.names, 0..) |n, i| {
if (n == 0) break @intCast(i); if (n == 0) break @intCast(i);
} else s.names.len], } else s.names.len],
}; };
@ -425,7 +425,7 @@ fn Descriptor(comptime Id: type, comptime Integer: type) type {
}; };
} }
const Expression = struct{ const Expression = struct {
type: *Type, type: *Type,
value: *Value, value: *Value,
}; };
@ -439,7 +439,7 @@ const Value = struct {
reserved: u7 = 0, reserved: u7 = 0,
id: Id, id: Id,
}, },
const Id = enum(u8){ const Id = enum(u8) {
constant_int, constant_int,
lazy_expression, lazy_expression,
instruction, instruction,
@ -454,7 +454,7 @@ const Type = struct {
id: Id, id: Id,
}, },
const Id = enum(u8){ const Id = enum(u8) {
unresolved, unresolved,
void, void,
integer, integer,
@ -466,14 +466,13 @@ const Type = struct {
reserved: u7 = 0, reserved: u7 = 0,
id: Id = .integer, id: Id = .integer,
const Signedness = enum(u1){ const Signedness = enum(u1) {
unsigned, unsigned,
signed, signed,
}; };
}; };
}; };
fn integer_bit_count(t: *Type) u16 { fn integer_bit_count(t: *Type) u16 {
const integer: Type.Integer = @bitCast(t.sema); const integer: Type.Integer = @bitCast(t.sema);
return integer.bit_count; return integer.bit_count;
@ -484,10 +483,9 @@ fn integer_signedness(t: *Type) Type.Integer.Signedness {
return integer.signedness; return integer.signedness;
} }
const IntegerType = struct{ const IntegerType = struct {};
};
const Keyword = enum{ const Keyword = enum {
@"for", @"for",
}; };
@ -506,12 +504,12 @@ const Scope = Descriptor(enum(u3) {
function, function,
local, local,
}, u32); }, u32);
const Range = struct{ const Range = struct {
start: u32, start: u32,
end: u32, end: u32,
}; };
const FileScope = struct{ const FileScope = struct {
declarations: PinnedHashMap(u32, GlobalSymbolReference) = .{}, declarations: PinnedHashMap(u32, GlobalSymbolReference) = .{},
}; };
@ -522,7 +520,7 @@ const GlobalSymbolReference = Descriptor(enum(u3) {
unresolved_import, unresolved_import,
}, u32); }, u32);
const BasicBlock = struct{ const BasicBlock = struct {
instructions: PinnedArray(*Instruction) = .{}, instructions: PinnedArray(*Instruction) = .{},
predecessors: PinnedArray(u32) = .{}, predecessors: PinnedArray(u32) = .{},
is_terminated: bool = false, is_terminated: bool = false,
@ -530,15 +528,15 @@ const BasicBlock = struct{
const Index = PinnedArray(BasicBlock).Index; const Index = PinnedArray(BasicBlock).Index;
}; };
const Function = struct{ const Function = struct {
declaration: Function.Declaration, declaration: Function.Declaration,
entry_block: BasicBlock.Index, entry_block: BasicBlock.Index,
const Attributes = struct{ const Attributes = struct {
calling_convention: CallingConvention = .custom, calling_convention: CallingConvention = .custom,
}; };
const Attribute = enum{ const Attribute = enum {
cc, cc,
pub const Mask = std.EnumSet(Function.Attribute); pub const Mask = std.EnumSet(Function.Attribute);
@ -553,36 +551,34 @@ const Function = struct{
}; };
}; };
const Instruction = struct {
const Instruction = struct{
index: u24, index: u24,
id: Id, id: Id,
llvm: ?*LLVM.Value = null, llvm: ?*LLVM.Value = null,
const Id = enum{ const Id = enum {
call, call,
ret, ret,
ret_void, ret_void,
}; };
}; };
const ConstantInt = struct{ const ConstantInt = struct {
value: u64, value: u64,
type: *Type, type: *Type,
}; };
const Call = struct {
const Call = struct{
value: *Value, value: *Value,
const Index = PinnedArray(Call).Index; const Index = PinnedArray(Call).Index;
}; };
const Return = struct{ const Return = struct {
value: *Value, value: *Value,
const Index = PinnedArray(Call).Index; const Index = PinnedArray(Call).Index;
}; };
const Thread = struct{ const Thread = struct {
arena: *Arena = undefined, arena: *Arena = undefined,
functions: PinnedArray(Function) = .{}, functions: PinnedArray(Function) = .{},
external_functions: PinnedArray(Function.Declaration) = .{}, external_functions: PinnedArray(Function.Declaration) = .{},
@ -610,7 +606,6 @@ const Thread = struct{
attributes: LLVM.Attributes, attributes: LLVM.Attributes,
} = undefined, } = undefined,
fn add_thread_work(thread: *Thread, job: Job) void { fn add_thread_work(thread: *Thread, job: Job) void {
thread.task_system.job.queue_job(job); thread.task_system.job.queue_job(job);
} }
@ -638,7 +633,7 @@ const Job = packed struct(u64) {
count: u24 = 0, count: u24 = 0,
id: Id, id: Id,
const Id = enum(u8){ const Id = enum(u8) {
analyze_file, analyze_file,
llvm_setup, llvm_setup,
notify_file_resolved, notify_file_resolved,
@ -647,12 +642,12 @@ const Job = packed struct(u64) {
}; };
}; };
const TaskSystem = struct{ const TaskSystem = struct {
job: JobQueue = .{}, job: JobQueue = .{},
ask: JobQueue = .{}, ask: JobQueue = .{},
}; };
const JobQueue = struct{ const JobQueue = struct {
entries: [64]Job = [1]Job{@bitCast(@as(u64, 0))} ** 64, entries: [64]Job = [1]Job{@bitCast(@as(u64, 0))} ** 64,
to_do: u64 = 0, to_do: u64 = 0,
completed: u64 = 0, completed: u64 = 0,
@ -666,13 +661,13 @@ const JobQueue = struct{
var threads: []Thread = undefined; var threads: []Thread = undefined;
const Instance = struct{ const Instance = struct {
files: PinnedArray(File) = .{}, files: PinnedArray(File) = .{},
file_paths: PinnedArray(u32) = .{}, file_paths: PinnedArray(u32) = .{},
arena: *Arena = undefined, arena: *Arena = undefined,
}; };
const File = struct{ const File = struct {
scope: Scope, scope: Scope,
source_code: []const u8, source_code: []const u8,
path: []const u8, path: []const u8,
@ -688,7 +683,7 @@ const File = struct{
return std.fs.path.dirname(file.path) orelse unreachable; return std.fs.path.dirname(file.path) orelse unreachable;
} }
const State = enum{ const State = enum {
queued, queued,
analyzing, analyzing,
}; };
@ -700,7 +695,7 @@ var instance = Instance{};
const do_codegen = true; const do_codegen = true;
const codegen_backend = CodegenBackend.llvm; const codegen_backend = CodegenBackend.llvm;
const CodegenBackend = enum{ const CodegenBackend = enum {
llvm, llvm,
}; };
@ -830,7 +825,7 @@ pub fn make() void {
for (threads, 0..) |*thread, i| { for (threads, 0..) |*thread, i| {
const control_pending = thread.task_system.ask.to_do - thread.task_system.ask.completed; const control_pending = thread.task_system.ask.to_do - thread.task_system.ask.completed;
if (control_pending != 0) { if (control_pending != 0) {
const jobs_to_do = thread.task_system.ask.entries[thread.task_system.ask.completed .. thread.task_system.ask.to_do]; const jobs_to_do = thread.task_system.ask.entries[thread.task_system.ask.completed..thread.task_system.ask.to_do];
for (jobs_to_do) |job| { for (jobs_to_do) |job| {
switch (job.id) { switch (job.id) {
@ -1046,24 +1041,366 @@ fn resolve_value(thread: *Thread, file_index: u32, value: *Value) void {
// } // }
} }
const Bitcode = struct { const Bitcode = struct {};
};
fn write_bitcode() void { fn write_bitcode() void {
var buffer = PinnedArray(u8){}; var buffer = PinnedArray(u8){};
// Magic // Magic
buffer.append_slice(&.{0x42, 0x43, 0xc0, 0xde}); const magic = [_]u8{ 0x42, 0x43, 0xc0, 0xde };
buffer.append_slice(&.{0x35, 0x14, 0x00, 0x00}); buffer.append_slice(&magic);
buffer.append_slice(sample_bitcode[buffer.length..]); const identification_block = [_]u8{
0x35, 0x14, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00,
0x62, 0x0c, 0x30, 0x24,
0x4a, 0x59, 0xbe, 0x66,
0xbd, 0xfb, 0xb4, 0xaf,
0x0b, 0x51, 0x80, 0x4c,
0x01, 0x00, 0x00, 0x00,
};
buffer.append_slice(&identification_block);
// ==================
// MODULE BLOCK START
// ==================
const module_block_start = [_]u8{
0x21, 0x0c, 0x00, 0x00,
0x1f, 0x01, 0x00, 0x00,
0x0b, 0x02, 0x21, 0x00,
};
buffer.append_slice(&module_block_start);
const blockinfo_block = [_]u8{
0x02, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00,
0x07, 0x81, 0x23, 0x91,
0x41, 0xc8, 0x04, 0x49,
0x06, 0x10, 0x32, 0x39,
0x92, 0x01, 0x84, 0x0c,
0x25, 0x05, 0x08, 0x19,
0x1e, 0x04, 0x8b, 0x62,
0x80, 0x04, 0x45, 0x02,
0x42, 0x92, 0x0b, 0x42,
0x24, 0x10, 0x32, 0x14,
0x38, 0x08, 0x18, 0x4b,
0x0a, 0x32, 0x12, 0x88,
0x48, 0x70, 0xc4, 0x21,
0x23, 0x44, 0x12, 0x87,
0x8c, 0x10, 0x41, 0x92,
0x02, 0x64, 0xc8, 0x08,
0xb1, 0x14, 0x20, 0x43,
0x46, 0x88, 0x20, 0xc9,
0x01, 0x32, 0x12, 0x84,
0x18, 0x2a, 0x28, 0x2a,
0x90, 0x31, 0x7c, 0xb0,
0x5c, 0x91, 0x20, 0xc1,
0xc8, 0x00, 0x00, 0x00,
};
buffer.append_slice(&blockinfo_block);
const typeinfo_block = [_]u8{
0x89, 0x20, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00,
0x22, 0x66, 0x04, 0x10,
0xb2, 0x42, 0x82, 0x49,
0x10, 0x52, 0x42, 0x82,
0x49, 0x90, 0x71, 0xc2,
0x50, 0x48, 0x0a, 0x09,
0x26, 0x41, 0xc6, 0x05,
0x42, 0x12, 0x26, 0x08,
0x82, 0x81, 0x00, 0x00,
0x1a, 0x21, 0x4c, 0x0e,
0x13, 0x36, 0xdb, 0xde,
0x6e, 0xb1, 0xd3, 0xee,
0xb5, 0xc4, 0x06, 0x81,
0xa2, 0x24, 0x01, 0x00,
};
buffer.append_slice(&typeinfo_block);
const metadata_kind_block = [_]u8{
0x00, 0xb1, 0x18, 0x00,
0xb9, 0x00, 0x00, 0x00,
0x33, 0x08, 0x80, 0x1c,
0xc4, 0xe1, 0x1c, 0x66,
0x14, 0x01, 0x3d, 0x88,
0x43, 0x38, 0x84, 0xc3,
0x8c, 0x42, 0x80, 0x07,
0x79, 0x78, 0x07, 0x73,
0x98, 0x71, 0x0c, 0xe6,
0x00, 0x0f, 0xed, 0x10,
0x0e, 0xf4, 0x80, 0x0e,
0x33, 0x0c, 0x42, 0x1e,
0xc2, 0xc1, 0x1d, 0xce,
0xa1, 0x1c, 0x66, 0x30,
0x05, 0x3d, 0x88, 0x43,
0x38, 0x84, 0x83, 0x1b,
0xcc, 0x03, 0x3d, 0xc8,
0x43, 0x3d, 0x8c, 0x03,
0x3d, 0xcc, 0x78, 0x8c,
0x74, 0x70, 0x07, 0x7b,
0x08, 0x07, 0x79, 0x48,
0x87, 0x70, 0x70, 0x07,
0x7a, 0x70, 0x03, 0x76,
0x78, 0x87, 0x70, 0x20,
0x87, 0x19, 0xcc, 0x11,
0x0e, 0xec, 0x90, 0x0e,
0xe1, 0x30, 0x0f, 0x6e,
0x30, 0x0f, 0xe3, 0xf0,
0x0e, 0xf0, 0x50, 0x0e,
0x33, 0x10, 0xc4, 0x1d,
0xde, 0x21, 0x1c, 0xd8,
0x21, 0x1d, 0xc2, 0x61,
0x1e, 0x66, 0x30, 0x89,
0x3b, 0xbc, 0x83, 0x3b,
0xd0, 0x43, 0x39, 0xb4,
0x03, 0x3c, 0xbc, 0x83,
0x3c, 0x84, 0x03, 0x3b,
0xcc, 0xf0, 0x14, 0x76,
0x60, 0x07, 0x7b, 0x68,
0x07, 0x37, 0x68, 0x87,
0x72, 0x68, 0x07, 0x37,
0x80, 0x87, 0x70, 0x90,
0x87, 0x70, 0x60, 0x07,
0x76, 0x28, 0x07, 0x76,
0xf8, 0x05, 0x76, 0x78,
0x87, 0x77, 0x80, 0x87,
0x5f, 0x08, 0x87, 0x71,
0x18, 0x87, 0x72, 0x98,
0x87, 0x79, 0x98, 0x81,
0x2c, 0xee, 0xf0, 0x0e,
0xee, 0xe0, 0x0e, 0xf5,
0xc0, 0x0e, 0xec, 0x30,
0x03, 0x62, 0xc8, 0xa1,
0x1c, 0xe4, 0xa1, 0x1c,
0xcc, 0xa1, 0x1c, 0xe4,
0xa1, 0x1c, 0xdc, 0x61,
0x1c, 0xca, 0x21, 0x1c,
0xc4, 0x81, 0x1d, 0xca,
0x61, 0x06, 0xd6, 0x90,
0x43, 0x39, 0xc8, 0x43,
0x39, 0x98, 0x43, 0x39,
0xc8, 0x43, 0x39, 0xb8,
0xc3, 0x38, 0x94, 0x43,
0x38, 0x88, 0x03, 0x3b,
0x94, 0xc3, 0x2f, 0xbc,
0x83, 0x3c, 0xfc, 0x82,
0x3b, 0xd4, 0x03, 0x3b,
0xb0, 0xc3, 0x0c, 0xc7,
0x69, 0x87, 0x70, 0x58,
0x87, 0x72, 0x70, 0x83,
0x74, 0x68, 0x07, 0x78,
0x60, 0x87, 0x74, 0x18,
0x87, 0x74, 0xa0, 0x87,
0x19, 0xce, 0x53, 0x0f,
0xee, 0x00, 0x0f, 0xf2,
0x50, 0x0e, 0xe4, 0x90,
0x0e, 0xe3, 0x40, 0x0f,
0xe1, 0x20, 0x0e, 0xec,
0x50, 0x0e, 0x33, 0x20,
0x28, 0x1d, 0xdc, 0xc1,
0x1e, 0xc2, 0x41, 0x1e,
0xd2, 0x21, 0x1c, 0xdc,
0x81, 0x1e, 0xdc, 0xe0,
0x1c, 0xe4, 0xe1, 0x1d,
0xea, 0x01, 0x1e, 0x66,
0x18, 0x51, 0x38, 0xb0,
0x43, 0x3a, 0x9c, 0x83,
0x3b, 0xcc, 0x50, 0x24,
0x76, 0x60, 0x07, 0x7b,
0x68, 0x07, 0x37, 0x60,
0x87, 0x77, 0x78, 0x07,
0x78, 0x98, 0x51, 0x4c,
0xf4, 0x90, 0x0f, 0xf0,
0x50, 0x0e, 0x33, 0x1e,
0x6a, 0x1e, 0xca, 0x61,
0x1c, 0xe8, 0x21, 0x1d,
0xde, 0xc1, 0x1d, 0x7e,
0x01, 0x1e, 0xe4, 0xa1,
0x1c, 0xcc, 0x21, 0x1d,
0xf0, 0x61, 0x06, 0x54,
0x85, 0x83, 0x38, 0xcc,
0xc3, 0x3b, 0xb0, 0x43,
0x3d, 0xd0, 0x43, 0x39,
0xfc, 0xc2, 0x3c, 0xe4,
0x43, 0x3b, 0x88, 0xc3,
0x3b, 0xb0, 0xc3, 0x8c,
0xc5, 0x0a, 0x87, 0x79,
0x98, 0x87, 0x77, 0x18,
0x87, 0x74, 0x08, 0x07,
0x7a, 0x28, 0x07, 0x72,
0x98, 0x81, 0x5c, 0xe3,
0x10, 0x0e, 0xec, 0xc0,
0x0e, 0xe5, 0x50, 0x0e,
0xf3, 0x30, 0x23, 0xc1,
0xd2, 0x41, 0x1e, 0xe4,
0xe1, 0x17, 0xd8, 0xe1,
0x1d, 0xde, 0x01, 0x1e,
0x66, 0x48, 0x19, 0x3b,
0xb0, 0x83, 0x3d, 0xb4,
0x83, 0x1b, 0x84, 0xc3,
0x38, 0x8c, 0x43, 0x39,
0xcc, 0xc3, 0x3c, 0xb8,
0xc1, 0x39, 0xc8, 0xc3,
0x3b, 0xd4, 0x03, 0x3c,
0xcc, 0x48, 0xb4, 0x71,
0x08, 0x07, 0x76, 0x60,
0x07, 0x71, 0x08, 0x87,
0x71, 0x58, 0x87, 0x19,
0xdb, 0xc6, 0x0e, 0xec,
0x60, 0x0f, 0xed, 0xe0,
0x06, 0xf0, 0x20, 0x0f,
0xe5, 0x30, 0x0f, 0xe5,
0x20, 0x0f, 0xf6, 0x50,
0x0e, 0x6e, 0x10, 0x0e,
0xe3, 0x30, 0x0e, 0xe5,
0x30, 0x0f, 0xf3, 0xe0,
0x06, 0xe9, 0xe0, 0x0e,
0xe4, 0x50, 0x0e, 0xf8,
0x30, 0x23, 0xe2, 0xec,
0x61, 0x1c, 0xc2, 0x81,
0x1d, 0xd8, 0xe1, 0x17,
0xec, 0x21, 0x1d, 0xe6,
0x21, 0x1d, 0xc4, 0x21,
0x1d, 0xd8, 0x21, 0x1d,
0xe8, 0x21, 0x1f, 0x66,
0x20, 0x9d, 0x3b, 0xbc,
0x43, 0x3d, 0xb8, 0x03,
0x39, 0x94, 0x83, 0x39,
0xcc, 0x58, 0xbc, 0x70,
0x70, 0x07, 0x77, 0x78,
0x07, 0x7a, 0x08, 0x07,
0x7a, 0x48, 0x87, 0x77,
0x70, 0x87, 0x19, 0xcb,
0xe7, 0x0e, 0xef, 0x30,
0x0f, 0xe1, 0xe0, 0x0e,
0xe9, 0x40, 0x0f, 0xe9,
0xa0, 0x0f, 0xe5, 0x30,
0xc3, 0x01, 0x03, 0x73,
0xa8, 0x07, 0x77, 0x18,
0x87, 0x5f, 0x98, 0x87,
0x70, 0x70, 0x87, 0x74,
0xa0, 0x87, 0x74, 0xd0,
0x87, 0x72, 0x98, 0x81,
0x84, 0x41, 0x39, 0xe0,
0xc3, 0x38, 0xb0, 0x43,
0x3d, 0x90, 0x43, 0x39,
0xcc, 0x40, 0xc4, 0xa0,
0x1d, 0xca, 0xa1, 0x1d,
0xe0, 0x41, 0x1e, 0xde,
0xc1, 0x1c, 0x66, 0x24,
0x63, 0x30, 0x0e, 0xe1,
0xc0, 0x0e, 0xec, 0x30,
0x0f, 0xe9, 0x40, 0x0f,
0xe5, 0x30, 0x43, 0x21,
0x83, 0x75, 0x18, 0x07,
0x73, 0x48, 0x87, 0x5f,
0xa0, 0x87, 0x7c, 0x80,
0x87, 0x72, 0x98, 0xb1,
0x94, 0x01, 0x3c, 0x8c,
0xc3, 0x3c, 0x94, 0xc3,
0x38, 0xd0, 0x43, 0x3a,
0xbc, 0x83, 0x3b, 0xcc,
0xc3, 0x8c, 0xc5, 0x0c,
0x48, 0x21, 0x15, 0x42,
0x61, 0x1e, 0xe6, 0x21,
0x1d, 0xce, 0xc1, 0x1d,
0x52, 0x81, 0x14, 0x00,
};
buffer.append_slice(&metadata_kind_block);
const operand_bundle_tag = [_]u8{
0xa9, 0x18, 0x00, 0x00,
0x2d, 0x00, 0x00, 0x00,
0x0b, 0x0a, 0x72, 0x28,
0x87, 0x77, 0x80, 0x07,
0x7a, 0x58, 0x70, 0x98,
0x43, 0x3d, 0xb8, 0xc3,
0x38, 0xb0, 0x43, 0x39,
0xd0, 0xc3, 0x82, 0xe6,
0x1c, 0xc6, 0xa1, 0x0d,
0xe8, 0x41, 0x1e, 0xc2,
0xc1, 0x1d, 0xe6, 0x21,
0x1d, 0xe8, 0x21, 0x1d,
0xde, 0xc1, 0x1d, 0x16,
0x34, 0xe3, 0x60, 0x0e,
0xe7, 0x50, 0x0f, 0xe1,
0x20, 0x0f, 0xe4, 0x40,
0x0f, 0xe1, 0x20, 0x0f,
0xe7, 0x50, 0x0e, 0xf4,
0xb0, 0x80, 0x81, 0x07,
0x79, 0x28, 0x87, 0x70,
0x60, 0x07, 0x76, 0x78,
0x87, 0x71, 0x08, 0x07,
0x7a, 0x28, 0x07, 0x72,
0x58, 0x70, 0x9c, 0xc3,
0x38, 0xb4, 0x01, 0x3b,
0xa4, 0x83, 0x3d, 0x94,
0xc3, 0x02, 0x6b, 0x1c,
0xd8, 0x21, 0x1c, 0xdc,
0xe1, 0x1c, 0xdc, 0x20,
0x1c, 0xe4, 0x61, 0x1c,
0xdc, 0x20, 0x1c, 0xe8,
0x81, 0x1e, 0xc2, 0x61,
0x1c, 0xd0, 0xa1, 0x1c,
0xc8, 0x61, 0x1c, 0xc2,
0x81, 0x1d, 0xd8, 0x61,
0xc1, 0x01, 0x0f, 0xf4,
0x20, 0x0f, 0xe1, 0x50,
0x0f, 0xf4, 0x80, 0x0e,
0x0b, 0x88, 0x75, 0x18,
0x07, 0x73, 0x48, 0x87,
0x05, 0xcf, 0x38, 0xbc,
0x83, 0x3b, 0xd8, 0x43,
0x39, 0xc8, 0xc3, 0x39,
0x94, 0x83, 0x3b, 0x8c,
0x43, 0x39, 0x8c, 0x03,
0x3d, 0xc8, 0x03, 0x3b,
0x00, 0x00, 0x00, 0x00,
};
buffer.append_slice(&operand_bundle_tag);
const value26 = [_]u8{
0xd1, 0x10, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00,
0x07, 0xcc, 0x3c, 0xa4,
0x83, 0x3b, 0x9c, 0x03,
0x3b, 0x94, 0x03, 0x3d,
0xa0, 0x83, 0x3c, 0x94,
0x43, 0x38, 0x90, 0xc3,
0x01, 0x00, 0x00, 0x00,
};
buffer.append_slice(&value26);
const value_symtab = [_]u8{
0x71, 0x20, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00,
0x32, 0x0e, 0x10, 0x22,
0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
buffer.append_slice(&value_symtab);
const strtab = [_]u8{
0x5d, 0x0c, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00,
0x12, 0x03, 0x94, 0x0f,
0x31, 0x37, 0x2e, 0x30,
0x2e, 0x36, 0x6c, 0x6c,
0x76, 0x6d, 0x2d, 0x6c,
0x69, 0x6e, 0x6b, 0x00,
0x00, 0x00, 0x00, 0x00,
};
buffer.append_slice(&strtab);
assert(buffer.length == sample_bitcode.len);
const context = LLVM.Context.create(); const context = LLVM.Context.create();
const module = context.parse_bitcode(buffer.slice()) orelse exit(1); const module = context.parse_bitcode(buffer.slice()) orelse exit(1);
_ = module; // autofix _ = module; // autofix
// //
exit(0); exit(0);
} }
const sample_bitcode = [_]u8{ const sample_bitcode = [_]u8{
// Magic
0x42, 0x43, 0xc0, 0xde, 0x42, 0x43, 0xc0, 0xde,
// Start of the identification block
0x35, 0x14, 0x00, 0x00, 0x35, 0x14, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x62, 0x0c, 0x30, 0x24, 0x62, 0x0c, 0x30, 0x24,
@ -1071,9 +1408,11 @@ const sample_bitcode = [_]u8{
0xbd, 0xfb, 0xb4, 0xaf, 0xbd, 0xfb, 0xb4, 0xaf,
0x0b, 0x51, 0x80, 0x4c, 0x0b, 0x51, 0x80, 0x4c,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
// It looks like this is the start of the module block
0x21, 0x0c, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00,
0x1f, 0x01, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00,
0x0b, 0x02, 0x21, 0x00, 0x0b, 0x02, 0x21, 0x00,
// start of the blockinfo block?
0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
0x07, 0x81, 0x23, 0x91, 0x07, 0x81, 0x23, 0x91,
@ -1098,6 +1437,7 @@ const sample_bitcode = [_]u8{
0x90, 0x31, 0x7c, 0xb0, 0x90, 0x31, 0x7c, 0xb0,
0x5c, 0x91, 0x20, 0xc1, 0x5c, 0x91, 0x20, 0xc1,
0xc8, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00,
// type block?
0x89, 0x20, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x22, 0x66, 0x04, 0x10, 0x22, 0x66, 0x04, 0x10,
@ -1113,6 +1453,7 @@ const sample_bitcode = [_]u8{
0x6e, 0xb1, 0xd3, 0xee, 0x6e, 0xb1, 0xd3, 0xee,
0xb5, 0xc4, 0x06, 0x81, 0xb5, 0xc4, 0x06, 0x81,
0xa2, 0x24, 0x01, 0x00, 0xa2, 0x24, 0x01, 0x00,
// metadata kind block?
0x00, 0xb1, 0x18, 0x00, 0x00, 0xb1, 0x18, 0x00,
0xb9, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00,
0x33, 0x08, 0x80, 0x1c, 0x33, 0x08, 0x80, 0x1c,
@ -1300,6 +1641,7 @@ const sample_bitcode = [_]u8{
0x61, 0x1e, 0xe6, 0x21, 0x61, 0x1e, 0xe6, 0x21,
0x1d, 0xce, 0xc1, 0x1d, 0x1d, 0xce, 0xc1, 0x1d,
0x52, 0x81, 0x14, 0x00, 0x52, 0x81, 0x14, 0x00,
// operand bundle tags block?
0xa9, 0x18, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00,
0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00,
0x0b, 0x0a, 0x72, 0x28, 0x0b, 0x0a, 0x72, 0x28,
@ -1347,6 +1689,7 @@ const sample_bitcode = [_]u8{
0x43, 0x39, 0x8c, 0x03, 0x43, 0x39, 0x8c, 0x03,
0x3d, 0xc8, 0x03, 0x3b, 0x3d, 0xc8, 0x03, 0x3b,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Unknown block 26?
0xd1, 0x10, 0x00, 0x00, 0xd1, 0x10, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
0x07, 0xcc, 0x3c, 0xa4, 0x07, 0xcc, 0x3c, 0xa4,
@ -1355,11 +1698,13 @@ const sample_bitcode = [_]u8{
0xa0, 0x83, 0x3c, 0x94, 0xa0, 0x83, 0x3c, 0x94,
0x43, 0x38, 0x90, 0xc3, 0x43, 0x38, 0x90, 0xc3,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
// Value symtab block?
0x71, 0x20, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x32, 0x0e, 0x10, 0x22, 0x32, 0x0e, 0x10, 0x22,
0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Start of the strtab block
0x5d, 0x0c, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
0x12, 0x03, 0x94, 0x0f, 0x12, 0x03, 0x94, 0x0f,
@ -1370,16 +1715,12 @@ const sample_bitcode = [_]u8{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };
fn get_integer_type(thread: *Thread) void { const CallingConvention = enum {
_ = thread; // autofix
}
const CallingConvention = enum{
c, c,
custom, custom,
}; };
const Analyzer = struct{ const Analyzer = struct {
current_basic_block: *BasicBlock = undefined, current_basic_block: *BasicBlock = undefined,
current_function: *Function = undefined, current_function: *Function = undefined,
}; };
@ -1419,8 +1760,8 @@ fn thread_callback(thread_index: u32) void {
for (jobs) |job| { for (jobs) |job| {
switch (job.id) { switch (job.id) {
.llvm_setup => { .llvm_setup => {
for ([_]Type.Integer.Signedness{.unsigned, .signed}) |signedness| { for ([_]Type.Integer.Signedness{ .unsigned, .signed }) |signedness| {
for (0..64+1) |bit_count| { for (0..64 + 1) |bit_count| {
const integer_type = Type.Integer{ const integer_type = Type.Integer{
.bit_count = @intCast(bit_count), .bit_count = @intCast(bit_count),
.signedness = signedness, .signedness = signedness,
@ -1551,7 +1892,7 @@ fn thread_callback(thread_index: u32) void {
.lazy_expression => { .lazy_expression => {
const lazy_expression = thread.lazy_expressions.get(@enumFromInt(value.sema.index)); const lazy_expression = thread.lazy_expressions.get(@enumFromInt(value.sema.index));
assert(lazy_expression.* == .static); assert(lazy_expression.* == .static);
for ( lazy_expression.static.names) |n| { for (lazy_expression.static.names) |n| {
assert(n == 0); assert(n == 0);
} }
const declaration = lazy_expression.static.outsider; const declaration = lazy_expression.static.outsider;
@ -1777,7 +2118,7 @@ fn llvm_get_file(thread: *Thread, file_index: u32) *LLVMFile {
const builder = thread.llvm.module.createDebugInfoBuilder(); const builder = thread.llvm.module.createDebugInfoBuilder();
const file = &instance.files.slice()[file_index]; const file = &instance.files.slice()[file_index];
const filename = std.fs.path.basename(file.path); const filename = std.fs.path.basename(file.path);
const directory = file.path[0..file.path.len - filename.len]; const directory = file.path[0 .. file.path.len - filename.len];
const llvm_file = builder.createFile(filename.ptr, filename.len, directory.ptr, directory.len); const llvm_file = builder.createFile(filename.ptr, filename.len, directory.ptr, directory.len);
const producer = "nativity"; const producer = "nativity";
const is_optimized = false; const is_optimized = false;
@ -1923,7 +2264,6 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
const identifier = parser.parse_identifier(thread, src); const identifier = parser.parse_identifier(thread, src);
_ = identifier; // autofix _ = identifier; // autofix
exit(1); exit(1);
}, },
'f' => { 'f' => {
@ -1941,12 +2281,12 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
function.* = .{ function.* = .{
.declaration = .{ .declaration = .{
.return_type = undefined, .return_type = undefined,
.global = .{ .global = .{
.name = undefined, .name = undefined,
},
.file = file_index,
}, },
.file = file_index,
},
.entry_block = entry_block_index, .entry_block = entry_block_index,
}; };
@ -2047,7 +2387,7 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
.@"extern" => {}, .@"extern" => {},
} }
const after_ch =src[parser.i]; const after_ch = src[parser.i];
switch (after_ch) { switch (after_ch) {
']' => {}, ']' => {},
else => unreachable, else => unreachable,
@ -2101,7 +2441,7 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
_ = block_line; // autofix _ = block_line; // autofix
const block_column = block_start - parser.line_offset + 1; const block_column = block_start - parser.line_offset + 1;
_ = block_column; // autofix _ = block_column; // autofix
// //
parser.expect_character(src, bracket_open); parser.expect_character(src, bracket_open);
const file_scope = thread.file_scopes.get(@enumFromInt(file.scope.index)); const file_scope = thread.file_scopes.get(@enumFromInt(file.scope.index));
file_scope.declarations.put_no_clobber(function.declaration.global.name, .{ file_scope.declarations.put_no_clobber(function.declaration.global.name, .{
@ -2126,7 +2466,6 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
const return_value = parser.parse_typed_expression(&analyzer, thread, file, function.declaration.return_type); const return_value = parser.parse_typed_expression(&analyzer, thread, file, function.declaration.return_type);
parser.expect_character(src, ';'); parser.expect_character(src, ';');
const return_expression = thread.returns.append_index(.{ const return_expression = thread.returns.append_index(.{
.value = return_value, .value = return_value,
}); });
@ -2138,7 +2477,7 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
_ = analyzer.current_basic_block.instructions.append(return_instruction); _ = analyzer.current_basic_block.instructions.append(return_instruction);
analyzer.current_basic_block.is_terminated = true; analyzer.current_basic_block.is_terminated = true;
} else { } else {
exit(1); exit(1);
} }
} else { } else {
@ -2167,11 +2506,11 @@ pub fn analyze_file(thread: *Thread, file_index: u32) void {
parser.expect_character(src, ';'); parser.expect_character(src, ';');
const filename = std.fs.path.basename(string_literal); const filename = std.fs.path.basename(string_literal);
const has_right_extension = filename.len > ".nat".len and byte_equal(filename[filename.len - ".nat".len..], ".nat"); const has_right_extension = filename.len > ".nat".len and byte_equal(filename[filename.len - ".nat".len ..], ".nat");
if (!has_right_extension) { if (!has_right_extension) {
exit(1); exit(1);
} }
const filename_without_extension = filename[0..filename.len - ".nat".len]; const filename_without_extension = filename[0 .. filename.len - ".nat".len];
const filename_without_extension_hash = hash_bytes(filename_without_extension); const filename_without_extension_hash = hash_bytes(filename_without_extension);
const directory_path = file.get_directory_path(); const directory_path = file.get_directory_path();
@ -2282,7 +2621,6 @@ pub const LLVM = struct {
const getAttributeFromType = bindings.NativityLLVMContextGetAttributeFromType; const getAttributeFromType = bindings.NativityLLVMContextGetAttributeFromType;
const getAttributeSet = bindings.NativityLLVMContextGetAttributeSet; const getAttributeSet = bindings.NativityLLVMContextGetAttributeSet;
pub fn parse_bitcode(context: *LLVM.Context, bytes: []const u8) ?*LLVM.Module { pub fn parse_bitcode(context: *LLVM.Context, bytes: []const u8) ?*LLVM.Module {
const memory_buffer = bindings.LLVMCreateMemoryBufferWithMemoryRange(bytes.ptr, bytes.len, null, 0); const memory_buffer = bindings.LLVMCreateMemoryBufferWithMemoryRange(bytes.ptr, bytes.len, null, 0);
var out_module: *LLVM.Module = undefined; var out_module: *LLVM.Module = undefined;
@ -2930,10 +3268,9 @@ pub const LLVM = struct {
intrinsic, intrinsic,
array, array,
}; };
}; };
pub const MemoryBuffer = opaque{}; pub const MemoryBuffer = opaque {};
pub const Value = opaque { pub const Value = opaque {
const setName = bindings.NativityLLVMValueSetName; const setName = bindings.NativityLLVMValueSetName;

3
bootstrap/library.zig
View File

@ -253,7 +253,7 @@ pub fn PinnedArrayAdvanced(comptime T: type, comptime MaybeIndex: ?type, comptim
return ptr; return ptr;
} }
pub fn add_one(array: *Array) *T{ pub fn add_one(array: *Array) *T {
array.ensure_capacity(1); array.ensure_capacity(1);
return array.add_one_with_capacity(); return array.add_one_with_capacity();
} }
@ -784,7 +784,6 @@ pub fn read_file(arena: *Arena, directory: std.fs.Dir, file_relative_path: []con
return file_buffer[0..read_byte_count]; return file_buffer[0..read_byte_count];
} }
pub fn self_exe_path(arena: *Arena) ![]const u8 { pub fn self_exe_path(arena: *Arena) ![]const u8 {
var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined; var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
return try arena.duplicate_bytes(try std.fs.selfExePath(&buffer)); return try arena.duplicate_bytes(try std.fs.selfExePath(&buffer));

2
bootstrap/main.zig
View File

@ -76,5 +76,3 @@ pub fn main() !void {
pub const std_options = std.Options{ pub const std_options = std.Options{
.enable_segfault_handler = false, .enable_segfault_handler = false,
}; };