birth-software/nativity
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity
nativity/bootstrap/compiler.zig
David Gonzalez Martin 5c6b050a94 C ABI implementation
2024-06-15 21:01:54 -05:00

10676 lines
456 KiB
Zig
Raw Blame History

const compiler = @This();
const configuration = @import("configuration");
const std = @import("std");
const builtin = @import("builtin");
const library = @import("library.zig");
const assert = library.assert;
const Arena = library.Arena;
const PinnedArray = library.PinnedArray;
const PinnedHashMap = library.PinnedHashMap;
const byte_equal = library.byte_equal;
const first_byte = library.first_byte;
const hash_bytes = library.my_hash;
const last_byte = library.last_byte;
const starts_with_slice = library.starts_with_slice;
const Atomic = std.atomic.Value;
const weak_memory_model = switch (builtin.cpu.arch) {
.aarch64 => true,
.x86_64 => false,
else => @compileError("Error: unknown arch"),
};
fn fail() noreturn {
@setCold(true);
@breakpoint();
std.posix.exit(1);
}
fn fail_term(message: []const u8, term: []const u8) noreturn {
@setCold(true);
write(message);
write(": '");
write(term);
write("'\n");
fail();
}
fn is_space(ch: u8, next_ch: u8) bool {
const is_comment = ch == '/' and next_ch == '/';
const is_whitespace = ch == ' ';
const is_vertical_tab = ch == 0x0b;
const is_horizontal_tab = ch == '\t';
const is_line_feed = ch == '\n';
const is_carry_return = ch == '\r';
const result = ((is_vertical_tab or is_horizontal_tab) or (is_line_feed or is_carry_return)) or (is_comment or is_whitespace);
return result;
}
pub fn write(string: []const u8) void {
std.io.getStdOut().writeAll(string) catch unreachable;
}
fn fail_message(string: []const u8) noreturn {
@setCold(true);
write("error: ");
write(string);
write("\n");
fail();
}
fn is_lower(ch: u8) bool {
return ch >= 'a' and ch <= 'z';
}
fn is_upper(ch: u8) bool {
return ch >= 'A' and ch <= 'Z';
}
fn is_decimal_digit(ch: u8) bool {
return ch >= '0' and ch <= '9';
}
fn is_hex_digit(ch: u8) bool {
return (is_decimal_digit(ch) or ((ch == 'a' or ch == 'A') or (ch == 'b' or ch == 'B'))) or (((ch == 'c' or ch == 'C') or (ch == 'd' or ch == 'D')) or ((ch == 'e' or ch == 'E') or (ch == 'f' or ch == 'F')));
}
fn is_alphabetic(ch: u8) bool {
const lower = is_lower(ch);
const upper = is_upper(ch);
return lower or upper;
}
fn is_identifier_char_start(ch: u8) bool {
const is_alpha = is_alphabetic(ch);
const is_underscore = ch == '_';
return is_alpha or is_underscore;
}
fn is_identifier_char(ch: u8) bool {
const is_identifier_start_ch = is_identifier_char_start(ch);
const is_digit = is_decimal_digit(ch);
return is_identifier_start_ch or is_digit;
}
const Side = enum {
left,
right,
};
const GlobalSymbol = struct{
attributes: Attributes = .{},
global_declaration: GlobalDeclaration,
type: *Type,
pointer_type: *Type,
alignment: u32,
value: Value,
id: GlobalSymbol.Id,
const Id = enum{
function_declaration,
function_definition,
global_variable,
};
const Attributes = struct{
@"export": bool = false,
@"extern": bool = false,
mutability: Mutability = .@"var",
};
const Attribute = enum{
@"export",
@"extern",
const Mask = std.EnumSet(Attribute);
};
const id_to_global_symbol_map = std.EnumArray(Id, type).init(.{
.function_declaration = Function.Declaration,
.function_definition = Function,
.global_variable = GlobalVariable,
});
fn get_payload(global_symbol: *GlobalSymbol, comptime id: Id) *id_to_global_symbol_map.get(id) {
if (id == .function_definition) {
const function_declaration: *Function.Declaration = @alignCast(@fieldParentPtr("global_symbol", global_symbol));
const function_definition: *Function = @alignCast(@fieldParentPtr("declaration", function_declaration));
return function_definition;
}
return @fieldParentPtr("global_symbol", global_symbol);
}
};
const GlobalVariable = struct {
global_symbol: GlobalSymbol,
initial_value: *Value,
};
const Mutability = enum(u1){
@"const" = 0,
@"var" = 1,
};
const ArgumentSymbol = struct {
attributes: Attributes = .{},
argument_declaration: ArgumentDeclaration,
type: *Type,
pointer_type: *Type,
instruction: Instruction,
alignment: u32,
index: u32,
const Attributes = struct{
};
const Attribute = enum{
const Mask = std.EnumSet(Attribute);
};
};
const LocalSymbol = struct {
attributes: Attributes = .{},
local_declaration: LocalDeclaration,
type: *Type,
pointer_type: *Type,
instruction: Instruction,
alignment: u32,
const Attributes = struct{
mutability: Mutability = .@"const",
};
const Attribute = enum{
const Mask = std.EnumSet(Attribute);
};
};
const Parser = struct{
i: u64 = 0,
line: u32 = 0,
column: u32 = 0,
fn get_debug_line(parser: *const Parser) u32 {
return parser.line + 1;
}
fn get_debug_column(parser: *const Parser) u32 {
return @intCast(parser.i - parser.column + 1);
}
fn safe_flag(value: anytype, boolean: bool) @TypeOf(value) {
const result = value & (@as(@TypeOf(value), 0) -% @intFromBool(boolean));
return result;
}
fn get_next_ch_safe(file: []const u8, index: u64) u8 {
const next_index = index + 1;
const is_in_range = next_index < file.len;
const safe_index = safe_flag(next_index, is_in_range);
const unsafe_result = file[safe_index];
const safe_result = safe_flag(unsafe_result, is_in_range);
return safe_result;
}
fn skip_space(parser: *Parser, file: []const u8) void {
const original_i = parser.i;
if (original_i == file.len or !is_space(file[original_i], get_next_ch_safe(file, original_i))) return;
while (parser.i < file.len) : (parser.i += 1) {
const ch = file[parser.i];
const new_line = ch == '\n';
parser.line += @intFromBool(new_line);
if (new_line) {
parser.column = @intCast(parser.i + 1);
}
if (!is_space(ch, get_next_ch_safe(file, parser.i))) {
return;
}
if (file[parser.i] == '/') {
parser.i += 2;
while (parser.i < file.len) : (parser.i += 1) {
const is_line_feed = file[parser.i] == '\n';
if (is_line_feed) {
parser.line += 1;
break;
}
}
if (parser.i == file.len) break;
}
}
}
const ParseFieldData = struct{
type: *Type,
name: u32,
line: u32,
column: u32,
};
fn parse_field(parser: *Parser, thread: *Thread, file: *File) ?ParseFieldData{
const src = file.source_code;
parser.skip_space(src);
if (src[parser.i] == brace_close) {
return null;
}
const field_line = parser.get_debug_line();
const field_column = parser.get_debug_column();
const field_name = parser.parse_identifier(thread, src);
parser.skip_space(src);
parser.expect_character(src, ':');
parser.skip_space(src);
const field_type = parser.parse_type_expression(thread, file, &file.scope.scope);
parser.skip_space(src);
switch (src[parser.i]) {
',' => parser.i += 1,
'=' => {
fail_message("TODO: field default value");
},
else => fail(),
}
return ParseFieldData{
.type = field_type,
.name = field_name,
.line = field_line,
.column = field_column,
};
}
const ExpectFailureAction = enum{
@"unreachable",
trap,
};
fn parse_boolean_expect_intrinsic(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File, failure_action: ExpectFailureAction, debug_line: u32, debug_column: u32) void {
const condition = parser.parse_condition(analyzer, thread, file);
const expect_true_block = create_basic_block(thread);
const expect_false_block = create_basic_block(thread);
_ = emit_branch(analyzer, thread, .{
.condition = condition,
.taken = expect_true_block,
.not_taken = expect_false_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
analyzer.current_basic_block = expect_false_block;
switch (failure_action) {
.@"unreachable" => emit_unreachable(analyzer, thread, .{
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
.trap => emit_trap(analyzer, thread, .{
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
}
analyzer.current_basic_block = expect_true_block;
}
fn parse_intrinsic(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File, ty: ?*Type) ?*Value {
const src = file.source_code;
const debug_line = parser.get_debug_line();
const debug_column = parser.get_debug_column();
parser.expect_character(src, '#');
// TODO: make it more efficient
const identifier = parser.parse_raw_identifier(src);
if (identifier[0] == '"') {
unreachable;
} else {
const intrinsic_id = inline for (@typeInfo(Intrinsic).Enum.fields) |i_field| {
if (byte_equal(i_field.name, identifier)) {
break @field(Intrinsic, i_field.name);
}
} else {
fail_term("Unknown intrinsic", identifier);
};
switch (intrinsic_id) {
.assert => {
parser.parse_boolean_expect_intrinsic(analyzer, thread, file, .@"unreachable", debug_line, debug_column);
return null;
},
.require => {
parser.parse_boolean_expect_intrinsic(analyzer, thread, file, .trap, debug_line, debug_column);
return null;
},
.size => {
parser.skip_space(src);
parser.expect_character(src, '(');
parser.skip_space(src);
const size_type = parser.parse_type_expression(thread, file, analyzer.current_scope);
parser.skip_space(src);
parser.expect_character(src, ')');
const constant_int = create_constant_int(thread, .{
.n = size_type.size,
.type = ty orelse unreachable,
});
return &constant_int.value;
},
.trailing_zeroes => {
parser.skip_space(src);
parser.expect_character(src, '(');
parser.skip_space(src);
const value = parser.parse_expression(analyzer, thread, file, ty, .right);
parser.skip_space(src);
parser.expect_character(src, ')');
const tz = thread.trailing_zeroes.append(.{
.value = value,
.instruction = new_instruction(thread, .{
.id = .trailing_zeroes,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
});
analyzer.append_instruction(&tz.instruction);
return &tz.instruction.value;
},
.leading_zeroes => {
parser.skip_space(src);
parser.expect_character(src, '(');
parser.skip_space(src);
const value = parser.parse_expression(analyzer, thread, file, ty, .right);
parser.skip_space(src);
parser.expect_character(src, ')');
const lz = thread.leading_zeroes.append(.{
.value = value,
.instruction = new_instruction(thread, .{
.id = .leading_zeroes,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
});
analyzer.append_instruction(&lz.instruction);
return &lz.instruction.value;
},
.transmute => {
const destination_type = ty orelse fail();
parser.skip_space(src);
parser.expect_character(src, '(');
parser.skip_space(src);
const value = parser.parse_expression(analyzer, thread, file, null, .right);
parser.skip_space(src);
parser.expect_character(src, ')');
const source_type = value.get_type();
if (destination_type == source_type) {
fail();
}
const cast_id: Cast.Id = switch (destination_type.sema.id) {
.integer => block: {
const destination_integer = destination_type.get_payload(.integer);
_ = destination_integer; // autofix
switch (source_type.sema.id) {
.bitfield => {
const source_bitfield = source_type.get_payload(.bitfield);
if (source_bitfield.backing_type == destination_type) {
break :block .int_from_bitfield;
} else {
fail();
}
},
else => |t| @panic(@tagName(t)),
}
},
.bitfield => block: {
const destination_bitfield = destination_type.get_payload(.bitfield);
if (destination_bitfield.backing_type == source_type) {
break :block .int_from_bitfield;
} else {
fail();
}
},
else => |t| @panic(@tagName(t)),
};
const cast = emit_cast(analyzer, thread, .{
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.value = value,
.type = destination_type,
.id = cast_id,
});
return &cast.instruction.value;
},
.int_from_pointer => {
if (ty) |expected_type| {
_ = expected_type; // autofix
unreachable;
}
const expected_type = &thread.integers[63].type;
parser.skip_space(src);
parser.expect_character(src, '(');
parser.skip_space(src);
const value = parser.parse_expression(analyzer, thread, file, null, .right);
switch (value.get_type().sema.id) {
.typed_pointer => {},
else => |t| @panic(@tagName(t)),
}
parser.skip_space(src);
parser.expect_character(src, ')');
const cast = emit_cast(analyzer, thread, .{
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.value = value,
.type = expected_type,
.id = .int_from_pointer,
});
return &cast.instruction.value;
},
else => |t| @panic(@tagName(t)),
}
}
}
fn parse_raw_identifier(parser: *Parser, file: []const u8) []const u8 {
const identifier_start = parser.i;
const is_string_literal_identifier = file[identifier_start] == '"';
parser.i += @intFromBool(is_string_literal_identifier);
const start_ch = file[parser.i];
const is_valid_identifier_start = is_identifier_char_start(start_ch);
parser.i += @intFromBool(is_valid_identifier_start);
if (is_valid_identifier_start) {
while (parser.i < file.len) {
const ch = file[parser.i];
const is_ident = is_identifier_char(ch);
parser.i += @intFromBool(is_ident);
if (!is_ident) {
if (is_string_literal_identifier) {
if (file[parser.i] != '"') {
fail();
}
}
const identifier = file[identifier_start..parser.i];
return identifier;
}
} else {
fail();
}
} else {
fail();
}
}
fn parse_identifier(parser: *Parser, thread: *Thread, file: []const u8) u32 {
const identifier = parser.parse_raw_identifier(file);
const keyword = parse_keyword(identifier);
if (keyword != ~(@as(u32, 0))) {
fail();
}
if (byte_equal(identifier, "_")) {
return 0;
} else return intern_identifier(&thread.identifiers, identifier);
}
fn parse_non_escaped_string_literal(parser: *Parser, src: []const u8) []const u8 {
const start = parser.i;
const is_double_quote = src[start] == '"';
parser.i += @intFromBool(is_double_quote);
if (!is_double_quote) {
fail();
}
while (src[parser.i] != '"') : (parser.i += 1) {
if (src[parser.i] == '\\') fail();
}
parser.i += 1;
const end = parser.i;
return src[start..end];
}
fn parse_non_escaped_string_literal_content(parser: *Parser, src: []const u8) []const u8 {
const string_literal = parser.parse_non_escaped_string_literal(src);
return string_literal[1..][0..string_literal.len - 2];
}
fn expect_character(parser: *Parser, file: []const u8, expected: u8) void {
const index = parser.i;
if (index < file.len) {
const ch = file[index];
const matches = ch == expected;
parser.i += @intFromBool(matches);
if (!matches) {
fail();
}
} else {
fail();
}
}
pub fn parse_hex(slice: []const u8) u64 {
var value: u64 = 0;
for (slice) |ch| {
const byte = switch (ch) {
'0'...'9' => ch - '0',
'a'...'f' => ch - 'a' + 10,
'A'...'F' => ch - 'A' + 10,
else => fail(),
};
value = (value << 4) | (byte & 0xf);
}
return value;
}
fn parse_type_expression(parser: *Parser, thread: *Thread, file: *File, current_scope: *Scope) *Type {
const src = file.source_code;
const starting_index = parser.i;
const starting_ch = src[starting_index];
const is_array_start = starting_ch == '[';
const is_start_u = starting_ch == 'u';
const is_start_s = starting_ch == 's';
const float_start = starting_ch == 'f';
const is_void_start = starting_ch == 'v';
const is_pointer_sign_start = starting_ch == '*';
const integer_start = is_start_s or is_start_u;
const is_number_type_start = integer_start or float_start;
if (is_void_start) {
const id = parser.parse_raw_identifier(src);
if (byte_equal(id, "void")) {
return &thread.void;
} else {
parser.i = starting_index;
}
} else if (is_number_type_start) {
const expected_digit_start = parser.i + 1;
var i = expected_digit_start;
var decimal_digit_count: u32 = 0;
const top = i + 5;
while (i < top) : (i += 1) {
const ch = src[i];
const is_digit = is_decimal_digit(ch);
decimal_digit_count += @intFromBool(is_digit);
if (!is_digit) {
const is_alpha = is_alphabetic(ch);
if (is_alpha) decimal_digit_count = 0;
break;
}
}
if (decimal_digit_count != 0) {
parser.i += 1;
if (integer_start) {
const signedness: Type.Integer.Signedness = @enumFromInt(@intFromBool(is_start_s));
const bit_count: u32 = switch (decimal_digit_count) {
0 => unreachable,
1 => src[parser.i] - '0',
2 => @as(u32, src[parser.i] - '0') * 10 + (src[parser.i + 1] - '0'),
else => fail(),
};
parser.i += decimal_digit_count;
const index = bit_count - 1 + @intFromEnum(signedness) * @as(usize, 64);
const result = &thread.integers[index];
assert(result.type.bit_size == bit_count);
assert(result.signedness == signedness);
return &result.type;
} else if (float_start) {
fail();
} else {
unreachable;
}
} else {
fail();
}
} else if (is_pointer_sign_start) {
parser.i += 1;
const pointee_type = parser.parse_type_expression(thread, file, current_scope);
const typed_pointer = get_typed_pointer(thread, .{
.pointee = pointee_type,
});
return typed_pointer;
} else if (is_array_start) {
parser.i += 1;
parser.skip_space(src);
const element_count = parser.parse_constant_expression(thread, file, null);
switch (element_count.sema.id) {
.constant_int => {
const constant_int = element_count.get_payload(.constant_int);
parser.skip_space(src);
parser.expect_character(src, ']');
parser.skip_space(src);
const element_type = parser.parse_type_expression(thread, file, current_scope);
const array_type = get_array_type(thread, .{
.element_type = element_type,
.element_count = constant_int.n,
});
return array_type;
},
else => |t| @panic(@tagName(t)),
}
}
const identifier = parser.parse_identifier(thread, src);
if (current_scope.get_declaration(identifier)) |lookup| {
const declaration = lookup.declaration.*;
switch (declaration.id) {
.@"struct" => {
const struct_type = declaration.get_payload(.@"struct");
return &struct_type.type;
},
.bitfield => {
const bitfield_type = declaration.get_payload(.bitfield);
return &bitfield_type.type;
},
else => |t| @panic(@tagName(t)),
}
} else {
fail_term("Unrecognized type expression", thread.identifiers.get(identifier).?);
}
}
fn parse_constant_integer(parser: *Parser, thread: *Thread, file: *File, ty: *Type) *ConstantInt {
const src = file.source_code;
const starting_index = parser.i;
const starting_ch = src[starting_index];
if (starting_ch == '0') {
const follow_up_character = src[parser.i + 1];
const is_hex_start = follow_up_character == 'x';
const is_octal_start = follow_up_character == 'o';
const is_bin_start = follow_up_character == 'b';
const is_prefixed_start = is_hex_start or is_octal_start or is_bin_start;
const follow_up_alpha = is_alphabetic(follow_up_character);
const follow_up_digit = is_decimal_digit(follow_up_character);
const is_valid_after_zero = is_space(follow_up_character, get_next_ch_safe(src, follow_up_character)) or (!follow_up_digit and !follow_up_alpha);
if (is_prefixed_start) {
const Prefix = enum {
hexadecimal,
octal,
binary,
};
const prefix: Prefix = switch (follow_up_character) {
'x' => .hexadecimal,
'o' => .octal,
'b' => .binary,
else => unreachable,
};
parser.i += 2;
const start = parser.i;
switch (prefix) {
.hexadecimal => {
while (is_hex_digit(src[parser.i])) {
parser.i += 1;
}
const slice = src[start..parser.i];
const number = parse_hex(slice);
const constant_int = create_constant_int(thread, .{
.n = number,
.type = ty,
});
return constant_int;
},
.octal => {
unreachable;
},
.binary => {
unreachable;
},
}
fail();
} else if (is_valid_after_zero) {
parser.i += 1;
const constant_int = create_constant_int(thread, .{
.n = 0,
.type = ty,
});
return constant_int;
} else {
fail();
}
}
while (is_decimal_digit(src[parser.i])) {
parser.i += 1;
}
const character_count = parser.i - starting_index;
const slice = src[starting_index..][0..character_count];
var i = character_count;
var integer: u64 = 0;
var factor: u64 = 1;
while (i > 0) {
i -= 1;
const ch = slice[i];
const int = ch - '0';
const extra = int * factor;
integer += extra;
factor *= 10;
}
const constant_int = create_constant_int(thread, .{
.n = integer,
.type = ty,
});
return constant_int;
}
const ParseFieldInitialization = struct{
value: *Value,
name: u32,
index: u32,
line: u32,
column: u32,
};
fn parse_field_initialization(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File, names_initialized: []const u32, fields: []const *Type.AggregateField) ?ParseFieldInitialization{
const src = file.source_code;
parser.skip_space(src);
if (src[parser.i] == brace_close) {
return null;
}
const line = parser.get_debug_line();
const column = parser.get_debug_column();
parser.expect_character(src, '.');
const name = parser.parse_identifier(thread, src);
for (names_initialized) |initialized_name| {
if (initialized_name == name) {
fail();
}
}
const field_index = for (fields) |field| {
if (field.name == name) {
break field.index;
}
} else {
fail();
};
const field_type = fields[field_index].type;
parser.skip_space(src);
parser.expect_character(src, '=');
parser.skip_space(src);
const field_value = parser.parse_expression(analyzer, thread, file, field_type, .right);
parser.skip_space(src);
switch (src[parser.i]) {
brace_close => {},
',' => parser.i += 1,
else => fail(),
}
return ParseFieldInitialization{
.value = field_value,
.name = name,
.index = field_index,
.line = line,
.column = column,
};
}
fn parse_single_expression(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File, maybe_type: ?*Type, side: Side) *Value {
const src = file.source_code;
const Unary = enum{
none,
one_complement,
negation,
};
const unary: Unary = switch (src[parser.i]) {
'A'...'Z', 'a'...'z', '_' => Unary.none,
'0'...'9' => Unary.none,
'-' => block: {
parser.i += 1;
break :block .negation;
},
'~' => block: {
parser.i += 1;
break :block .one_complement;
},
'#' => {
// parse intrinsic
const value = parser.parse_intrinsic(analyzer, thread, file, maybe_type) orelse unreachable;
return value;
},
brace_open => {
parser.i += 1;
// This is a composite initialization
const ty = maybe_type orelse fail();
switch (ty.sema.id) {
.@"struct" => {
const struct_type = ty.get_payload(.@"struct");
var names_initialized = PinnedArray(u32){};
var is_constant = true;
var values = PinnedArray(*Value){};
var field_index: u32 = 0;
var is_field_ordered = true;
var line_info = PinnedArray(struct{ line: u32, column: u32 }){};
while (parser.parse_field_initialization(analyzer, thread, file, names_initialized.const_slice(), struct_type.fields)) |field_data| : (field_index += 1) {
is_field_ordered = is_field_ordered and field_index == field_data.index;
_ = names_initialized.append(field_data.name);
_ = values.append(field_data.value);
_ = line_info.append(.{ .line = field_data.line, .column = field_data.column });
is_constant = is_constant and field_data.value.is_constant();
}
parser.i += 1;
if (is_field_ordered and field_index == struct_type.fields.len) {
if (is_constant) {
const constant_struct = thread.constant_structs.append(.{
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = true,
.id = .constant_struct,
},
},
.values = values.const_slice(),
.type = ty,
});
return &constant_struct.value;
} else {
const undefined_value = thread.undefined_values.append(.{
.value = .{
.sema = .{
.id = .undefined,
.resolved = true,
.thread = thread.get_index(),
},
},
.type = ty,
});
if (true) unreachable;
var aggregate = &undefined_value.value;
for (values.const_slice(), line_info.const_slice(), 0..) |value, li, index| {
if (true) unreachable;
const insert_value = emit_insert_value(thread, analyzer, .{
.aggregate = aggregate,
.value = value,
.index = @intCast(index),
.line = li.line,
.column = li.column,
.scope = analyzer.current_scope,
.type = ty,
});
aggregate = &insert_value.instruction.value;
}
return aggregate;
}
} else {
fail();
}
},
.bitfield => {
const bitfield_type = ty.get_payload(.bitfield);
var names_initialized = PinnedArray(u32){};
var is_constant = true;
var values = PinnedArray(*Value){};
var field_index: u32 = 0;
var is_field_ordered = true;
while (parser.parse_field_initialization(analyzer, thread, file, names_initialized.const_slice(), bitfield_type.fields)) |field_data| : (field_index += 1) {
is_field_ordered = is_field_ordered and field_index == field_data.index;
_ = names_initialized.append(field_data.name);
_ = values.append(field_data.value);
is_constant = is_constant and field_data.value.is_constant();
}
parser.i += 1;
if (is_constant) {
if (is_field_ordered and field_index == bitfield_type.fields.len) {
var result: u64 = 0;
var bit_offset: u16 = 0;
for (values.const_slice()) |value| {
switch (value.sema.id) {
.constant_int => {
const constant_int = value.get_payload(.constant_int);
const field_bit_count = constant_int.type.bit_size;
const field_value = constant_int.n;
const offset_value = field_value << @as(u6, @intCast(bit_offset));
result |= offset_value;
bit_offset += @intCast(field_bit_count);
},
else => |t| @panic(@tagName(t)),
}
}
const constant_int = create_constant_int(thread, .{
.n = result,
.type = bitfield_type.backing_type,
});
return &constant_int.value; // autofix
} else {
unreachable;
}
} else {
fail_message("TODO: runtime struct initialization");
}
},
else => |t| @panic(@tagName(t)),
}
},
'[' => {
// This is an array expression
parser.i += 1;
const ty = maybe_type orelse fail();
const array_type = ty.get_payload(.array);
const element_count = array_type.descriptor.element_count;
const element_type = array_type.descriptor.element_type;
parser.skip_space(src);
var values = PinnedArray(*Value){};
var is_constant = true;
while (true) {
parser.skip_space(src);
if (src[parser.i] == ']') {
break;
}
const value = parser.parse_expression(analyzer, thread, file, element_type, .right);
is_constant = is_constant and value.is_constant();
_ = values.append(value);
parser.skip_space(src);
switch (src[parser.i]) {
']' => {},
',' => parser.i += 1,
else => unreachable,
}
}
parser.i += 1;
if (values.length != element_count) {
fail();
}
if (is_constant) {
const constant_array = thread.constant_arrays.append(.{
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = true,
.id = .constant_array,
},
},
.values = values.const_slice(),
.type = ty,
});
return &constant_array.value;
} else {
unreachable;
}
},
else => unreachable,
};
const starting_index = parser.i;
const starting_ch = src[starting_index];
const is_digit_start = is_decimal_digit(starting_ch);
const is_alpha_start = is_alphabetic(starting_ch);
const debug_line = parser.get_debug_line();
const debug_column = parser.get_debug_column();
if (is_digit_start) {
const ty = maybe_type orelse switch (unary) {
.none => &thread.integers[63].type,
.one_complement => fail(),
.negation => fail(),
};
switch (ty.sema.id) {
.integer => {
const constant_int = parser.parse_constant_integer(thread, file, ty);
switch (unary) {
.none => return &constant_int.value,
.one_complement => unreachable,
.negation => {
const integer_ty = ty.get_payload(.integer);
switch (integer_ty.signedness) {
.signed => {
var n: i64 = @intCast(constant_int.n);
n = 0 - n;
const result = create_constant_int(thread, .{
.n = @bitCast(n),
.type = ty,
});
return &result.value;
},
.unsigned => fail(),
}
},
}
},
else => unreachable,
}
} else if (is_alpha_start) {
var resolved = true;
const name = parser.parse_raw_identifier(src);
const keyword = parse_keyword(name);
if (keyword != ~(@as(u32, 0))) {
switch (@as(Keyword, @enumFromInt(keyword))) {
.undefined => {
const ty = maybe_type orelse fail();
const undef = thread.undefined_values.append(.{
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = true,
.id = .undefined,
},
},
.type = ty,
});
return &undef.value;
},
else => |t| @panic(@tagName(t)),
}
}
const identifier: u32 = if (byte_equal(name, "_")) 0 else intern_identifier(&thread.identifiers, name);
var initial_type: ?*Type = null;
const initial_value = if (analyzer.current_scope.get_declaration(identifier)) |lookup_result| blk: {
switch (lookup_result.declaration.*.id) {
.local => {
const local_declaration = lookup_result.declaration.*.get_payload(.local);
const local_symbol = local_declaration.to_symbol();
initial_type = local_symbol.type;
break :blk &local_symbol.instruction.value;
},
.global => {
const global_declaration = lookup_result.declaration.*.get_payload(.global);
switch (global_declaration.id) {
.global_symbol => {
const global_symbol = global_declaration.to_symbol();
initial_type = global_symbol.type;
break :blk &global_symbol.value;
},
.unresolved_import => {
const import: *Import = global_declaration.get_payload(.unresolved_import);
assert(!import.resolved);
resolved = false;
const import_index = for (file.imports.slice(), 0..) |existing_import, i| {
if (import == existing_import) break i;
} else unreachable;
const lazy_expression = thread.lazy_expressions.append(LazyExpression.init(@ptrCast(lookup_result.declaration), thread));
while (true) {
switch (src[parser.i]) {
'.' => {
parser.i += 1;
const right = parser.parse_identifier(thread, src);
lazy_expression.add(right);
},
'(' => break,
else => @panic((src.ptr + parser.i)[0..1]),
}
}
switch (src[parser.i]) {
'(' => {
parser.i += 1;
// TODO: arguments
parser.expect_character(src, ')');
const call = thread.calls.append(.{
.instruction = new_instruction(thread, .{
.id = .call,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.resolved = false,
}),
.callable = &lazy_expression.value,
.arguments = &.{},
.calling_convention = .c,
});
analyzer.append_instruction(&call.instruction);
_ = file.values_per_import.get(@enumFromInt(import_index)).append(&call.instruction.value);
return &call.instruction.value;
},
else => @panic((src.ptr + parser.i)[0..1]),
}
},
else => |t| @panic(@tagName(t)),
}
},
.argument => {
const argument_declaration = lookup_result.declaration.*.get_payload(.argument);
const argument_symbol = argument_declaration.to_symbol();
initial_type = argument_symbol.type;
break :blk &argument_symbol.instruction.value;
},
else => |t| @panic(@tagName(t)),
}
} else blk: {
resolved = false;
const lazy_expression = thread.local_lazy_expressions.append(.{
.value = .{
.sema = .{
.id = .local_lazy_expression,
.thread = thread.get_index(),
.resolved = false,
},
},
.name = identifier,
});
_ = file.local_lazy_expressions.append(lazy_expression);
break :blk &lazy_expression.value;
};
switch (src[parser.i]) {
' ', ',', ';', ')' => {
return switch (unary) {
.none => switch (side) {
.right => right: {
const ty = if (initial_type) |source_ty| if (maybe_type) |destination_ty| blk: {
switch (typecheck(destination_ty, source_ty)) {
.success => {},
}
break :blk source_ty;
} else source_ty
else if (maybe_type) |ty| ty else fail();
const load = emit_load(analyzer, thread, .{
.value = initial_value,
.type = ty,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
break :right &load.instruction.value;
},
.left => initial_value,
},
.negation => neg: {
assert(side == .right);
var r = initial_value;
if (initial_value.get_type() != initial_type.?) {
const load = emit_load(analyzer, thread, .{
.value = initial_value,
.type = initial_type.?,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
r = &load.instruction.value;
}
const operand = create_constant_int(thread, .{
.type = initial_type.?,
.n = 0,
});
const sub = emit_integer_binary_operation(analyzer, thread, .{
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.left = &operand.value,
.right = r,
.id = .sub,
.type = initial_type.?,
});
break :neg &sub.instruction.value;
},
.one_complement => oc: {
assert(side == .right);
var r = initial_value;
if (initial_value.get_type() != initial_type.?) {
const load = emit_load(analyzer, thread, .{
.value = initial_value,
.type = initial_type.?,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
r = &load.instruction.value;
}
const operand = create_constant_int(thread, .{
.type = initial_type.?,
.n = std.math.maxInt(u64),
});
const xor = emit_integer_binary_operation(analyzer, thread, .{
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.left = r,
.right = &operand.value,
.id = .xor,
.type = initial_type.?,
});
break :oc &xor.instruction.value;
},
};
},
'&' => {
parser.i += 1;
return initial_value;
},
'(' => {
parser.i += 1;
parser.skip_space(src);
switch (initial_value.sema.resolved) {
true => {
const FunctionCallData = struct{
type: *Type.Function,
value: *Value,
calling_convention: CallingConvention,
};
const function_call_data: FunctionCallData = switch (initial_type.?.sema.id) {
.function => .{
.type = initial_type.?.get_payload(.function),
.value = initial_value,
.calling_convention = switch (initial_value.sema.id) {
.global_symbol => b: {
const global_symbol = initial_value.get_payload(.global_symbol);
switch (global_symbol.id) {
.function_definition => {
const function_definition = global_symbol.get_payload(.function_definition);
break :b function_definition.declaration.get_function_type().abi.calling_convention;
},
.function_declaration => {
const function_declaration = global_symbol.get_payload(.function_declaration);
break :b function_declaration.get_function_type().abi.calling_convention;
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
},
},
.typed_pointer => switch (initial_value.sema.id) {
.instruction => blk: {
const instruction = initial_value.get_payload(.instruction);
switch (instruction.id) {
.local_symbol => {
const local_symbol = instruction.get_payload(.local_symbol);
const pointer_type = local_symbol.type.get_payload(.typed_pointer);
const function_type = pointer_type.descriptor.pointee.get_payload(.function);
const load = emit_load(analyzer, thread, .{
.value = &local_symbol.instruction.value,
.type = local_symbol.type,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
break :blk .{
.type = function_type,
.value = &load.instruction.value,
// TODO:
.calling_convention = .c,
};
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
},
else => |t| @panic(@tagName(t)),
};
const function_type = function_call_data.type;
const function_value = function_call_data.value;
var abi_argument_values = PinnedArray(*Value){};
const indirect_return_value: ?*Value = switch (function_type.abi.return_type_abi.kind) {
.indirect => |indirect| ind: {
if (indirect.alignment <= indirect.type.alignment) {
const return_local = emit_local_symbol(analyzer, thread, .{
.name = 0,
.initial_value = null,
.type = indirect.type,
.line = 0,
.column = 0,
});
const return_value = &return_local.instruction.value;
_ = abi_argument_values.append(return_value);
break :ind return_value;
} else {
unreachable;
}
},
else => null,
};
var original_argument_i: u32 = 0;
const declaration_argument_count = function_type.abi.original_argument_types.len;
while (true) {
parser.skip_space(src);
if (src[parser.i] == ')') {
break;
}
const argument_index = original_argument_i;
if (argument_index >= declaration_argument_count) {
fail();
}
const argument_abi = function_type.abi.argument_types_abi[argument_index];
const argument_type = function_type.abi.original_argument_types[argument_index];
const argument_value = parser.parse_expression(analyzer, thread, file, argument_type, .right);
const argument_value_type = argument_value.get_type();
parser.skip_space(src);
switch (src[parser.i]) {
',' => parser.i += 1,
')' => {},
else => unreachable,
}
switch (argument_abi.kind) {
.direct => {
assert(argument_value_type == argument_type);
_ = abi_argument_values.append(argument_value);
},
.direct_coerce => |coerced_type| {
const coerced_value = emit_direct_coerce(analyzer, thread, .{
.original_value = argument_value,
.coerced_type = coerced_type,
});
_ = abi_argument_values.append(coerced_value);
},
.indirect => |indirect| {
assert(argument_type == indirect.type);
const direct = if (!argument_abi.attributes.by_value) false else switch (argument_type.sema.id) {
.typed_pointer => unreachable,
else => false,
};
if (direct) {
unreachable;
} else {
const indirect_local = emit_local_symbol(analyzer, thread, .{
.type = argument_type,
.name = 0,
.initial_value = argument_value,
.line = 0,
.column = 0,
});
_ = abi_argument_values.append(&indirect_local.instruction.value);
}
},
.direct_pair => |pair| {
const pair_struct_type = get_anonymous_two_field_struct(thread, pair);
const are_similar = b: {
if (pair_struct_type == argument_type) {
break :b true;
} else {
switch (argument_type.sema.id) {
.@"struct" => {
const original_struct_type = argument_type.get_payload(.@"struct");
if (original_struct_type.fields.len == 2) {
for (original_struct_type.fields, pair) |field, pair_type| {
if (field.type != pair_type) break :b false;
}
break :b true;
} else break :b false;
},
else => |t| @panic(@tagName(t)),
}
}
};
if (are_similar) {
const extract_0 = emit_extract_value(thread, analyzer, .{
.aggregate = argument_value,
.index = 0,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
.type = pair[0],
});
_ = abi_argument_values.append(&extract_0.instruction.value);
const extract_1 = emit_extract_value(thread, analyzer, .{
.aggregate = argument_value,
.index = 1,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
.type = pair[1],
});
_ = abi_argument_values.append(&extract_1.instruction.value);
} else {
const local_value = if (argument_type.alignment < pair_struct_type.alignment) b: {
const coerced_local = emit_local_symbol(analyzer, thread, .{
.type = pair_struct_type,
.name = 0,
.initial_value = argument_value,
.line = 0,
.column = 0,
});
break :b &coerced_local.instruction.value;
} else b: {
const argument_local = emit_local_symbol(analyzer, thread, .{
.type = argument_type,
.name = 0,
.initial_value = argument_value,
.line = 0,
.column = 0,
});
break :b &argument_local.instruction.value;
};
const gep0 = emit_gep(thread, analyzer, .{
.pointer = local_value,
.type = pair[0],
.aggregate_type = pair_struct_type,
.is_struct = true,
.index = &create_constant_int(thread, .{
.n = 0,
.type = &thread.integers[31].type,
}).value,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
const load0 = emit_load(analyzer, thread, .{
.type = pair[0],
.value = &gep0.instruction.value,
.scope = analyzer.current_scope,
.line = 0,
.column = 0,
});
_ = abi_argument_values.append(&load0.instruction.value);
const gep1 = emit_gep(thread, analyzer, .{
.pointer = local_value,
.type = pair[1],
.aggregate_type = pair_struct_type,
.is_struct = true,
.index = &create_constant_int(thread, .{
.n = 1,
.type = &thread.integers[31].type,
}).value,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
const load1 = emit_load(analyzer, thread, .{
.type = pair[1],
.value = &gep1.instruction.value,
.scope = analyzer.current_scope,
.line = 0,
.column = 0,
});
_ = abi_argument_values.append(&load1.instruction.value);
}
},
else => |t| @panic(@tagName(t)),
}
original_argument_i += 1;
}
parser.i += 1;
const call = thread.calls.append(.{
.instruction = new_instruction(thread, .{
.id = .call,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
.callable = function_value,
.arguments = abi_argument_values.const_slice(),
.calling_convention = function_call_data.calling_convention,
});
analyzer.append_instruction(&call.instruction);
if (indirect_return_value) |irv| {
const load = emit_load(analyzer, thread, .{
.value = irv,
.type = function_type.abi.original_return_type,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
return &load.instruction.value;
} else {
return &call.instruction.value;
}
},
false => {
var argument_values = PinnedArray(*Value){};
while (true) {
parser.skip_space(src);
if (src[parser.i] == ')') {
break;
}
const passed_argument_value = parser.parse_expression(analyzer, thread, file, null, .right);
_ = argument_values.append(passed_argument_value);
parser.skip_space(src);
switch (src[parser.i]) {
',' => parser.i += 1,
')' => {},
else => unreachable,
}
}
parser.i += 1;
const call = thread.calls.append(.{
.instruction = new_instruction(thread, .{
.id = .call,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.resolved = false,
}),
.callable = initial_value,
.arguments = argument_values.const_slice(),
.calling_convention = .c,
});
switch (initial_value.sema.id) {
.local_lazy_expression => {
const local_lazy_expression = initial_value.get_payload(.local_lazy_expression);
_ = local_lazy_expression.values.append(&call.instruction.value);
},
else => |t| @panic(@tagName(t)),
}
analyzer.append_instruction(&call.instruction);
return &call.instruction.value;
},
}
},
'[' => {
parser.i += 1;
parser.skip_space(src);
const declaration_element_type = switch (initial_type.?.sema.id) {
.array => block: {
const array_type = initial_type.?.get_payload(.array);
break :block array_type.descriptor.element_type;
},
else => |t| @panic(@tagName(t)),
};
const index = parser.parse_expression(analyzer, thread, file, null, .right);
parser.skip_space(src);
parser.expect_character(src, ']');
const gep = emit_gep(thread, analyzer, .{
.pointer = initial_value,
.index = index,
.type = declaration_element_type,
.aggregate_type = initial_type.?,
.is_struct = false,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
return switch (side) {
.left => &gep.instruction.value,
.right => block: {
const load = emit_load(analyzer, thread, .{
.value = &gep.instruction.value,
.type = declaration_element_type,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
break :block &load.instruction.value;
},
};
},
'.' => {
const result = parser.parse_field_access(analyzer, thread, file, maybe_type, side, initial_value, initial_type.?, debug_line, debug_column);
return result;
},
'@' => {
parser.i += 1;
assert(initial_type.?.sema.id == .typed_pointer);
const load = emit_load(analyzer, thread, .{
.value = initial_value,
.type = initial_type.?,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
return switch (side) {
.left => &load.instruction.value,
.right => block: {
const pointer_load_type = switch (initial_type.?.sema.id) {
.typed_pointer => b: {
const typed_pointer = initial_type.?.get_payload(.typed_pointer);
break :b typed_pointer.descriptor.pointee;
},
else => |t| @panic(@tagName(t)),
};
if (maybe_type) |ty| {
switch (typecheck(ty, pointer_load_type)) {
.success => {},
}
}
const pointer_load = emit_load(analyzer, thread, .{
.value = &load.instruction.value,
.type = pointer_load_type,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
break :block &pointer_load.instruction.value;
},
};
},
else => unreachable,
}
} else {
fail();
}
}
const CurrentOperation = enum{
none,
assign,
add,
add_assign,
sub,
sub_assign,
mul,
mul_assign,
udiv,
udiv_assign,
sdiv,
sdiv_assign,
@"and",
and_assign,
@"or",
or_assign,
@"xor",
xor_assign,
shift_left,
shift_left_assign,
arithmetic_shift_right,
arithmetic_shift_right_assign,
logical_shift_right,
logical_shift_right_assign,
compare_equal,
compare_not_equal,
compare_unsigned_greater,
compare_unsigned_greater_equal,
compare_signed_greater,
compare_signed_greater_equal,
compare_unsigned_less,
compare_unsigned_less_equal,
compare_signed_less,
compare_signed_less_equal,
@"orelse",
};
fn parse_constant_expression(parser: *Parser, thread: *Thread, file: *File, maybe_type: ?*Type) *Value {
const src = file.source_code;
const starting_index = parser.i;
const starting_ch = src[starting_index];
const is_digit_start = is_decimal_digit(starting_ch);
if (is_digit_start) {
const ty = maybe_type orelse &thread.integers[63].type;
switch (ty.sema.id) {
.integer => {
const constant_int = parser.parse_constant_integer(thread, file, ty);
return &constant_int.value;
},
else => unreachable,
}
} else {
unreachable;
}
}
fn parse_field_access(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File, expected_type: ?*Type, side: Side, value: *Value, ty: *Type, line: u32, column: u32) *Value{
const src = file.source_code;
parser.expect_character(src, '.');
switch (ty.sema.id) {
.@"struct" => {
const struct_type = ty.get_payload(.@"struct");
const field_name = parser.parse_identifier(thread, src);
const field_index = for (struct_type.fields) |field| {
if (field.name == field_name) {
break field.index;
}
} else fail();
const index_value = create_constant_int(thread, .{
.type = &thread.integers[31].type,
.n = field_index,
});
const gep = emit_gep(thread, analyzer, .{
.line = line,
.column = column,
.scope = analyzer.current_scope,
.pointer = value,
.index = &index_value.value,
.aggregate_type = ty,
.type = struct_type.fields[field_index].type,
.is_struct = true,
});
const result = switch (side) {
.right => block: {
const load = emit_load(analyzer, thread, .{
.value = &gep.instruction.value,
.type = gep.type,
.scope = analyzer.current_scope,
.line = line,
.column = column,
});
break :block &load.instruction.value;
},
else => |t| @panic(@tagName(t)),
};
const result_type = result.get_type();
if (expected_type) |expected| {
switch (typecheck(expected, result_type)) {
.success => {},
}
}
return result;
},
.bitfield => {
const bitfield_type = ty.get_payload(.bitfield);
const field_name = parser.parse_identifier(thread, src);
const field_index = for (bitfield_type.fields) |field| {
if (field.name == field_name) {
break field.index;
}
} else fail();
const field = bitfield_type.fields[field_index];
const load = emit_load(analyzer, thread, .{
.value = value,
.type = bitfield_type.backing_type,
.line = line,
.column = column,
.scope = analyzer.current_scope,
});
var result = &load.instruction.value;
if (field.member_offset > 0) {
const shifter = create_constant_int(thread, .{
.n = field.member_offset,
.type = ty,
});
const shift = emit_integer_binary_operation(analyzer, thread, .{
.line = line,
.column = column,
.scope = analyzer.current_scope,
.left = result,
.right = &shifter.value,
.id = .logical_shift_right,
.type = bitfield_type.backing_type,
});
result = &shift.instruction.value;
}
if (field.type != bitfield_type.backing_type) {
const cast = emit_cast(analyzer, thread, .{
.value = result,
.type = field.type,
.id = .truncate,
.line = line,
.column = column,
.scope = analyzer.current_scope,
});
result = &cast.instruction.value;
}
assert(result != value);
return result;
},
else => |t| @panic(@tagName(t)),
}
}
fn parse_expression(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File, ty: ?*Type, side: Side) *Value {
const src = file.source_code;
var current_operation = CurrentOperation.none;
var previous_value: *Value = undefined;
var iterations: usize = 0;
var it_ty: ?*Type = ty;
while (true) {
if (iterations == 1 and it_ty == null) {
it_ty = previous_value.get_type();
}
const debug_line = parser.get_debug_line();
const debug_column = parser.get_debug_column();
var current_value: *Value = undefined;
if (src[parser.i] == '(') {
parser.i += 1;
current_value = parser.parse_expression(analyzer, thread, file, it_ty, side);
parser.expect_character(src, ')');
} else {
current_value = parser.parse_single_expression(analyzer, thread, file, it_ty, side);
}
parser.skip_space(src);
switch (current_operation) {
.none => {
previous_value = current_value;
},
.compare_equal, .compare_not_equal, .compare_unsigned_greater, .compare_unsigned_greater_equal, .compare_signed_greater, .compare_signed_greater_equal, .compare_unsigned_less, .compare_unsigned_less_equal, .compare_signed_less, .compare_signed_less_equal => {
switch (current_operation) {
else => unreachable,
inline .compare_equal, .compare_not_equal, .compare_unsigned_greater, .compare_unsigned_greater_equal, .compare_signed_greater, .compare_signed_greater_equal, .compare_unsigned_less, .compare_unsigned_less_equal, .compare_signed_less, .compare_signed_less_equal => |co| {
const string = @tagName(co)["compare_".len..];
const comparison = @field(IntegerCompare.Id, string);
const compare = thread.integer_compares.append(.{
.instruction = new_instruction(thread, .{
.id = .integer_compare,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
.left = previous_value,
.right = current_value,
.id = comparison,
});
analyzer.append_instruction(&compare.instruction);
previous_value = &compare.instruction.value;
}
}
},
.add, .sub, .mul, .udiv, .sdiv, .@"and", .@"or", .xor, .shift_left, .arithmetic_shift_right, .logical_shift_right => {
const i = emit_integer_binary_operation(analyzer, thread, .{
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.left = previous_value,
.right = current_value,
.id = switch (current_operation) {
else => unreachable,
inline
.add,
.sub,
.mul,
.udiv,
.sdiv,
.@"and",
.@"or",
.@"xor",
.shift_left,
.arithmetic_shift_right,
.logical_shift_right,
=> |co| @field(IntegerBinaryOperation.Id, @tagName(co)),
},
.type = if (it_ty) |t| t else current_value.get_type(),
});
previous_value = &i.instruction.value;
},
.assign, .add_assign, .sub_assign, .mul_assign, .udiv_assign, .sdiv_assign, .and_assign, .or_assign, .xor_assign, .shift_left_assign, .logical_shift_right_assign, .arithmetic_shift_right_assign => unreachable,
.@"orelse" => {
const orelse_type = ty orelse unreachable;
const condition = emit_condition(analyzer, thread, .{
.condition = previous_value,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
const true_block = create_basic_block(thread);
const false_block = create_basic_block(thread);
const phi_block = create_basic_block(thread);
_ = emit_branch(analyzer, thread, .{
.condition = condition,
.taken = true_block,
.not_taken = false_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
const phi = thread.phis.append(.{
.instruction = new_instruction(thread, .{
.id = .phi,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
.type = orelse_type,
});
_ = phi.nodes.append(.{
.value = previous_value,
.basic_block = true_block,
});
_ = phi.nodes.append(.{
.value = current_value,
.basic_block = false_block,
});
analyzer.current_basic_block = true_block;
_ = emit_jump(analyzer, thread, .{
.basic_block = phi_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
analyzer.current_basic_block = false_block;
_ = emit_jump(analyzer, thread, .{
.basic_block = phi_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
analyzer.current_basic_block = phi_block;
analyzer.append_instruction(&phi.instruction);
previous_value = &phi.instruction.value;
},
}
const original_index = parser.i;
const original = src[original_index];
switch (original) {
')', ';', ',', ']' => return previous_value,
'o' => {
const identifier = parser.parse_raw_identifier(src);
if (byte_equal(identifier, "orelse")) {
current_operation = .@"orelse";
} else {
parser.i = original;
fail();
}
parser.skip_space(src);
},
'=' => {
current_operation = .assign;
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .compare_equal;
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'!' => {
current_operation = undefined;
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .compare_not_equal;
parser.i += 1;
},
else => unreachable,
}
parser.skip_space(src);
},
'+' => {
current_operation = .add;
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .add_assign;
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'-' => {
current_operation = .sub;
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .sub_assign;
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'*' => {
current_operation = .mul;
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .mul_assign;
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'/' => {
const int_ty = it_ty orelse previous_value.get_type();
const integer_type = int_ty.get_payload(.integer);
current_operation = switch (integer_type.signedness) {
.unsigned => .udiv,
.signed => .sdiv,
};
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = switch (integer_type.signedness) {
.unsigned => .udiv_assign,
.signed => .sdiv_assign,
};
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'&' => {
current_operation = .@"and";
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .and_assign;
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'|' => {
current_operation = .@"or";
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .or_assign;
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'^' => {
current_operation = .@"xor";
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .xor_assign;
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
'<' => {
const int_ty = it_ty orelse previous_value.get_type();
const integer_type = int_ty.get_payload(.integer);
current_operation = switch (integer_type.signedness) {
.unsigned => .compare_unsigned_less,
.signed => .compare_signed_less,
};
parser.i += 1;
switch (src[parser.i]) {
'<' => {
current_operation = .shift_left;
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = .shift_left_assign;
parser.i += 1;
},
else => {},
}
},
'=' => {
unreachable;
},
else => {},
}
parser.skip_space(src);
},
'>' => {
const int_ty = it_ty orelse previous_value.get_type();
const integer_type = int_ty.get_payload(.integer);
current_operation = switch (integer_type.signedness) {
.unsigned => .compare_unsigned_greater,
.signed => .compare_signed_greater,
};
parser.i += 1;
switch (src[parser.i]) {
'>' => {
current_operation = switch (integer_type.signedness) {
.unsigned => .logical_shift_right,
.signed => .arithmetic_shift_right,
};
parser.i += 1;
switch (src[parser.i]) {
'=' => {
current_operation = switch (integer_type.signedness) {
.unsigned => .logical_shift_right_assign,
.signed => .arithmetic_shift_right_assign,
};
parser.i += 1;
},
else => {},
}
},
'=' => {
current_operation = switch (integer_type.signedness) {
.unsigned => .compare_unsigned_greater_equal,
.signed => .compare_signed_greater_equal,
};
parser.i += 1;
},
else => {},
}
parser.skip_space(src);
},
else => @panic((src.ptr + parser.i)[0..1]),
}
iterations += 1;
}
}
const IfResult = struct {
terminated: bool,
};
fn parse_condition(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File) *Value {
const src = file.source_code;
parser.expect_character(src, '(');
parser.skip_space(src);
const debug_line = parser.get_debug_line();
const debug_column = parser.get_debug_column();
const scope = analyzer.current_scope;
const condition = parser.parse_expression(analyzer, thread, file, null, .right);
parser.skip_space(src);
parser.expect_character(src, ')');
parser.skip_space(src);
return emit_condition(analyzer, thread, .{
.condition = condition,
.line = debug_line,
.column = debug_column,
.scope = scope,
});
}
fn parse_if_expression(parser: *Parser, analyzer: *Analyzer, thread: *Thread, file: *File) IfResult {
const src = file.source_code;
parser.i += 2;
parser.skip_space(src);
const debug_line = parser.get_debug_line();
const debug_column = parser.get_debug_line();
const compare = parser.parse_condition(analyzer, thread, file);
const original_block = analyzer.current_basic_block;
const taken_block = create_basic_block(thread);
const exit_block = create_basic_block(thread);
_ = analyzer.exit_blocks.append(exit_block);
const exit_block_count = analyzer.exit_blocks.length;
const branch_emission = emit_branch(analyzer, thread, .{
.condition = compare,
.taken = taken_block,
.not_taken = exit_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
_ = branch_emission; // autofix
analyzer.current_basic_block = taken_block;
var if_terminated = false;
var else_terminated = false;
var if_jump_emission: JumpEmission = undefined;
switch (src[parser.i]) {
brace_open => {
const if_block = analyze_local_block(thread, analyzer, parser, file);
if_terminated = if_block.terminated;
if (!if_terminated) {
if_jump_emission = emit_jump(analyzer, thread, .{
.basic_block = exit_block,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
}
},
else => @panic((src.ptr + parser.i)[0..1]),
}
parser.skip_space(src);
if (src[parser.i] == 'e' and byte_equal(src[parser.i..][0.."else".len], "else")) {
// TODO: create not taken block
parser.i += "else".len;
analyzer.current_basic_block = exit_block;
parser.skip_space(src);
switch (src[parser.i]) {
brace_open => {
const else_block = analyze_local_block(thread, analyzer, parser, file);
else_terminated = else_block.terminated;
},
'i' => {
if (src[parser.i + 1] == 'f') {
const else_if = parser.parse_if_expression(analyzer, thread, file);
else_terminated = else_if.terminated;
} else {
unreachable;
}
},
else => @panic((src.ptr + parser.i)[0..1]),
}
if (!if_terminated or !else_terminated) {
const new_exit_block = create_basic_block(thread);
const not_taken_block = exit_block;
// Fix jump
if (!if_terminated) {
assert(if_jump_emission.jump.basic_block == not_taken_block);
if_jump_emission.jump.basic_block.predecessors.length = 0;
_ = if_jump_emission.jump.basic_block.predecessors.append(original_block);
_ = new_exit_block.predecessors.append(if_jump_emission.jump.basic_block);
if_jump_emission.jump.basic_block = new_exit_block;
}
if (!else_terminated) {
// Emit jump to the new exit block
_ = emit_jump(analyzer, thread, .{
.basic_block = new_exit_block,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
}
analyzer.current_basic_block = new_exit_block;
}
} else {
_ = exit_block.predecessors.append(original_block);
analyzer.current_basic_block = exit_block;
}
if (!if_terminated and !else_terminated) {
assert(analyzer.exit_blocks.length == exit_block_count);
analyzer.exit_blocks.length -= 1;
}
return .{
.terminated = if_terminated and else_terminated,
};
}
};
const LocalLazyExpression = struct{
value: Value,
name: u32,
values: PinnedArray(*Value) = .{},
};
const LazyExpression = struct {
value: Value,
u: union(enum) {
dynamic: struct{
names: PinnedArray(u32) = .{},
outsider: GlobalDeclaration.Reference,
},
static: struct {
names: [4]u32 = .{0} ** 4,
outsider: GlobalDeclaration.Reference,
},
},
fn init(global_declaration: GlobalDeclaration.Reference, thread: *Thread) LazyExpression {
return .{
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = false,
.id = .lazy_expression,
},
},
.u = .{
.static = .{
.outsider = global_declaration,
},
}
};
}
fn length(lazy_expression: *LazyExpression) u32 {
return switch (lazy_expression.u) {
.dynamic => |*d| d.names.length,
.static => |*s| for (s.names, 0..) |n, i| {
if (n == 0) break @intCast(i);
} else s.names.len,
};
}
fn names(lazy_expression: *LazyExpression) []const u32 {
return switch (lazy_expression.u) {
.dynamic => |*d| d.names.slice(),
.static => |*s| s.names[0.. for (s.names, 0..) |n, i| {
if (n == 0) break @intCast(i);
} else s.names.len],
};
}
fn add(lazy_expression: *LazyExpression, name: u32) void {
const index = lazy_expression.length();
if (index < 4) {
lazy_expression.u.static.names[index] = name;
} else {
unreachable;
}
}
};
const Value = struct {
llvm: ?*LLVM.Value = null,
sema: struct {
thread: u16,
resolved: bool,
reserved: u7 = 0,
id: Id,
},
reserved: u32 = 0,
const Id = enum(u8){
argument,
basic_block,
constant_array,
constant_struct,
constant_bitfield,
constant_int,
instruction,
global_symbol,
lazy_expression,
local_lazy_expression,
undefined,
};
const id_to_value_map = std.EnumArray(Id, type).init(.{
.argument = ArgumentSymbol,
.basic_block = BasicBlock,
.constant_array = ConstantArray,
.constant_struct = ConstantStruct,
.constant_bitfield = ConstantBitfield,
.constant_int = ConstantInt,
.global_symbol = GlobalSymbol,
.instruction = Instruction,
.lazy_expression = LazyExpression,
.local_lazy_expression = LocalLazyExpression,
.undefined = Undefined,
});
fn is_constant(value: *Value) bool {
return switch (value.sema.id) {
.constant_int,
.constant_struct,
.undefined,
=> true,
.instruction => false,
else => |t| @panic(@tagName(t)),
};
}
fn get_payload(value: *Value, comptime id: Id) *id_to_value_map.get(id) {
assert(value.sema.id == id);
return @fieldParentPtr("value", value);
}
fn get_type(value: *Value) *Type {
return switch (value.sema.id) {
.instruction => blk: {
const instruction = value.get_payload(.instruction);
break :blk switch (instruction.id) {
.integer_binary_operation => block: {
const bin_op = instruction.get_payload(.integer_binary_operation);
break :block bin_op.type;
},
.load => block: {
const load = instruction.get_payload(.load);
break :block load.type;
},
.call => {
const call = instruction.get_payload(.call);
const function_type = call.get_function_type();
return function_type.abi.original_return_type;
},
.integer_compare => {
return &instance.threads[value.sema.thread].integers[0].type;
},
.trailing_zeroes => {
const tz = instruction.get_payload(.trailing_zeroes);
return tz.value.get_type();
},
.leading_zeroes => {
const lz = instruction.get_payload(.leading_zeroes);
return lz.value.get_type();
},
.local_symbol => {
const local_symbol = instruction.get_payload(.local_symbol);
return local_symbol.pointer_type;
},
.argument_storage => {
const argument_symbol = instruction.get_payload(.argument_storage);
return argument_symbol.pointer_type;
},
.cast => {
const cast = instruction.get_payload(.cast);
return cast.type;
},
.insert_value => {
const insert_value = instruction.get_payload(.insert_value);
return insert_value.type;
},
.phi => {
const phi = instruction.get_payload(.phi);
return phi.type;
},
else => |t| @panic(@tagName(t)),
};
},
.constant_int => {
const constant_int = value.get_payload(.constant_int);
return constant_int.type;
},
.global_symbol => {
const global_symbol = value.get_payload(.global_symbol);
return global_symbol.pointer_type;
},
.constant_struct => {
const constant_struct = value.get_payload(.constant_struct);
return constant_struct.type;
},
else => |t| @panic(@tagName(t)),
};
}
};
const Type = struct {
llvm: ?*LLVM.Type = null,
llvm_debug: ?*LLVM.DebugInfo.Type = null,
// TODO: ZIG BUG: if this is a packed struct, the initialization is broken
sema: struct {
thread: u16,
id: Id,
resolved: bool,
reserved: u7 = 0,
},
size: u64,
bit_size: u64,
alignment: u32,
const Id = enum(u8){
unresolved,
void,
noreturn,
integer,
array,
opaque_pointer,
typed_pointer,
function,
@"struct",
bitfield,
anonymous_struct,
};
const Integer = struct {
type: Type,
signedness: Signedness,
const Signedness = enum(u1){
unsigned,
signed,
};
};
const Array = struct {
type: Type,
descriptor: Descriptor,
const Descriptor = struct{
element_count: u64,
element_type: *Type,
};
};
const Function = struct{
type: Type,
abi: compiler.Function.Abi,
};
const Struct = struct {
type: Type,
declaration: Declaration,
fields: []const *AggregateField,
};
const AnonymousStruct = struct{
type: Type,
fields: []const *AggregateField,
};
const Bitfield = struct{
type: Type,
declaration: Declaration,
fields: []const *AggregateField,
backing_type: *Type,
};
const AggregateField = struct{
type: *Type,
parent: *Type,
member_offset: u64,
name: u32,
index: u32,
line: u32,
column: u32,
};
const TypedPointer = struct{
type: Type,
descriptor: Descriptor,
const Descriptor = struct{
pointee: *Type,
};
};
const id_to_type_map = std.EnumArray(Id, type).init(.{
.unresolved = void,
.void = void,
.noreturn = void,
.integer = Integer,
.array = Array,
.opaque_pointer = void,
.function = Type.Function,
.@"struct" = Type.Struct,
.bitfield = Type.Bitfield,
.typed_pointer = TypedPointer,
.anonymous_struct = AnonymousStruct,
});
fn get_payload(ty: *Type, comptime id: Id) *id_to_type_map.get(id) {
assert(ty.sema.id == id);
return @fieldParentPtr("type", ty);
}
fn clone(ty: *Type, args: struct{
destination_thread: *Thread,
source_thread_index: u16,
}) *Type {
assert(args.destination_thread.get_index() == 0);
const result: *Type = if (args.destination_thread.cloned_types.get(ty)) |result| blk: {
assert(result.sema.thread == args.destination_thread.get_index());
break :blk result;
} else blk: {
assert(ty.sema.resolved);
assert(ty.sema.thread == args.source_thread_index);
const result: *Type = switch (ty.sema.id) {
.integer => {
const source_thread = &instance.threads[args.source_thread_index];
const source_integer_type = ty.get_payload(.integer);
const index = @divExact(@intFromPtr(source_integer_type) - @intFromPtr(&source_thread.integers), @sizeOf(Type.Integer));
break :blk &args.destination_thread.integers[index].type;
},
.function => block: {
const source_function_type = ty.get_payload(.function);
const original_return_type = source_function_type.abi.original_return_type.clone(.{
.destination_thread = args.destination_thread,
.source_thread_index = args.source_thread_index,
});
const abi_return_type = source_function_type.abi.abi_return_type.clone(.{
.destination_thread = args.destination_thread,
.source_thread_index = args.source_thread_index,
});
const return_type_abi = source_function_type.abi.return_type_abi.clone(.{
.destination_thread = args.destination_thread,
.source_thread_index = args.source_thread_index,
});
var original_argument_types = PinnedArray(*Type){};
for (source_function_type.abi.original_argument_types) |original_argument_type| {
const new = original_argument_type.clone(.{
.destination_thread = args.destination_thread,
.source_thread_index = args.source_thread_index,
});
_ = original_argument_types.append(new);
}
var abi_argument_types = PinnedArray(*Type){};
for (source_function_type.abi.original_argument_types) |abi_argument_type| {
const new = abi_argument_type.clone(.{
.destination_thread = args.destination_thread,
.source_thread_index = args.source_thread_index,
});
_ = abi_argument_types.append(new);
}
var argument_type_abis = PinnedArray(compiler.Function.Abi.Information){};
for (source_function_type.abi.argument_types_abi) |argument_type_abi| {
const new = argument_type_abi.clone(.{
.destination_thread = args.destination_thread,
.source_thread_index = args.source_thread_index,
});
_ = argument_type_abis.append(new);
}
const function_type = args.destination_thread.function_types.append(.{
.type = source_function_type.type,
.abi = .{
.return_type_abi = return_type_abi,
.original_argument_types = original_argument_types.const_slice(),
.original_return_type = original_return_type,
.abi_return_type = abi_return_type,
.abi_argument_types = abi_argument_types.const_slice(),
.argument_types_abi = argument_type_abis.const_slice(),
.calling_convention = source_function_type.abi.calling_convention,
},
});
break :block &function_type.type;
},
else => |t| @panic(@tagName(t)),
};
result.llvm = null;
result.sema.thread = args.destination_thread.get_index();
args.destination_thread.cloned_types.put_no_clobber(ty, result);
break :blk result;
};
assert(result.llvm == null);
assert(result.sema.thread == args.destination_thread.get_index());
return result;
}
fn is_aggregate(ty: *Type) bool {
return switch (ty.sema.id) {
.unresolved => unreachable,
.array => unreachable,
.function => unreachable,
.void,
.noreturn,
.integer,
.opaque_pointer,
.typed_pointer,
.bitfield,
=>
false,
.@"struct", .anonymous_struct => true,
};
}
fn returns_nothing(ty: *Type) bool {
return switch (ty.sema.id) {
.void, .noreturn => true,
else => false,
};
}
const HomogeneousAggregate = struct{
type: *Type,
count: u32,
};
fn get_homogeneous_aggregate(ty: *Type) ?HomogeneousAggregate {
switch (ty.sema.id) {
.@"struct" => {
const struct_type = ty.get_payload(.@"struct");
for (struct_type.fields) |field| {
while (field.type.sema.id == .array) {
unreachable;
}
if (field.type.get_homogeneous_aggregate()) |homogeneous_aggregate| {
_ = homogeneous_aggregate; // autofix
unreachable;
} else {
return null;
}
unreachable;
}
unreachable;
},
.integer => {
return null;
},
else => |t| @panic(@tagName(t)),
}
}
fn get_integer_index(ty: *Type) usize {
assert(ty.sema.id == .integer);
const thread = &instance.threads[ty.sema.thread];
comptime assert(@offsetOf(Type.Integer, "type") == 0);
const index = @divExact(@intFromPtr(ty) - @intFromPtr(&thread.integers[0]), @sizeOf(Type.Integer));
return index;
}
};
const Keyword = enum{
@"break",
@"else",
@"for",
@"if",
@"loop",
@"orelse",
@"undefined",
};
const Intrinsic = enum{
assert,
int_from_pointer,
leading_zeroes,
require,
size,
trailing_zeroes,
trap,
transmute,
@"unreachable",
};
fn parse_keyword(identifier: []const u8) u32 {
assert(identifier.len > 0);
if (identifier[0] != '"') {
inline for (@typeInfo(Keyword).Enum.fields) |keyword| {
if (byte_equal(identifier, keyword.name)) {
return keyword.value;
}
}
}
return ~@as(u32, 0);
}
const Scope = struct {
declarations: PinnedHashMap(u32, *Declaration) = .{},
parent: ?*Scope,
llvm: ?*LLVM.DebugInfo.Scope = null,
line: u32,
column: u32,
file: u32,
id: Id,
pub fn get_global_declaration(scope: *Scope, name: u32) ?*GlobalDeclaration {
assert(scope.id == .file);
if (scope.get_declaration_one_level(name)) |decl_ref| {
return decl_ref.*.get_payload(.global);
} else {
return null;
}
}
pub fn get_declaration_one_level(scope: *Scope, name: u32) ?Declaration.Reference {
const result = scope.declarations.get_pointer(name);
return result;
}
const DeclarationLookupResult = struct {
declaration: Declaration.Reference,
scope: *Scope,
};
pub fn get_declaration(scope: *Scope, name: u32) ?DeclarationLookupResult{
var s: ?*Scope = scope;
while (s) |search_scope| {
if (search_scope.get_declaration_one_level(name)) |declaration| {
return .{
.declaration = declaration,
.scope = search_scope,
};
}
s = search_scope.parent;
}
return null;
}
const Id = enum{
file,
function,
local,
};
};
const Range = struct{
start: u32,
end: u32,
};
const ArgumentDeclaration = struct {
declaration: Declaration,
fn to_symbol(argument_declaration: *ArgumentDeclaration) *ArgumentSymbol {
return @alignCast(@fieldParentPtr("argument_declaration", argument_declaration));
}
};
const LocalDeclaration = struct {
declaration: Declaration,
fn to_symbol(local_declaration: *LocalDeclaration) *LocalSymbol {
return @alignCast(@fieldParentPtr("local_declaration", local_declaration));
}
};
const GlobalDeclaration = struct {
declaration: Declaration,
id: Id,
const Id = enum(u8) {
file,
unresolved_import,
global_symbol,
};
const id_to_global_declaration_map = std.EnumArray(Id, type).init(.{
.file = File,
.global_symbol = GlobalSymbol,
.unresolved_import = Import,
});
fn get_payload(global_declaration: *GlobalDeclaration, comptime id: Id) *id_to_global_declaration_map.get(id) {
assert(global_declaration.id == id);
return @alignCast(@fieldParentPtr("global_declaration", global_declaration));
}
fn to_symbol(global_declaration: *GlobalDeclaration) *GlobalSymbol {
assert(global_declaration.id == .global_symbol);
return @alignCast(@fieldParentPtr("global_declaration", global_declaration));
}
const Reference = **GlobalDeclaration;
};
const BasicBlock = struct{
value: Value,
instructions: PinnedArray(*Instruction) = .{},
predecessors: PinnedArray(*BasicBlock) = .{},
is_terminated: bool = false,
command_node: CommandList.Node = .{
.data = {},
},
pub const Reference = **BasicBlock;
const CommandList = std.DoublyLinkedList(void);
pub fn get_llvm(basic_block: *BasicBlock) *LLVM.Value.BasicBlock{
return basic_block.value.llvm.?.toBasicBlock() orelse unreachable;
}
};
const Declaration = struct {
name: u32,
id: Id,
line: u32,
column: u32,
scope: *Scope,
const Reference = **Declaration;
const Id = enum {
local,
global,
argument,
@"struct",
@"bitfield",
};
const id_to_declaration_map = std.EnumArray(Id, type).init(.{
.global = GlobalDeclaration,
.local = LocalDeclaration,
.argument = ArgumentDeclaration,
.@"struct" = Type.Struct,
.bitfield = Type.Bitfield,
});
fn get_payload(declaration: *Declaration, comptime id: Id) *id_to_declaration_map.get(id) {
assert(declaration.id == id);
return @fieldParentPtr("declaration", declaration);
}
};
const Function = struct{
declaration: Function.Declaration,
entry_block: *BasicBlock,
stack_slots: PinnedArray(*LocalSymbol) = .{},
scope: Function.Scope,
arguments: PinnedArray(*ArgumentSymbol) = .{},
const Attributes = struct{
};
const Attribute = enum{
cc,
pub const Mask = std.EnumSet(Function.Attribute);
};
const Abi = struct{
original_return_type: *Type,
original_argument_types: []const *Type,
abi_return_type: *Type,
abi_argument_types: []const *Type,
return_type_abi: Function.Abi.Information,
argument_types_abi: []const Function.Abi.Information,
calling_convention: CallingConvention,
const Kind = union(enum) {
ignore,
direct,
direct_pair: [2]*Type,
direct_coerce: *Type,
direct_coerce_int,
direct_split_struct_i32,
expand_coerce,
indirect: struct {
type: *Type,
alignment: u32,
},
expand,
};
const Attributes = struct {
by_reg: bool = false,
zero_extend: bool = false,
sign_extend: bool = false,
realign: bool = false,
by_value: bool = false,
};
const Information = struct{
kind: Kind = .direct,
indices: [2]u16 = .{0, 0},
attributes: Function.Abi.Attributes = .{},
fn clone(abi_info: *const Information, args: struct{
destination_thread: *Thread,
source_thread_index: u16,
}) Information {
_ = args;
const kind: Kind = switch (abi_info.kind) {
.direct => .direct,
else => |t| @panic(@tagName(t)),
};
const indices = abi_info.indices;
const attributes = abi_info.attributes;
return .{
.kind = kind,
.indices = indices,
.attributes = attributes,
};
}
};
};
const Declaration = struct {
attributes: Attributes = .{},
global_symbol: GlobalSymbol,
fn get_function_type(declaration: *Function.Declaration) *Type.Function {
const ty = declaration.global_symbol.type;
const function_type = ty.get_payload(.function);
return function_type;
}
fn clone(declaration: Function.Declaration, destination_thread: *Thread) *Function.Declaration{
assert(declaration.global_symbol.value.sema.resolved);
const source_thread_index = declaration.global_symbol.value.sema.thread;
const source_thread = &instance.threads[source_thread_index];
assert(source_thread != destination_thread);
const type_cloned = declaration.global_symbol.type.clone(.{
.destination_thread = destination_thread,
.source_thread_index = source_thread_index,
});
assert(type_cloned.sema.thread == destination_thread.get_index());
const result = destination_thread.external_functions.append(.{
.global_symbol = .{
.type = type_cloned,
.pointer_type = get_typed_pointer(destination_thread, .{
.pointee = type_cloned,
}),
.attributes = declaration.global_symbol.attributes,
.global_declaration = declaration.global_symbol.global_declaration,
.alignment = declaration.global_symbol.alignment,
.value = declaration.global_symbol.value,
.id = declaration.global_symbol.id,
},
});
result.global_symbol.attributes.@"export" = false;
result.global_symbol.attributes.@"extern" = true;
result.global_symbol.value.sema.thread = destination_thread.get_index();
result.global_symbol.value.llvm = null;
return result;
}
};
const Scope = struct {
scope: compiler.Scope,
pub fn lookup_declaration(scope: *Function.Scope, parent: bool) ?*compiler.Declaration {
_ = scope;
_ = parent;
unreachable;
}
};
};
const ConstantInt = struct{
value: Value,
n: u64,
type: *Type,
};
const ConstantArray = struct{
value: Value,
values: []const *Value,
type: *Type,
};
const ConstantStruct = struct{
value: Value,
values: []const *Value,
type: *Type,
};
const Undefined = struct{
value: Value,
type: *Type,
};
const ConstantBitfield = struct{
value: Value,
n: u64,
type: *Type,
};
const Instruction = struct{
value: Value,
basic_block: ?*BasicBlock = null,
scope: *Scope,
line: u32,
column: u32,
id: Id,
const Id = enum{
abi_argument,
abi_indirect_argument,
argument_storage,
branch,
call,
cast,
debug_argument,
debug_local,
extract_value,
get_element_pointer,
insert_value,
integer_binary_operation,
integer_compare,
jump,
leading_zeroes,
load,
local_symbol,
memcpy,
phi,
ret,
ret_void,
store,
trailing_zeroes,
trap,
@"unreachable",
};
const id_to_instruction_map = std.EnumArray(Id, type).init(.{
.abi_argument = AbiArgument,
.abi_indirect_argument = ArgumentSymbol,
.argument_storage = ArgumentSymbol,
.branch = Branch,
.call = Call,
.cast = Cast,
.debug_argument = DebugArgument,
.debug_local = DebugLocal,
.extract_value = ExtractValue,
.get_element_pointer = GEP,
.insert_value = InsertValue,
.integer_binary_operation = IntegerBinaryOperation,
.integer_compare = IntegerCompare,
.jump = Jump,
.leading_zeroes = LeadingZeroes,
.local_symbol = LocalSymbol,
.load = Load,
.memcpy = Memcpy,
.phi = Phi,
.ret = Return,
.ret_void = Instruction,
.store = Store,
.trailing_zeroes = TrailingZeroes,
.trap = Instruction,
.@"unreachable" = Instruction,
});
fn get_payload(instruction: *Instruction, comptime id: Id) *id_to_instruction_map.get(id) {
assert(instruction.id == id);
return @fieldParentPtr("instruction", instruction);
}
};
const AbiArgument = struct{
instruction: Instruction,
index: u32,
};
const ExtractValue = struct{
instruction: Instruction,
aggregate: *Value,
index: u32,
type: *Type,
};
const InsertValue = struct{
instruction: Instruction,
aggregate: *Value,
value: *Value,
index: u32,
type: *Type,
};
const GEP = struct {
instruction: Instruction,
pointer: *Value,
index: *Value,
aggregate_type: *Type,
type: *Type,
is_struct: bool,
};
const IntegerBinaryOperation = struct {
instruction: Instruction,
left: *Value,
right: *Value,
type: *Type,
id: Id,
const Id = enum{
add,
sub,
mul,
udiv,
sdiv,
@"and",
@"or",
@"xor",
shift_left,
arithmetic_shift_right,
logical_shift_right,
};
};
const IntegerCompare = struct {
instruction: Instruction,
left: *Value,
right: *Value,
id: Id,
const Id = enum{
unsigned_greater,
unsigned_greater_equal,
signed_greater,
signed_greater_equal,
unsigned_less,
unsigned_less_equal,
signed_less,
signed_less_equal,
equal,
not_equal,
not_zero,
};
};
const Branch = struct {
instruction: Instruction,
condition: *Value,
taken: *BasicBlock,
not_taken: *BasicBlock,
};
const Jump = struct {
instruction: Instruction,
basic_block: *BasicBlock,
};
const Call = struct{
instruction: Instruction,
callable: *Value,
arguments: []const *Value,
calling_convention: CallingConvention,
fn get_function_type(call: *Call) *Type.Function{
switch (call.callable.sema.id) {
.global_symbol => {
const global_symbol = call.callable.get_payload(.global_symbol);
switch (global_symbol.id) {
.function_definition, .function_declaration => {
const function_declaration = global_symbol.get_payload(.function_declaration);
const function_type = function_declaration.get_function_type();
return function_type;
},
else => |t| @panic(@tagName(t)),
}
},
.instruction => {
const callable_instruction = call.callable.get_payload(.instruction);
_ = callable_instruction; // autofix
const callable_type = call.callable.get_type();
switch (callable_type.sema.id) {
.typed_pointer => {
const typed_pointer = callable_type.get_payload(.typed_pointer);
switch (typed_pointer.descriptor.pointee.sema.id) {
.function => {
const function_type = typed_pointer.descriptor.pointee.get_payload(.function);
return function_type;
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
}
};
const Cast = struct{
instruction: Instruction,
value: *Value,
type: *Type,
id: Id,
const Id = enum{
bitfield_from_int,
int_from_bitfield,
int_from_pointer,
truncate,
};
};
const Load = struct {
instruction: Instruction,
value: *Value,
type: *Type,
alignment: u32,
is_volatile: bool,
};
const Store = struct {
instruction: Instruction,
destination: *Value,
source: *Value,
alignment: u32,
is_volatile: bool,
};
const Phi = struct {
instruction: Instruction,
type: *Type,
nodes: PinnedArray(Node) = .{},
const Node = struct {
value: *Value,
basic_block: *BasicBlock,
};
};
const Return = struct{
instruction: Instruction,
value: *Value,
};
const Import = struct {
global_declaration: GlobalDeclaration,
hash: u32,
resolved: bool = false,
files: PinnedArray(*File) = .{},
};
const LocalBlock = struct {
scope: Scope,
terminated: bool = false,
};
fn get_power_of_two_byte_count_from_bit_count(bit_count: u32) u32 {
if (bit_count == 0) unreachable;
if (bit_count <= 8) return 1;
if (bit_count <= 16) return 2;
if (bit_count <= 32) return 4;
if (bit_count <= 64) return 8;
unreachable;
}
const LeadingZeroes = struct{
instruction: Instruction,
value: *Value,
};
const TrailingZeroes = struct{
instruction: Instruction,
value: *Value,
};
const DebugLocal = struct{
instruction: Instruction,
local: *LocalSymbol,
};
const DebugArgument = struct{
instruction: Instruction,
argument: *ArgumentSymbol,
};
const Thread = struct{
arena: *Arena = undefined,
functions: PinnedArray(Function) = .{},
external_functions: PinnedArray(Function.Declaration) = .{},
identifiers: PinnedHashMap(u32, []const u8) = .{},
constant_ints: PinnedArray(ConstantInt) = .{},
constant_arrays: PinnedArray(ConstantArray) = .{},
constant_structs: PinnedArray(ConstantStruct) = .{},
constant_bitfields: PinnedArray(ConstantBitfield) = .{},
basic_blocks: PinnedArray(BasicBlock) = .{},
task_system: TaskSystem = .{},
debug_info_file_map: PinnedHashMap(u32, LLVMFile) = .{},
branches: PinnedArray(Branch) = .{},
jumps: PinnedArray(Jump) = .{},
calls: PinnedArray(Call) = .{},
integer_binary_operations: PinnedArray(IntegerBinaryOperation) = .{},
integer_compares: PinnedArray(IntegerCompare) = .{},
loads: PinnedArray(Load) = .{},
stores: PinnedArray(Store) = .{},
phis: PinnedArray(Phi) = .{},
returns: PinnedArray(Return) = .{},
geps: PinnedArray(GEP) = .{},
lazy_expressions: PinnedArray(LazyExpression) = .{},
local_lazy_expressions: PinnedArray(LocalLazyExpression) = .{},
imports: PinnedArray(Import) = .{},
local_blocks: PinnedArray(LocalBlock) = .{},
local_symbols: PinnedArray(LocalSymbol) = .{},
argument_symbols: PinnedArray(ArgumentSymbol) = .{},
global_variables: PinnedArray(GlobalVariable) = .{},
abi_arguments: PinnedArray(AbiArgument) = .{},
standalone_instructions: PinnedArray(Instruction) = .{},
leading_zeroes: PinnedArray(LeadingZeroes) = .{},
trailing_zeroes: PinnedArray(TrailingZeroes) = .{},
casts: PinnedArray(Cast) = .{},
memcopies: PinnedArray(Memcpy) = .{},
undefined_values: PinnedArray(Undefined) = .{},
insert_values: PinnedArray(InsertValue) = .{},
extract_values: PinnedArray(ExtractValue) = .{},
debug_arguments: PinnedArray(DebugArgument) = .{},
debug_locals: PinnedArray(DebugLocal) = .{},
function_types: PinnedArray(Type.Function) = .{},
array_type_map: PinnedHashMap(Type.Array.Descriptor, *Type) = .{},
typed_pointer_type_map: PinnedHashMap(Type.TypedPointer.Descriptor, *Type) = .{},
array_types: PinnedArray(Type.Array) = .{},
typed_pointer_types: PinnedArray(Type.TypedPointer) = .{},
structs: PinnedArray(Type.Struct) = .{},
anonymous_structs: PinnedArray(Type.AnonymousStruct) = .{},
two_struct_map: PinnedHashMap([2]*Type, *Type) = .{},
fields: PinnedArray(Type.AggregateField) = .{},
bitfields: PinnedArray(Type.Bitfield) = .{},
cloned_types: PinnedHashMap(*Type, *Type) = .{},
analyzed_file_count: u32 = 0,
assigned_file_count: u32 = 0,
llvm: struct {
context: *LLVM.Context,
module: *LLVM.Module,
attributes: LLVM.Attributes,
target_machine: *LLVM.Target.Machine,
object: ?[]const u8 = null,
intrinsic_ids: std.EnumArray(LLVMIntrinsic, LLVM.Value.IntrinsicID),
fixed_intrinsic_functions: std.EnumArray(LLVMFixedIntrinsic, *LLVM.Value.Constant.Function),
intrinsic_id_map: PinnedHashMap([]const u8, LLVM.Value.IntrinsicID) = .{},
intrinsic_function_map: PinnedHashMap(LLVMIntrinsic.Parameters, *LLVM.Value.Constant.Function) = .{},
} = undefined,
integers: [128]Type.Integer = blk: {
var integers: [128]Type.Integer = undefined;
for ([_]Type.Integer.Signedness{.unsigned, .signed }) |signedness| {
for (1..64 + 1) |bit_count| {
const integer_type_index = @intFromEnum(signedness) * @as(usize, 64) + bit_count - 1;
const byte_count = get_power_of_two_byte_count_from_bit_count(bit_count);
integers[integer_type_index] = .{
.type = .{
.sema = .{
.thread = undefined,
.id = .integer,
.resolved = true,
},
.size = byte_count,
.bit_size = bit_count,
.alignment = byte_count,
},
.signedness = signedness,
};
}
}
break :blk integers;
},
void: Type = .{
.sema = .{
.thread = undefined,
.id = .void,
.resolved = true,
},
.size = 0,
.bit_size = 0,
.alignment = 0,
},
noreturn: Type = .{
.sema = .{
.thread = undefined,
.id = .noreturn,
.resolved = true,
},
.size = 0,
.bit_size = 0,
.alignment = 0,
},
opaque_pointer: Type = .{
.sema = .{
.thread = undefined,
.id = .opaque_pointer,
.resolved = true,
},
.bit_size = 64,
.size = 8,
.alignment = 8,
},
discard_count: u64 = 0,
handle: std.Thread = undefined,
generate_debug_information: bool = true,
fn add_thread_work(thread: *Thread, job: Job) void {
@atomicStore(@TypeOf(thread.task_system.state), &thread.task_system.state, .running, .seq_cst);
assert(@atomicLoad(@TypeOf(thread.task_system.program_state), &thread.task_system.program_state, .seq_cst) != .none);
thread.task_system.job.queue_job(job);
}
fn add_control_work(thread: *Thread, job: Job) void {
thread.task_system.ask.queue_job(job);
}
fn get_worker_job(thread: *Thread) ?Job {
if (thread.task_system.job.get_next_job()) |job| {
// std.debug.print("[WORKER] Thread #{} getting job {s}\n", .{thread.get_index(), @tagName(job.id)});
return job;
}
return null;
}
fn get_control_job(thread: *Thread) ?Job {
if (thread.task_system.ask.get_next_job()) |job| {
// std.debug.print("[CONTROL] Getting job {s} from thread #{}\n", .{@tagName(job.id), thread.get_index()});
return job;
}
return null;
}
pub fn get_index(thread: *Thread) u16 {
const index = @divExact(@intFromPtr(thread) - @intFromPtr(instance.threads.ptr), @sizeOf(Thread));
return @intCast(index);
}
};
const LLVMFixedIntrinsic = enum{
trap,
};
const LLVMIntrinsic = enum{
leading_zeroes,
trailing_zeroes,
const Parameters = struct{
id: LLVM.Value.IntrinsicID,
types: []const *LLVM.Type,
};
};
const LLVMFile = struct {
file: *LLVM.DebugInfo.File,
compile_unit: *LLVM.DebugInfo.CompileUnit,
builder: *LLVM.DebugInfo.Builder,
};
const Job = packed struct(u64) {
offset: u32 = 0,
count: u24 = 0,
id: Id,
const Id = enum(u8){
analyze_file,
notify_file_resolved,
notify_analysis_complete,
llvm_generate_ir,
llvm_notify_ir_done,
llvm_optimize,
llvm_emit_object,
llvm_notify_object_done,
compile_c_source_file,
};
};
const TaskSystem = struct{
job: JobQueue = .{},
ask: JobQueue = .{},
program_state: ProgramState = .none,
state: ThreadState = .idle,
const ProgramState = enum{
none,
c_source_file,
c_source_file_done,
analysis,
analysis_resolution,
llvm_generate_ir,
llvm_emit_object,
llvm_finished_object,
};
const ThreadState = enum{
idle,
running,
};
};
const JobQueue = struct{
entries: [job_entry_count]Job align(cache_line_size) = [1]Job{@bitCast(@as(u64, 0))} ** job_entry_count,
queuer: struct {
to_do: u64 = 0,
next_write: u64 = 0,
} = .{},
worker: struct {
completed: u64 = 0,
next_read: u64 = 0,
} = .{},
reserved: [padding_byte_count]u8 = [1]u8{0} ** padding_byte_count,
const job_entry_count = 64;
const valuable_size = job_entry_count * @sizeOf(Job) + 4 * @sizeOf(u64);
const real_size = std.mem.alignForward(usize, valuable_size, cache_line_size);
const padding_byte_count = real_size - valuable_size;
comptime {
assert(@sizeOf(JobQueue) % cache_line_size == 0);
}
fn queue_job(job_queue: *JobQueue, job: Job) void {
// std.debug.print("[0x{x}] Queueing job '{s}'\n", .{@intFromPtr(job_queue) & 0xfff, @tagName(job.id)});
const index = job_queue.queuer.next_write;
if (weak_memory_model) @fence(.seq_cst);
assert(index + 1 != @atomicLoad(@TypeOf(job_queue.worker.next_read), &job_queue.worker.next_read, .seq_cst));
if (weak_memory_model) @fence(.seq_cst);
const ptr = &job_queue.entries[index];
//if (job.id == .analyze_file and job.count == 0 and job.offset == 0) unreachable;
// std.debug.print("Before W 0x{x} - 0x{x}\n", .{@intFromPtr(ptr), job.offset});
ptr.* = job;
if (weak_memory_model) @fence(.seq_cst);
// std.debug.print("After W 0x{x}\n", .{@intFromPtr(ptr)});
job_queue.queuer.to_do += 1;
if (weak_memory_model) @fence(.seq_cst);
job_queue.queuer.next_write = index + 1;
if (weak_memory_model) @fence(.seq_cst);
}
fn get_next_job(job_queue: *JobQueue) ?Job{
const index = job_queue.worker.next_read;
if (weak_memory_model) @fence(.seq_cst);
const nw = @atomicLoad(@TypeOf(job_queue.queuer.next_write), &job_queue.queuer.next_write, .seq_cst);
if (weak_memory_model) @fence(.seq_cst);
if (index != nw) {
if (weak_memory_model) @fence(.seq_cst);
job_queue.worker.next_read += 1;
if (weak_memory_model) @fence(.seq_cst);
const job_ptr = &job_queue.entries[index];
if (weak_memory_model) @fence(.seq_cst);
const job = job_ptr.*;
if (weak_memory_model) @fence(.seq_cst);
// std.debug.print("[0x{x}] Getting job #{} (0x{x} -\n{}\n) (nw: {})\n", .{@intFromPtr(job_queue) & 0xfff, index, @intFromPtr(job), job.*, nw});
//if (job.id == .analyze_file and job.count == 0 and job.offset == 0) unreachable;
return job;
}
return null;
}
fn complete_job(job_queue: *JobQueue) void {
job_queue.worker.completed += 1;
}
};
const Instance = struct{
files: PinnedArray(File) = .{},
file_paths: PinnedArray(u32) = .{},
file_mutex: std.Thread.Mutex = .{},
units: PinnedArray(Unit) = .{},
arena: *Arena = undefined,
threads: []Thread = undefined,
paths: struct {
cwd: []const u8,
executable: []const u8,
executable_directory: []const u8,
} = .{
.cwd = &.{},
.executable = &.{},
.executable_directory = &.{},
},
fn path_from_cwd(i: *Instance, arena: *Arena, relative_path: []const u8) []const u8 {
return arena.join(&.{i.paths.cwd, "/", relative_path}) catch unreachable;
}
fn path_from_compiler(i: *Instance, arena: *Arena, relative_path: []const u8) []const u8 {
return arena.join(&.{i.paths.executable_directory, "/", relative_path}) catch unreachable;
}
};
const File = struct{
global_declaration: GlobalDeclaration,
scope: File.Scope,
source_code: []const u8,
path: []const u8,
functions: Range = .{
.start = 0,
.end = 0,
},
state: State = .queued,
thread: u32 = 0,
interested_threads: PinnedArray(u32) = .{},
interested_files: PinnedArray(*File) = .{},
imports: PinnedArray(*Import) = .{},
values_per_import: PinnedArray(PinnedArray(*Value)) = .{},
resolved_import_count: u32 = 0,
local_lazy_expressions: PinnedArray(*LocalLazyExpression) = .{},
pub fn get_index(file: *File) u32 {
return instance.files.get_index(file);
}
pub fn get_directory_path(file: *const File) []const u8 {
return std.fs.path.dirname(file.path) orelse unreachable;
}
const State = enum{
queued,
analyzing,
};
const Scope = struct {
scope: compiler.Scope,
};
};
var instance = Instance{};
const do_codegen = true;
const codegen_backend = CodegenBackend.llvm;
const CodegenBackend = union(enum){
llvm: struct {
split_object_per_thread: bool,
},
};
fn add_file(file_absolute_path: []const u8, interested_threads: []const u32) u32 {
instance.file_mutex.lock();
defer instance.file_mutex.unlock();
const hash = hash_bytes(file_absolute_path);
const new_file = instance.files.add_one();
_ = instance.file_paths.append(hash);
const new_file_index = instance.files.get_index(new_file);
new_file.* = .{
.global_declaration = .{
.declaration = .{
.name = std.math.maxInt(u32),
.id = .global,
.line = 1,
.column = 1,
.scope = &new_file.scope.scope,
},
.id = .file,
},
.scope = .{
.scope = .{
.id = .file,
.parent = null,
.line = 1,
.column = 1,
.file = new_file_index,
},
},
.source_code = &.{},
.path = file_absolute_path,
};
new_file.interested_threads.append_slice(interested_threads);
return new_file_index;
}
const Arch = enum {
x86_64,
aarch64,
};
const Os = enum {
linux,
macos,
windows,
};
const Abi = enum {
none,
gnu,
musl,
};
const Optimization = enum {
none,
debug_prefer_fast,
debug_prefer_size,
lightly_optimize_for_speed,
optimize_for_speed,
optimize_for_size,
aggressively_optimize_for_speed,
aggressively_optimize_for_size,
};
fn error_insufficient_arguments_command(command: []const u8) noreturn {
@setCold(true);
write("Command '");
write(command);
write("' requires at least one argument\n");
fail();
}
fn error_unterminated_argument(argument: []const u8) noreturn {
@setCold(true);
write("Argument '");
write(argument);
write("' must be terminated\n");
fail();
}
const Target = struct {
arch: Arch,
os: Os,
abi: Abi,
};
const Unit = struct {
descriptor: Descriptor,
const Descriptor = struct {
main_source_file_path: []const u8,
executable_path: []const u8,
object_path: []const u8,
c_source_files: []const []const u8,
c_object_files: []const []const u8,
target: Target,
optimization: Optimization,
generate_debug_information: bool,
link_libc: bool,
link_libcpp: bool,
codegen_backend: CodegenBackend,
};
fn compile(descriptor: Descriptor) *Unit {
const unit = instance.units.add_one();
unit.* = .{
.descriptor = descriptor,
};
if (descriptor.c_source_files.len > 0) {
LLVM.initializeAll();
} else {
switch (unit.descriptor.target.arch) {
inline else => |a| {
const arch = @field(LLVM, @tagName(a));
arch.initializeTarget();
arch.initializeTargetInfo();
arch.initializeTargetMC();
arch.initializeAsmPrinter();
arch.initializeAsmParser();
},
}
}
var last_assigned_thread_index: u32 = 0;
var c_objects = PinnedArray([]const u8){};
for (descriptor.c_source_files) |source_file| {
const extension_start = last_byte(source_file, '.') orelse fail();
const name = std.fs.path.basename(source_file[0..extension_start]);
const object_path = instance.arena.join(&.{"nat/o/", name, ".o"}) catch unreachable;
_ = c_objects.append(object_path);
}
unit.descriptor.c_object_files = c_objects.slice();
const main_source_file_absolute = instance.path_from_cwd(instance.arena, unit.descriptor.main_source_file_path);
const new_file_index = add_file(main_source_file_absolute, &.{});
instance.threads[last_assigned_thread_index].task_system.program_state = .analysis;
instance.threads[last_assigned_thread_index].add_thread_work(Job{
.offset = new_file_index,
.count = 1,
.id = .analyze_file,
});
last_assigned_thread_index += 1;
for (descriptor.c_source_files, 0..) |_, index| {
const thread_index = last_assigned_thread_index % instance.threads.len;
const thread = &instance.threads[thread_index];
thread.task_system.program_state = .analysis;
thread.add_thread_work(Job{
.offset = @intCast(index),
.count = 1,
.id = .compile_c_source_file,
});
last_assigned_thread_index += 1;
}
control_thread(unit, last_assigned_thread_index);
return unit;
}
};
fn control_thread(unit: *Unit, lati: u32) void {
var last_assigned_thread_index: u32 = lati;
var first_ir_done = false;
var total_is_done: bool = false;
var iterations_without_work_done: u32 = 0;
while (!total_is_done) {
total_is_done = first_ir_done;
var task_done_this_iteration: u32 = 0;
for (instance.threads, 0..) |*thread, i| {
const completed = @atomicLoad(u64, &thread.task_system.job.worker.completed, .seq_cst);
// INFO: No need to do an atomic load here since it's only this thread writing to the value
const program_state = thread.task_system.program_state;
const to_do = thread.task_system.job.queuer.to_do;
total_is_done = total_is_done and completed == to_do and if (@intFromEnum(program_state) >= @intFromEnum(TaskSystem.ProgramState.analysis) and (thread.functions.length > 0 or thread.global_variables.length > 0)) program_state == .llvm_finished_object else true;
var previous_job: Job = undefined;
while (thread.get_control_job()) |job| {
assert(!(previous_job.id == job.id and previous_job.offset == job.offset and previous_job.count == job.count));
switch (job.id) {
.analyze_file => {
const analyze_file_path_hash = job.offset;
const interested_file_index = job.count;
// std.debug.print("[CONTROL] Trying to retrieve file path hash (0x{x}) interested file index: {} in thread #{}\n", .{analyze_file_path_hash, interested_file_index, thread.get_index()});
assert(analyze_file_path_hash != 0);
for (instance.file_paths.slice()) |file_path_hash| {
if (analyze_file_path_hash == file_path_hash) {
fail();
}
} else {
const thread_index = last_assigned_thread_index % instance.threads.len;
last_assigned_thread_index += 1;
const file_absolute_path = thread.identifiers.get(analyze_file_path_hash).?;
const interested_thread_index: u32 = @intCast(i);
const file_index = add_file(file_absolute_path, &.{interested_thread_index});
_ = instance.files.get_unchecked(file_index).interested_files.append(&instance.files.pointer[interested_file_index]);
const assigned_thread = &instance.threads[thread_index];
assigned_thread.task_system.program_state = .analysis;
assigned_thread.add_thread_work(Job{
.offset = file_index,
.id = .analyze_file,
.count = 1,
});
}
},
.notify_file_resolved => {
const file_index = job.offset;
const thread_index = job.count;
const destination_thread = &instance.threads[thread_index];
const file = instance.files.get(@enumFromInt(file_index));
const file_path_hash = hash_bytes(file.path);
destination_thread.add_thread_work(.{
.id = .notify_file_resolved,
.count = @intCast(file_index),
.offset = file_path_hash,
});
},
.notify_analysis_complete => {
thread.add_thread_work(.{
.id = .llvm_generate_ir,
});
},
.llvm_notify_ir_done => {
thread.add_thread_work(.{
.id = .llvm_emit_object,
});
},
.llvm_notify_object_done => {
thread.task_system.program_state = .llvm_finished_object;
first_ir_done = true;
},
else => |t| @panic(@tagName(t)),
}
thread.task_system.ask.complete_job();
previous_job = job;
task_done_this_iteration += 1;
}
}
total_is_done = total_is_done and task_done_this_iteration == 0;
iterations_without_work_done += @intFromBool(task_done_this_iteration == 0);
if (configuration.sleep_on_thread_hot_loops) {
if (iterations_without_work_done > 5) {
std.time.sleep(100);
}
} else {
std.atomic.spinLoopHint();
}
}
var objects = PinnedArray([]const u8){};
for (instance.threads) |*thread| {
if (thread.llvm.object) |object| {
_ = objects.append(object);
}
}
for (unit.descriptor.c_object_files) |object_path| {
_ = objects.append(object_path);
}
// for (instance.threads) |*thread| {
// std.debug.print("Thread #{}: {s}\n", .{thread.get_index(), @tagName(thread.task_system.program_state)});
// }
assert(objects.length > 0);
link(.{
.output_file_path = unit.descriptor.executable_path,
.extra_arguments = &.{},
.objects = objects.const_slice(),
.libraries = &.{},
.link_libc = true,
.link_libcpp = false,
});
}
fn command_exe(arguments: []const []const u8) void {
if (arguments.len == 0) {
error_insufficient_arguments_command("exe");
}
// TODO: make these mutable
const arch: Arch = switch (builtin.cpu.arch) {
.aarch64 => .aarch64,
.x86_64 => .x86_64,
else => unreachable,
};
const os: Os = switch (builtin.os.tag) {
.linux => .linux,
.macos => .macos,
.windows => .windows,
else => unreachable,
};
const abi: Abi = switch (builtin.os.tag) {
.linux => .gnu,
.macos => .none,
.windows => .gnu,
else => unreachable,
};
var maybe_executable_path: ?[]const u8 = null;
var maybe_executable_name: ?[]const u8 = null;
var maybe_main_source_file_path: ?[]const u8 = null;
var c_source_files = PinnedArray([]const u8){};
var optimization = Optimization.none;
var generate_debug_information = true;
var link_libc = true;
const link_libcpp = false;
var i: usize = 0;
while (i < arguments.len) : (i += 1) {
const current_argument = arguments[i];
if (byte_equal(current_argument, "-o")) {
if (i + 1 != arguments.len) {
maybe_executable_path = arguments[i + 1];
assert(maybe_executable_path.?.len != 0);
i += 1;
} else {
error_unterminated_argument(current_argument);
}
} else if (byte_equal(current_argument, "-link_libc")) {
if (i + 1 != arguments.len) {
i += 1;
const arg = arguments[i];
if (byte_equal(arg, "true")) {
link_libc = true;
} else if (byte_equal(arg, "false")) {
link_libc = false;
} else {
unreachable;
}
} else {
error_unterminated_argument(current_argument);
}
} else if (byte_equal(current_argument, "-main_source_file")) {
if (i + 1 != arguments.len) {
i += 1;
const arg = arguments[i];
maybe_main_source_file_path = arg;
} else {
error_unterminated_argument(current_argument);
}
} else if (byte_equal(current_argument, "-name")) {
if (i + 1 != arguments.len) {
i += 1;
const arg = arguments[i];
maybe_executable_name = arg;
} else {
error_unterminated_argument(current_argument);
}
} else if (byte_equal(current_argument, "-c_source_files")) {
if (i + 1 != arguments.len) {
i += 1;
c_source_files.append_slice(arguments[i..]);
i = arguments.len;
} else {
error_unterminated_argument(current_argument);
}
} else if (byte_equal(current_argument, "-optimize")) {
if (i + 1 != arguments.len) {
i += 1;
const optimize_string = arguments[i];
optimization = library.enumFromString(Optimization, optimize_string) orelse unreachable;
} else {
error_unterminated_argument(current_argument);
}
} else if (byte_equal(current_argument, "-debug")) {
if (i + 1 != arguments.len) {
i += 1;
const debug_string = arguments[i];
generate_debug_information = if (byte_equal(debug_string, "true")) true else if (byte_equal(debug_string, "false")) false else unreachable;
} else {
error_unterminated_argument(current_argument);
}
} else if (byte_equal(current_argument, "-c_source_files_start")) {
i += 1;
var sentinel = false;
while (i < arguments.len) : (i += 1) {
const arg = arguments[i];
if (byte_equal(arg, "-c_source_files_end")) {
sentinel = true;
break;
}
_ = c_source_files.append(arg);
}
if (!sentinel) {
fail_message("No sentinel for C source files arguments");
}
} else {
@panic(current_argument);
// std.debug.panic("Unrecognized argument: {s}", .{current_argument});
}
}
const main_source_file_path = maybe_main_source_file_path orelse fail_message("Main source file must be specified with -main_source_file");
// TODO: undo this incongruency
const executable_name = if (maybe_executable_name) |executable_name| executable_name else std.fs.path.basename(main_source_file_path[0..main_source_file_path.len - "/main.nat".len]);
const executable_path = maybe_executable_path orelse blk: {
assert(executable_name.len > 0);
const result = instance.arena.join(&.{"nat/", executable_name }) catch unreachable;
break :blk result;
};
const object_path = instance.arena.join(&.{"nat/o/", executable_name, ".o"}) catch unreachable;
_ = Unit.compile(.{
.target = .{
.arch = arch,
.os = os,
.abi = abi,
},
.link_libc = link_libc,
.link_libcpp = link_libcpp,
.main_source_file_path = main_source_file_path,
.object_path = object_path,
.executable_path = executable_path,
.c_source_files = c_source_files.slice(),
.c_object_files = &.{},
.optimization = optimization,
.generate_debug_information = generate_debug_information,
.codegen_backend = .{
.llvm = .{
.split_object_per_thread = true,
},
},
});
}
pub fn main() void {
instance.arena = library.Arena.init(4 * 1024 * 1024) catch unreachable;
const executable_path = library.self_exe_path(instance.arena) catch unreachable;
const executable_directory = std.fs.path.dirname(executable_path).?;
std.fs.cwd().makePath("nat") catch |err| switch (err) {
else => @panic(@errorName(err)),
};
std.fs.cwd().makePath("nat/o") catch |err| switch (err) {
else => @panic(@errorName(err)),
};
instance.paths = .{
.cwd = library.realpath(instance.arena, std.fs.cwd(), ".") catch unreachable,
.executable = executable_path,
.executable_directory = executable_directory,
};
const thread_count = std.Thread.getCpuCount() catch unreachable;
const cpu_count = &cpu_count_buffer[0];
instance.arena.align_forward(@alignOf(Thread));
instance.threads = instance.arena.new_array(Thread, thread_count - 1) catch unreachable;
cpu_count.* = @intCast(thread_count - 2);
for (instance.threads) |*thread| {
thread.* = .{};
}
const thread_index = cpu_count.*;
instance.threads[thread_index].handle = std.Thread.spawn(.{}, worker_thread, .{thread_index, cpu_count}) catch unreachable;
var arg_iterator = std.process.args();
var argument_buffer = PinnedArray([]const u8){};
while (arg_iterator.next()) |arg| {
_ = argument_buffer.append(arg);
}
const arguments = argument_buffer.const_slice();
if (arguments.len < 2) {
fail_message("Insufficient number of arguments");
}
const command = arguments[1];
const command_arguments = arguments[2..];
if (byte_equal(command, "exe")) {
command_exe(command_arguments);
} else if (byte_equal(command, "clang") or byte_equal(command, "-cc1") or byte_equal(command, "-cc1as")) {
fail_message("TODO: clang");
} else if (byte_equal(command, "cc")) {
fail_message("TODO: clang");
} else if (byte_equal(command, "c++")) {
fail_message("TODO: clang");
} else {
fail_message("Unrecognized command");
}
}
const LinkerOptions = struct {
output_file_path: []const u8,
extra_arguments: []const []const u8,
objects: []const []const u8,
libraries: []const []const u8,
link_libc: bool,
link_libcpp: bool,
};
pub fn link(options: LinkerOptions) void {
var argv = PinnedArray([]const u8){};
const driver_program = switch (builtin.os.tag) {
.windows => "lld-link",
.linux => "ld.lld",
.macos => "ld64.lld",
else => @compileError("OS not supported"),
};
_ = argv.append(driver_program);
_ = argv.append("--error-limit=0");
switch (builtin.cpu.arch) {
.aarch64 => switch (builtin.os.tag) {
.linux => {
_ = argv.append("-znow");
_ = argv.append_slice(&.{ "-m", "aarch64linux" });
},
else => {},
},
else => {},
}
// const output_path = out_path orelse "a.out";
_ = argv.append("-o");
_ = argv.append(options.output_file_path);
argv.append_slice(options.extra_arguments);
for (options.objects) |object| {
_ = argv.append(object);
}
const ci = configuration.ci;
switch (builtin.os.tag) {
.macos => {
_ = argv.append("-dynamic");
argv.append_slice(&.{ "-platform_version", "macos", "13.4.1", "13.3" });
_ = argv.append("-arch");
_ = argv.append(switch (builtin.cpu.arch) {
.aarch64 => "arm64",
else => |t| @panic(@tagName(t)),
});
argv.append_slice(&.{ "-syslibroot", "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk" });
if (!library.ends_with_slice(options.output_file_path, ".dylib")) {
argv.append_slice(&.{ "-e", "_main" });
}
_ = argv.append("-lSystem");
if (options.link_libcpp) {
_ = argv.append("-L/Library/Developer/CommandLineTools/SDKs/MacOSX13.3.sdk/usr/lib");
_ = argv.append("-lc++");
}
},
.linux => {
if (ci) {
if (options.link_libcpp) {
assert(options.link_libc);
_ = argv.append("/lib/x86_64-linux-gnu/libstdc++.so.6");
}
if (options.link_libc) {
_ = argv.append("/lib/x86_64-linux-gnu/crt1.o");
_ = argv.append("/lib/x86_64-linux-gnu/crti.o");
argv.append_slice(&.{ "-L", "/lib/x86_64-linux-gnu" });
argv.append_slice(&.{ "-dynamic-linker", "/lib64/ld-linux-x86-64.so.2" });
_ = argv.append("--as-needed");
_ = argv.append("-lm");
_ = argv.append("-lpthread");
_ = argv.append("-lc");
_ = argv.append("-ldl");
_ = argv.append("-lrt");
_ = argv.append("-lutil");
_ = argv.append("/lib/x86_64-linux-gnu/crtn.o");
}
} else {
if (options.link_libcpp) {
assert(options.link_libc);
_ = argv.append("/usr/lib64/libstdc++.so.6");
}
if (options.link_libc) {
_ = argv.append("/usr/lib64/crt1.o");
_ = argv.append("/usr/lib64/crti.o");
argv.append_slice(&.{ "-L", "/usr/lib64" });
_ = argv.append("-dynamic-linker");
switch (builtin.cpu.arch) {
.x86_64 => _ = argv.append("/lib64/ld-linux-x86-64.so.2"),
.aarch64 => _ = argv.append("/lib/ld-linux-aarch64.so.1"),
else => unreachable,
}
_ = argv.append("--as-needed");
_ = argv.append("-lm");
_ = argv.append("-lpthread");
_ = argv.append("-lc");
_ = argv.append("-ldl");
_ = argv.append("-lrt");
_ = argv.append("-lutil");
_ = argv.append("/usr/lib64/crtn.o");
}
}
},
.windows => {},
else => @compileError("OS not supported"),
}
for (options.libraries) |lib| {
_ = argv.append(instance.arena.join(&.{ "-l", lib }) catch unreachable);
}
const argv_zero_terminated = library.argument_copy_zero_terminated(instance.arena, argv.const_slice()) catch unreachable;
var stdout_ptr: [*]const u8 = undefined;
var stdout_len: usize = 0;
var stderr_ptr: [*]const u8 = undefined;
var stderr_len: usize = 0;
const result = switch (builtin.os.tag) {
.linux => NativityLLDLinkELF(argv_zero_terminated.ptr, argv_zero_terminated.len, &stdout_ptr, &stdout_len, &stderr_ptr, &stderr_len),
.macos => NativityLLDLinkMachO(argv_zero_terminated.ptr, argv_zero_terminated.len, &stdout_ptr, &stdout_len, &stderr_ptr, &stderr_len),
.windows => NativityLLDLinkCOFF(argv_zero_terminated.ptr, argv_zero_terminated.len, &stdout_ptr, &stdout_len, &stderr_ptr, &stderr_len),
else => @compileError("OS not supported"),
};
if (!result) {
const stdout = stdout_ptr[0..stdout_len];
const stderr = stderr_ptr[0..stderr_len];
for (argv.const_slice()) |arg| {
write(arg);
write(" ");
}
write("\n");
if (stdout.len > 0) {
write(stdout);
write("\n");
}
if (stderr.len > 0) {
write(stderr);
write("\n");
}
@panic("Linking with LLD failed");
}
}
extern fn NativityLLDLinkELF(argument_ptr: [*:null]?[*:0]u8, argument_count: usize, stdout_ptr: *[*]const u8, stdout_len: *usize, stderr_ptr: *[*]const u8, stderr_len: *usize) bool;
extern fn NativityLLDLinkCOFF(argument_ptr: [*:null]?[*:0]u8, argument_count: usize, stdout_ptr: *[*]const u8, stdout_len: *usize, stderr_ptr: *[*]const u8, stderr_len: *usize) bool;
extern fn NativityLLDLinkMachO(argument_ptr: [*:null]?[*:0]u8, argument_count: usize, stdout_ptr: *[*]const u8, stdout_len: *usize, stderr_ptr: *[*]const u8, stderr_len: *usize) bool;
extern fn NativityLLDLinkWasm(argument_ptr: [*:null]?[*:0]u8, argument_count: usize, stdout_ptr: *[*]const u8, stdout_len: *usize, stderr_ptr: *[*]const u8, stderr_len: *usize) bool;
fn intern_identifier(pool: *PinnedHashMap(u32, []const u8), identifier: []const u8) u32 {
const start_index = @intFromBool(identifier[0] == '"');
const end_index = identifier.len - start_index;
const hash = hash_bytes(identifier[start_index..end_index]);
pool.put(hash, identifier);
return hash;
}
const CallingConvention = enum{
c,
custom,
};
const Analyzer = struct{
current_basic_block: *BasicBlock,
current_function: *Function,
current_scope: *Scope,
exit_blocks: PinnedArray(*BasicBlock) = .{},
loops: PinnedArray(LoopData) = .{},
return_block: ?*BasicBlock = null,
return_phi: ?*Phi = null,
return_pointer: ?*Instruction = null,
fn append_instruction(analyzer: *Analyzer, instruction: *Instruction) void {
assert(!analyzer.current_basic_block.is_terminated);
assert(instruction.basic_block == null);
instruction.basic_block = analyzer.current_basic_block;
_ = analyzer.current_basic_block.instructions.append(instruction);
}
};
const LoopData = struct {
break_block: *BasicBlock,
continue_block: *BasicBlock,
};
const brace_open = '{';
const brace_close = '}';
const pointer_token = '*';
const cache_line_size = switch (builtin.os.tag) {
.macos => 128,
else => 64,
};
var cpu_count_buffer = [1]u32{0} ** @divExact(cache_line_size, @sizeOf(u32));
const address_space = 0;
fn try_end_analyzing_file(file: *File) void {
_ = file; // autofix
}
fn worker_thread(thread_index: u32, cpu_count: *u32) void {
while (true) {
const local_cpu_count = cpu_count.*;
if (local_cpu_count == 0) {
break;
}
if (@cmpxchgWeak(u32, cpu_count, local_cpu_count, local_cpu_count - 1, .seq_cst, .seq_cst) == null) {
const new_thread_index = local_cpu_count - 1;
instance.threads[thread_index].handle = std.Thread.spawn(.{}, worker_thread, .{new_thread_index, cpu_count}) catch unreachable;
}
}
const thread = &instance.threads[thread_index];
thread.arena = Arena.init(4 * 1024 * 1024) catch unreachable;
for (&thread.integers) |*integer| {
integer.type.sema.thread = @intCast(thread_index);
}
thread.opaque_pointer.sema.thread = @intCast(thread_index);
thread.void.sema.thread = @intCast(thread_index);
thread.noreturn.sema.thread = @intCast(thread_index);
while (true) {
while (thread.get_worker_job()) |job| {
const c = thread.task_system.job.worker.completed;
switch (job.id) {
.analyze_file => {
thread.assigned_file_count += 1;
const file_index = job.offset;
const file = &instance.files.slice()[file_index];
file.state = .analyzing;
file.source_code = library.read_file(thread.arena, std.fs.cwd(), file.path);
file.thread = thread_index;
analyze_file(thread, file_index);
},
.notify_file_resolved => {
const file_index = job.count;
const file = &instance.files.pointer[file_index];
if (thread == &instance.threads[file.thread]) {
fail_message("Threads match!");
} else {
const file_path_hash = job.offset;
for (file.interested_files.slice()) |interested_file| {
if (interested_file.thread == thread.get_index()) {
assert(interested_file.resolved_import_count != interested_file.imports.length);
for (interested_file.imports.slice(), 0..) |import, i| {
if (import.hash == file_path_hash) {
const values_per_import = interested_file.values_per_import.get(@enumFromInt(i));
for (values_per_import.slice()) |value| {
assert(value.sema.thread == thread.get_index());
assert(!value.sema.resolved);
if (!value.sema.resolved) {
switch (value.sema.id) {
.instruction => {
const instruction = value.get_payload(.instruction);
switch (instruction.id) {
.call => {
const call: *Call = instruction.get_payload(.call);
assert(!call.callable.sema.resolved);
switch (call.callable.sema.id) {
.lazy_expression => {
const lazy_expression = call.callable.get_payload(.lazy_expression);
const names = lazy_expression.names();
assert(names.len > 0);
switch (lazy_expression.u) {
.static => |*static| {
_ = static; // autofix
},
.dynamic => unreachable,
}
const declaration_reference = lazy_expression.u.static.outsider;
switch (declaration_reference.*.id) {
.file => {
assert(names.len == 1);
const file_declaration = declaration_reference.*.get_payload(.file);
assert(file_declaration == file);
if (file.scope.scope.declarations.get(names[0])) |callable_declaration| {
const global_declaration = callable_declaration.get_payload(.global);
switch (global_declaration.id) {
.global_symbol => {
const global_symbol = global_declaration.to_symbol();
switch (global_symbol.id) {
.function_definition => {
const function_definition = global_symbol.get_payload(.function_definition);
const external_fn = function_definition.declaration.clone(thread);
call.callable = &external_fn.global_symbol.value;
value.sema.resolved = true;
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
} else {
unreachable;
}
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
},
.lazy_expression => {
const lazy_expression = value.get_payload(.lazy_expression);
assert(lazy_expression.u == .static);
for (lazy_expression.u.static.names) |n| {
assert(n == 0);
}
const declaration_reference = lazy_expression.u.static.outsider;
switch (declaration_reference.*.id) {
.unresolved_import => {
declaration_reference.* = &file.global_declaration;
value.sema.resolved = true;
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
}
}
}
}
interested_file.resolved_import_count += 1;
try_resolve_file(thread, interested_file);
}
}
}
},
.llvm_generate_ir => {
if (thread.functions.length > 0 or thread.global_variables.length > 0) {
const context = LLVM.Context.create();
const module_name: []const u8 = "thread";
const module = LLVM.Module.create(module_name.ptr, module_name.len, context);
const builder = LLVM.Builder.create(context);
const attributes = LLVM.Attributes{
.naked = context.getAttributeFromEnum(.Naked, 0),
.noreturn = context.getAttributeFromEnum(.NoReturn, 0),
.nounwind = context.getAttributeFromEnum(.NoUnwind, 0),
.inreg = context.getAttributeFromEnum(.InReg, 0),
.@"noalias" = context.getAttributeFromEnum(.NoAlias, 0),
.sign_extend = context.getAttributeFromEnum(.SExt, 0),
.zero_extend = context.getAttributeFromEnum(.ZExt, 0),
};
const target_triple = switch (builtin.os.tag) {
.linux => switch (builtin.cpu.arch) {
.aarch64 => "aarch64-linux-none",
.x86_64 => "x86_64-unknown-linux-gnu",
else => @compileError("CPU not supported"),
},
.macos => "aarch64-apple-macosx-none",
.windows => "x86_64-windows-gnu",
else => @compileError("OS not supported"),
};
const cpu = builtin.cpu.model.llvm_name.?;
var features = PinnedArray(u8){
.pointer = @constCast(""),
};
const temp_use_native_features = true;
if (temp_use_native_features) {
const feature_list = builtin.cpu.arch.allFeaturesList();
if (feature_list.len > 0) {
for (feature_list, 0..) |feature, index_usize| {
const index = @as(std.Target.Cpu.Feature.Set.Index, @intCast(index_usize));
const is_enabled = builtin.cpu.features.isEnabled(index);
if (feature.llvm_name) |llvm_name| {
const plus_or_minus = "-+"[@intFromBool(is_enabled)];
_ = features.append(plus_or_minus);
features.append_slice(llvm_name);
features.append_slice(",");
}
}
assert(std.mem.endsWith(u8, features.slice(), ","));
features.length -= 1;
}
}
const target = blk: {
var error_message: [*]const u8 = undefined;
var error_message_len: usize = 0;
const optional_target = LLVM.bindings.NativityLLVMGetTarget(target_triple.ptr, target_triple.len, &error_message, &error_message_len);
const target = optional_target orelse {
fail_message(error_message[0..error_message_len]);
};
break :blk target;
};
const jit = false;
const code_model: LLVM.CodeModel = undefined;
const is_code_model_present = false;
// TODO:
const codegen_optimization_level: LLVM.CodegenOptimizationLevel = switch (Optimization.none) {
.none => .none,
.debug_prefer_fast, .debug_prefer_size => .none,
.lightly_optimize_for_speed => .less,
.optimize_for_speed, .optimize_for_size => .default,
.aggressively_optimize_for_speed, .aggressively_optimize_for_size => .aggressive,
};
const target_machine = target.createTargetMachine(target_triple.ptr, target_triple.len, cpu.ptr, cpu.len, features.pointer, features.length, LLVM.RelocationModel.static, code_model, is_code_model_present, codegen_optimization_level, jit);
module.setTargetMachineDataLayout(target_machine);
module.setTargetTriple(target_triple.ptr, target_triple.len);
thread.llvm = .{
.context = context,
.module = module,
.attributes = attributes,
.target_machine = target_machine,
.intrinsic_ids = @TypeOf(thread.llvm.intrinsic_ids).init(.{
.leading_zeroes = llvm_get_intrinsic_id("llvm.ctlz"),
.trailing_zeroes = llvm_get_intrinsic_id("llvm.cttz"),
}),
.fixed_intrinsic_functions = @TypeOf(thread.llvm.fixed_intrinsic_functions).init(.{
.trap = llvm_get_intrinsic_function(thread, .{
.id = llvm_get_intrinsic_id("llvm.trap"),
.types = &.{},
}),
}),
};
for (thread.external_functions.slice()) |*nat_function| {
llvm_emit_function_declaration(thread, nat_function);
}
for (thread.functions.slice()) |*nat_function| {
assert(nat_function.declaration.global_symbol.id == .function_definition);
llvm_emit_function_declaration(thread, &nat_function.declaration);
}
for (thread.global_variables.slice()) |*nat_global| {
const global_type = llvm_get_type(thread, nat_global.global_symbol.type);
const linkage: LLVM.Linkage = switch (nat_global.global_symbol.attributes.@"export") {
true => .@"extern",
false => .internal,
};
const constant = switch (nat_global.global_symbol.attributes.mutability) {
.@"var" => false,
.@"const" => true,
};
const initializer = llvm_get_value(thread, nat_global.initial_value).toConstant() orelse unreachable;
const thread_local_mode = LLVM.ThreadLocalMode.not_thread_local;
const externally_initialized = false;
const name = thread.identifiers.get(nat_global.global_symbol.global_declaration.declaration.name).?;
const global_variable = module.addGlobalVariable(global_type, constant, linkage, initializer, name.ptr, name.len, null, thread_local_mode, address_space, externally_initialized);
global_variable.toGlobalObject().setAlignment(nat_global.global_symbol.alignment);
nat_global.global_symbol.value.llvm = global_variable.toValue();
if (thread.generate_debug_information) {
const file_index = nat_global.global_symbol.global_declaration.declaration.scope.file;
const file_struct = llvm_get_file(thread, file_index);
const file = file_struct.file;
const scope = file.toScope();
const debug_type = llvm_get_debug_type(thread, file_struct.builder, nat_global.global_symbol.type);
const is_local_to_unit = !nat_global.global_symbol.attributes.@"export";
const is_defined = !nat_global.global_symbol.attributes.@"extern";
const expression = null;
const declaration = null;
const template_parameters = null;
const alignment = 0;
const line = nat_global.global_symbol.global_declaration.declaration.line;
const debug_global_variable = file_struct.builder.createGlobalVariableExpression(scope, name.ptr, name.len, name.ptr, name.len, file, line, debug_type, is_local_to_unit, is_defined, expression, declaration, template_parameters, alignment);
global_variable.addDebugInfo(debug_global_variable);
}
}
for (thread.functions.slice()) |*nat_function| {
const function = nat_function.declaration.global_symbol.value.llvm.?.toFunction() orelse unreachable;
const file_index = nat_function.declaration.global_symbol.global_declaration.declaration.scope.file;
var basic_block_command_buffer = BasicBlock.CommandList{};
var emit_allocas = true;
{
const nat_entry_basic_block = nat_function.entry_block;
assert(nat_entry_basic_block.predecessors.length == 0);
const entry_block_name = "entry";
const entry_block = thread.llvm.context.createBasicBlock(entry_block_name, entry_block_name.len, function, null);
nat_entry_basic_block.value.llvm = entry_block.toValue();
basic_block_command_buffer.append(&nat_entry_basic_block.command_node);
}
var phis = PinnedArray(*Phi){};
var llvm_phi_nodes = PinnedArray(*LLVM.Value.Instruction.PhiNode){};
while (basic_block_command_buffer.len != 0) {
const basic_block_node = basic_block_command_buffer.first orelse unreachable;
const basic_block: *BasicBlock = @fieldParentPtr("command_node", basic_block_node);
const llvm_basic_block = basic_block.get_llvm();
builder.setInsertPoint(llvm_basic_block);
var last_block = basic_block_node;
if (emit_allocas) {
for (nat_function.arguments.slice(), nat_function.declaration.get_function_type().abi.argument_types_abi) |argument, abi| {
_ = abi; // autofix
switch (argument.instruction.id) {
.argument_storage => {
const alloca_type = llvm_get_type(thread, argument.type);
argument.instruction.value.llvm = builder.createAlloca(alloca_type, address_space, null, "", "".len, argument.alignment).toValue();
},
.abi_indirect_argument => {
const llvm_argument = function.getArgument(argument.index);
argument.instruction.value.llvm = llvm_argument.toValue();
},
else => |t| @panic(@tagName(t)),
}
}
for (nat_function.stack_slots.slice()) |local_slot| {
const alloca_type = llvm_get_type(thread, local_slot.type);
local_slot.instruction.value.llvm = builder.createAlloca(alloca_type, address_space, null, "", "".len, local_slot.alignment).toValue();
}
emit_allocas = false;
}
for (basic_block.instructions.slice()) |instruction| {
if (thread.generate_debug_information) {
if (instruction.line != 0) {
const scope = llvm_get_scope(thread, instruction.scope);
builder.setCurrentDebugLocation(context, instruction.line, instruction.column, scope, function);
} else {
builder.clearCurrentDebugLocation();
}
}
const value: *LLVM.Value = switch (instruction.id) {
.abi_argument => block: {
const abi_argument = instruction.get_payload(.abi_argument);
const llvm_argument = function.getArgument(abi_argument.index);
break :block llvm_argument.toValue();
},
.debug_argument => block: {
assert(thread.generate_debug_information);
const debug_argument = instruction.get_payload(.debug_argument);
const argument_symbol = debug_argument.argument;
const name_hash = argument_symbol.argument_declaration.declaration.name;
assert(name_hash != 0);
const name = thread.identifiers.get(name_hash).?;
const file_struct = llvm_get_file(thread, file_index);
const scope = llvm_get_scope(thread, instruction.scope);
const debug_declaration_type = llvm_get_debug_type(thread, file_struct.builder, argument_symbol.type);
const always_preserve = true;
const flags = LLVM.DebugInfo.Node.Flags{
.visibility = .none,
.forward_declaration = false,
.apple_block = false,
.block_by_ref_struct = false,
.virtual = false,
.artificial = false,
.explicit = false,
.prototyped = false,
.objective_c_class_complete = false,
.object_pointer = false,
.vector = false,
.static_member = false,
.lvalue_reference = false,
.rvalue_reference = false,
.reserved = false,
.inheritance = .none,
.introduced_virtual = false,
.bit_field = false,
.no_return = false,
.type_pass_by_value = false,
.type_pass_by_reference = false,
.enum_class = false,
.thunk = false,
.non_trivial = false,
.big_endian = false,
.little_endian = false,
.all_calls_described = false,
};
const argument_index = argument_symbol.index + 1;
const line = argument_symbol.argument_declaration.declaration.line;
const column = argument_symbol.argument_declaration.declaration.column;
const debug_parameter_variable = file_struct.builder.createParameterVariable(scope, name.ptr, name.len, argument_index, file_struct.file, line, debug_declaration_type, always_preserve, flags);
const argument_alloca = argument_symbol.instruction.value.llvm.?;
const insert_declare = file_struct.builder.insertDeclare(argument_alloca, debug_parameter_variable, context, line, column, function.getSubprogram().toLocalScope().toScope(), builder.getInsertBlock());
break :block insert_declare.toValue();
},
.debug_local => block: {
assert(thread.generate_debug_information);
const file = llvm_get_file(thread, file_index);
const debug_local = instruction.get_payload(.debug_local);
const local_symbol = debug_local.local;
const debug_declaration_type = llvm_get_debug_type(thread, file.builder, local_symbol.type);
const always_preserve = true;
const flags = LLVM.DebugInfo.Node.Flags{
.visibility = .none,
.forward_declaration = false,
.apple_block = false,
.block_by_ref_struct = false,
.virtual = false,
.artificial = false,
.explicit = false,
.prototyped = false,
.objective_c_class_complete = false,
.object_pointer = false,
.vector = false,
.static_member = false,
.lvalue_reference = false,
.rvalue_reference = false,
.reserved = false,
.inheritance = .none,
.introduced_virtual = false,
.bit_field = false,
.no_return = false,
.type_pass_by_value = false,
.type_pass_by_reference = false,
.enum_class = false,
.thunk = false,
.non_trivial = false,
.big_endian = false,
.little_endian = false,
.all_calls_described = false,
};
const alignment = 0;
const declaration_name = thread.identifiers.get(local_symbol.local_declaration.declaration.name).?;
const line = local_symbol.local_declaration.declaration.line;
const column = local_symbol.local_declaration.declaration.column;
const scope = llvm_get_scope(thread, local_symbol.local_declaration.declaration.scope);
const debug_local_variable = file.builder.createAutoVariable(scope, declaration_name.ptr, declaration_name.len, file.file, line, debug_declaration_type, always_preserve, flags, alignment);
const insert_declare = file.builder.insertDeclare(local_symbol.instruction.value.llvm.?, debug_local_variable, context, line, column, (function.getSubprogram()).toLocalScope().toScope(), builder.getInsertBlock());
break :block insert_declare.toValue();
},
.store => block: {
const store = instruction.get_payload(.store);
const destination = llvm_get_value(thread, store.destination);
const source = llvm_get_value(thread, store.source);
const store_instruction = builder.createStore(source, destination, store.is_volatile, store.alignment);
builder.setInstructionDebugLocation(@ptrCast(store_instruction));
break :block store_instruction.toValue();
},
.load => block: {
const load = instruction.get_payload(.load);
const load_value = llvm_get_value(thread, load.value);
const load_type = llvm_get_type(thread, load.type);
// TODO: precise alignment
const load_instruction = builder.createLoad(load_type, load_value, load.is_volatile, "", "".len, load.alignment);
builder.setInstructionDebugLocation(@ptrCast(load_instruction));
break :block load_instruction.toValue();
},
.ret => block: {
const return_instruction = instruction.get_payload(.ret);
const return_value = llvm_get_value(thread, return_instruction.value);
const ret = builder.createRet(return_value);
break :block ret.toValue();
},
.ret_void => block: {
const ret = builder.createRet(null);
break :block ret.toValue();
},
.integer_binary_operation => block: {
const integer_binary_operation = instruction.get_payload(.integer_binary_operation);
const left = llvm_get_value(thread, integer_binary_operation.left);
const right = llvm_get_value(thread, integer_binary_operation.right);
const integer_type = integer_binary_operation.type.get_payload(.integer);
const no_unsigned_wrapping = integer_type.signedness == .unsigned;
const no_signed_wrapping = integer_type.signedness == .signed;
const name = "";
const is_exact = false;
break :block switch (integer_binary_operation.id) {
.add => builder.createAdd(left, right, name, name.len, no_unsigned_wrapping, no_signed_wrapping),
.sub => builder.createSub(left, right, name, name.len, no_unsigned_wrapping, no_signed_wrapping),
.mul => builder.createMultiply(left, right, name, name.len, no_unsigned_wrapping, no_signed_wrapping),
.udiv => builder.createUDiv(left, right, name, name.len, is_exact),
.sdiv => builder.createSDiv(left, right, name, name.len, is_exact),
.@"and" => builder.createAnd(left, right, name, name.len),
.@"or" => builder.createOr(left, right, name, name.len),
.@"xor" => builder.createXor(left, right, name, name.len),
.shift_left => builder.createShiftLeft(left, right, name, name.len, no_unsigned_wrapping, no_signed_wrapping),
.arithmetic_shift_right => builder.createArithmeticShiftRight(left, right, name, name.len, is_exact),
.logical_shift_right => builder.createLogicalShiftRight(left, right, name, name.len, is_exact),
};
},
.call => block: {
const call = instruction.get_payload(.call);
const nat_function_type = call.get_function_type();
const function_type = llvm_get_type(thread, &nat_function_type.type);
const callee = llvm_get_value(thread, call.callable);
var arguments = std.BoundedArray(*LLVM.Value, 512){};
for (call.arguments) |argument| {
const llvm_argument = llvm_get_value(thread, argument);
_ = arguments.appendAssumeCapacity(llvm_argument);
}
const args = arguments.constSlice();
const call_i = builder.createCall(function_type.toFunction() orelse unreachable, callee, args.ptr, args.len, "", "".len, null);
var parameter_attribute_sets = std.BoundedArray(*const LLVM.Attribute.Set, 512){};
const function_attributes = llvm_emit_function_attributes(thread, nat_function_type, &parameter_attribute_sets);
call_i.setAttributes(thread.llvm.context, function_attributes.function_attributes, function_attributes.return_attribute_set, function_attributes.parameter_attribute_sets.ptr, function_attributes.parameter_attribute_sets.len);
const calling_convention = calling_convention_map.get(nat_function_type.abi.calling_convention);
call_i.setCallingConvention(calling_convention);
break :block call_i.toValue();
},
.integer_compare => block: {
const compare = instruction.get_payload(.integer_compare);
const type_a = compare.left.get_type();
const type_b = compare.right.get_type();
assert(type_a == type_b);
const left = llvm_get_value(thread, compare.left);
if (compare.id == .not_zero) {
const is_not_null = builder.createIsNotNull(left, "", "".len);
break :block is_not_null;
} else {
const right = llvm_get_value(thread, compare.right);
const name = "";
const comparison: LLVM.Value.Instruction.ICmp.Kind = switch (compare.id) {
.equal => .eq,
.not_equal => .ne,
.not_zero => unreachable,
.unsigned_greater_equal => .uge,
.unsigned_greater => .ugt,
.signed_greater_equal => .sge,
.signed_greater => .sgt,
.unsigned_less_equal => .ule,
.unsigned_less => .ult,
.signed_less_equal => .sle,
.signed_less => .slt,
};
const cmp = builder.createICmp(comparison, left, right, name, name.len);
break :block cmp;
}
},
.branch => block: {
const branch = instruction.get_payload(.branch);
basic_block_command_buffer.insertAfter(last_block, &branch.taken.command_node);
basic_block_command_buffer.insertAfter(&branch.taken.command_node, &branch.not_taken.command_node);
last_block = &branch.not_taken.command_node;
const taken = thread.llvm.context.createBasicBlock("", "".len, function, null);
branch.taken.value.llvm = taken.toValue();
assert(taken.toValue().toBasicBlock() != null);
const not_taken = thread.llvm.context.createBasicBlock("", "".len, function, null);
assert(not_taken.toValue().toBasicBlock() != null);
branch.not_taken.value.llvm = not_taken.toValue();
const condition = llvm_get_value(thread, branch.condition);
const branch_weights = null;
const unpredictable = null;
const br = builder.createConditionalBranch(condition, taken, not_taken, branch_weights, unpredictable);
break :block br.toValue();
},
.jump => block: {
const jump = instruction.get_payload(.jump);
const target_block = jump.basic_block;
assert(target_block.value.sema.thread == thread.get_index());
const llvm_target_block = if (target_block.value.llvm) |llvm| llvm.toBasicBlock() orelse unreachable else bb: {
const block = thread.llvm.context.createBasicBlock("", "".len, function, null);
assert(block.toValue().toBasicBlock() != null);
target_block.value.llvm = block.toValue();
basic_block_command_buffer.insertAfter(last_block, &target_block.command_node);
last_block = &target_block.command_node;
break :bb block;
};
const br = builder.createBranch(llvm_target_block);
break :block br.toValue();
},
.phi => block: {
const phi = instruction.get_payload(.phi);
const phi_type = llvm_get_type(thread, phi.type);
const reserved_value_count = phi.nodes.length;
const phi_node = builder.createPhi(phi_type, reserved_value_count, "", "".len);
_ = phis.append(phi);
_ = llvm_phi_nodes.append(phi_node);
break :block phi_node.toValue();
},
.@"unreachable" => block: {
const ur = builder.createUnreachable();
break :block ur.toValue();
},
.trap => block: {
const args: []const *LLVM.Value = &.{};
const intrinsic = thread.llvm.fixed_intrinsic_functions.get(.trap);
const call_i = builder.createCall(intrinsic.getType(), intrinsic.toValue(), args.ptr, args.len, "", "".len, null);
break :block call_i.toValue();
},
.leading_zeroes => block: {
const leading_zeroes = instruction.get_payload(.leading_zeroes);
const v = llvm_get_value(thread, leading_zeroes.value);
const v_type = v.getType();
const lz_id = thread.llvm.intrinsic_ids.get(.leading_zeroes);
const parameters = LLVMIntrinsic.Parameters{
.id = lz_id,
.types = &.{v_type},
};
const intrinsic_function = llvm_get_intrinsic_function(thread, parameters);
const intrinsic_function_type = intrinsic_function.getType();
const is_poison = context.getConstantInt(1, 0, false);
const args: []const *LLVM.Value = &.{v, is_poison.toValue()};
const call_i = builder.createCall(intrinsic_function_type, intrinsic_function.toValue(), args.ptr, args.len, "", "".len, null);
break :block call_i.toValue();
},
.trailing_zeroes => block: {
const trailing_zeroes = instruction.get_payload(.trailing_zeroes);
const v = llvm_get_value(thread, trailing_zeroes.value);
const v_type = v.getType();
const tz_id = thread.llvm.intrinsic_ids.get(.trailing_zeroes);
const parameters = LLVMIntrinsic.Parameters{
.id = tz_id,
.types = &.{v_type},
};
const intrinsic_function = llvm_get_intrinsic_function(thread, parameters);
const intrinsic_function_type = intrinsic_function.getType();
const is_poison = context.getConstantInt(1, 0, false);
const args: []const *LLVM.Value = &.{v, is_poison.toValue()};
const call_i = builder.createCall(intrinsic_function_type, intrinsic_function.toValue(), args.ptr, args.len, "", "".len, null);
break :block call_i.toValue();
},
.get_element_pointer => block: {
const gep = instruction.get_payload(.get_element_pointer);
const aggregate_type = llvm_get_type(thread, gep.aggregate_type);
const pointer = llvm_get_value(thread, gep.pointer);
const in_bounds = true;
const index = llvm_get_value(thread, gep.index);
const struct_index = context.getConstantInt(@bitSizeOf(u32), 0, false);
const index_buffer = [2]*LLVM.Value{ struct_index.toValue(), index };
const indices = index_buffer[@intFromBool(!gep.is_struct)..];
const get_element_pointer = builder.createGEP(aggregate_type, pointer, indices.ptr, indices.len, "".ptr, "".len, in_bounds);
break :block get_element_pointer;
},
.cast => block: {
const cast = instruction.get_payload(.cast);
const cast_value = llvm_get_value(thread, cast.value);
const v = switch (cast.id) {
.int_from_bitfield => cast_value,
.truncate, .int_from_pointer => |cast_id| b: {
const cast_type = llvm_get_type(thread, cast.type);
const cast_i = builder.createCast(switch (cast_id) {
.truncate => .truncate,
.int_from_pointer => .pointer_to_int,
else => |t| @panic(@tagName(t)),
}, cast_value, cast_type, "", "".len);
break :b cast_i;
},
else => |t| @panic(@tagName(t)),
};
break :block v;
},
.memcpy => block: {
const memcpy = instruction.get_payload(.memcpy);
const destination = llvm_get_value(thread, memcpy.destination);
const source = llvm_get_value(thread, memcpy.source);
const memcopy = builder.createMemcpy(destination, memcpy.destination_alignment, source, memcpy.source_alignment, memcpy.size, memcpy.is_volatile);
break :block memcopy.toValue();
},
.extract_value => block: {
const extract_value = instruction.get_payload(.extract_value);
const aggregate = llvm_get_value(thread, extract_value.aggregate);
const indices = [1]c_uint{extract_value.index};
const i = builder.createExtractValue(aggregate, &indices, indices.len, "", "".len);
break :block i;
},
else => |t| @panic(@tagName(t)),
};
instruction.value.llvm = value;
}
_ = basic_block_command_buffer.popFirst();
}
for (phis.const_slice(), llvm_phi_nodes.const_slice()) |phi, llvm_phi| {
for (phi.nodes.const_slice()) |phi_node| {
const llvm_value = llvm_get_value(thread, phi_node.value);
const llvm_basic_block = phi_node.basic_block.get_llvm();
llvm_phi.addIncoming(llvm_value, llvm_basic_block);
}
}
if (thread.generate_debug_information) {
const llvm_file = thread.debug_info_file_map.get_pointer(file_index).?;
const subprogram = function.getSubprogram();
llvm_file.builder.finalizeSubprogram(subprogram, function);
}
const verify_function = false;
if (verify_function) {
var message: []const u8 = undefined;
const verification_success = function.verify(&message.ptr, &message.len);
if (!verification_success) {
var function_msg: []const u8 = undefined;
function.toString(&function_msg.ptr, &function_msg.len);
write(function_msg);
write("\n");
fail_message(message);
}
}
}
if (thread.generate_debug_information) {
for (thread.debug_info_file_map.values()) |v| {
v.builder.finalize();
}
}
const verify_module = true;
const print_module_at_failure = true;
const print_module = false;
if (verify_module) {
var verification_message: []const u8 = undefined;
const verification_success = thread.llvm.module.verify(&verification_message.ptr, &verification_message.len);
if (!verification_success) {
if (print_module_at_failure) {
var module_content: []const u8 = undefined;
thread.llvm.module.toString(&module_content.ptr, &module_content.len);
write(module_content);
write("\n");
}
fail_message(verification_message);
}
}
if (print_module) {
var module_content: []const u8 = undefined;
thread.llvm.module.toString(&module_content.ptr, &module_content.len);
write(module_content);
write("\n");
}
thread.add_control_work(.{
.id = .llvm_notify_ir_done,
});
}
},
.llvm_emit_object => {
const timestamp = std.time.nanoTimestamp();
const thread_object = std.fmt.allocPrint(std.heap.page_allocator, "nat/o/{s}_thread{}_{}.o", .{std.fs.path.basename(std.fs.path.dirname(instance.files.get(@enumFromInt(0)).path).?), thread.get_index(), timestamp}) catch unreachable;
thread.llvm.object = thread_object;
const disable_verify = false;
const result = thread.llvm.module.addPassesToEmitFile(thread.llvm.target_machine, thread_object.ptr, thread_object.len, LLVM.CodeGenFileType.object, disable_verify);
if (!result) {
@panic("can't generate machine code");
}
thread.add_control_work(.{
.id = .llvm_notify_object_done,
});
// std.debug.print("Thread #{} emitted object and notified\n", .{thread_index});
},
.compile_c_source_file => {
// TODO: FIXME
const unit = instance.units.get_unchecked(0);
const c_source_file_index = job.offset;
const source_file = unit.descriptor.c_source_files[c_source_file_index];
const object_path = unit.descriptor.c_object_files[c_source_file_index];
compile_c_source_files(thread, &.{ "-c", source_file, "-o", object_path, "-std=c99"});
},
else => |t| @panic(@tagName(t)),
}
thread.task_system.job.complete_job();
assert(thread.task_system.job.worker.completed == c + 1);
}
if (configuration.sleep_on_thread_hot_loops) {
std.time.sleep(1000);
} else {
std.atomic.spinLoopHint();
}
}
}
const CSourceFileCompilationInvoker = enum{
nat,
external,
};
fn compile_c_source_files(thread: *Thread, arguments: []const []const u8) void {
var argument_index: usize = 0;
_ = &argument_index;
const Mode = enum {
object,
link,
};
var out_path: ?[]const u8 = null;
var out_mode: ?Mode = null;
const Extension = enum {
c,
cpp,
assembly,
object,
static_library,
shared_library,
};
const CSourceFile = struct {
path: []const u8,
extension: Extension,
};
const DebugInfo = enum {
yes,
no,
};
const LinkArch = enum {
arm64,
};
var debug_info: ?DebugInfo = null;
var stack_protector: ?bool = null;
var link_arch: ?LinkArch = null;
var cc_argv = std.BoundedArray([]const u8, 4096){};
var ld_argv = std.BoundedArray([]const u8, 4096){};
var c_source_files = std.BoundedArray(CSourceFile, 4096){};
var link_objects = std.BoundedArray([]const u8, 4096){};
var link_libraries = std.BoundedArray([]const u8, 4096){};
while (argument_index < arguments.len) {
const argument = arguments[argument_index];
if (argument[0] != '-') {
if (last_byte(argument, '.')) |dot_index| {
const extension_string = argument[dot_index..];
const extension: Extension =
if (byte_equal(extension_string, ".c")) .c else if (byte_equal(extension_string, ".cpp") or byte_equal(extension_string, ".cxx") or byte_equal(extension_string, ".cc")) .cpp else if (byte_equal(extension_string, ".S")) .assembly else if (byte_equal(extension_string, ".o")) .object else if (byte_equal(extension_string, ".a")) .static_library else if (byte_equal(extension_string, ".so") or
byte_equal(extension_string, ".dll") or
byte_equal(extension_string, ".dylib") or
byte_equal(extension_string, ".tbd")) .shared_library else {
write(argument);
write("\n");
@panic("Unable to recognize extension for the file above");
};
switch (extension) {
.c, .cpp, .assembly => {
c_source_files.appendAssumeCapacity(.{
.path = argument,
.extension = extension,
});
},
.object, .static_library, .shared_library => {
link_objects.appendAssumeCapacity(argument);
},
}
} else {
write(argument);
write("\n");
@panic("Positional argument without extension");
}
} else if (byte_equal(argument, "-c")) {
out_mode = .object;
} else if (byte_equal(argument, "-o")) {
argument_index += 1;
out_path = arguments[argument_index];
} else if (byte_equal(argument, "-g")) {
debug_info = .yes;
} else if (byte_equal(argument, "-fno-stack-protector")) {
stack_protector = false;
} else if (byte_equal(argument, "-arch")) {
argument_index += 1;
const arch_argument = arguments[argument_index];
if (byte_equal(arch_argument, "arm64")) {
link_arch = .arm64;
cc_argv.appendAssumeCapacity("-arch");
cc_argv.appendAssumeCapacity("arm64");
} else {
unreachable;
}
} else if (byte_equal(argument, "-bundle")) {
ld_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-pthread")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-fPIC")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-MD")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-MT")) {
cc_argv.appendAssumeCapacity(argument);
argument_index += 1;
const arg = arguments[argument_index];
cc_argv.appendAssumeCapacity(arg);
} else if (byte_equal(argument, "-MF")) {
cc_argv.appendAssumeCapacity(argument);
argument_index += 1;
const arg = arguments[argument_index];
cc_argv.appendAssumeCapacity(arg);
} else if (byte_equal(argument, "-isysroot")) {
cc_argv.appendAssumeCapacity(argument);
argument_index += 1;
const arg = arguments[argument_index];
cc_argv.appendAssumeCapacity(arg);
} else if (byte_equal(argument, "-isystem")) {
cc_argv.appendAssumeCapacity(argument);
argument_index += 1;
const arg = arguments[argument_index];
cc_argv.appendAssumeCapacity(arg);
} else if (byte_equal(argument, "-h")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-framework")) {
ld_argv.appendAssumeCapacity(argument);
argument_index += 1;
const framework = arguments[argument_index];
ld_argv.appendAssumeCapacity(framework);
} else if (byte_equal(argument, "--coverage")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-pedantic")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-pedantic-errors")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-?")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-v")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-V")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "--version")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-version")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-qversion")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-print-resource-dir")) {
cc_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-shared")) {
ld_argv.appendAssumeCapacity(argument);
} else if (byte_equal(argument, "-compatibility_version")) {
ld_argv.appendAssumeCapacity(argument);
argument_index += 1;
const arg = arguments[argument_index];
ld_argv.appendAssumeCapacity(arg);
} else if (byte_equal(argument, "-current_version")) {
ld_argv.appendAssumeCapacity(argument);
argument_index += 1;
const arg = arguments[argument_index];
ld_argv.appendAssumeCapacity(arg);
} else if (byte_equal(argument, "-install_name")) {
ld_argv.appendAssumeCapacity(argument);
argument_index += 1;
const arg = arguments[argument_index];
ld_argv.appendAssumeCapacity(arg);
} else if (starts_with_slice(argument, "-f")) {
cc_argv.appendAssumeCapacity(argument);
} else if (starts_with_slice(argument, "-wd")) {
cc_argv.appendAssumeCapacity(argument);
} else if (starts_with_slice(argument, "-D")) {
cc_argv.appendAssumeCapacity(argument);
} else if (starts_with_slice(argument, "-I")) {
cc_argv.appendAssumeCapacity(argument);
} else if (starts_with_slice(argument, "-W")) {
cc_argv.appendAssumeCapacity(argument);
} else if (starts_with_slice(argument, "-l")) {
link_libraries.appendAssumeCapacity(argument[2..]);
} else if (starts_with_slice(argument, "-O")) {
cc_argv.appendAssumeCapacity(argument);
} else if (starts_with_slice(argument, "-std=")) {
cc_argv.appendAssumeCapacity(argument);
} else if (starts_with_slice(argument, "-rdynamic")) {
ld_argv.appendAssumeCapacity("-export_dynamic");
} else if (starts_with_slice(argument, "-dynamiclib")) {
ld_argv.appendAssumeCapacity("-dylib");
} else if (starts_with_slice(argument, "-Wl,")) {
const wl_arg = argument["-Wl,".len..];
if (first_byte(wl_arg, ',')) |comma_index| {
const key = wl_arg[0..comma_index];
const value = wl_arg[comma_index + 1 ..];
ld_argv.appendAssumeCapacity(key);
ld_argv.appendAssumeCapacity(value);
} else {
ld_argv.appendAssumeCapacity(wl_arg);
}
} else if (starts_with_slice(argument, "-m")) {
cc_argv.appendAssumeCapacity(argument);
} else {
fail_term("Unhandled argument", argument);
}
argument_index += 1;
}
const link_libcpp = true;
const mode = out_mode orelse .link;
var argv = std.BoundedArray([]const u8, 4096){};
if (c_source_files.len > 0) {
for (c_source_files.slice()) |c_source_file| {
argv.appendAssumeCapacity(instance.paths.executable);
argv.appendAssumeCapacity("clang");
argv.appendAssumeCapacity("--no-default-config");
argv.appendAssumeCapacity(c_source_file.path);
if (c_source_file.extension == .cpp) {
argv.appendAssumeCapacity("-nostdinc++");
}
const caret = true;
if (!caret) {
argv.appendAssumeCapacity("-fno-caret-diagnostics");
}
const function_sections = false;
if (function_sections) {
argv.appendAssumeCapacity("-ffunction-sections");
}
const data_sections = false;
if (data_sections) {
argv.appendAssumeCapacity("-fdata-sections");
}
const use_builtin = true;
if (!use_builtin) {
argv.appendAssumeCapacity("-fno-builtin");
}
if (link_libcpp) {
// include paths
}
const link_libc = c_source_file.extension == .c;
if (link_libc) {}
const link_libunwind = false;
if (link_libunwind) {
unreachable;
}
var target_triple_buffer = std.BoundedArray(u8, 512){};
const target_triple = blk: {
// Emit target
switch (@import("builtin").target.cpu.arch) {
.x86_64 => {
target_triple_buffer.appendSliceAssumeCapacity("x86_64-");
},
.aarch64 => {
target_triple_buffer.appendSliceAssumeCapacity("aarch64-");
},
else => @compileError("Architecture not supported"),
}
if (@import("builtin").target.cpu.arch == .aarch64 and @import("builtin").target.os.tag == .macos) {
target_triple_buffer.appendSliceAssumeCapacity("apple-");
} else {
target_triple_buffer.appendSliceAssumeCapacity("pc-");
}
switch (@import("builtin").target.os.tag) {
.linux => {
target_triple_buffer.appendSliceAssumeCapacity("linux-");
},
.macos => {
target_triple_buffer.appendSliceAssumeCapacity("macos-");
},
.windows => {
target_triple_buffer.appendSliceAssumeCapacity("windows-");
},
else => @compileError("OS not supported"),
}
switch (@import("builtin").target.abi) {
.musl => {
target_triple_buffer.appendSliceAssumeCapacity("musl");
},
.gnu => {
target_triple_buffer.appendSliceAssumeCapacity("gnu");
},
.none => {
target_triple_buffer.appendSliceAssumeCapacity("unknown");
},
else => @compileError("OS not supported"),
}
break :blk target_triple_buffer.slice();
};
argv.appendSliceAssumeCapacity(&.{ "-target", target_triple });
const object_path = switch (mode) {
.object => out_path.?,
.link => thread.arena.join(&.{ if (out_path) |op| op else "a.o", ".o" }) catch unreachable,
};
link_objects.appendAssumeCapacity(object_path);
switch (c_source_file.extension) {
.c, .cpp => {
argv.appendAssumeCapacity("-nostdinc");
argv.appendAssumeCapacity("-fno-spell-checking");
const lto = false;
if (lto) {
argv.appendAssumeCapacity("-flto");
}
const mm = false;
if (mm) {
argv.appendAssumeCapacity("-ObjC++");
}
const libc_framework_dirs: []const []const u8 = switch (@import("builtin").os.tag) {
.macos => &.{"/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks"},
else => &.{},
};
for (libc_framework_dirs) |framework_dir| {
argv.appendSliceAssumeCapacity(&.{ "-iframework", framework_dir });
}
const framework_dirs = &[_][]const u8{};
for (framework_dirs) |framework_dir| {
argv.appendSliceAssumeCapacity(&.{ "-F", framework_dir });
}
// TODO: c headers dir
const libc_include_dirs: []const []const u8 = switch (@import("builtin").os.tag) {
.macos => &.{
"/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/c++/v1",
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/15.0.0/include",
"/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include",
},
.linux => switch (@import("builtin").abi) {
.gnu => if (@import("configuration").ci) &.{
"/usr/include/c++/11",
"/usr/include/x86_64-linux-gnu/c++/11",
"/usr/lib/clang/17/include",
"/usr/include",
"/usr/include/x86_64-linux-gnu",
} else switch (@import("builtin").cpu.arch) {
.x86_64 => &.{
"/usr/include/c++/14",
"/usr/include/c++/14/x86_64-pc-linux-gnu",
"/usr/lib/clang/17/include",
"/usr/include",
"/usr/include/linux",
},
.aarch64 => &.{
"/usr/include/c++/14",
"/usr/include/c++/14/aarch64-redhat-linux",
"/usr/lib/clang/18/include",
"/usr/include",
"/usr/include/linux",
},
else => unreachable,
},
else => unreachable, //@compileError("ABI not supported"),
},
.windows => &.{},
else => @compileError("OS not supported"),
};
for (libc_include_dirs) |include_dir| {
argv.appendSliceAssumeCapacity(&.{ "-isystem", include_dir });
}
// TODO: cpu model
// TODO: cpu features
// TODO: code model
// TODO: OS-specific flags
// TODO: sanitize flags
// const red_zone = true;
// if (red_zone) {
// argv.appendAssumeCapacity("-mred-zone");
// } else {
// unreachable;
// }
const omit_frame_pointer = false;
if (omit_frame_pointer) {
argv.appendAssumeCapacity("-fomit-frame-pointer");
} else {
argv.appendAssumeCapacity("-fno-omit-frame-pointer");
}
if (stack_protector orelse false) {
argv.appendAssumeCapacity("-fstack-protector-strong");
} else {
argv.appendAssumeCapacity("-fno-stack-protector");
}
const is_debug = true;
if (is_debug) {
argv.appendAssumeCapacity("-D_DEBUG");
argv.appendAssumeCapacity("-O0");
} else {
unreachable;
}
const pic = false;
if (pic) {
argv.appendAssumeCapacity("-fPIC");
}
const unwind_tables = false;
if (unwind_tables) {
argv.appendAssumeCapacity("-funwind-tables");
} else {
argv.appendAssumeCapacity("-fno-unwind-tables");
}
},
.assembly => {
// TODO:
},
.object, .static_library, .shared_library => unreachable,
}
const has_debug_info = true;
if (has_debug_info) {
argv.appendAssumeCapacity("-g");
} else {
unreachable;
}
// TODO: machine ABI
const freestanding = false;
if (freestanding) {
argv.appendAssumeCapacity("-ffrestanding");
}
// TODO: native system include paths
// TODO: global cc argv
argv.appendSliceAssumeCapacity(cc_argv.slice());
// TODO: extra flags
// TODO: cache exempt flags
argv.appendSliceAssumeCapacity(&.{ "-c", "-o", object_path });
// TODO: emit ASM/LLVM IR
const debug_clang_args = false;
if (debug_clang_args) {
std.debug.print("Argv: {s}\n", .{argv.slice()});
}
clang_main(thread.arena, argv.slice());
}
} else if (link_objects.len == 0) {
unreachable;
// argv.appendAssumeCapacity(context.executable_absolute_path);
// argv.appendAssumeCapacity("clang");
// argv.appendAssumeCapacity("--no-default-config");
// argv.appendSliceAssumeCapacity(cc_argv.slice());
// const result = try clangMain(context.arena, argv.slice());
// if (result != 0) {
// unreachable;
// }
// return;
}
// if (mode == .link) {
// unreachable;
// // assert(link_objects.len > 0);
// // try linker.link(context, .{
// // .backend = .lld,
// // .output_file_path = out_path orelse "a.out",
// // .objects = link_objects.slice(),
// // .libraries = link_libraries.slice(),
// // .extra_arguments = ld_argv.slice(),
// // .link_libc = true,
// // .link_libcpp = link_libcpp,
// // });
// }
}
extern "c" fn nat_clang_main(argc: c_int, argv: [*:null]?[*:0]u8) c_int;
fn clang_main(arena: *Arena, arguments: []const []const u8) void {
const argv = library.argument_copy_zero_terminated(arena, arguments) catch unreachable;
const exit_code = nat_clang_main(@as(c_int, @intCast(arguments.len)), argv.ptr);
if (exit_code != 0) {
@breakpoint();
std.posix.exit(@intCast(exit_code));
}
}
fn llvm_emit_parameter_attributes(thread: *Thread, abi: Function.Abi.Information, is_return: bool) *const LLVM.Attribute.Set{
var attributes = std.BoundedArray(*LLVM.Attribute, 64){};
if (abi.attributes.zero_extend) {
attributes.appendAssumeCapacity(thread.llvm.attributes.zero_extend);
}
if (abi.attributes.sign_extend) {
attributes.appendAssumeCapacity(thread.llvm.attributes.sign_extend);
}
if (abi.attributes.by_reg) {
attributes.appendAssumeCapacity(thread.llvm.attributes.inreg);
}
switch (abi.kind) {
.ignore => {
assert(is_return);
},
.direct, .direct_pair, .direct_coerce => {},
.indirect => |indirect| {
const indirect_type = llvm_get_type(thread, indirect.type);
if (is_return) {
const sret = thread.llvm.context.getAttributeFromType(.StructRet, indirect_type);
attributes.appendAssumeCapacity(sret);
attributes.appendAssumeCapacity(thread.llvm.attributes.@"noalias");
// TODO: alignment
} else {
if (abi.attributes.by_value) {
const byval = thread.llvm.context.getAttributeFromType(.ByVal, indirect_type);
attributes.appendAssumeCapacity(byval);
}
//TODO: alignment
}
},
else => |t| @panic(@tagName(t)),
}
const attribute_set = thread.llvm.context.getAttributeSet(&attributes.buffer, attributes.len);
return attribute_set;
}
const LLVMFunctionAttributes = struct {
function_attributes: *const LLVM.Attribute.Set,
return_attribute_set: *const LLVM.Attribute.Set,
parameter_attribute_sets: []const *const LLVM.Attribute.Set,
};
fn llvm_emit_function_attributes(thread: *Thread, function_type: *Type.Function, parameter_attribute_sets: *std.BoundedArray(*const LLVM.Attribute.Set, 512)) LLVMFunctionAttributes {
const function_attributes = blk: {
var function_attributes = std.BoundedArray(*LLVM.Attribute, 256){};
function_attributes.appendAssumeCapacity(thread.llvm.attributes.nounwind);
switch (function_type.abi.original_return_type.sema.id) {
.noreturn => {
function_attributes.appendAssumeCapacity(thread.llvm.attributes.noreturn);
},
else => {},
}
// const naked = false;
// if (naked) {
// function_attributes.appendAssumeCapacity(thread.llvm.attributes.naked);
// }
const function_attribute_set = thread.llvm.context.getAttributeSet(&function_attributes.buffer, function_attributes.len);
break :blk function_attribute_set;
};
const return_attribute_set = blk: {
const attribute_set = llvm_emit_parameter_attributes(thread, function_type.abi.return_type_abi, true);
break :blk switch (function_type.abi.return_type_abi.kind) {
.indirect => b: {
parameter_attribute_sets.appendAssumeCapacity(attribute_set);
break :b thread.llvm.context.getAttributeSet(null, 0);
},
else => attribute_set,
};
};
for (function_type.abi.argument_types_abi) |abi| {
const attribute_set = llvm_emit_parameter_attributes(thread, abi, false);
parameter_attribute_sets.appendAssumeCapacity(attribute_set);
}
return .{
.function_attributes = function_attributes,
.return_attribute_set = return_attribute_set,
.parameter_attribute_sets = parameter_attribute_sets.constSlice(),
};
}
fn llvm_get_intrinsic_id(intrinsic: []const u8) LLVM.Value.IntrinsicID{
const intrinsic_id = LLVM.lookupIntrinsic(intrinsic.ptr, intrinsic.len);
assert(intrinsic_id != .none);
return intrinsic_id;
}
fn llvm_get_intrinsic_function_from_map(thread: *Thread, parameters: LLVMIntrinsic.Parameters) *LLVM.Value.Constant.Function{
if (thread.llvm.intrinsic_function_map.get(parameters)) |llvm| return llvm else {
const intrinsic_function = llvm_get_intrinsic_function(thread, parameters);
thread.llvm.intrinsic_function_map.put_no_clobber(parameters, intrinsic_function);
return intrinsic_function;
}
}
fn llvm_get_intrinsic_function(thread: *Thread, parameters: LLVMIntrinsic.Parameters) *LLVM.Value.Constant.Function{
const intrinsic_function = thread.llvm.module.getIntrinsicDeclaration(parameters.id, parameters.types.ptr, parameters.types.len);
return intrinsic_function;
}
fn llvm_get_value(thread: *Thread, value: *Value) *LLVM.Value {
if (value.llvm) |llvm| {
assert(value.sema.thread == thread.get_index());
if (llvm.getContext() != thread.llvm.context) {
std.debug.print("Value was assigned to thread #{} ", .{thread.get_index()});
const thread_index = for (instance.threads, 0..) |*t, i| {
if (t.functions.length > 0) {
if (t.llvm.context == llvm.getContext()) {
break i;
}
}
} else unreachable;
std.debug.print("but context from which it was generated belongs to thread #{}\n", .{thread_index});
@panic("internal error");
}
return llvm;
} else {
const value_id = value.sema.id;
const llvm_value: *LLVM.Value = switch (value_id) {
.constant_int => b: {
const constant_int = value.get_payload(.constant_int);
const integer_type = switch (constant_int.type.sema.id) {
.integer => i: {
const integer_type = constant_int.type.get_payload(.integer);
break :i integer_type;
},
.bitfield => bf: {
const bitfield_type = constant_int.type.get_payload(.bitfield);
const integer_type = bitfield_type.backing_type.get_payload(.integer);
break :bf integer_type;
},
else => |t| @panic(@tagName(t)),
};
const result = thread.llvm.context.getConstantInt(@intCast(integer_type.type.bit_size), constant_int.n, @intFromEnum(integer_type.signedness) != 0);
break :b result.toValue();
},
.constant_array => b: {
const constant_array = value.get_payload(.constant_array);
const array_type = llvm_get_type(thread, constant_array.type);
var values = PinnedArray(*LLVM.Value.Constant){};
for (constant_array.values) |v| {
const val = llvm_get_value(thread, v);
_ = values.append(val.toConstant() orelse unreachable);
}
const result = array_type.toArray().?.getConstant(values.pointer, values.length);
break :b result.toValue();
},
.constant_struct => b: {
const constant_struct = value.get_payload(.constant_struct);
const struct_type = llvm_get_type(thread, constant_struct.type);
var values = PinnedArray(*LLVM.Value.Constant){};
for (constant_struct.values) |v| {
const val = llvm_get_value(thread, v);
_ = values.append(val.toConstant() orelse unreachable);
}
const result = struct_type.toStruct().?.getConstant(values.pointer, values.length);
break :b result.toValue();
},
.constant_bitfield => b: {
const constant_bitfield = value.get_payload(.constant_bitfield);
const bitfield_type = constant_bitfield.type.get_payload(.bitfield);
const bitfield_backing_type = bitfield_type.backing_type.get_payload(.integer);
const result = thread.llvm.context.getConstantInt(@intCast(bitfield_backing_type.type.bit_size), constant_bitfield.n, @intFromEnum(bitfield_backing_type.signedness) != 0);
break :b result.toValue();
},
.undefined => b: {
const undef = value.get_payload(.undefined);
const ty = llvm_get_type(thread, undef.type);
const poison = ty.getPoison();
break :b poison.toValue();
},
else => |t| @panic(@tagName(t)),
};
value.llvm = llvm_value;
return llvm_value;
}
}
fn llvm_get_debug_type(thread: *Thread, builder: *LLVM.DebugInfo.Builder, ty: *Type) *LLVM.DebugInfo.Type {
if (ty.llvm_debug) |llvm| return llvm else {
const llvm_debug_type = switch (ty.sema.id) {
.integer => block: {
const integer = ty.get_payload(.integer);
const dwarf_encoding: LLVM.DebugInfo.AttributeType = switch (integer.signedness) {
.unsigned => .unsigned,
.signed => .signed,
};
const flags = LLVM.DebugInfo.Node.Flags{
.visibility = .none,
.forward_declaration = false,
.apple_block = false,
.block_by_ref_struct = false,
.virtual = false,
.artificial = false,
.explicit = false,
.prototyped = false,
.objective_c_class_complete = false,
.object_pointer = false,
.vector = false,
.static_member = false,
.lvalue_reference = false,
.rvalue_reference = false,
.reserved = false,
.inheritance = .none,
.introduced_virtual = false,
.bit_field = false,
.no_return = false,
.type_pass_by_value = false,
.type_pass_by_reference = false,
.enum_class = false,
.thunk = false,
.non_trivial = false,
.big_endian = false,
.little_endian = false,
.all_calls_described = false,
};
var buffer: [65]u8 = undefined;
const format = library.format_int(&buffer, integer.type.bit_size, 10, false);
const slice_ptr = format.ptr - 1;
const slice = slice_ptr[0 .. format.len + 1];
slice[0] = switch (integer.signedness) {
.signed => 's',
.unsigned => 'u',
};
const name = thread.arena.duplicate_bytes(slice) catch unreachable;
const integer_type = builder.createBasicType(name.ptr, name.len, integer.type.bit_size, dwarf_encoding, flags);
break :block integer_type;
},
.array => block: {
const array = ty.get_payload(.array);
const bitsize = array.type.size * 8;
const element_type = llvm_get_debug_type(thread, builder, array.descriptor.element_type);
const array_type = builder.createArrayType(bitsize, array.type.alignment * 8, element_type, array.descriptor.element_count);
break :block array_type.toType();
},
.typed_pointer => block: {
const typed_pointer = ty.get_payload(.typed_pointer);
const element_type = llvm_get_debug_type(thread, builder, typed_pointer.descriptor.pointee);
const alignment = 3;
const pointer_width = @bitSizeOf(usize);
// TODO:
const pointer_type = builder.createPointerType(element_type, pointer_width, alignment, "ptr", "ptr".len);
break :block pointer_type.toType();
},
.@"struct" => block: {
const nat_struct_type = ty.get_payload(.@"struct");
const file_struct = llvm_get_file(thread, nat_struct_type.declaration.scope.file);
const flags = LLVM.DebugInfo.Node.Flags{
.visibility = .none,
.forward_declaration = false,
.apple_block = false,
.block_by_ref_struct = false,
.virtual = false,
.artificial = false,
.explicit = false,
.prototyped = false,
.objective_c_class_complete = false,
.object_pointer = false,
.vector = false,
.static_member = false,
.lvalue_reference = false,
.rvalue_reference = false,
.reserved = false,
.inheritance = .none,
.introduced_virtual = false,
.bit_field = false,
.no_return = false,
.type_pass_by_value = false,
.type_pass_by_reference = false,
.enum_class = false,
.thunk = false,
.non_trivial = false,
.big_endian = false,
.little_endian = false,
.all_calls_described = false,
};
const file = file_struct.file;
const name = thread.identifiers.get(nat_struct_type.declaration.name).?;
const line = nat_struct_type.declaration.line;
const bitsize = nat_struct_type.type.size * 8;
const alignment = nat_struct_type.type.alignment;
var member_types = PinnedArray(*LLVM.DebugInfo.Type){};
const struct_type = builder.createStructType(file.toScope(), name.ptr, name.len, file, line, bitsize, alignment, flags, null, member_types.pointer, member_types.length, null);
ty.llvm_debug = struct_type.toType();
for (nat_struct_type.fields) |field| {
const field_type = llvm_get_debug_type(thread, builder, field.type);
const field_name = thread.identifiers.get(field.name).?;
const field_bitsize = field.type.size * 8;
const field_alignment = field.type.alignment * 8;
const field_offset = field.member_offset * 8;
const member_type = builder.createMemberType(file.toScope(), field_name.ptr, field_name.len, file, field.line, field_bitsize, field_alignment, field_offset, flags, field_type);
_ = member_types.append(member_type.toType());
}
builder.replaceCompositeTypes(struct_type, member_types.pointer, member_types.length);
break :block struct_type.toType();
},
.bitfield => block: {
const nat_bitfield_type = ty.get_payload(.bitfield);
const file_struct = llvm_get_file(thread, nat_bitfield_type.declaration.scope.file);
const flags = LLVM.DebugInfo.Node.Flags{
.visibility = .none,
.forward_declaration = false,
.apple_block = false,
.block_by_ref_struct = false,
.virtual = false,
.artificial = false,
.explicit = false,
.prototyped = false,
.objective_c_class_complete = false,
.object_pointer = false,
.vector = false,
.static_member = false,
.lvalue_reference = false,
.rvalue_reference = false,
.reserved = false,
.inheritance = .none,
.introduced_virtual = false,
.bit_field = false,
.no_return = false,
.type_pass_by_value = false,
.type_pass_by_reference = false,
.enum_class = false,
.thunk = false,
.non_trivial = false,
.big_endian = false,
.little_endian = false,
.all_calls_described = false,
};
const file = file_struct.file;
const name = thread.identifiers.get(nat_bitfield_type.declaration.name).?;
const line = nat_bitfield_type.declaration.line;
const bitsize = nat_bitfield_type.type.size * 8;
const alignment = nat_bitfield_type.type.alignment;
var member_types = PinnedArray(*LLVM.DebugInfo.Type){};
const struct_type = builder.createStructType(file.toScope(), name.ptr, name.len, file, line, bitsize, alignment, flags, null, member_types.pointer, member_types.length, null);
ty.llvm_debug = struct_type.toType();
const nat_backing_type = &thread.integers[nat_bitfield_type.type.bit_size - 1];
const backing_type = llvm_get_debug_type(thread, builder, &nat_backing_type.type);
for (nat_bitfield_type.fields) |field| {
const field_name = thread.identifiers.get(field.name).?;
const field_bitsize = field.type.bit_size;
const field_offset = field.member_offset;
const member_flags = LLVM.DebugInfo.Node.Flags{
.visibility = .none,
.forward_declaration = false,
.apple_block = false,
.block_by_ref_struct = false,
.virtual = false,
.artificial = false,
.explicit = false,
.prototyped = false,
.objective_c_class_complete = false,
.object_pointer = false,
.vector = false,
.static_member = false,
.lvalue_reference = false,
.rvalue_reference = false,
.reserved = false,
.inheritance = .none,
.introduced_virtual = false,
.bit_field = true,
.no_return = false,
.type_pass_by_value = false,
.type_pass_by_reference = false,
.enum_class = false,
.thunk = false,
.non_trivial = false,
.big_endian = false,
.little_endian = false,
.all_calls_described = false,
};
const member_type = builder.createBitfieldMemberType(file.toScope(), field_name.ptr, field_name.len, file, field.line, field_bitsize, field_offset, 0, member_flags, backing_type);
_ = member_types.append(member_type.toType());
}
builder.replaceCompositeTypes(struct_type, member_types.pointer, member_types.length);
break :block struct_type.toType();
},
else => |t| @panic(@tagName(t)),
};
ty.llvm_debug = llvm_debug_type;
return llvm_debug_type;
}
}
fn llvm_get_type(thread: *Thread, ty: *Type) *LLVM.Type {
if (ty.llvm) |llvm| {
assert(ty.sema.thread == thread.get_index());
assert(llvm.getContext() == thread.llvm.context);
return llvm;
} else {
const llvm_type: *LLVM.Type = switch (ty.sema.id) {
.void => b: {
const void_type = thread.llvm.context.getVoidType();
break :b void_type;
},
.integer => b: {
const integer_type = thread.llvm.context.getIntegerType(@intCast(ty.bit_size));
break :b integer_type.toType();
},
.array => b: {
const array_ty = ty.get_payload(.array);
const element_type = llvm_get_type(thread, array_ty.descriptor.element_type);
const array_type = LLVM.Type.Array.get(element_type, array_ty.descriptor.element_count);
break :b array_type.toType();
},
.opaque_pointer, .typed_pointer => b: {
const pointer_type = thread.llvm.context.getPointerType(address_space);
break :b pointer_type.toType();
},
.function => b: {
const nat_function_type = ty.get_payload(.function);
const return_type = llvm_get_type(thread, nat_function_type.abi.abi_return_type);
var argument_types = PinnedArray(*LLVM.Type){};
_ = &argument_types;
for (nat_function_type.abi.abi_argument_types) |argument_type| {
const llvm_arg_type = llvm_get_type(thread, argument_type);
_ = argument_types.append(llvm_arg_type);
}
const is_var_args = false;
const function_type = LLVM.getFunctionType(return_type, argument_types.pointer, argument_types.length, is_var_args);
break :b function_type.toType();
},
.@"struct" => b: {
const nat_struct_type = ty.get_payload(.@"struct");
var struct_types = PinnedArray(*LLVM.Type){};
for (nat_struct_type.fields) |field| {
const field_type = llvm_get_type(thread, field.type);
_ = struct_types.append(field_type);
}
const types = struct_types.const_slice();
const is_packed = false;
const name = thread.identifiers.get(nat_struct_type.declaration.name).?;
const struct_type = thread.llvm.context.createStructType(types.ptr, types.len, name.ptr, name.len, is_packed);
break :b struct_type.toType();
},
.anonymous_struct => b: {
const nat_struct_type = ty.get_payload(.anonymous_struct);
var struct_types = PinnedArray(*LLVM.Type){};
for (nat_struct_type.fields) |field| {
const field_type = llvm_get_type(thread, field.type);
_ = struct_types.append(field_type);
}
const types = struct_types.const_slice();
const is_packed = false;
const struct_type = thread.llvm.context.getStructType(types.ptr, types.len, is_packed);
break :b struct_type.toType();
},
.bitfield => b: {
const nat_bitfield_type = ty.get_payload(.bitfield);
const backing_type = llvm_get_type(thread, nat_bitfield_type.backing_type);
break :b backing_type;
},
else => |t| @panic(@tagName(t)),
};
ty.llvm = llvm_type;
return llvm_type;
}
}
fn llvm_get_file(thread: *Thread, file_index: u32) *LLVMFile {
assert(thread.generate_debug_information);
if (thread.debug_info_file_map.get_pointer(file_index)) |llvm| return llvm else {
const builder = thread.llvm.module.createDebugInfoBuilder();
const file = &instance.files.slice()[file_index];
const filename = std.fs.path.basename(file.path);
const directory = file.path[0..file.path.len - filename.len];
const llvm_file = builder.createFile(filename.ptr, filename.len, directory.ptr, directory.len);
const producer = "nativity";
const is_optimized = false;
const flags = "";
const runtime_version = 0;
const splitname = "";
const DWOId = 0;
const debug_info_kind = LLVM.DebugInfo.CompileUnit.EmissionKind.full_debug;
const split_debug_inlining = true;
const debug_info_for_profiling = false;
const name_table_kind = LLVM.DebugInfo.CompileUnit.NameTableKind.default;
const ranges_base_address = false;
const sysroot = "";
const sdk = "";
const compile_unit = builder.createCompileUnit(LLVM.DebugInfo.Language.c11, llvm_file, producer, producer.len, is_optimized, flags, flags.len, runtime_version, splitname, splitname.len, debug_info_kind, DWOId, split_debug_inlining, debug_info_for_profiling, name_table_kind, ranges_base_address, sysroot, sysroot.len, sdk, sdk.len);
thread.debug_info_file_map.put_no_clobber(file_index, .{
.file = llvm_file,
.compile_unit = compile_unit,
.builder = builder,
});
return thread.debug_info_file_map.get_pointer(file_index).?;
}
}
fn llvm_get_scope(thread: *Thread, scope: *Scope) *LLVM.DebugInfo.Scope {
assert(scope.id != .file);
if (scope.llvm) |llvm| {
return llvm;
} else {
const llvm_scope = switch (scope.id) {
.local => block: {
const local_block: *LocalBlock = @fieldParentPtr("scope", scope);
const file = llvm_get_file(thread, local_block.scope.file);
const parent_scope = llvm_get_scope(thread, scope.parent.?);
const lexical_block = file.builder.createLexicalBlock(parent_scope, file.file, scope.line, scope.column);
break :block lexical_block.toScope();
},
else => |t| @panic(@tagName(t)),
};
scope.llvm = llvm_scope;
return llvm_scope;
}
}
const calling_convention_map = std.EnumArray(CallingConvention, LLVM.Value.Constant.Function.CallingConvention).init(.{
.c = .C,
.custom = .Fast,
});
fn llvm_emit_function_declaration(thread: *Thread, nat_function: *Function.Declaration) void {
assert(nat_function.global_symbol.value.llvm == null);
const function_name = thread.identifiers.get(nat_function.global_symbol.global_declaration.declaration.name) orelse unreachable;
const nat_function_type = nat_function.get_function_type();
const function_type = llvm_get_type(thread, &nat_function_type.type);
const is_extern_function = nat_function.global_symbol.attributes.@"extern";
const export_or_extern = nat_function.global_symbol.attributes.@"export" or is_extern_function;
const linkage: LLVM.Linkage = switch (export_or_extern) {
true => .@"extern",
false => .internal,
};
const function = thread.llvm.module.createFunction(function_type.toFunction() orelse unreachable, linkage, address_space, function_name.ptr, function_name.len);
var parameter_attribute_sets = std.BoundedArray(*const LLVM.Attribute.Set, 512){};
const function_attributes = llvm_emit_function_attributes(thread, nat_function_type, &parameter_attribute_sets);
function.setAttributes(thread.llvm.context, function_attributes.function_attributes, function_attributes.return_attribute_set, function_attributes.parameter_attribute_sets.ptr, function_attributes.parameter_attribute_sets.len);
const calling_convention = calling_convention_map.get(nat_function_type.abi.calling_convention);
function.setCallingConvention(calling_convention);
if (thread.generate_debug_information) {
const file_index = nat_function.global_symbol.global_declaration.declaration.scope.file;
const llvm_file = llvm_get_file(thread, file_index);
// TODO: emit original arguments
var debug_argument_types = PinnedArray(*LLVM.DebugInfo.Type){};
for (nat_function.get_function_type().abi.original_argument_types) |argument_type| {
const arg_type = llvm_get_debug_type(thread, llvm_file.builder, argument_type);
_ = debug_argument_types.append(arg_type);
}
const subroutine_type_flags = LLVM.DebugInfo.Node.Flags{
.visibility = .none,
.forward_declaration = is_extern_function,
.apple_block = false,
.block_by_ref_struct = false,
.virtual = false,
.artificial = false,
.explicit = false,
.prototyped = false,
.objective_c_class_complete = false,
.object_pointer = false,
.vector = false,
.static_member = false,
.lvalue_reference = false,
.rvalue_reference = false,
.reserved = false,
.inheritance = .none,
.introduced_virtual = false,
.bit_field = false,
.no_return = false,
.type_pass_by_value = false,
.type_pass_by_reference = false,
.enum_class = false,
.thunk = false,
.non_trivial = false,
.big_endian = false,
.little_endian = false,
.all_calls_described = false,
};
const subroutine_type_calling_convention = LLVM.DebugInfo.CallingConvention.none;
const subroutine_type = llvm_file.builder.createSubroutineType(debug_argument_types.pointer, debug_argument_types.length, subroutine_type_flags, subroutine_type_calling_convention);
const subprogram_flags = LLVM.DebugInfo.Subprogram.Flags{
.virtuality = .none,
.local_to_unit = !export_or_extern,
.definition = !is_extern_function,
.optimized = false,
.pure = false,
.elemental = false,
.recursive = false,
.main_subprogram = false,
.deleted = false,
.object_c_direct = false,
};
const subprogram_declaration = null;
const file = llvm_file.file;
const scope = file.toScope();
const line = nat_function.global_symbol.global_declaration.declaration.line;
const scope_line = line + 1;
const subprogram = llvm_file.builder.createFunction(scope, function_name.ptr, function_name.len, function_name.ptr, function_name.len, file, line, subroutine_type, scope_line, subroutine_type_flags, subprogram_flags, subprogram_declaration);
nat_function.global_symbol.type.llvm_debug = subroutine_type.toType();
function.setSubprogram(subprogram);
if (nat_function.global_symbol.id == .function_definition) {
const function_definition = nat_function.global_symbol.get_payload(.function_definition);
function_definition.scope.scope.llvm = subprogram.toLocalScope().toScope();
}
}
nat_function.global_symbol.value.llvm = function.toValue();
}
fn create_constant_int(thread: *Thread, args: struct {
n: u64,
type: *Type,
resolved: bool = true,
}) *ConstantInt {
const constant_int = thread.constant_ints.append(.{
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = args.resolved,
.id = .constant_int,
},
},
.n = args.n,
.type = args.type,
});
return constant_int;
}
fn create_basic_block(thread: *Thread) *BasicBlock {
const block = thread.basic_blocks.append(.{
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = true,
.id = .basic_block,
},
},
});
return block;
}
fn emit_gep(thread: *Thread, analyzer: *Analyzer, args: struct{
pointer: *Value,
index: *Value,
type: *Type,
aggregate_type: *Type,
is_struct: bool,
line: u32,
column: u32,
scope: *Scope,
}) *GEP{
const gep = thread.geps.append(.{
.instruction = new_instruction(thread, .{
.scope = args.scope,
.line = args.line,
.column = args.column,
.id = .get_element_pointer,
}),
.pointer = args.pointer,
.index = args.index,
.type = args.type,
.aggregate_type = args.aggregate_type,
.is_struct = args.is_struct,
});
analyzer.append_instruction(&gep.instruction);
return gep;
}
fn emit_extract_value(thread: *Thread, analyzer: *Analyzer, args: struct{
aggregate: *Value,
index: u32,
type: *Type,
line: u32,
column: u32,
scope: *Scope,
}) *ExtractValue{
const extract_value = thread.extract_values.append(.{
.instruction = new_instruction(thread, .{
.scope = args.scope,
.line = args.line,
.column = args.column,
.id = .extract_value,
}),
.aggregate = args.aggregate,
.index = args.index,
.type = args.type,
});
analyzer.append_instruction(&extract_value.instruction);
return extract_value;
}
fn emit_insert_value(thread: *Thread, analyzer: *Analyzer, args: struct{
aggregate: *Value,
value: *Value,
index: u32,
type: *Type,
line: u32,
column: u32,
scope: *Scope,
}) *InsertValue{
const insert_value = thread.insert_values.append(.{
.instruction = new_instruction(thread, .{
.scope = args.scope,
.line = args.line,
.column = args.column,
.id = .insert_value,
}),
.value = args.value,
.aggregate = args.aggregate,
.index = args.index,
.type = args.type,
});
analyzer.append_instruction(&insert_value.instruction);
return insert_value;
}
fn emit_ret_void(thread: *Thread, analyzer: *Analyzer, args: RawEmitArgs) void {
const return_expression = thread.standalone_instructions.append(new_instruction(thread, .{
.id = .ret_void,
.line = args.line,
.column = args.column,
.scope = args.scope,
}));
analyzer.append_instruction(return_expression);
analyzer.current_basic_block.is_terminated = true;
}
fn emit_direct_coerce(analyzer: *Analyzer, thread: *Thread, args: struct{
coerced_type: *Type,
original_value: *Value,
}) *Value {
const source_type = args.original_value.get_type();
const local = emit_local_symbol(analyzer, thread, .{
.type = source_type,
.name = 0,
.initial_value = args.original_value,
.line = 0,
.column = 0,
});
const target_type = args.coerced_type;
const target_size = args.coerced_type.size;
const target_alignment = args.coerced_type.alignment;
const source_size = source_type.size;
const source_alignment = source_type.alignment;
const target_is_scalable_vector_type = false;
const source_is_scalable_vector_type = false;
if (source_size >= target_size and !source_is_scalable_vector_type and !target_is_scalable_vector_type) {
const load = emit_load(analyzer, thread, .{
.value = &local.instruction.value,
.type = target_type,
.scope = analyzer.current_scope,
.line = 0,
.column = 0,
});
return &load.instruction.value;
} else {
const alignment = @max(target_alignment, source_alignment);
const temporal = emit_local_symbol(analyzer, thread, .{
.name = 0,
.initial_value = null,
.type = args.coerced_type,
.line = 0,
.column = 0,
});
emit_memcpy(analyzer, thread, .{
.destination = &temporal.instruction.value,
.source = &local.instruction.value,
.destination_alignment = .{
.alignment = alignment,
},
.source_alignment = .{
.alignment = source_alignment,
},
.size = source_size,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
const load = emit_load(analyzer, thread, .{
.value = &temporal.instruction.value,
.type = args.coerced_type,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
return &load.instruction.value;
}
}
fn emit_return(thread: *Thread, analyzer: *Analyzer, args: struct {
return_value: *Value,
scope: *Scope,
line: u32,
column: u32,
}) void {
const function = analyzer.current_function;
const function_type = function.declaration.get_function_type();
const abi_value: *Value = switch (function_type.abi.return_type_abi.kind) {
.ignore => unreachable,
.direct => args.return_value,
// TODO:
.direct_coerce => |coerced_type| emit_direct_coerce(analyzer, thread, .{
.original_value = args.return_value,
.coerced_type = coerced_type,
}),
.direct_pair => |pair| b: {
const pair_struct_type = get_anonymous_two_field_struct(thread, pair);
assert(pair_struct_type == function_type.abi.abi_return_type);
const return_value_type = args.return_value.get_type();
if (pair_struct_type == return_value_type) {
unreachable;
} else {
const local = emit_local_symbol(analyzer, thread, .{
.type = return_value_type,
.name = 0,
.initial_value = args.return_value,
.line = 0,
.column = 0,
});
const source_is_scalable_vector_type = false;
const target_is_scalable_vector_type = false;
if (return_value_type.size >= pair_struct_type.size and !source_is_scalable_vector_type and !target_is_scalable_vector_type) {
const load = emit_load(analyzer, thread, .{
.value = &local.instruction.value,
.type = pair_struct_type,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
break :b &load.instruction.value;
} else {
const alignment = @max(return_value_type.alignment, pair_struct_type.alignment);
const temporal = emit_local_symbol(analyzer, thread, .{
.name = 0,
.initial_value = null,
.type = pair_struct_type,
.alignment = alignment,
.line = 0,
.column = 0,
});
emit_memcpy(analyzer, thread, .{
.destination = &temporal.instruction.value,
.destination_alignment = .{ .alignment = alignment },
.source = &local.instruction.value,
.source_alignment = .{ .alignment = local.alignment },
.size = local.type.size,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
const load = emit_load(analyzer, thread, .{
.value = &temporal.instruction.value,
.type = pair_struct_type,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
break :b &load.instruction.value;
}
}
},
.indirect => {
const return_pointer = analyzer.return_pointer orelse unreachable;
emit_store(analyzer, thread, .{
.destination = &return_pointer.value,
.source = args.return_value,
.alignment = function_type.abi.original_return_type.alignment,
.line = args.line,
.column = args.column,
.scope = args.scope,
});
emit_ret_void(thread, analyzer, .{
.line = args.line,
.column = args.column,
.scope = args.scope,
});
return;
},
else => |t| @panic(@tagName(t)),
};
const return_expression = thread.returns.append(.{
.instruction = new_instruction(thread, .{
.id = .ret,
.line = args.line,
.column = args.column,
.scope = args.scope,
}),
.value = abi_value,
});
analyzer.append_instruction(&return_expression.instruction);
analyzer.current_basic_block.is_terminated = true;
}
pub fn analyze_local_block(thread: *Thread, analyzer: *Analyzer, parser: *Parser, file: *File) *LocalBlock {
const src = file.source_code;
const function = analyzer.current_function;
const block_line = parser.get_debug_line();
const block_column = parser.get_debug_column();
parser.expect_character(src, brace_open);
const local_block = thread.local_blocks.append(.{
.scope = .{
.id = .local,
.parent = analyzer.current_scope,
.line = block_line,
.column = @intCast(block_column),
.file = file.scope.scope.file,
},
});
analyzer.current_scope = &local_block.scope;
parser.skip_space(src);
while (true) {
parser.skip_space(src);
const statement_start_ch_index = parser.i;
const statement_start_ch = src[statement_start_ch_index];
if (statement_start_ch == brace_close) {
break;
}
const debug_line = parser.get_debug_line();
const debug_column = parser.get_debug_column();
switch (statement_start_ch) {
// Local variable
'>' => {
parser.i += 1;
parser.skip_space(src);
const local_name = parser.parse_identifier(thread, src);
if (analyzer.current_scope.get_declaration(local_name)) |lookup_result| {
_ = lookup_result;
fail_message("Existing declaration with the same name");
}
const has_local_attributes = src[parser.i] == '[';
parser.i += @intFromBool(has_local_attributes);
if (has_local_attributes) {
fail_message("TODO: local attributes");
}
parser.skip_space(src);
const LocalResult = struct {
initial_value: *Value,
type: *Type,
};
const result: LocalResult = switch (src[parser.i]) {
':' => block: {
parser.i += 1;
parser.skip_space(src);
const local_type = parser.parse_type_expression(thread, file, analyzer.current_scope);
parser.skip_space(src);
parser.expect_character(src, '=');
parser.skip_space(src);
const local_initial_value = parser.parse_expression(analyzer, thread, file, local_type, .right);
break :block .{
.initial_value = local_initial_value,
.type = local_type,
};
},
'=' => block: {
parser.i += 1;
parser.skip_space(src);
const local_initial_value = parser.parse_expression(analyzer, thread, file, null, .right);
const local_type = local_initial_value.get_type();
break :block .{
.initial_value = local_initial_value,
.type = local_type,
};
},
else => fail(),
};
parser.skip_space(src);
parser.expect_character(src, ';');
_ = emit_local_symbol(analyzer, thread, .{
.name = local_name,
.initial_value = result.initial_value,
.type = result.type,
.line = debug_line,
.column = debug_column,
});
},
'b' => {
const identifier = parser.parse_raw_identifier(src);
const break_kw = "break";
if (byte_equal(identifier, break_kw)) {
parser.skip_space(src);
parser.expect_character(src, ';');
if (analyzer.loops.length == 0) {
fail_message("break when no loop");
}
const inner_loop = analyzer.loops.const_slice()[analyzer.loops.length - 1];
_ = emit_jump(analyzer, thread, .{
.basic_block = inner_loop.break_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
local_block.terminated = true;
} else {
parser.i = statement_start_ch_index;
}
},
'c' => {
const identifier = parser.parse_raw_identifier(src);
const continue_kw = "continue";
if (byte_equal(identifier, continue_kw)) {
parser.skip_space(src);
parser.expect_character(src, ';');
if (analyzer.loops.length == 0) {
fail_message("continue when no loop");
}
const inner_loop = analyzer.loops.const_slice()[analyzer.loops.length - 1];
_ = emit_jump(analyzer, thread, .{
.basic_block = inner_loop.continue_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
local_block.terminated = true;
} else {
parser.i = statement_start_ch_index;
}
},
'i' => {
if (src[parser.i + 1] == 'f') {
const if_block = parser.parse_if_expression(analyzer, thread, file);
local_block.terminated = local_block.terminated or if_block.terminated;
}
},
'l' => {
const identifier = parser.parse_raw_identifier(src);
const loop_text = "loop";
if (byte_equal(identifier, loop_text)) {
parser.skip_space(src);
const loop_header_block = create_basic_block(thread);
const loop_body_block = create_basic_block(thread);
const loop_exit_block = create_basic_block(thread);
_ = emit_jump(analyzer, thread, .{
.basic_block = loop_header_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
analyzer.current_basic_block = loop_header_block;
if (src[parser.i] == '(') {
const condition = parser.parse_condition(analyzer, thread, file);
_ = emit_branch(analyzer, thread, .{
.condition = condition,
.taken = loop_body_block,
.not_taken = loop_exit_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
} else {
_ = emit_jump(analyzer, thread, .{
.basic_block = loop_body_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
}
parser.skip_space(src);
analyzer.current_basic_block = loop_body_block;
_ = analyzer.loops.append(.{
.continue_block = loop_header_block,
.break_block = loop_exit_block,
});
switch (src[parser.i]) {
brace_open => {
const loop_block = analyze_local_block(thread, analyzer, parser, file);
if (!loop_block.terminated) {
_ = emit_jump(analyzer, thread, .{
.basic_block = loop_header_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
}
},
else => unreachable,
}
analyzer.current_basic_block = loop_exit_block;
analyzer.loops.length -= 1;
} else {
parser.i = statement_start_ch_index;
}
},
'r' => {
const identifier = parser.parse_raw_identifier(src);
if (byte_equal(identifier, "return")) {
parser.skip_space(src);
const function_type = function.declaration.get_function_type();
if (!function_type.abi.original_return_type.sema.resolved) {
fail_message("Return type not resolved");
}
const return_value = parser.parse_expression(analyzer, thread, file, function_type.abi.original_return_type, .right);
parser.expect_character(src, ';');
if (analyzer.return_block) |return_block| {
const return_phi = analyzer.return_phi.?;
_ = return_phi.nodes.append(.{
.value = return_value,
.basic_block = analyzer.current_basic_block,
});
assert(analyzer.current_basic_block != return_block);
_ = emit_jump(analyzer, thread, .{
.basic_block = return_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
} else if (analyzer.exit_blocks.length > 0) {
const return_phi = thread.phis.append(.{
.instruction = new_instruction(thread, .{
.id = .phi,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
}),
.type = function_type.abi.original_return_type,
});
analyzer.return_phi = return_phi;
const return_block = create_basic_block(thread);
analyzer.return_block = return_block;
_ = return_phi.nodes.append(.{
.value = return_value,
.basic_block = analyzer.current_basic_block,
});
_ = emit_jump(analyzer, thread, .{
.basic_block = return_block,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
} else {
emit_return(thread, analyzer, .{
.return_value = return_value,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
}
local_block.terminated = true;
} else {
parser.i = statement_start_ch_index;
}
},
'#' => {
const intrinsic = parser.parse_intrinsic(analyzer, thread, file, &thread.void);
assert(intrinsic == null);
parser.skip_space(src);
parser.expect_character(src, ';');
},
else => {},
}
if (statement_start_ch_index == parser.i) {
const left = parser.parse_single_expression(analyzer, thread, file, null, .left);
parser.skip_space(src);
const operation_index = parser.i;
const operation_ch = src[operation_index];
var is_binary_operation = false;
switch (operation_ch) {
'+', '-', '*', '/', '=' => {
if (operation_ch != '=') {
if (src[parser.i + 1] == '=') {
parser.i += 2;
is_binary_operation = true;
} else {
unreachable;
}
} else {
parser.i += 1;
}
parser.skip_space(src);
const expected_right_type = switch (left.sema.id) {
.instruction => b: {
const instruction = left.get_payload(.instruction);
switch (instruction.id) {
.load => {
const load = instruction.get_payload(.load);
switch (load.value.sema.id) {
.instruction => {
const load_instruction = load.value.get_payload(.instruction);
switch (load_instruction.id) {
.local_symbol => {
const local_symbol = load_instruction.get_payload(.local_symbol);
if (local_symbol.type.sema.id == .typed_pointer) {
const pointer_type = local_symbol.type.get_payload(.typed_pointer);
break :b pointer_type.descriptor.pointee;
} else if (local_symbol.type.sema.id == .opaque_pointer) {
unreachable;
} else {
break :b local_symbol.type;
}
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
},
.local_symbol => {
const local_symbol = instruction.get_payload(.local_symbol);
break :b local_symbol.type;
},
else => |t| @panic(@tagName(t)),
}
},
.global_symbol => b: {
const global_symbol = left.get_payload(.global_symbol);
const global_type = global_symbol.type;
break :b global_type;
},
else => |t| @panic(@tagName(t)),
};
const source = switch (is_binary_operation) {
false => parser.parse_expression(analyzer, thread, file, expected_right_type, .right),
true => block: {
const left_load = emit_load(analyzer, thread, .{
.value = left,
.type = expected_right_type,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
const right = parser.parse_expression(analyzer, thread, file, expected_right_type, .right);
const binary_operation_id: IntegerBinaryOperation.Id = switch (operation_ch) {
'+' => .add,
else => unreachable,
};
const binary_operation = emit_integer_binary_operation(analyzer, thread, .{
.id = binary_operation_id,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
.left = &left_load.instruction.value,
.right = right,
.type = expected_right_type,
});
break :block &binary_operation.instruction.value;
},
};
parser.skip_space(src);
parser.expect_character(src, ';');
emit_store(analyzer, thread, .{
.destination = left,
.source = source,
.alignment = expected_right_type.alignment,
.line = debug_line,
.column = debug_column,
.scope = analyzer.current_scope,
});
},
';' => {
switch (left.sema.id) {
.instruction => {
const instruction = left.get_payload(.instruction);
switch (instruction.id) {
.call => parser.i += 1,
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
},
else => @panic((src.ptr + parser.i)[0..1]),
}
}
}
analyzer.current_scope = analyzer.current_scope.parent.?;
parser.expect_character(src, brace_close);
return local_block;
}
const Aarch64 = struct{
};
const SystemV = struct{
const RegisterCount = struct{
gp_registers: u32,
sse_registers: u32,
};
const Class = enum {
no_class,
memory,
integer,
sse,
sseup,
fn merge(accumulator: Class, field: Class) Class {
assert(accumulator != .memory);
if (accumulator == field) {
return accumulator;
} else {
var a = accumulator;
var f = field;
if (@intFromEnum(accumulator) > @intFromEnum(field)) {
a = field;
f = accumulator;
}
return switch (a) {
.no_class => f,
.memory => .memory,
.integer => .integer,
.sse, .sseup => .sse,
};
}
}
};
fn classify(ty: *Type, base_offset: u64) [2]Class {
var result: [2]Class = undefined;
const is_memory = base_offset >= 8;
const current_index = @intFromBool(is_memory);
const not_current_index = @intFromBool(!is_memory);
assert(current_index != not_current_index);
result[current_index] = .memory;
result[not_current_index] = .no_class;
switch (ty.sema.id) {
.void, .noreturn => result[current_index] = .no_class,
.bitfield => result[current_index] = .integer,
.integer => {
const integer_index = ty.get_integer_index();
switch (integer_index) {
8 - 1, 16 - 1, 32 - 1, 64 - 1,
64 + 8 - 1, 64 + 16 - 1, 64 + 32 - 1, 64 + 64 - 1,
=> result[current_index] = .integer,
else => unreachable,
}
},
.typed_pointer => result[current_index] = .integer,
.@"struct" => {
if (ty.size <= 64) {
const has_variable_array = false;
if (!has_variable_array) {
const struct_type = ty.get_payload(.@"struct");
result[current_index] = .no_class;
const is_union = false;
var member_offset: u32 = 0;
for (struct_type.fields) |field| {
const offset = base_offset + member_offset;
const member_size = field.type.size;
const member_alignment = field.type.alignment;
member_offset = @intCast(library.align_forward(member_offset + member_size, ty.alignment));
const native_vector_size = 16;
if (ty.size > 16 and ((!is_union and ty.size != member_size) or ty.size > native_vector_size)) {
result[0] = .memory;
const r = classify_post_merge(ty.size, result);
return r;
}
if (offset % member_alignment != 0) {
result[0] = .memory;
const r = classify_post_merge(ty.size, result);
return r;
}
const member_classes = classify(field.type, offset);
for (&result, member_classes) |*r, m| {
const merge_result = r.merge(m);
r.* = merge_result;
}
if (result[0] == .memory or result[1] == .memory) break;
}
const final = classify_post_merge(ty.size, result);
result = final;
}
}
},
.array => {
if (ty.size <= 64) {
if (base_offset % ty.alignment == 0) {
const array_type = ty.get_payload(.array);
result[current_index] = .no_class;
const vector_size = 16;
if (ty.size > 16 and (ty.size != array_type.descriptor.element_type.size or ty.size > vector_size)) {
unreachable;
} else {
var offset = base_offset;
for (0..array_type.descriptor.element_count) |_| {
const element_classes = classify(array_type.descriptor.element_type, offset);
offset += array_type.descriptor.element_type.size;
const merge_result = [2]Class{ result[0].merge(element_classes[0]), result[1].merge(element_classes[1]) };
result = merge_result;
if (result[0] == .memory or result[1] == .memory) {
break;
}
}
const final_result = classify_post_merge(ty.size, result);
assert(final_result[1] != .sseup or final_result[0] != .sse);
result = final_result;
}
}
}
},
else => |t| @panic(@tagName(t)),
}
return result;
}
fn classify_post_merge(size: u64, classes: [2]Class) [2]Class{
if (classes[1] == .memory) {
return .{ .memory, .memory };
} else if (size > 16 and (classes[0] != .sse or classes[1] != .sseup)) {
return .{ .memory, classes[1] };
} else if (classes[1] == .sseup and classes[0] != .sse and classes[0] != .sseup) {
return .{ classes[0], .sse };
} else {
return classes;
}
}
fn get_int_type_at_offset(ty: *Type, offset: u32, source_type: *Type, source_offset: u32) *Type {
switch (ty.sema.id) {
.bitfield => {
const bitfield = ty.get_payload(.bitfield);
return get_int_type_at_offset(bitfield.backing_type, offset, if (source_type == ty) bitfield.backing_type else source_type, source_offset);
},
.integer => {
const integer_index = ty.get_integer_index();
switch (integer_index) {
64 - 1, 64 + 64 - 1 => return ty,
8 - 1, 16 - 1, 32 - 1, 64 + 8 - 1, 64 + 16 - 1, 64 + 32 - 1 => {
if (offset != 0) unreachable;
const start = source_offset + ty.size;
const end = source_offset + 8;
if (contains_no_user_data(source_type, start, end)) {
return ty;
}
},
else => unreachable,
}
},
.typed_pointer => return if (offset == 0) ty else unreachable,
.@"struct" => {
if (get_member_at_offset(ty, offset)) |field| {
return get_int_type_at_offset(field.type, @intCast(offset - field.member_offset), source_type, source_offset);
}
unreachable;
},
.array => {
const array_type = ty.get_payload(.array);
const element_type = array_type.descriptor.element_type;
const element_size = element_type.size;
const element_offset = (offset / element_size) * element_size;
return get_int_type_at_offset(element_type, @intCast(offset - element_offset), source_type, source_offset);
},
else => |t| @panic(@tagName(t)),
}
if (source_type.size - source_offset > 8) {
return &instance.threads[ty.sema.thread].integers[63].type;
} else {
const byte_count = source_type.size - source_offset;
const bit_count = byte_count * 8;
return &instance.threads[ty.sema.thread].integers[bit_count - 1].type;
}
unreachable;
}
fn get_member_at_offset(ty: *Type, offset: u32) ?*Type.AggregateField{
if (ty.size <= offset) {
return null;
}
var offset_it: u32 = 0;
var last_match: ?*Type.AggregateField = null;
const struct_type = ty.get_payload(.@"struct");
for (struct_type.fields) |field| {
if (offset_it > offset) {
break;
}
last_match = field;
offset_it = @intCast(library.align_forward(offset_it + field.type.size, ty.alignment));
}
assert(last_match != null);
return last_match;
}
fn contains_no_user_data(ty: *Type, start: u64, end: u64) bool {
if (ty.size <= start) {
return true;
}
switch (ty.sema.id) {
.@"struct" => {
const struct_type = ty.get_payload(.@"struct");
var offset: u64 = 0;
for (struct_type.fields) |field| {
if (offset >= end) break;
const field_start = if (offset < start) start - offset else 0;
if (!contains_no_user_data(field.type, field_start, end - offset)) return false;
offset += field.type.size;
}
return true;
},
.array => {
const array_type = ty.get_payload(.array);
for (0..array_type.descriptor.element_count) |i| {
const offset = i * array_type.descriptor.element_type.size;
if (offset >= end) break;
const element_start = if (offset < start) start - offset else 0;
if (!contains_no_user_data(array_type.descriptor.element_type, element_start, end - offset)) return false;
}
return true;
},
.anonymous_struct => unreachable,
else => return false,
}
}
fn get_argument_pair(types: [2]*Type) Function.Abi.Information{
const low_size = types[0].size;
const high_alignment = types[1].alignment;
const high_start = library.align_forward(low_size, high_alignment);
assert(high_start == 8);
return .{
.kind = .{
.direct_pair = types,
},
};
}
fn indirect_argument(ty: *Type, free_integer_registers: u32) Function.Abi.Information{
const is_illegal_vector = false;
if (!ty.is_aggregate() and !is_illegal_vector) {
if (ty.sema.id == .integer and ty.bit_size < 32) {
unreachable;
} else {
return .{
.kind = .direct,
};
}
} else {
if (free_integer_registers == 0) {
if (ty.alignment <= 8 and ty.size <= 8) {
unreachable;
}
}
if (ty.alignment < 8) {
return .{
.kind = .{
.indirect = .{
.type = ty,
.alignment = 8,
},
},
.attributes = .{
.realign = true,
.by_value = true,
},
};
} else {
return .{
.kind = .{
.indirect = .{
.type = ty,
.alignment = ty.alignment,
},
},
.attributes = .{
.by_value = true,
},
};
}
}
unreachable;
}
fn indirect_return(ty: *Type) Function.Abi.Information{
if (ty.is_aggregate()) {
return .{
.kind = .{
.indirect = .{
.type = ty,
.alignment = ty.alignment,
},
},
};
} else {
unreachable;
}
}
};
fn get_declaration_value(analyzer: *Analyzer, thread: *Thread, declaration: *Declaration, maybe_type: ?*Type, side: Side) *Value {
var declaration_type: *Type = undefined;
const declaration_value = switch (declaration.id) {
.local => block: {
const local_declaration = declaration.get_payload(.local);
const local_symbol = local_declaration.to_symbol();
declaration_type = local_symbol.type;
break :block &local_symbol.instruction.value;
},
.argument => block: {
const argument_declaration = declaration.get_payload(.argument);
const argument_symbol = argument_declaration.to_symbol();
declaration_type = argument_symbol.type;
break :block &argument_symbol.instruction.value;
},
.global => block: {
const global_declaration = declaration.get_payload(.global);
const global_symbol = global_declaration.to_symbol();
const global_type = global_symbol.get_type();
declaration_type = global_type;
break :block &global_symbol.value;
},
};
if (maybe_type) |ty| {
switch (typecheck(ty, declaration_type)) {
.success => {},
}
}
return switch (side) {
.left => declaration_value,
.right => block: {
const load = emit_load(analyzer, thread, .{
.value = declaration_value,
.type = declaration_type,
});
break :block &load.instruction.value;
},
};
}
pub fn analyze_file(thread: *Thread, file_index: u32) void {
const file = instance.files.get(@enumFromInt(file_index));
const src = file.source_code;
if (src.len > std.math.maxInt(u32)) {
fail_message("File too big");
}
file.functions.start = @intCast(thread.functions.length);
var parser = Parser{};
while (true) {
parser.skip_space(src);
if (parser.i >= src.len) {
break;
}
const declaration_start_i = parser.i;
const declaration_start_ch = src[declaration_start_i];
const declaration_line = parser.get_debug_line();
const declaration_column = parser.get_debug_column();
switch (declaration_start_ch) {
'>' => {
parser.i += 1;
parser.skip_space(src);
const global_name = parser.parse_identifier(thread, src);
if (global_name == 0) {
fail_message("discard identifier '_' cannot be used as a global variable name");
}
if (file.scope.scope.get_global_declaration(global_name)) |existing_global| {
_ = existing_global; // autofix
fail();
}
parser.skip_space(src);
parser.expect_character(src, ':');
parser.skip_space(src);
const global_type = parser.parse_type_expression(thread, file, &file.scope.scope);
parser.skip_space(src);
parser.expect_character(src, '=');
parser.skip_space(src);
const global_initial_value = parser.parse_constant_expression(thread, file, global_type);
parser.expect_character(src, ';');
const global_variable = thread.global_variables.append(.{
.global_symbol = .{
.global_declaration = .{
.declaration = .{
.id = .global,
.name = global_name,
.line = declaration_line,
.column = declaration_column,
.scope = &file.scope.scope,
},
.id = .global_symbol,
},
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = global_type.sema.resolved and global_initial_value.sema.resolved,
.id = .global_symbol,
},
},
.alignment = global_type.alignment,
.id = .global_variable,
.type = global_type,
.pointer_type = get_typed_pointer(thread, .{
.pointee = global_type,
}),
},
.initial_value = global_initial_value,
});
file.scope.scope.declarations.put_no_clobber(global_name, &global_variable.global_symbol.global_declaration.declaration);
},
'b' => {
const identifier = parser.parse_raw_identifier(src);
if (byte_equal(identifier, "bitfield")) {
parser.expect_character(src, '(');
const backing_type = parser.parse_type_expression(thread, file, &file.scope.scope);
parser.expect_character(src, ')');
switch (backing_type.sema.id) {
.integer => {
if (backing_type.bit_size > 64) {
fail();
}
if (backing_type.bit_size % 8 != 0) {
fail();
}
parser.skip_space(src);
const bitfield_name = parser.parse_identifier(thread, src);
const bitfield_type = thread.bitfields.append(.{
.type = .{
.sema = .{
.id = .bitfield,
.thread = thread.get_index(),
.resolved = true,
},
.size = backing_type.size,
.alignment = backing_type.alignment,
.bit_size = backing_type.bit_size,
},
.declaration = .{
.name = bitfield_name,
.id = .bitfield,
.line = declaration_line,
.column = declaration_column,
.scope = &file.scope.scope,
},
.fields = &.{},
.backing_type = backing_type,
});
file.scope.scope.declarations.put_no_clobber(bitfield_name, &bitfield_type.declaration);
parser.skip_space(src);
parser.expect_character(src, brace_open);
var fields = PinnedArray(*Type.AggregateField){};
var total_bit_count: u64 = 0;
while (parser.parse_field(thread, file)) |field_data| {
const field_bit_offset = total_bit_count;
const field_bit_count = field_data.type.bit_size;
if (field_bit_count == 0) {
fail();
}
total_bit_count += field_bit_count;
const field = thread.fields.append(.{
.type = field_data.type,
.parent = &bitfield_type.type,
.name = field_data.name,
.index = fields.length,
.line = field_data.line,
.column = field_data.column,
.member_offset = field_bit_offset,
});
_ = fields.append(field);
}
parser.i += 1;
if (total_bit_count != backing_type.bit_size) {
fail();
}
bitfield_type.fields = fields.const_slice();
},
else => |t| @panic(@tagName(t)),
}
} else {
fail();
}
},
'f' => {
if (src[parser.i + 1] == 'n') {
parser.i += 2;
parser.skip_space(src);
// This variable lives in the stack as mere data collector,
// so it will be consumed by other data structure later when
// it is certain if this declaration is an external function or
// a function definition
var function_declaration_data = Function.Declaration{
.global_symbol = .{
.global_declaration = .{
.declaration = .{
.name = std.math.maxInt(u32),
.id = .global,
.line = declaration_line,
.column = declaration_column,
.scope = &file.scope.scope,
},
.id = .global_symbol,
},
.alignment = 1,
.value = .{
.sema = .{
.thread = thread.get_index(),
.resolved = true, // TODO: is this correct?
.id = .global_symbol,
},
},
.id = .function_definition,
.type = undefined,
.pointer_type = undefined,
},
};
const has_function_attributes = src[parser.i] == '[';
parser.i += @intFromBool(has_function_attributes);
var calling_convention = CallingConvention.custom;
if (has_function_attributes) {
var attribute_mask = Function.Attribute.Mask.initEmpty();
while (true) {
parser.skip_space(src);
if (src[parser.i] == ']') break;
const attribute_identifier = parser.parse_raw_identifier(src);
b: inline for (@typeInfo(Function.Attribute).Enum.fields) |fa_field| {
if (byte_equal(fa_field.name, attribute_identifier)) {
const function_attribute = @field(Function.Attribute, fa_field.name);
if (attribute_mask.contains(function_attribute)) {
fail();
}
attribute_mask.setPresent(function_attribute, true);
switch (function_attribute) {
.cc => {
parser.skip_space(src);
parser.expect_character(src, '(');
parser.skip_space(src);
parser.expect_character(src, '.');
const cc_identifier = parser.parse_raw_identifier(src);
parser.skip_space(src);
parser.expect_character(src, ')');
inline for (@typeInfo(CallingConvention).Enum.fields) |cc_field| {
if (byte_equal(cc_field.name, cc_identifier)) {
calling_convention = @field(CallingConvention, cc_field.name);
break :b;
}
} else {
fail();
}
},
}
}
} else {
fail();
}
parser.skip_space(src);
const after_ch = src[parser.i];
switch (after_ch) {
']' => {},
else => unreachable,
}
}
parser.i += 1;
parser.skip_space(src);
}
function_declaration_data.global_symbol.global_declaration.declaration.name = parser.parse_identifier(thread, src);
parser.skip_space(src);
const has_global_attributes = src[parser.i] == '[';
parser.i += @intFromBool(has_global_attributes);
if (has_global_attributes) {
var attribute_mask = GlobalSymbol.Attribute.Mask.initEmpty();
while (true) {
parser.skip_space(src);
if (src[parser.i] == ']') break;
const attribute_identifier = parser.parse_raw_identifier(src);
inline for (@typeInfo(GlobalSymbol.Attribute).Enum.fields) |fa_field| {
if (byte_equal(fa_field.name, attribute_identifier)) {
const global_attribute = @field(GlobalSymbol.Attribute, fa_field.name);
if (attribute_mask.contains(global_attribute)) {
fail();
}
attribute_mask.setPresent(global_attribute, true);
switch (global_attribute) {
.@"export" => {
function_declaration_data.global_symbol.attributes.@"export" = true;
},
.@"extern" => {
function_declaration_data.global_symbol.attributes.@"extern" = true;
},
}
const after_ch =src[parser.i];
switch (after_ch) {
']' => {},
else => unreachable,
}
break;
}
} else {
fail();
}
parser.skip_space(src);
const after_ch = src[parser.i];
switch (after_ch) {
']' => {},
else => unreachable,
}
}
parser.i += 1;
parser.skip_space(src);
}
if (function_declaration_data.global_symbol.attributes.@"export" and function_declaration_data.global_symbol.attributes.@"extern") {
fail();
}
const split_modules = true;
if (split_modules and !function_declaration_data.global_symbol.attributes.@"extern") {
function_declaration_data.global_symbol.attributes.@"export" = true;
}
parser.expect_character(src, '(');
const ArgumentData = struct{
type: *Type,
name: u32,
line: u32,
column: u32,
};
var original_arguments = PinnedArray(ArgumentData){};
var original_argument_types = PinnedArray(*Type){};
var fully_resolved = true;
while (true) {
parser.skip_space(src);
if (src[parser.i] == ')') break;
const argument_line = parser.get_debug_line();
const argument_column = parser.get_debug_column();
const argument_name = parser.parse_identifier(thread, src);
parser.skip_space(src);
parser.expect_character(src, ':');
parser.skip_space(src);
const argument_type = parser.parse_type_expression(thread, file, &file.scope.scope);
fully_resolved = fully_resolved and argument_type.sema.resolved;
_ = original_arguments.append(.{
.type = argument_type,
.name = argument_name,
.line = argument_line,
.column = argument_column,
});
_ = original_argument_types.append(argument_type);
parser.skip_space(src);
switch (src[parser.i]) {
',' => parser.i += 1,
')' => {},
else => fail(),
}
}
parser.expect_character(src, ')');
parser.skip_space(src);
const original_return_type = parser.parse_type_expression(thread, file, &file.scope.scope);
fully_resolved = fully_resolved and original_return_type.sema.resolved;
const function_abi: Function.Abi = if (fully_resolved) switch (calling_convention) {
.c => abi: {
var argument_type_abis = PinnedArray(Function.Abi.Information){};
const return_type_abi: Function.Abi.Information = switch (builtin.cpu.arch) {
.x86_64 => block: {
switch (builtin.os.tag) {
.linux => {
const return_type_abi: Function.Abi.Information = rta: {
const type_classes = SystemV.classify(original_return_type, 0);
assert(type_classes[1] != .memory or type_classes[0] == .memory);
assert(type_classes[1] != .sseup or type_classes[0] == .sse);
const result_type = switch (type_classes[0]) {
.no_class => switch (type_classes[1]) {
.no_class => break :rta .{
.kind = .ignore,
},
else => |t| @panic(@tagName(t)),
},
.integer => b: {
const result_type = SystemV.get_int_type_at_offset(original_return_type, 0, original_return_type, 0);
if (type_classes[1] == .no_class and original_return_type.bit_size < 32) {
const signed = switch (original_return_type.sema.id) {
.integer => @intFromEnum(original_return_type.get_payload(.integer).signedness) != 0,
.bitfield => false,
else => |t| @panic(@tagName(t)),
};
break :rta .{
.kind = .{
.direct_coerce = original_return_type,
},
.attributes = .{
.sign_extend = signed,
.zero_extend = !signed,
},
};
}
break :b result_type;
},
.memory => break :rta SystemV.indirect_return(original_return_type),
else => |t| @panic(@tagName(t)),
};
const high_part: ?*Type = switch (type_classes[1]) {
.no_class, .memory => null,
.integer => b: {
assert(type_classes[0] != .no_class);
const high_part = SystemV.get_int_type_at_offset(original_return_type, 8, original_return_type, 8);
break :b high_part;
},
else => |t| @panic(@tagName(t)),
};
if (high_part) |hp| {
break :rta SystemV.get_argument_pair(.{ result_type, hp });
} else {
// TODO
const is_type = true;
if (is_type) {
if (result_type == original_return_type) {
break :rta Function.Abi.Information{
.kind = .direct,
};
} else {
break :rta Function.Abi.Information{
.kind = .{
.direct_coerce = result_type,
},
};
}
} else {
unreachable;
}
}
};
var available_registers = SystemV.RegisterCount{
.gp_registers = 6,
.sse_registers = 8,
};
if (return_type_abi.kind == .indirect) {
available_registers.gp_registers -= 1;
}
const return_by_reference = false;
if (return_by_reference) {
unreachable;
}
for (original_argument_types.const_slice()) |original_argument_type| {
var needed_registers = SystemV.RegisterCount{
.gp_registers = 0,
.sse_registers = 0,
};
const argument_type_abi_classification: Function.Abi.Information = ata: {
const type_classes = SystemV.classify(original_argument_type, 0);
assert(type_classes[1] != .memory or type_classes[0] == .memory);
assert(type_classes[1] != .sseup or type_classes[0] == .sse);
_ = &needed_registers; // autofix
const result_type = switch (type_classes[0]) {
.integer => b: {
needed_registers.gp_registers += 1;
const result_type = SystemV.get_int_type_at_offset(original_argument_type, 0, original_argument_type, 0);
if (type_classes[1] == .no_class and original_argument_type.bit_size < 32) {
const signed = switch (original_argument_type.sema.id) {
.integer => @intFromEnum(original_argument_type.get_payload(.integer).signedness) != 0,
.bitfield => false,
else => |t| @panic(@tagName(t)),
};
break :ata .{
.kind = .{
.direct_coerce = original_argument_type,
},
.attributes = .{
.sign_extend = signed,
.zero_extend = !signed,
},
};
}
break :b result_type;
},
.memory => break :ata SystemV.indirect_argument(original_argument_type, available_registers.gp_registers),
else => |t| @panic(@tagName(t)),
};
const high_part: ?*Type = switch (type_classes[1]) {
.no_class, .memory => null,
.integer => b: {
assert(type_classes[0] != .no_class);
needed_registers.gp_registers += 1;
const high_part = SystemV.get_int_type_at_offset(original_argument_type, 8, original_argument_type, 8);
break :b high_part;
},
else => |t| @panic(@tagName(t)),
};
if (high_part) |hp| {
break :ata SystemV.get_argument_pair(.{ result_type, hp });
} else {
// TODO
const is_type = true;
if (is_type) {
if (result_type == original_argument_type) {
break :ata Function.Abi.Information{
.kind = .direct,
};
} else if (result_type.sema.id == .integer and original_argument_type.sema.id == .integer and original_argument_type.size == result_type.size) {
unreachable;
} else {
break :ata Function.Abi.Information{
.kind = .{
.direct_coerce = result_type,
},
};
}
}
unreachable;
}
};
const argument_type_abi = if (available_registers.sse_registers < needed_registers.sse_registers or available_registers.gp_registers < needed_registers.gp_registers) b: {
break :b SystemV.indirect_argument(original_argument_type, available_registers.gp_registers);
} else b: {
available_registers.gp_registers -= needed_registers.gp_registers;
available_registers.sse_registers -= needed_registers.sse_registers;
break :b argument_type_abi_classification;
};
_ = argument_type_abis.append(argument_type_abi);
}
break :block return_type_abi;
},
else => |t| @panic(@tagName(t)),
}
},
.aarch64 => block: {
const return_type_abi: Function.Abi.Information = blk: {
if (original_return_type.returns_nothing()) {
break :blk .{
.kind = .ignore,
};
}
const size = original_return_type.size;
const alignment = original_return_type.alignment;
const is_vector = false;
if (is_vector and size > 16) {
unreachable;
}
if (!original_return_type.is_aggregate()) {
const extend = builtin.os.tag.isDarwin() and switch (original_return_type.sema.id) {
.integer => original_return_type.bit_size < 32,
.bitfield => original_return_type.bit_size < 32,
else => |t| @panic(@tagName(t)),
};
if (extend) {
const signed = switch (original_return_type.sema.id) {
else => |t| @panic(@tagName(t)),
.bitfield => @intFromEnum(original_return_type.get_payload(.bitfield).backing_type.get_payload(.integer).signedness) != 0,
.integer => @intFromEnum(original_return_type.get_payload(.integer).signedness) != 0,
.typed_pointer => false,
};
break :blk Function.Abi.Information{
.kind = .direct,
.attributes = .{
.zero_extend = !signed,
.sign_extend = signed,
},
};
} else break :blk .{
.kind = .direct,
};
} else {
assert(size > 0);
const is_variadic = false;
const is_aarch64_32 = false;
const maybe_homogeneous_aggregate = original_return_type.get_homogeneous_aggregate();
if (maybe_homogeneous_aggregate != null and !(is_aarch64_32 and is_variadic)) {
unreachable;
} else if (size <= 16) {
if (size <= 8 and builtin.cpu.arch.endian() == .little) {
break :blk .{
.kind = .{
.direct_coerce = &thread.integers[size * 8 - 1].type,
},
};
} else {
const aligned_size = library.align_forward(size, 8);
if (alignment < 16 and aligned_size == 16) {
break :blk .{
.kind = .{
.direct_coerce = get_array_type(thread, .{
.element_type = &thread.integers[63].type,
.element_count = 2,
}),
},
};
} else {
unreachable;
}
unreachable;
}
} else {
assert(alignment > 0);
break :blk .{
.kind = .{
.indirect = .{
.type = original_return_type,
.alignment = alignment,
},
},
.attributes = .{
.by_value = true,
},
};
}
}
};
for (original_argument_types.const_slice()) |argument_type| {
const argument_type_abi: Function.Abi.Information = blk: {
if (argument_type.returns_nothing()) {
break :blk .{
.kind = .ignore,
};
}
// TODO:
const is_illegal_vector = false;
if (is_illegal_vector) {
unreachable;
}
if (!argument_type.is_aggregate()) {
const extend = builtin.os.tag.isDarwin() and switch (argument_type.sema.id) {
else => |t| @panic(@tagName(t)),
.bitfield => argument_type.bit_size < 32,
.integer => argument_type.bit_size < 32,
.typed_pointer => false,
};
if (extend) {
const signed = switch (argument_type.sema.id) {
else => |t| @panic(@tagName(t)),
.bitfield => @intFromEnum(argument_type.get_payload(.bitfield).backing_type.get_payload(.integer).signedness) != 0,
.integer => @intFromEnum(argument_type.get_payload(.integer).signedness) != 0,
.typed_pointer => false,
};
break :blk Function.Abi.Information{
.kind = .direct,
.attributes = .{
.zero_extend = !signed,
.sign_extend = signed,
},
};
} else break :blk .{
.kind = .direct,
};
} else {
assert(argument_type.size > 0);
if (argument_type.get_homogeneous_aggregate()) |homogeneous_aggregate| {
_ = homogeneous_aggregate; // autofix
unreachable;
} else if (argument_type.size <= 16) {
const base_alignment = argument_type.alignment;
const is_aapcs = false;
const alignment = switch (is_aapcs) {
true => if (base_alignment < 16) 8 else 16,
false => @max(base_alignment, 8),
};
assert(alignment == 8 or alignment == 16);
const aligned_size = library.align_forward(argument_type.size, alignment);
if (alignment == 16) {
unreachable;
} else {
const element_count = @divExact(aligned_size, alignment);
if (element_count > 1) {
break :blk .{
.kind = .{
.direct_coerce = get_array_type(thread, .{
.element_type = &thread.integers[63].type,
.element_count = element_count,
}),
}
};
} else break :blk .{
.kind = .{
.direct_coerce = &thread.integers[63].type,
},
};
}
} else {
const alignment = argument_type.alignment;
assert(alignment > 0);
break :blk .{
.kind = .{
.indirect = .{
.type = argument_type,
.alignment = alignment,
},
},
};
}
}
};
_ = argument_type_abis.append(argument_type_abi);
}
break :block return_type_abi;
},
else => fail_message("ABI not supported"),
};
var abi_argument_types = PinnedArray(*Type){};
const abi_return_type = switch (return_type_abi.kind) {
.ignore, .direct => original_return_type,
.direct_coerce => |coerced_type| coerced_type,
.indirect => |indirect| b: {
_ = abi_argument_types.append(get_typed_pointer(thread, .{
.pointee = indirect.type,
}));
break :b &thread.void;
},
.direct_pair => |pair| get_anonymous_two_field_struct(thread, pair),
else => |t| @panic(@tagName(t)),
};
for (argument_type_abis.slice(), original_argument_types.const_slice()) |*argument_abi, original_argument_type| {
const start: u16 = @intCast(abi_argument_types.length);
switch (argument_abi.kind) {
.direct => _ = abi_argument_types.append(original_argument_type),
.direct_coerce => |coerced_type| _ = abi_argument_types.append(coerced_type),
.direct_pair => |pair| {
_ = abi_argument_types.append(pair[0]);
_ = abi_argument_types.append(pair[1]);
},
.indirect => |indirect| _ = abi_argument_types.append(get_typed_pointer(thread, .{
.pointee = indirect.type,
})),
else => |t| @panic(@tagName(t)),
}
const end: u16 = @intCast(abi_argument_types.length);
argument_abi.indices = .{start, end};
}
break :abi Function.Abi{
.original_return_type = original_return_type,
.original_argument_types = original_argument_types.const_slice(),
.abi_return_type = abi_return_type,
.abi_argument_types = abi_argument_types.const_slice(),
.return_type_abi = return_type_abi,
.argument_types_abi = argument_type_abis.const_slice(),
.calling_convention = calling_convention,
};
},
.custom => custom: {
break :custom Function.Abi{
.original_return_type = original_return_type,
.original_argument_types = original_argument_types.const_slice(),
.abi_return_type = original_return_type,
.abi_argument_types = original_argument_types.const_slice(),
.return_type_abi = .{
.kind = .direct,
},
.argument_types_abi = blk: {
var argument_abis = PinnedArray(Function.Abi.Information){};
for (0..original_argument_types.length) |i| {
_ = argument_abis.append(.{
.indices = .{@intCast(i), @intCast(i + 1) },
.kind = .direct,
});
}
break :blk argument_abis.const_slice();
},
.calling_convention = calling_convention,
};
},
} else {
unreachable;
};
const function_type = thread.function_types.append(.{
.type = .{
.sema = .{
.id = .function,
.resolved = true,
.thread = thread.get_index(),
},
.size = 0,
.alignment = 0,
.bit_size = 0,
},
.abi = function_abi,
});
function_declaration_data.global_symbol.type = &function_type.type;
function_declaration_data.global_symbol.pointer_type = get_typed_pointer(thread, .{
.pointee = function_declaration_data.global_symbol.type,
});
parser.skip_space(src);
switch (src[parser.i]) {
brace_open => {
if (function_declaration_data.global_symbol.attributes.@"extern") {
fail();
}
const function = thread.functions.add_one();
const entry_block = create_basic_block(thread);
function.* = .{
.declaration = function_declaration_data,
.scope = .{
.scope = .{
.id = .function,
.parent = &file.scope.scope,
.line = declaration_line + 1,
.column = declaration_column + 1,
.file = file_index,
},
},
.entry_block = entry_block,
};
file.scope.scope.declarations.put_no_clobber(function.declaration.global_symbol.global_declaration.declaration.name, &function.declaration.global_symbol.global_declaration.declaration);
var analyzer = Analyzer{
.current_function = function,
.current_basic_block = entry_block,
.current_scope = &function.scope.scope,
};
analyzer.current_scope = &analyzer.current_function.scope.scope;
switch (function_type.abi.return_type_abi.kind) {
.indirect => |indirect| {
_ = indirect; // autofix
const abi_argument = thread.abi_arguments.append(.{
.instruction = new_instruction(thread, .{
.scope = analyzer.current_scope,
.line = 0,
.column = 0,
.id = .abi_argument,
}),
.index = 0,
});
analyzer.append_instruction(&abi_argument.instruction);
analyzer.return_pointer = &abi_argument.instruction;
},
else => {},
}
if (original_arguments.length > 0) {
// var runtime_parameter_count: u64 = 0;
for (original_arguments.const_slice(), function_abi.argument_types_abi, 0..) |argument, argument_abi, argument_index| {
if (analyzer.current_scope.declarations.get(argument.name) != null) {
fail_message("A declaration already exists with such name");
}
var argument_abi_instructions = std.BoundedArray(*Instruction, 12){};
const argument_abi_count = argument_abi.indices[1] - argument_abi.indices[0];
const argument_symbol = if (argument_abi.kind == .indirect) blk: {
assert(argument_abi_count == 1);
const argument_symbol = emit_argument_symbol(&analyzer, thread, .{
.type = argument.type,
.name = argument.name,
.line = argument.line,
.column = argument.column,
.index = @intCast(argument_index),
.indirect_argument = argument_abi.indices[0],
});
argument_symbol.instruction.id = .abi_indirect_argument;
break :blk argument_symbol;
} else blk: {
for (0..argument_abi_count) |abi_argument_index| {
const abi_argument = thread.abi_arguments.append(.{
.instruction = new_instruction(thread, .{
.scope = analyzer.current_scope,
.line = 0,
.column = 0,
.id = .abi_argument,
}),
.index = @intCast(abi_argument_index + argument_abi.indices[0]),
});
analyzer.append_instruction(&abi_argument.instruction);
argument_abi_instructions.appendAssumeCapacity(&abi_argument.instruction);
}
const LowerKind = union(enum) {
direct,
direct_pair: [2]*Type,
direct_coerce: *Type,
indirect,
};
const lower_kind: LowerKind = switch (argument_abi.kind) {
.direct => .direct,
.direct_coerce => |coerced_type| if (argument.type == coerced_type) .direct else .{ .direct_coerce = coerced_type },
.direct_pair => |pair| .{ .direct_pair = pair },
.indirect => .indirect,
else => |t| @panic(@tagName(t)),
};
const argument_symbol = switch (lower_kind) {
.indirect => unreachable,
.direct => block: {
assert(argument_abi_count == 1);
const argument_symbol = emit_argument_symbol(&analyzer, thread, .{
.type = argument.type,
.name = argument.name,
.line = argument.line,
.column = argument.column,
.index = @intCast(argument_index),
});
_ = emit_store(&analyzer, thread, .{
.destination = &argument_symbol.instruction.value,
.source = &argument_abi_instructions.slice()[0].value,
.alignment = argument.type.alignment,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
break :block argument_symbol;
},
.direct_coerce => |coerced_type| block: {
assert(coerced_type != argument.type);
assert(argument_abi_count == 1);
const argument_symbol = emit_argument_symbol(&analyzer, thread, .{
.type = argument.type,
.name = argument.name,
.line = argument.line,
.column = argument.column,
.index = @intCast(argument_index),
});
switch (argument.type.sema.id) {
.@"struct" => {
// TODO:
const is_vector = false;
if (coerced_type.size <= argument.type.size and !is_vector) {
_ = emit_store(&analyzer, thread, .{
.destination = &argument_symbol.instruction.value,
.source = &argument_abi_instructions.slice()[0].value,
.alignment = coerced_type.alignment,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
} else {
const temporal = emit_local_symbol(&analyzer, thread, .{
.name = 0,
.initial_value = &argument_abi_instructions.slice()[0].value,
.type = coerced_type,
.line = 0,
.column = 0,
});
emit_memcpy(&analyzer, thread, .{
.destination = &argument_symbol.instruction.value,
.source = &temporal.instruction.value,
.destination_alignment = .{
.type = argument_symbol.type,
},
.source_alignment = .{
.type = temporal.type,
},
.size = argument.type.size,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
}
break :block argument_symbol;
},
else => |t| @panic(@tagName(t)),
}
unreachable;
},
.direct_pair => |pair| b: {
assert(argument_abi_count == 2);
assert(argument_abi_instructions.len == 2);
assert(pair[0].sema.id == .integer);
assert(pair[1].sema.id == .integer);
const alignments = [2]u32{ pair[0].alignment, pair[1].alignment };
const sizes = [2]u64{ pair[0].size, pair[1].size };
const alignment = @max(alignments[0], alignments[1]);
_ = alignment; // autofix
const high_aligned_size: u32 = @intCast(library.align_forward(sizes[1], alignments[1]));
_ = high_aligned_size; // autofix
const high_offset: u32 = @intCast(library.align_forward(sizes[0], alignments[1]));
assert(high_offset + sizes[1] <= argument.type.size);
const argument_symbol = emit_argument_symbol(&analyzer, thread, .{
.type = argument.type,
.name = argument.name,
.line = argument.line,
.column = argument.column,
.index = @intCast(argument_index),
});
_ = emit_store(&analyzer, thread, .{
.destination = &argument_symbol.instruction.value,
.source = &argument_abi_instructions.slice()[0].value,
.alignment = pair[0].alignment,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
const gep = emit_gep(thread, &analyzer, .{
.pointer = &argument_symbol.instruction.value,
.type = pair[1],
.aggregate_type = pair[0],
.index = &create_constant_int(thread, .{
.n = 1,
.type = &thread.integers[31].type,
}).value,
.is_struct = false,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
_ = emit_store(&analyzer, thread, .{
.destination = &gep.instruction.value,
.source = &argument_abi_instructions.slice()[1].value,
.alignment = pair[1].alignment,
.line = 0,
.column = 0,
.scope = analyzer.current_scope,
});
break :b argument_symbol;
},
};
break :blk argument_symbol;
};
if (argument.name != 0) {
analyzer.current_scope.declarations.put_no_clobber(argument.name, &argument_symbol.argument_declaration.declaration);
if (thread.generate_debug_information) {
emit_debug_argument(&analyzer, thread, .{
.argument_symbol = argument_symbol,
});
}
}
}
}
const result = analyze_local_block(thread, &analyzer, &parser, file);
_ = result;
const current_basic_block = analyzer.current_basic_block;
if (analyzer.return_phi) |return_phi| {
analyzer.current_basic_block = analyzer.return_block.?;
analyzer.append_instruction(&return_phi.instruction);
emit_return(thread, &analyzer, .{
.return_value = &return_phi.instruction.value,
.line = parser.get_debug_line(),
.column = parser.get_debug_column(),
.scope = analyzer.current_scope,
});
analyzer.current_basic_block = current_basic_block;
}
if (!current_basic_block.is_terminated and (current_basic_block.instructions.length > 0 or current_basic_block.predecessors.length > 0)) {
if (analyzer.return_block == null) {
switch (original_return_type.sema.id) {
.void => {
emit_ret_void(thread, &analyzer, .{
.line = parser.get_debug_line(),
.column = parser.get_debug_column(),
.scope = analyzer.current_scope,
});
},
else => |t| @panic(@tagName(t)),
}
} else {
unreachable;
}
}
},
';' => {
parser.i += 1;
if (!function_declaration_data.global_symbol.attributes.@"extern") {
fail();
}
function_declaration_data.global_symbol.id = .function_declaration;
const function_declaration = thread.external_functions.append(function_declaration_data);
file.scope.scope.declarations.put_no_clobber(function_declaration.global_symbol.global_declaration.declaration.name, &function_declaration.global_symbol.global_declaration.declaration);
},
else => fail_message("Unexpected character to close function declaration"),
}
} else {
fail();
}
},
'i' => {
const import_keyword = "import";
if (byte_equal(src[parser.i..][0..import_keyword.len], import_keyword)) {
parser.i += import_keyword.len;
parser.skip_space(src);
const string_literal = parser.parse_non_escaped_string_literal_content(src);
parser.skip_space(src);
parser.expect_character(src, ';');
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");
if (!has_right_extension) {
fail();
}
const filename_without_extension = filename[0..filename.len - ".nat".len];
const filename_without_extension_hash = hash_bytes(filename_without_extension);
const directory_path = file.get_directory_path();
const directory = std.fs.openDirAbsolute(directory_path, .{}) catch unreachable;
const file_path = library.realpath(thread.arena, directory, string_literal) catch unreachable;
const file_path_hash = intern_identifier(&thread.identifiers, file_path);
// std.debug.print("Interning '{s}' (0x{x}) in thread #{}\n", .{file_path, file_path_hash, thread.get_index()});
for (thread.imports.slice()) |import| {
const pending_file_hash = import.hash;
if (pending_file_hash == file_path_hash) {
fail();
}
} else {
const import = thread.imports.append(.{
.global_declaration = .{
.declaration = .{
.id = .global,
.name = std.math.maxInt(u32),
.line = declaration_line,
.column = declaration_column,
.scope = &file.scope.scope,
},
.id = .unresolved_import,
},
.hash = file_path_hash,
});
_ = import.files.append(file);
_ = file.imports.append(import);
file.scope.scope.declarations.put_no_clobber(filename_without_extension_hash, &import.global_declaration.declaration);
const global_declaration_reference: **GlobalDeclaration = @ptrCast(file.scope.scope.declarations.get_pointer(filename_without_extension_hash) orelse unreachable);
const import_values = file.values_per_import.append(.{});
const lazy_expression = thread.lazy_expressions.append(LazyExpression.init(global_declaration_reference, thread));
_ = import_values.append(&lazy_expression.value);
thread.add_control_work(.{
.id = .analyze_file,
.offset = file_path_hash,
.count = @intCast(file_index),
});
}
} else {
fail();
}
},
's' => {
const lead_identifier = parser.parse_raw_identifier(src);
if (byte_equal(lead_identifier, "struct")) {
parser.skip_space(src);
const struct_name = parser.parse_identifier(thread, src);
const struct_type = thread.structs.append(.{
.type = .{
.sema = .{
.id = .@"struct",
.thread = thread.get_index(),
.resolved = true,
},
.size = 0,
.alignment = 1,
.bit_size = 0,
},
.declaration = .{
.name = struct_name,
.id = .@"struct",
.line = declaration_line,
.column = declaration_column,
.scope = &file.scope.scope,
},
.fields = &.{},
});
file.scope.scope.declarations.put_no_clobber(struct_name, &struct_type.declaration);
parser.skip_space(src);
parser.expect_character(src, brace_open);
var fields = PinnedArray(*Type.AggregateField){};
while (parser.parse_field(thread, file)) |field_data| {
struct_type.type.alignment = @max(struct_type.type.alignment, field_data.type.alignment);
const aligned_offset = library.align_forward(struct_type.type.size, field_data.type.alignment);
const field = thread.fields.append(.{
.type = field_data.type,
.parent = &struct_type.type,
.name = field_data.name,
.index = fields.length,
.line = field_data.line,
.column = field_data.column,
.member_offset = aligned_offset,
});
struct_type.type.size = aligned_offset + field.type.size;
_ = fields.append(field);
}
parser.i += 1;
struct_type.type.size = library.align_forward(struct_type.type.size, struct_type.type.alignment);
struct_type.type.bit_size = struct_type.type.size * 8;
struct_type.fields = fields.const_slice();
} else {
fail();
}
},
else => fail(),
}
}
for (file.local_lazy_expressions.slice()) |local_lazy_expression| {
const name = local_lazy_expression.name;
if (file.scope.scope.get_global_declaration(name)) |global_declaration| {
switch (global_declaration.id) {
.global_symbol => {
const global_symbol = global_declaration.to_symbol();
switch (global_symbol.id) {
.function_definition => {
const function_definition = global_symbol.get_payload(.function_definition);
for (local_lazy_expression.values.slice()) |value| {
switch (value.sema.id) {
.instruction => {
const instruction = value.get_payload(.instruction);
switch (instruction.id) {
.call => {
const call = instruction.get_payload(.call);
call.callable = &function_definition.declaration.global_symbol.value;
call.instruction.value.sema.resolved = true;
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
}
},
else => |t| @panic(@tagName(t)),
}
},
else => |t| @panic(@tagName(t)),
}
} else {
fail_term("Unable to find lazy expression", thread.identifiers.get(name).?);
}
}
try_resolve_file(thread, file);
}
fn try_resolve_file(thread: *Thread, file: *File) void {
if (file.imports.length == file.resolved_import_count) {
thread.analyzed_file_count += 1;
if (thread.analyzed_file_count == thread.assigned_file_count) {
if (@atomicLoad(@TypeOf(thread.task_system.job.queuer.to_do), &thread.task_system.job.queuer.to_do, .seq_cst) == thread.task_system.job.worker.completed + 1) {
thread.add_control_work(.{
.id = .notify_analysis_complete,
});
} else {
unreachable;
}
}
for (file.interested_threads.slice()) |ti| {
thread.add_control_work(.{
.id = .notify_file_resolved,
.offset = file.get_index(),
.count = @intCast(ti),
});
}
}
}
const TypecheckResult = enum{
success,
};
fn typecheck(expected: *Type, have: *Type) TypecheckResult {
if (expected == have) {
return TypecheckResult.success;
} else {
fail();
}
}
fn emit_integer_binary_operation(analyzer: *Analyzer, thread: *Thread, args: struct{
left: *Value,
right: *Value,
type: *Type,
id: IntegerBinaryOperation.Id,
scope: *Scope,
line: u32,
column: u32,
}) *IntegerBinaryOperation{
const integer_binary_operation = thread.integer_binary_operations.append(.{
.instruction = new_instruction(thread, .{
.id = .integer_binary_operation,
.line = args.line,
.column = args.column,
.scope = analyzer.current_scope,
}),
.left = args.left,
.right = args.right,
.type = args.type,
.id = args.id,
});
analyzer.append_instruction(&integer_binary_operation.instruction);
return integer_binary_operation;
}
fn emit_cast(analyzer: *Analyzer, thread: *Thread, args: struct{
value: *Value,
type: *Type,
id: Cast.Id,
scope: *Scope,
line: u32,
column: u32,
}) *Cast{
const cast = thread.casts.append(.{
.instruction = new_instruction(thread, .{
.id = .cast,
.line = args.line,
.column = args.column,
.scope = analyzer.current_scope,
}),
.value = args.value,
.type = args.type,
.id = args.id,
});
analyzer.append_instruction(&cast.instruction);
return cast;
}
fn emit_load(analyzer: *Analyzer, thread: *Thread, args: struct {
value: *Value,
type: *Type,
scope: *Scope,
line: u32,
column: u32,
is_volatile: bool = false,
}) *Load {
const load = thread.loads.append(.{
.instruction = new_instruction(thread, .{
.id = .load,
.line = args.line,
.column = args.column,
.scope = args.scope,
}),
.value = args.value,
.type = args.type,
.alignment = args.type.alignment,
.is_volatile = args.is_volatile,
});
analyzer.append_instruction(&load.instruction);
return load;
}
fn emit_argument_symbol(analyzer: *Analyzer, thread: *Thread, args: struct{
type: *Type,
name: u32,
line: u32,
column: u32,
index: u32,
indirect_argument: ?u32 = null,
}) *ArgumentSymbol{
const argument_symbol = thread.argument_symbols.append(.{
.argument_declaration = .{
.declaration = .{
.id = .argument,
.name = args.name,
.line = args.line,
.column = args.column,
.scope = analyzer.current_scope,
},
},
.type = args.type,
.pointer_type = get_typed_pointer(thread, .{
.pointee = args.type,
}),
.alignment = args.type.alignment,
.index = if (args.indirect_argument) |i| i else args.index,
.instruction = new_instruction(thread, .{
.scope = analyzer.current_scope,
.id = if (args.indirect_argument) |_| .abi_indirect_argument else .argument_storage,
.line = args.line,
.column = args.column,
}),
});
_ = analyzer.current_function.arguments.append(argument_symbol);
return argument_symbol;
}
fn emit_debug_argument(analyzer: *Analyzer, thread: *Thread, args: struct {
argument_symbol: *ArgumentSymbol,
}) void {
assert(thread.generate_debug_information);
var i = args.argument_symbol.instruction;
i.id = .debug_argument;
const debug_argument = thread.debug_arguments.append(.{
.argument = args.argument_symbol,
.instruction = i,
});
analyzer.append_instruction(&debug_argument.instruction);
}
fn emit_local_symbol(analyzer: *Analyzer, thread: *Thread, args: struct{
name: u32,
initial_value: ?*Value,
type: *Type,
line: u32,
column: u32,
alignment: ?u32 = null,
}) *LocalSymbol {
const local_symbol = thread.local_symbols.append(.{
.local_declaration = .{
.declaration = .{
.id = .local,
.name = args.name,
.line = args.line,
.column = args.column,
.scope = analyzer.current_scope,
},
},
.type = args.type,
.pointer_type = get_typed_pointer(thread, .{
.pointee = args.type,
}),
.instruction = new_instruction(thread, .{
.resolved = args.type.sema.resolved and if (args.initial_value) |iv| iv.sema.resolved else true,
.id = .local_symbol,
.line = args.line,
.column = args.column,
.scope = analyzer.current_scope,
}),
.alignment = if (args.alignment) |a| a else args.type.alignment,
});
_ = analyzer.current_function.stack_slots.append(local_symbol);
if (args.name != 0) {
analyzer.current_scope.declarations.put_no_clobber(args.name, &local_symbol.local_declaration.declaration);
if (thread.generate_debug_information) {
emit_debug_local(analyzer, thread, .{
.local_symbol = local_symbol,
});
}
}
if (args.initial_value) |initial_value| {
emit_store(analyzer, thread, .{
.destination = &local_symbol.instruction.value,
.source = initial_value,
.alignment = local_symbol.alignment,
.line = args.line,
.column = args.column,
.scope = analyzer.current_scope,
});
}
return local_symbol;
}
fn emit_debug_local(analyzer: *Analyzer, thread: *Thread, args: struct {
local_symbol: *LocalSymbol,
}) void {
assert(thread.generate_debug_information);
var i = args.local_symbol.instruction;
i.id = .debug_local;
const debug_local = thread.debug_locals.append(.{
.local = args.local_symbol,
.instruction = i,
});
analyzer.append_instruction(&debug_local.instruction);
}
fn emit_store(analyzer: *Analyzer, thread: *Thread, args: struct {
destination: *Value,
source: *Value,
alignment: u32,
line: u32,
column: u32,
scope: *Scope,
is_volatile: bool = false,
}) void {
const store = thread.stores.append(.{
.instruction = new_instruction(thread, .{
.id = .store,
.line = args.line,
.column = args.column,
.scope = args.scope,
}),
.destination = args.destination,
.source = args.source,
.alignment = args.alignment,
.is_volatile = args.is_volatile,
});
analyzer.append_instruction(&store.instruction);
}
const Memcpy = struct{
instruction: Instruction,
destination: *Value,
destination_alignment: u32,
source: *Value,
source_alignment: u32,
size: u64,
is_volatile: bool,
const Alignment = union(enum){
alignment: u32,
type: *Type,
};
};
fn emit_memcpy(analyzer: *Analyzer, thread: *Thread, args: struct{
destination: *Value,
destination_alignment: Memcpy.Alignment,
source: *Value,
source_alignment: Memcpy.Alignment,
size: u64,
is_volatile: bool = false,
line: u32,
column: u32,
scope: *Scope,
}) void {
const memcpy = thread.memcopies.append(.{
.instruction = new_instruction(thread, .{
.scope = args.scope,
.line = args.line,
.column = args.column,
.id = .memcpy,
}),
.destination = args.destination,
.destination_alignment = switch (args.destination_alignment) {
.alignment => |a| a,
.type => |t| t.alignment,
},
.source = args.source,
.source_alignment = switch (args.source_alignment) {
.alignment => |a| a,
.type => |t| t.alignment,
},
.size = args.size,
.is_volatile = args.is_volatile,
});
analyzer.append_instruction(&memcpy.instruction);
}
const RawEmitArgs = struct{
line: u32,
column: u32,
scope: *Scope,
};
fn emit_unreachable(analyzer: *Analyzer, thread: *Thread, args: RawEmitArgs) void {
assert(!analyzer.current_basic_block.is_terminated);
const ur = thread.standalone_instructions.append(new_instruction(thread, .{
.scope = args.scope,
.line = args.line,
.column = args.column,
.id = .@"unreachable",
}));
analyzer.append_instruction(ur);
analyzer.current_basic_block.is_terminated = true;
}
fn emit_trap(analyzer: *Analyzer, thread: *Thread, args: RawEmitArgs) void {
assert(!analyzer.current_basic_block.is_terminated);
const trap = thread.standalone_instructions.append(new_instruction(thread, .{
.scope = args.scope,
.line = args.line,
.column = args.column,
.id = .@"trap",
}));
analyzer.append_instruction(trap);
emit_unreachable(analyzer, thread, args);
}
fn new_instruction(thread: *Thread, args: struct {
scope: *Scope,
line: u32,
column: u32,
id: Instruction.Id,
resolved: bool = true,
}) Instruction {
return Instruction{
.id = args.id,
.value = .{
.sema = .{
.thread = thread.get_index(),
.id = .instruction,
.resolved = args.resolved,
},
},
.scope = args.scope,
.line = args.line,
.column = args.column,
};
}
const JumpEmission = struct {
jump: *Jump,
basic_block: *BasicBlock,
};
fn emit_jump(analyzer: *Analyzer, thread: *Thread, args: struct {
basic_block: *BasicBlock,
line: u32,
column: u32,
scope: *Scope,
}) JumpEmission {
assert(!analyzer.current_basic_block.is_terminated);
const jump = thread.jumps.append(.{
.instruction = new_instruction(thread, .{
.id = .jump,
.line = args.line,
.column = args.column,
.scope = args.scope,
}),
.basic_block = args.basic_block,
});
const original_block = analyzer.current_basic_block;
analyzer.append_instruction(&jump.instruction);
analyzer.current_basic_block.is_terminated = true;
_ = args.basic_block.predecessors.append(analyzer.current_basic_block);
return .{
.jump = jump,
.basic_block = original_block,
};
}
const BranchEmission = struct {
branch: *Branch,
basic_block: *BasicBlock,
// index: u32,
};
fn emit_branch(analyzer: *Analyzer, thread: *Thread, args: struct {
condition: *Value,
taken: *BasicBlock,
not_taken: *BasicBlock,
line: u32,
column: u32,
scope: *Scope,
}) BranchEmission {
assert(!analyzer.current_basic_block.is_terminated);
const branch = thread.branches.append(.{
.instruction = new_instruction(thread, .{
.id = .branch,
.line = args.line,
.column = args.column,
.scope = args.scope,
}),
.condition = args.condition,
.taken = args.taken,
.not_taken = args.not_taken,
});
const original_block = analyzer.current_basic_block;
analyzer.append_instruction(&branch.instruction);
analyzer.current_basic_block.is_terminated = true;
_ = args.taken.predecessors.append(analyzer.current_basic_block);
_ = args.not_taken.predecessors.append(analyzer.current_basic_block);
return .{
.branch = branch,
.basic_block = original_block,
};
}
fn emit_condition(analyzer: *Analyzer, thread: *Thread, args: struct {
condition: *Value,
line: u32,
column: u32,
scope: *Scope,
}) *Value {
const condition_type = args.condition.get_type();
const compare = switch (condition_type.sema.id) {
.integer => int: {
if (condition_type.bit_size == 1) {
break :int args.condition;
} else {
const zero = create_constant_int(thread, .{
.n = 0,
.type = condition_type,
});
const compare = thread.integer_compares.append(.{
.instruction = new_instruction(thread, .{
.line = args.line,
.column = args.column,
.scope = args.scope,
.id = .integer_compare,
}),
.left = args.condition,
.right = &zero.value,
.id = .not_zero,
});
analyzer.append_instruction(&compare.instruction);
break :int &compare.instruction.value;
}
},
else => |t| @panic(@tagName(t)),
};
return compare;
}
fn get_typed_pointer(thread: *Thread, descriptor: Type.TypedPointer.Descriptor) *Type {
assert(descriptor.pointee.sema.resolved);
if (thread.typed_pointer_type_map.get(descriptor)) |result| return result else {
const typed_pointer_type = thread.typed_pointer_types.append(.{
.type = .{
.sema = .{
.thread = thread.get_index(),
.id = .typed_pointer,
.resolved = true,
},
.size = 8,
.alignment = 8,
.bit_size = 64,
},
.descriptor = descriptor,
});
thread.typed_pointer_type_map.put_no_clobber(descriptor, &typed_pointer_type.type);
return &typed_pointer_type.type;
}
}
fn get_anonymous_two_field_struct(thread: *Thread, types: [2]*Type) *Type {
if (thread.two_struct_map.get(types)) |result| return result else {
const anonymous_struct = thread.anonymous_structs.add_one();
const first_field = thread.fields.append(.{
.type = types[0],
.parent = &anonymous_struct.type,
.member_offset = 0,
.name = 0,
.index = 0,
.line = 0,
.column = 0,
});
const second_field = thread.fields.append(.{
.type = types[1],
.parent = &anonymous_struct.type,
.member_offset = types[0].alignment,
.name = 0,
.index = 1,
.line = 0,
.column = 0,
});
const fields = thread.arena.new_array(*Type.AggregateField, 2) catch unreachable;
fields[0] = first_field;
fields[1] = second_field;
const alignment = @max(types[0].alignment, types[1].alignment);
const size = library.align_forward(types[0].size + types[1].size, alignment);
anonymous_struct.* = .{
.type = .{
.sema = .{
.id = .anonymous_struct,
.thread = thread.get_index(),
.resolved = true,
},
.size = size,
.alignment = alignment,
.bit_size = @intCast(size * 8),
},
.fields = fields,
};
thread.two_struct_map.put_no_clobber(types, &anonymous_struct.type);
return &anonymous_struct.type;
}
}
fn get_array_type(thread: *Thread, descriptor: Type.Array.Descriptor) *Type {
assert(descriptor.element_type.sema.resolved);
if (thread.array_type_map.get(descriptor)) |result| return result else {
const array_type = thread.array_types.append(.{
.type = .{
.sema = .{
.thread = thread.get_index(),
.id = .array,
.resolved = true,
},
.size = descriptor.element_type.size * descriptor.element_count,
.alignment = descriptor.element_type.alignment,
.bit_size = 0,
},
.descriptor = descriptor,
});
thread.array_type_map.put_no_clobber(descriptor, &array_type.type);
return &array_type.type;
}
}
pub const LLVM = struct {
const bindings = @import("backend/llvm_bindings.zig");
pub const initializeAll = bindings.NativityLLVMInitializeAll;
pub const x86_64 = struct {
pub const initializeTarget = bindings.LLVMInitializeX86Target;
pub const initializeTargetInfo = bindings.LLVMInitializeX86TargetInfo;
pub const initializeTargetMC = bindings.LLVMInitializeX86TargetMC;
pub const initializeAsmPrinter = bindings.LLVMInitializeX86AsmPrinter;
pub const initializeAsmParser = bindings.LLVMInitializeX86AsmParser;
};
pub const aarch64 = struct {
pub const initializeTarget = bindings.LLVMInitializeAArch64Target;
pub const initializeTargetInfo = bindings.LLVMInitializeAArch64TargetInfo;
pub const initializeTargetMC = bindings.LLVMInitializeAArch64TargetMC;
pub const initializeAsmPrinter = bindings.LLVMInitializeAArch64AsmPrinter;
pub const initializeAsmParser = bindings.LLVMInitializeAArch64AsmParser;
};
pub const Attributes = struct {
noreturn: *Attribute,
naked: *Attribute,
nounwind: *Attribute,
inreg: *Attribute,
@"noalias": *Attribute,
sign_extend: *Attribute,
zero_extend: *Attribute,
};
pub const Linkage = enum(c_uint) {
@"extern" = 0,
available_external = 1,
link_once_any = 2,
link_once_odr = 3,
weak_any = 4,
weak_odr = 5,
appending = 6,
internal = 7,
private = 8,
external_weak = 9,
common = 10,
};
pub const ThreadLocalMode = enum(c_uint) {
not_thread_local = 0,
};
const getFunctionType = bindings.NativityLLVMGetFunctionType;
pub const Context = opaque {
const create = bindings.NativityLLVMCreateContext;
const createBasicBlock = bindings.NativityLLVMCreateBasicBlock;
const getConstantInt = bindings.NativityLLVMContextGetConstantInt;
const getConstString = bindings.NativityLLVMContextGetConstString;
const getVoidType = bindings.NativityLLVMGetVoidType;
const getIntegerType = bindings.NativityLLVMGetIntegerType;
const getPointerType = bindings.NativityLLVMGetPointerType;
const getStructType = bindings.NativityLLVMGetStructType;
const createStructType = bindings.NativityLLVMCreateStructType;
const getIntrinsicType = bindings.NativityLLVMContextGetIntrinsicType;
const getAttributeFromEnum = bindings.NativityLLVMContextGetAttributeFromEnum;
const getAttributeFromString = bindings.NativityLLVMContextGetAttributeFromString;
const getAttributeFromType = bindings.NativityLLVMContextGetAttributeFromType;
const getAttributeSet = bindings.NativityLLVMContextGetAttributeSet;
};
pub const Module = opaque {
const addGlobalVariable = bindings.NativityLLVMModuleAddGlobalVariable;
const create = bindings.NativityLLVMCreateModule;
const getFunction = bindings.NativityLLVMModuleGetFunction;
const createFunction = bindings.NativityLLVModuleCreateFunction;
const verify = bindings.NativityLLVMVerifyModule;
const toString = bindings.NativityLLVMModuleToString;
const getIntrinsicDeclaration = bindings.NativityLLVMModuleGetIntrinsicDeclaration;
const createDebugInfoBuilder = bindings.NativityLLVMModuleCreateDebugInfoBuilder;
const setTargetMachineDataLayout = bindings.NativityLLVMModuleSetTargetMachineDataLayout;
const setTargetTriple = bindings.NativityLLVMModuleSetTargetTriple;
const runOptimizationPipeline = bindings.NativityLLVMRunOptimizationPipeline;
const addPassesToEmitFile = bindings.NativityLLVMModuleAddPassesToEmitFile;
const link = bindings.NativityLLVMLinkModules;
};
pub const LinkFlags = packed struct(c_uint) {
override_from_source: bool,
link_only_needed: bool,
_: u30 = 0,
};
pub const Builder = opaque {
const create = bindings.NativityLLVMCreateBuilder;
const setInsertPoint = bindings.NativityLLVMBuilderSetInsertPoint;
const createAdd = bindings.NativityLLVMBuilderCreateAdd;
const createAlloca = bindings.NativityLLVMBuilderCreateAlloca;
const createAnd = bindings.NativityLLVMBuilderCreateAnd;
const createOr = bindings.NativityLLVMBuilderCreateOr;
const createCall = bindings.NativityLLVMBuilderCreateCall;
const createCast = bindings.NativityLLVMBuilderCreateCast;
const createBranch = bindings.NativityLLVMBuilderCreateBranch;
const createConditionalBranch = bindings.NativityLLVMBuilderCreateConditionalBranch;
const createSwitch = bindings.NativityLLVMBuilderCreateSwitch;
const createGEP = bindings.NativityLLVMBuilderCreateGEP;
const createICmp = bindings.NativityLLVMBuilderCreateICmp;
const createIsNotNull = bindings.NativityLLVMBuilderCreateIsNotNull;
const createLoad = bindings.NativityLLVMBuilderCreateLoad;
const createMultiply = bindings.NativityLLVMBuilderCreateMultiply;
const createRet = bindings.NativityLLVMBuilderCreateRet;
const createShiftLeft = bindings.NativityLLVMBuilderCreateShiftLeft;
const createArithmeticShiftRight = bindings.NativityLLVMBuilderCreateArithmeticShiftRight;
const createLogicalShiftRight = bindings.NativityLLVMBuilderCreateLogicalShiftRight;
const createStore = bindings.NativityLLVMBuilderCreateStore;
const createSub = bindings.NativityLLVMBuilderCreateSub;
const createUnreachable = bindings.NativityLLVMBuilderCreateUnreachable;
const createXor = bindings.NativityLLVMBuilderCreateXor;
const createUDiv = bindings.NativityLLVMBuilderCreateUDiv;
const createSDiv = bindings.NativityLLVMBuilderCreateSDiv;
const createURem = bindings.NativityLLVMBuilderCreateURem;
const createSRem = bindings.NativityLLVMBuilderCreateSRem;
const createExtractValue = bindings.NativityLLVMBuilderCreateExtractValue;
const createInsertValue = bindings.NativityLLVMBuilderCreateInsertValue;
const createGlobalString = bindings.NativityLLVMBuilderCreateGlobalString;
const createGlobalStringPointer = bindings.NativityLLVMBuilderCreateGlobalStringPointer;
const createPhi = bindings.NativityLLVMBuilderCreatePhi;
const createMemcpy = bindings.NativityLLVMBuilderCreateMemcpy;
const getInsertBlock = bindings.NativityLLVMBuilderGetInsertBlock;
const isCurrentBlockTerminated = bindings.NativityLLVMBuilderIsCurrentBlockTerminated;
const setCurrentDebugLocation = bindings.NativityLLVMBuilderSetCurrentDebugLocation;
const clearCurrentDebugLocation = bindings.NativityLLVMBuilderClearCurrentDebugLocation;
const setInstructionDebugLocation = bindings.NativityLLVMBuilderSetInstructionDebugLocation;
};
pub const DebugInfo = struct {
pub const AttributeType = enum(c_uint) {
address = 0x01,
boolean = 0x02,
complex_float = 0x03,
float = 0x04,
signed = 0x05,
signed_char = 0x06,
unsigned = 0x07,
unsigned_char = 0x08,
imaginary_float = 0x09,
packed_decimal = 0x0a,
numeric_string = 0x0b,
edited = 0x0c,
signed_fixed = 0x0d,
unsigned_fixed = 0x0e,
decimal_float = 0x0f,
UTF = 0x10,
UCS = 0x11,
ASCII = 0x12,
};
pub const CallingConvention = enum(c_uint) {
none = 0,
normal = 0x01,
program = 0x02,
nocall = 0x03,
pass_by_reference = 0x04,
pass_by_value = 0x05,
// Vendor extensions
GNU_renesas_sh = 0x40,
GNU_borland_fastcall_i386 = 0x41,
BORLAND_safecall = 0xb0,
BORLAND_stdcall = 0xb1,
BORLAND_pascal = 0xb2,
BORLAND_msfastcall = 0xb3,
BORLAND_msreturn = 0xb4,
BORLAND_thiscall = 0xb5,
BORLAND_fastcall = 0xb6,
LLVM_vectorcall = 0xc0,
LLVM_Win64 = 0xc1,
LLVM_X86_64SysV = 0xc2,
LLVM_AAPCS = 0xc3,
LLVM_AAPCS_VFP = 0xc4,
LLVM_IntelOclBicc = 0xc5,
LLVM_SpirFunction = 0xc6,
LLVM_OpenCLKernel = 0xc7,
LLVM_Swift = 0xc8,
LLVM_PreserveMost = 0xc9,
LLVM_PreserveAll = 0xca,
LLVM_X86RegCall = 0xcb,
GDB_IBM_OpenCL = 0xff,
};
pub const Builder = opaque {
const createCompileUnit = bindings.NativityLLVMDebugInfoBuilderCreateCompileUnit;
const createFile = bindings.NativityLLVMDebugInfoBuilderCreateFile;
const createFunction = bindings.NativityLLVMDebugInfoBuilderCreateFunction;
const createSubroutineType = bindings.NativityLLVMDebugInfoBuilderCreateSubroutineType;
const createLexicalBlock = bindings.NativityLLVMDebugInfoBuilderCreateLexicalBlock;
const createParameterVariable = bindings.NativityLLVMDebugInfoBuilderCreateParameterVariable;
const createAutoVariable = bindings.NativityLLVMDebugInfoBuilderCreateAutoVariable;
const createGlobalVariableExpression = bindings.NativityLLVMDebugInfoBuilderCreateGlobalVariableExpression;
const createExpression = bindings.NativityLLVMDebugInfoBuilderCreateExpression;
const createBasicType = bindings.NativityLLVMDebugInfoBuilderCreateBasicType;
const createPointerType = bindings.NativityLLVMDebugInfoBuilderCreatePointerType;
const createStructType = bindings.NativityLLVMDebugInfoBuilderCreateStructType;
const createArrayType = bindings.NativityLLVMDebugInfoBuilderCreateArrayType;
const createEnumerationType = bindings.NativityLLVMDebugInfoBuilderCreateEnumerationType;
const createEnumerator = bindings.NativityLLVMDebugInfoBuilderCreateEnumerator;
const createReplaceableCompositeType = bindings.NativityLLVMDebugInfoBuilderCreateReplaceableCompositeType;
const createMemberType = bindings.NativityLLVMDebugInfoBuilderCreateMemberType;
const createBitfieldMemberType = bindings.NativityLLVMDebugInfoBuilderCreateBitfieldMemberType;
const insertDeclare = bindings.NativityLLVMDebugInfoBuilderInsertDeclare;
const finalizeSubprogram = bindings.NativityLLVMDebugInfoBuilderFinalizeSubprogram;
const finalize = bindings.NativityLLVMDebugInfoBuilderFinalize;
const replaceCompositeTypes = bindings.NativityLLVMDebugInfoBuilderCompositeTypeReplaceTypes;
};
pub const CompileUnit = opaque {
fn toScope(this: *@This()) *LLVM.DebugInfo.Scope {
return @ptrCast(this);
}
pub const EmissionKind = enum(c_uint) {
no_debug = 0,
full_debug = 1,
line_tables_only = 2,
debug_directives_only = 3,
};
pub const NameTableKind = enum(c_uint) {
default = 0,
gnu = 1,
none = 2,
};
};
pub const Expression = opaque {};
pub const GlobalVariableExpression = opaque {};
pub const LocalVariable = opaque {};
pub const LexicalBlock = opaque {
fn toScope(this: *@This()) *LLVM.DebugInfo.Scope {
return @ptrCast(this);
}
};
pub const Node = opaque {
pub const Flags = packed struct(u32) {
visibility: Visibility,
forward_declaration: bool,
apple_block: bool,
block_by_ref_struct: bool,
virtual: bool,
artificial: bool,
explicit: bool,
prototyped: bool,
objective_c_class_complete: bool,
object_pointer: bool,
vector: bool,
static_member: bool,
lvalue_reference: bool,
rvalue_reference: bool,
reserved: bool = false,
inheritance: Inheritance,
introduced_virtual: bool,
bit_field: bool,
no_return: bool,
type_pass_by_value: bool,
type_pass_by_reference: bool,
enum_class: bool,
thunk: bool,
non_trivial: bool,
big_endian: bool,
little_endian: bool,
all_calls_described: bool,
_: u3 = 0,
const Visibility = enum(u2) {
none = 0,
private = 1,
protected = 2,
public = 3,
};
const Inheritance = enum(u2) {
none = 0,
single = 1,
multiple = 2,
virtual = 3,
};
};
};
pub const File = opaque {
fn toScope(this: *@This()) *LLVM.DebugInfo.Scope {
return @ptrCast(this);
}
};
pub const Language = enum(c_uint) {
c = 0x02,
c11 = 0x1d,
};
pub const Scope = opaque {
const toSubprogram = bindings.NativityLLVMDebugInfoScopeToSubprogram;
};
pub const LocalScope = opaque {
fn toScope(this: *@This()) *LLVM.DebugInfo.Scope {
return @ptrCast(this);
}
};
pub const Subprogram = opaque {
const getFile = bindings.NativityLLVMDebugInfoSubprogramGetFile;
const getArgumentType = bindings.NativityLLVMDebugInfoSubprogramGetArgumentType;
fn toLocalScope(this: *@This()) *LocalScope {
return @ptrCast(this);
}
pub const Flags = packed struct(u32) {
virtuality: Virtuality,
local_to_unit: bool,
definition: bool,
optimized: bool,
pure: bool,
elemental: bool,
recursive: bool,
main_subprogram: bool,
deleted: bool,
reserved: bool = false,
object_c_direct: bool,
_: u20 = 0,
const Virtuality = enum(u2) {
none = 0,
virtual = 1,
pure_virtual = 2,
};
};
};
pub const Type = opaque {
const isResolved = bindings.NativityLLLVMDITypeIsResolved;
fn toScope(this: *@This()) *LLVM.DebugInfo.Scope {
return @ptrCast(this);
}
pub const Derived = opaque {
fn toType(this: *@This()) *LLVM.DebugInfo.Type {
return @ptrCast(this);
}
};
pub const Composite = opaque {
fn toType(this: *@This()) *LLVM.DebugInfo.Type {
return @ptrCast(this);
}
};
pub const Enumerator = opaque {};
pub const Subroutine = opaque {
fn toType(this: *@This()) *LLVM.DebugInfo.Type {
return @ptrCast(this);
}
};
};
};
pub const FloatAbi = enum(c_uint) {
default = 0,
soft = 1,
hard = 2,
};
pub const FloatOperationFusionMode = enum(c_uint) {
fast = 0,
standard = 1,
strict = 2,
};
pub const JumpTableType = enum(c_uint) {
single = 0,
arity = 1,
simplified = 2,
full = 3,
};
pub const ThreadModel = enum(c_uint) {
posix = 0,
single = 1,
};
pub const BasicBlockSection = enum(c_uint) {
all = 0,
list = 1,
labels = 2,
preset = 3,
none = 4,
};
pub const EAbi = enum(c_uint) {
unknown = 0,
default = 1,
eabi4 = 2,
eabi5 = 3,
gnu = 4,
};
pub const DebuggerKind = enum(c_uint) {
default = 0,
gdb = 1,
lldb = 2,
sce = 3,
dbx = 4,
};
pub const GlobalISelAbortMode = enum(c_uint) {
disable = 0,
enable = 1,
disable_with_diagnostic = 2,
};
pub const DebugCompressionType = enum(c_uint) {
none = 0,
zlib = 1,
zstd = 2,
};
pub const RelocationModel = enum(c_uint) {
static = 0,
pic = 1,
dynamic_no_pic = 2,
ropi = 3,
rwpi = 4,
ropi_rwpi = 5,
};
pub const CodeModel = enum(c_uint) {
tiny = 0,
small = 1,
kernel = 2,
medium = 3,
large = 4,
};
pub const PicLevel = enum(c_uint) {
not_pic = 0,
small_pic = 1,
big_pic = 2,
};
pub const PieLevel = enum(c_uint) {
default = 0,
small = 1,
large = 2,
};
pub const TlsModel = enum(c_uint) {
general_dynamic = 0,
local_dynamic = 1,
initial_exec = 2,
local_exec = 3,
};
pub const CodegenOptimizationLevel = enum(c_int) {
none = 0,
less = 1,
default = 2,
aggressive = 3,
};
pub const OptimizationLevel = extern struct {
speed_level: c_uint,
size_level: c_uint,
};
pub const FramePointerKind = enum(c_uint) {
none = 0,
non_leaf = 1,
all = 2,
};
pub const CodeGenFileType = enum(c_uint) {
assembly = 0,
object = 1,
null = 2,
};
pub const Target = opaque {
const createTargetMachine = bindings.NativityLLVMTargetCreateTargetMachine;
pub const Machine = opaque {};
// This is a non-LLVM struct
const Options = extern struct {
bin_utils_version: struct { i32, i32 },
fp_math: extern struct {
unsafe: bool,
no_infs: bool,
no_nans: bool,
no_traping: bool,
no_signed_zeroes: bool,
approx_func: bool,
enable_aix_extended_altivec_abi: bool,
honor_sign_dependent_rounding: bool,
},
no_zeroes_in_bss: bool,
guaranteed_tail_call_optimization: bool,
stack_symbol_ordering: bool,
enable_fast_isel: bool,
enable_global_isel: bool,
global_isel_abort_mode: GlobalISelAbortMode,
use_init_array: bool,
disable_integrated_assembler: bool,
debug_compression_type: DebugCompressionType,
relax_elf_relocations: bool,
function_sections: bool,
data_sections: bool,
ignore_xcoff_visibility: bool,
xcoff_traceback_table: bool,
unique_section_names: bool,
unique_basic_block_section_names: bool,
trap_unreachable: bool,
no_trap_after_noreturn: bool,
tls_size: u8,
emulated_tls: bool,
enable_ipra: bool,
emit_stack_size_section: bool,
enable_machine_outliner: bool,
enable_machine_function_splitter: bool,
support_default_outlining: bool,
emit_address_significance_table: bool,
bb_sections: BasicBlockSection,
emit_call_site_info: bool,
support_debug_entry_values: bool,
enable_debug_entry_values: bool,
value_tracking_variable_locations: bool,
force_dwarf_frame_section: bool,
xray_function_index: bool,
debug_strict_dwarf: bool,
hotpatch: bool,
ppc_gen_scalar_mass_entries: bool,
jmc_instrument: bool,
cfi_fixup: bool,
loop_alignment: u32 = 0,
float_abi_type: FloatAbi,
fp_operation_fusion: FloatOperationFusionMode,
thread_model: ThreadModel,
eabi_version: EAbi,
debugger_tuning: DebuggerKind,
};
};
const lookupIntrinsic = bindings.NativityLLVMLookupIntrinsic;
const newPhiNode = bindings.NativityLLVMCreatePhiNode;
pub const Metadata = opaque {
pub const Node = opaque {};
pub const Tuple = opaque {};
};
pub const Attribute = opaque {
pub const Set = opaque {};
pub const Id = enum(u32) {
AllocAlign = 1,
AllocatedPointer = 2,
AlwaysInline = 3,
Builtin = 4,
Cold = 5,
Convergent = 6,
CoroDestroyOnlyWhenComplete = 7,
DeadOnUnwind = 8,
DisableSanitizerInstrumentation = 9,
FnRetThunkExtern = 10,
Hot = 11,
ImmArg = 12,
InReg = 13,
InlineHint = 14,
JumpTable = 15,
MinSize = 16,
MustProgress = 17,
Naked = 18,
Nest = 19,
NoAlias = 20,
NoBuiltin = 21,
NoCallback = 22,
NoCapture = 23,
NoCfCheck = 24,
NoDuplicate = 25,
NoFree = 26,
NoImplicitFloat = 27,
NoInline = 28,
NoMerge = 29,
NoProfile = 30,
NoRecurse = 31,
NoRedZone = 32,
NoReturn = 33,
NoSanitizeBounds = 34,
NoSanitizeCoverage = 35,
NoSync = 36,
NoUndef = 37,
NoUnwind = 38,
NonLazyBind = 39,
NonNull = 40,
NullPointerIsValid = 41,
OptForFuzzing = 42,
OptimizeForDebugging = 43,
OptimizeForSize = 44,
OptimizeNone = 45,
PresplitCoroutine = 46,
ReadNone = 47,
ReadOnly = 48,
Returned = 49,
ReturnsTwice = 50,
SExt = 51,
SafeStack = 52,
SanitizeAddress = 53,
SanitizeHWAddress = 54,
SanitizeMemTag = 55,
SanitizeMemory = 56,
SanitizeThread = 57,
ShadowCallStack = 58,
SkipProfile = 59,
Speculatable = 60,
SpeculativeLoadHardening = 61,
StackProtect = 62,
StackProtectReq = 63,
StackProtectStrong = 64,
StrictFP = 65,
SwiftAsync = 66,
SwiftError = 67,
SwiftSelf = 68,
WillReturn = 69,
Writable = 70,
WriteOnly = 71,
ZExt = 72,
ByRef = 73,
ByVal = 74,
ElementType = 75,
InAlloca = 76,
Preallocated = 77,
StructRet = 78,
Alignment = 79,
AllocKind = 80,
AllocSize = 81,
Dereferenceable = 82,
DereferenceableOrNull = 83,
Memory = 84,
NoFPClass = 85,
StackAlignment = 86,
UWTable = 87,
VScaleRange = 88,
};
};
pub const Type = opaque {
const compare = bindings.NativityLLVMCompareTypes;
const toStruct = bindings.NativityLLVMTypeToStruct;
const toFunction = bindings.NativityLLVMTypeToFunction;
const toArray = bindings.NativityLLVMTypeToArray;
const toPointer = bindings.NativityLLVMTypeToPointer;
const isPointer = bindings.NativityLLVMTypeIsPointer;
const isInteger = bindings.NativityLLVMTypeIsInteger;
const isVoid = bindings.NativityLLVMTypeIsVoid;
const assertEqual = bindings.NativityLLVMTypeAssertEqual;
const getPoison = bindings.NativityLLVMGetPoisonValue;
const getContext = bindings.NativityLLVMTypeGetContext;
pub const Array = opaque {
fn toType(integer: *@This()) *LLVM.Type {
return @ptrCast(integer);
}
const get = bindings.NativityLLVMGetArrayType;
const getConstant = bindings.NativityLLVMGetConstantArray;
const getElementType = bindings.NativityLLVMArrayTypeGetElementType;
};
pub const Integer = opaque {
fn toType(integer: *@This()) *LLVM.Type {
return @ptrCast(integer);
}
};
pub const Function = opaque {
fn toType(integer: *@This()) *LLVM.Type {
return @ptrCast(integer);
}
const getArgumentType = bindings.NativityLLVMFunctionTypeGetArgumentType;
const getReturnType = bindings.NativityLLVMFunctionTypeGetReturnType;
};
pub const Pointer = opaque {
fn toType(integer: *@This()) *LLVM.Type {
return @ptrCast(integer);
}
const getNull = bindings.NativityLLVMPointerTypeGetNull;
};
pub const Struct = opaque {
const getConstant = bindings.NativityLLVMGetConstantStruct;
fn toType(integer: *@This()) *LLVM.Type {
return @ptrCast(integer);
}
};
pub const Error = error{
void,
function,
integer,
pointer,
@"struct",
intrinsic,
array,
};
};
pub const Value = opaque {
const setName = bindings.NativityLLVMValueSetName;
const getType = bindings.NativityLLVMValueGetType;
const getContext = bindings.NativityLLVMValueGetContext;
const toConstant = bindings.NativityLLVMValueToConstant;
const toFunction = bindings.NativityLLVMValueToFunction;
const toAlloca = bindings.NativityLLVMValueToAlloca;
const toBasicBlock = bindings.NativityLLVMValueToBasicBlock;
const toString = bindings.NativityLLVMValueToString;
pub const IntrinsicID = enum(u32) {
none = 0,
_,
};
pub const BasicBlock = opaque {
const remove = bindings.NativityLLVMBasicBlockRemoveFromParent;
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Argument = opaque {
const getIndex = bindings.NativityLLVMArgumentGetIndex;
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Instruction = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
pub const Alloca = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
const getAllocatedType = bindings.NativityLLVMAllocatGetAllocatedType;
};
pub const Branch = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Call = opaque {
const setCallingConvention = bindings.NativityLLVMCallSetCallingConvention;
const setAttributes = bindings.NativityLLVMCallSetAttributes;
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Cast = opaque {
pub const Type = enum(c_uint) {
truncate = 38,
zero_extend = 39,
sign_extend = 40,
float_to_unsigned_integer = 41,
float_to_signed_integer = 42,
unsigned_integer_to_float = 43,
signed_integer_to_float = 44,
float_truncate = 45,
float_extend = 46,
pointer_to_int = 47,
int_to_pointer = 48,
bitcast = 49,
address_space_cast = 50,
};
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const ICmp = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
pub const Kind = enum(c_uint) {
eq = 32, // equal
ne = 33, // not equal
ugt = 34, // unsigned greater than
uge = 35, // unsigned greater or equal
ult = 36, // unsigned less than
ule = 37, // unsigned less or equal
sgt = 38, // signed greater than
sge = 39, // signed greater or equal
slt = 40, // signed less than
sle = 41, // signed less or equal
};
};
pub const Load = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const PhiNode = opaque {
pub const addIncoming = bindings.NativityLLVMPhiAddIncoming;
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Store = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Switch = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Ret = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Unreachable = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Error = error{
add,
alloca,
@"and",
arithmetic_shift_right,
call,
cast,
conditional_branch,
extract_value,
gep,
icmp,
insert_value,
load,
logical_shift_right,
multiply,
@"or",
ret,
sdiv,
shift_left,
store,
udiv,
@"unreachable",
xor,
};
};
pub const Constant = opaque {
pub const Function = opaque {
const getArgument = bindings.NativityLLVMFunctionGetArgument;
const getArguments = bindings.NativityLLVMFunctionGetArguments;
const getType = bindings.NativityLLVMFunctionGetType;
// const addAttributeKey = bindings.NativityLLVMFunctionAddAttributeKey;
const verify = bindings.NativityLLVMVerifyFunction;
const toString = bindings.NativityLLVMFunctionToString;
const setCallingConvention = bindings.NativityLLVMFunctionSetCallingConvention;
const getCallingConvention = bindings.NativityLLVMFunctionGetCallingConvention;
const setSubprogram = bindings.NativityLLVMFunctionSetSubprogram;
const getSubprogram = bindings.NativityLLVMFunctionGetSubprogram;
const setAttributes = bindings.NativityLLVMFunctionSetAttributes;
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
fn toConstant(this: *@This()) *Constant {
return @ptrCast(this);
}
pub const CallingConvention = enum(c_uint) {
/// The default llvm calling convention, compatible with C. This convention
/// is the only one that supports varargs calls. As with typical C calling
/// conventions, the callee/caller have to tolerate certain amounts of
/// prototype mismatch.
C = 0,
// Generic LLVM calling conventions. None of these support varargs calls,
// and all assume that the caller and callee prototype exactly match.
/// Attempts to make calls as fast as possible (e.g. by passing things in
/// registers).
Fast = 8,
/// Attempts to make code in the caller as efficient as possible under the
/// assumption that the call is not commonly executed. As such, these calls
/// often preserve all registers so that the call does not break any live
/// ranges in the caller side.
Cold = 9,
/// Used by the Glasgow Haskell Compiler (GHC).
GHC = 10,
/// Used by the High-Performance Erlang Compiler (HiPE).
HiPE = 11,
/// Used for stack based JavaScript calls
WebKit_JS = 12,
/// Used for dynamic register based calls (e.g. stackmap and patchpoint
/// intrinsics).
AnyReg = 13,
/// Used for runtime calls that preserves most registers.
PreserveMost = 14,
/// Used for runtime calls that preserves (almost) all registers.
PreserveAll = 15,
/// Calling convention for Swift.
Swift = 16,
/// Used for access functions.
CXX_FAST_TLS = 17,
/// Attemps to make calls as fast as possible while guaranteeing that tail
/// call optimization can always be performed.
Tail = 18,
/// Special calling convention on Windows for calling the Control Guard
/// Check ICall funtion. The function takes exactly one argument (address of
/// the target function) passed in the first argument register, and has no
/// return value. All register values are preserved.
CFGuard_Check = 19,
/// This follows the Swift calling convention in how arguments are passed
/// but guarantees tail calls will be made by making the callee clean up
/// their stack.
SwiftTail = 20,
/// This is the start of the target-specific calling conventions, e.g.
/// fastcall and thiscall on X86.
// FirstTargetCC = 64,
/// stdcall is mostly used by the Win32 API. It is basically the same as the
/// C convention with the difference in that the callee is responsible for
/// popping the arguments from the stack.
X86_StdCall = 64,
/// 'fast' analog of X86_StdCall. Passes first two arguments in ECX:EDX
/// registers, others - via stack. Callee is responsible for stack cleaning.
X86_FastCall = 65,
/// ARM Procedure Calling Standard (obsolete, but still used on some
/// targets).
ARM_APCS = 66,
/// ARM Architecture Procedure Calling Standard calling convention (aka
/// EABI). Soft float variant.
ARM_AAPCS = 67,
/// Same as ARM_AAPCS, but uses hard floating point ABI.
ARM_AAPCS_VFP = 68,
/// Used for MSP430 interrupt routines.
MSP430_INTR = 69,
/// Similar to X86_StdCall. Passes first argument in ECX, others via stack.
/// Callee is responsible for stack cleaning. MSVC uses this by default for
/// methods in its ABI.
X86_ThisCall = 70,
/// Call to a PTX kernel. Passes all arguments in parameter space.
PTX_Kernel = 71,
/// Call to a PTX device function. Passes all arguments in register or
/// parameter space.
PTX_Device = 72,
/// Used for SPIR non-kernel device functions. No lowering or expansion of
/// arguments. Structures are passed as a pointer to a struct with the
/// byval attribute. Functions can only call SPIR_FUNC and SPIR_KERNEL
/// functions. Functions can only have zero or one return values. Variable
/// arguments are not allowed, except for printf. How arguments/return
/// values are lowered are not specified. Functions are only visible to the
/// devices.
SPIR_FUNC = 75,
/// Used for SPIR kernel functions. Inherits the restrictions of SPIR_FUNC,
/// except it cannot have non-void return values, it cannot have variable
/// arguments, it can also be called by the host or it is externally
/// visible.
SPIR_KERNEL = 76,
/// Used for Intel OpenCL built-ins.
Intel_OCL_BI = 77,
/// The C convention as specified in the x86-64 supplement to the System V
/// ABI, used on most non-Windows systems.
X86_64_SysV = 78,
/// The C convention as implemented on Windows/x86-64 and AArch64. It
/// differs from the more common \c X86_64_SysV convention in a number of
/// ways, most notably in that XMM registers used to pass arguments are
/// shadowed by GPRs, and vice versa. On AArch64, this is identical to the
/// normal C (AAPCS) calling convention for normal functions, but floats are
/// passed in integer registers to variadic functions.
Win64 = 79,
/// MSVC calling convention that passes vectors and vector aggregates in SSE
/// registers.
X86_VectorCall = 80,
/// Used by HipHop Virtual Machine (HHVM) to perform calls to and from
/// translation cache, and for calling PHP functions. HHVM calling
/// convention supports tail/sibling call elimination.
HHVM = 81,
/// HHVM calling convention for invoking C/C++ helpers.
HHVM_C = 82,
/// x86 hardware interrupt context. Callee may take one or two parameters,
/// where the 1st represents a pointer to hardware context frame and the 2nd
/// represents hardware error code, the presence of the later depends on the
/// interrupt vector taken. Valid for both 32- and 64-bit subtargets.
X86_INTR = 83,
/// Used for AVR interrupt routines.
AVR_INTR = 84,
/// Used for AVR signal routines.
AVR_SIGNAL = 85,
/// Used for special AVR rtlib functions which have an "optimized"
/// convention to preserve registers.
AVR_BUILTIN = 86,
/// Used for Mesa vertex shaders, or AMDPAL last shader stage before
/// rasterization (vertex shader if tessellation and geometry are not in
/// use, or otherwise copy shader if one is needed).
AMDGPU_VS = 87,
/// Used for Mesa/AMDPAL geometry shaders.
AMDGPU_GS = 88,
/// Used for Mesa/AMDPAL pixel shaders.
AMDGPU_PS = 89,
/// Used for Mesa/AMDPAL compute shaders.
AMDGPU_CS = 90,
/// Used for AMDGPU code object kernels.
AMDGPU_KERNEL = 91,
/// Register calling convention used for parameters transfer optimization
X86_RegCall = 92,
/// Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
AMDGPU_HS = 93,
/// Used for special MSP430 rtlib functions which have an "optimized"
/// convention using additional registers.
MSP430_BUILTIN = 94,
/// Used for AMDPAL vertex shader if tessellation is in use.
AMDGPU_LS = 95,
/// Used for AMDPAL shader stage before geometry shader if geometry is in
/// use. So either the domain (= tessellation evaluation) shader if
/// tessellation is in use, or otherwise the vertex shader.
AMDGPU_ES = 96,
/// Used between AArch64 Advanced SIMD functions
AArch64_VectorCall = 97,
/// Used between AArch64 SVE functions
AArch64_SVE_VectorCall = 98,
/// For emscripten __invoke_* functions. The first argument is required to
/// be the function ptr being indirectly called. The remainder matches the
/// regular calling convention.
WASM_EmscriptenInvoke = 99,
/// Used for AMD graphics targets.
AMDGPU_Gfx = 100,
/// Used for M68k interrupt routines.
M68k_INTR = 101,
/// Preserve X0-X13, X19-X29, SP, Z0-Z31, P0-P15.
AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0 = 102,
/// Preserve X2-X15, X19-X29, SP, Z0-Z31, P0-P15.
AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2 = 103,
/// The highest possible ID. Must be some 2^k - 1.
MaxID = 1023,
};
};
pub const Int = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
fn toConstant(this: *@This()) *Constant {
return @ptrCast(this);
}
};
pub const GlobalObject = opaque{
const setAlignment = bindings.NativityLLVMGlobalObjectSetAlignment;
};
pub const GlobalVariable = opaque {
pub const setInitializer = bindings.NativityLLVMGlobalVariableSetInitializer;
pub const addDebugInfo = bindings.NativityLLVMDebugInfoGlobalVariableAddDebugInfo;
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
fn toConstant(this: *@This()) *Constant {
return @ptrCast(this);
}
fn toGlobalObject(this: *@This()) *LLVM.Value.Constant.GlobalObject{
return @ptrCast(this);
}
};
pub const PointerNull = opaque {
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
fn toConstant(this: *@This()) *Constant {
return @ptrCast(this);
}
};
pub const Undefined = opaque {
fn toConstant(this: *@This()) *Constant {
return @ptrCast(this);
}
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Poison = opaque {
fn toConstant(this: *@This()) *Constant {
return @ptrCast(this);
}
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
const toInt = bindings.NativityLLVMConstantToInt;
};
pub const InlineAssembly = opaque {
pub const Dialect = enum(c_uint) {
@"at&t",
intel,
};
const get = bindings.NativityLLVMGetInlineAssembly;
fn toValue(this: *@This()) *LLVM.Value {
return @ptrCast(this);
}
};
pub const Error = error{
constant_struct,
constant_int,
constant_array,
inline_assembly,
global_variable,
intrinsic,
};
};
};
pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, return_address: ?usize) noreturn {
@setCold(true);
const print_stack_trace = configuration.print_stack_trace;
switch (print_stack_trace) {
true => @call(.always_inline, std.builtin.default_panic, .{ message, stack_trace, return_address }),
false => {
compiler.write("\nPANIC: ");
compiler.write(message);
compiler.write("\n");
fail();
},
}
}
Reference in New Issue View Git Blame Copy Permalink