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

implement shifts

Browse Source
This commit is contained in:
David Gonzalez Martin 2023-11-13 20:49:24 -06:00
parent 33eb057529
commit 4c358c2f89
10 changed files with 824 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
ci.sh
View File

@ -2,7 +2,7 @@
echo "Testing Nativity with Zig"
echo "Compiling Nativity with Zig"
zig build -Doptimize=ReleaseSafe
zig build
failed_test_count=0
passed_test_count=0
test_directory_name=test
@ -10,12 +10,17 @@ test_directory=$test_directory_name/*
total_test_count=$(ls 2>/dev/null -Ubad1 -- test/* | wc -l)
ran_test_count=0
test_i=1
passed_compilation_count=0
failed_compilation_count=0
failed_compilations=()
failed_tests=()
for dir in $test_directory
do
MY_TESTNAME=${dir##*/}
zig build run -Doptimize=ReleaseSafe -- $dir/main.nat
zig build run -- $dir/main.nat
if [[ "$?" == "0" ]]; then
passed_compilation_count=$(($passed_compilation_count + 1))
if [[ "$OSTYPE" == "linux-gnu"* ]]; then
nat/$MY_TESTNAME
if [[ "$?" == "0" ]]; then
@ -24,19 +29,39 @@ do
else
failed_test_count=$(($failed_test_count + 1))
result="FAILED"
failed_tests+=("$test_i. $MY_TESTNAME")
fi
echo "[$test_i/$total_test_count] [$result] $MY_TESTNAME"
ran_test_count=$(($ran_test_count + 1))
fi
else
"$MY_TESTNAME failed to compile"
failed_compilation_count=$(($failed_compilation_count + 1))
echo "$MY_TESTNAME failed to compile"
failed_compilations+=("$test_i. $MY_TESTNAME")
fi
test_i=$(($test_i + 1))
done
echo "Ran $total_test_count compilations ($passed_compilation_count succeeded, $failed_compilation_count failed)."
echo "Ran $ran_test_count tests ($passed_test_count passed, $failed_test_count failed)."
if [[ $failed_test_count == "0" ]]; then
if [[ "$failed_compilation_count" != "0" ]]; then
echo "Failed compilations:"
for failed_compilation in "${failed_compilations[@]}"
do
echo "$failed_compilation"
done
fi
if [[ "$failed_test_count" != "0" ]]; then
echo "Failed tests:"
for failed_test in "${failed_tests[@]}"
do
echo "$failed_test"
done
fi
if [[ "$failed_test_count" == "0" && "$failed_compilation_count" == "0" ]]; then
true
else
false

9
src/Compilation.zig
View File

@ -546,7 +546,7 @@ pub const BinaryOperation = struct {
pub const Index = List.Index;
pub const Allocation = List.Allocation;
const Id = enum {
pub const Id = enum {
add,
sub,
logical_and,
@ -554,6 +554,8 @@ pub const BinaryOperation = struct {
logical_or,
multiply,
divide,
shift_left,
shift_right,
};
};
@ -602,12 +604,13 @@ pub const Value = union(enum) {
}
};
pub fn isComptime(value: Value) bool {
return switch (value) {
pub fn isComptime(value: *Value, module: *Module) bool {
return switch (value.*) {
.bool, .void, .undefined, .function, .type, .enum_field => true,
.integer => |integer| integer.type.eq(Type.comptime_int),
.call => false,
.binary_operation => false,
.declaration_reference => |declaration_reference| module.declarations.get(declaration_reference.value).mutability == .@"const" and isComptime(module.values.get(module.declarations.get(declaration_reference.value).init_value), module),
else => |t| @panic(@tagName(t)),
};
}

19
src/backend/intermediate_representation.zig
View File

@ -240,6 +240,8 @@ pub const BinaryOperation = struct {
logical_or,
signed_multiply,
signed_divide,
shift_left,
shift_right,
};
pub const List = BlockList(@This());
@ -749,7 +751,6 @@ pub const Builder = struct {
},
else => |t| @panic(@tagName(t)),
},
//.multiply,
.divide => switch (sema_type) {
.integer => |integer| switch (integer.signedness) {
.signed => .signed_divide,
@ -757,7 +758,8 @@ pub const Builder = struct {
},
else => |t| @panic(@tagName(t)),
},
//.divide,
.shift_left => .shift_left,
.shift_right => .shift_right,
},
.type = binary_operation_type,
});
@ -917,6 +919,19 @@ pub const Builder = struct {
}
},
.call => |sema_call_index| _ = try builder.processCall(sema_call_index),
.assign => |sema_assignment_index| {
const sema_assignment = builder.ir.module.assignments.get(sema_assignment_index);
const sema_left = builder.ir.module.values.get(sema_assignment.store);
assert(sema_left.* == .declaration_reference);
const sema_declaration_index = sema_left.declaration_reference.value;
const stack = builder.currentFunction().stack_map.get(sema_declaration_index).?;
const value_index = try builder.emitDeclarationInitValue(sema_assignment.load);
const store_instruction = try builder.store(.{
.source = value_index,
.destination = stack,
});
_ = store_instruction;
},
else => |t| @panic(@tagName(t)),
}
}

58
src/backend/macho.zig
View File

@ -2,7 +2,6 @@ const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const equal = std.mem.eql;
const print = std.debug.print;
const Compilation = @import("../Compilation.zig");
@ -487,7 +486,7 @@ pub fn interpretFile(allocator: Allocator, descriptor: Compilation.Module.Descri
_ = allocator;
_ = descriptor;
const header: *const Header = @ptrCast(@alignCast(file.ptr));
print("Header : {}", .{header});
//print("Header : {}", .{header});
assert(header.magic == Header.magic);
var text_segment: LoadCommand.Segment64 = undefined;
@ -503,69 +502,83 @@ pub fn interpretFile(allocator: Allocator, descriptor: Compilation.Module.Descri
if (equal(u8, segment_load_command.name[0..text_segment_name.len], text_segment_name)) {
text_segment = segment_load_command.*;
}
print("SLC: {}", .{segment_load_command});
print("segment name: {s}", .{segment_load_command.name});
//print("SLC: {}", .{segment_load_command});
//print("segment name: {s}", .{segment_load_command.name});
const section_ptr: [*]const LoadCommand.Segment64.Section = @ptrFromInt(@intFromPtr(segment_load_command) + @sizeOf(LoadCommand.Segment64));
const sections = section_ptr[0..segment_load_command.section_count];
for (sections) |section| {
print("{}", .{section});
print("Section name: {s}. Segment name: {s}", .{ section.name, section.segment_name });
_ = section;
//print("{}", .{section});
//print("Section name: {s}. Segment name: {s}", .{ section.name, section.segment_name });
}
},
.dyld_chained_fixups => {
const command: *const LoadCommand.LinkeditData = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.dyld_exports_trie => {
const command: *const LoadCommand.LinkeditData = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.symbol_table => {
const command: *const LoadCommand.SymbolTable = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.symbol_table_information => {
const command: *const LoadCommand.SymbolTableInformation = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.load_dylinker => {
const command: *const LoadCommand.Dylinker = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
//print("command: {}", .{command});
const name: [*:0]const u8 = @ptrFromInt(@intFromPtr(command) + command.name_offset);
print("Name: {s}", .{name});
_ = name;
//print("Name: {s}", .{name});
},
.uuid_number => {
const command: *const LoadCommand.Uuid = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.minimum_os_version => {
const command: *const LoadCommand.MinimumVersion = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.source_version => {
const command: *const LoadCommand.SourceVersion = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.dyld_main_entry_point => {
const command: *const LoadCommand.EntryPoint = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.load_dylib => {
const command: *const LoadCommand.Dylib = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
print("Dylib: {s}", .{@as([*:0]const u8, @ptrFromInt(@intFromPtr(load_command_ptr) + @sizeOf(LoadCommand.Dylib)))});
_ = command;
//print("command: {}", .{command});
//print("Dylib: {s}", .{@as([*:0]const u8, @ptrFromInt(@intFromPtr(load_command_ptr) + @sizeOf(LoadCommand.Dylib)))});
},
.function_starts => {
const command: *const LoadCommand.LinkeditData = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.data_in_code => {
const command: *const LoadCommand.LinkeditData = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
.code_signature => {
const command: *const LoadCommand.LinkeditData = @ptrCast(@alignCast(load_command_ptr));
print("command: {}", .{command});
_ = command;
//print("command: {}", .{command});
},
else => |t| @panic(@tagName(t)),
}
@ -666,7 +679,8 @@ pub fn interpretFile(allocator: Allocator, descriptor: Compilation.Module.Descri
writer.index = writer.segment_offset + @sizeOf(LoadCommand.Segment64);
for (file[16384 + 56 ..][0..48]) |b| {
print("0x{x}, ", .{b});
_ = b;
//print("0x{x}, ", .{b});
}
const chained_fixup_bytes = &.{ 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };

15
src/backend/pe.zig
View File

@ -1,6 +1,5 @@
const std = @import("std");
const assert = std.debug.assert;
const print = std.debug.print;
const Allocator = std.mem.Allocator;
const data_structures = @import("../data_structures.zig");
@ -22,21 +21,23 @@ pub const Writer = struct {
}
pub fn writeToMemory(writer: *Writer, image: *const emit.Result) !void {
print("File len: {}", .{writer.in_file.len});
//print("File len: {}", .{writer.in_file.len});
const dos_header: *const ImageDosHeader = @ptrCast(@alignCast(writer.in_file.ptr));
print("File address: {}", .{dos_header.file_address_of_new_exe_header});
print("File: {s}", .{writer.in_file[0x40..]});
//print("File address: {}", .{dos_header.file_address_of_new_exe_header});
//print("File: {s}", .{writer.in_file[0x40..]});
for (writer.in_file[0x40..], 0..) |byte, index| {
_ = index;
if (byte == 'T') {
print("Index: {}", .{index});
//print("Index: {}", .{index});
break;
}
}
assert(dos_header.magic_number == ImageDosHeader.magic);
// assert(dos_header.file_address_of_new_exe_header == @sizeOf(ImageDosHeader));
print("{}", .{dos_header});
//print("{}", .{dos_header});
const file_header: *const ImageFileHeader = @ptrCast(@alignCast(writer.in_file[dos_header.file_address_of_new_exe_header + 4 ..].ptr));
print("File header: {}", .{file_header});
_ = file_header;
//print("File header: {}", .{file_header});
writer.append(std.mem.asBytes(&ImageDosHeader{
.file_address_of_new_exe_header = 208,

904
src/backend/x86_64.zig
View File

File diff suppressed because it is too large Load Diff

87
src/frontend/semantic_analyzer.zig
View File

@ -202,7 +202,7 @@ const Analyzer = struct {
const declaration_index = try analyzer.symbolDeclaration(scope_index, statement_node_index, .local);
const declaration = analyzer.module.declarations.get(declaration_index);
const init_value = analyzer.module.values.get(declaration.init_value);
switch (init_value.isComptime() and declaration.mutability == .@"const") {
switch (init_value.isComptime(analyzer.module) and declaration.mutability == .@"const") {
// Dont add comptime declaration statements
true => continue,
false => {
@ -461,7 +461,7 @@ const Analyzer = struct {
fn processAssignment(analyzer: *Analyzer, scope_index: Scope.Index, node_index: Node.Index) !Value {
const node = analyzer.getScopeNode(scope_index, node_index);
assert(node.id == .assign);
const assignment = switch (node.left.invalid) {
switch (node.left.invalid) {
// In an assignment, the node being invalid means a discarding underscore, like this: ```_ = result```
true => {
var result = Value{
@ -477,23 +477,25 @@ const Analyzer = struct {
false => {
// const id = analyzer.tokenIdentifier(.token);
// logln("id: {s}\n", .{id});
// const left = try analyzer.expression(scope_index, ExpectType.none, statement_node.left);
const left = try analyzer.unresolvedAllocate(scope_index, ExpectType.none, node.left);
const right = try analyzer.unresolvedAllocate(scope_index, ExpectType{
.type_index = left.ptr.getType(analyzer.module),
}, node.right);
// if (analyzer.module.values.get(left).isComptime() and analyzer.module.values.get(right).isComptime()) {
// unreachable;
// } else {
// const assignment_index = try analyzer.module.assignments.append(analyzer.allocator, .{
// .store = result.left,
// .load = result.right,
// });
// return assignment_index;
// }
unreachable;
if (left.ptr.isComptime(analyzer.module) and right.ptr.isComptime(analyzer.module)) {
unreachable;
} else {
const assignment = try analyzer.module.assignments.append(analyzer.allocator, .{
.store = left.index,
.load = right.index,
});
return Value{
.assign = assignment.index,
};
}
},
};
_ = assignment;
unreachable;
}
}
fn processReturn(analyzer: *Analyzer, scope_index: Scope.Index, expect_type: ExpectType, node_index: Node.Index) !Value {
@ -524,29 +526,46 @@ const Analyzer = struct {
fn processBinaryOperation(analyzer: *Analyzer, scope_index: Scope.Index, expect_type: ExpectType, node_index: Node.Index) !Value {
const node = analyzer.getScopeNode(scope_index, node_index);
const binary_operation_id: Compilation.BinaryOperation.Id = switch (node.id) {
.add => .add,
.sub => .sub,
.logical_and => .logical_and,
.logical_xor => .logical_xor,
.logical_or => .logical_or,
.multiply => .multiply,
.divide => .divide,
.shift_left => .shift_left,
.shift_right => .shift_right,
else => |t| @panic(@tagName(t)),
};
const right_expect_type: ExpectType = switch (binary_operation_id) {
.add,
.sub,
.logical_and,
.logical_xor,
.logical_or,
.multiply,
.divide,
=> expect_type,
.shift_left,
.shift_right,
=> ExpectType{
.type_index = Type.u8,
},
};
const left_allocation = try analyzer.unresolvedAllocate(scope_index, expect_type, node.left);
const right_allocation = try analyzer.unresolvedAllocate(scope_index, expect_type, node.right);
const right_allocation = try analyzer.unresolvedAllocate(scope_index, right_expect_type, node.right);
const left_type = left_allocation.ptr.getType(analyzer.module);
const right_type = right_allocation.ptr.getType(analyzer.module);
if (!left_type.eq(right_type)) {
unreachable;
}
_ = right_type;
const binary_operation = try analyzer.module.binary_operations.append(analyzer.allocator, .{
.left = left_allocation.index,
.right = right_allocation.index,
.type = left_type,
.id = switch (node.id) {
.add => .add,
.sub => .sub,
.logical_and => .logical_and,
.logical_xor => .logical_xor,
.logical_or => .logical_or,
.multiply => .multiply,
.divide => .divide,
else => |t| @panic(@tagName(t)),
},
.id = binary_operation_id,
});
return .{
@ -606,11 +625,11 @@ const Analyzer = struct {
}
logln(.sema, .identifier, "Declaration resolved as: {}\n", .{init_value});
logln(.sema, .identifier, "Declaration mutability: {s}. Is comptime: {}\n", .{ @tagName(declaration.mutability), init_value.isComptime() });
logln(.sema, .identifier, "Declaration mutability: {s}. Is comptime: {}\n", .{ @tagName(declaration.mutability), init_value.isComptime(analyzer.module) });
const typecheck_result = try analyzer.typeCheck(expect_type, declaration.type);
if (init_value.isComptime() and declaration.mutability == .@"const") {
if (init_value.isComptime(analyzer.module) and declaration.mutability == .@"const") {
assert(!declaration.init_value.invalid);
assert(typecheck_result == .success);
return declaration.init_value;
@ -1017,6 +1036,8 @@ const Analyzer = struct {
.logical_or,
.multiply,
.divide,
.shift_left,
.shift_right,
=> try analyzer.processBinaryOperation(scope_index, expect_type, node_index),
.expression_group => return try analyzer.resolveNode(value, scope_index, expect_type, node.left), //unreachable,
else => |t| @panic(@tagName(t)),

28
src/frontend/syntactic_analyzer.zig
View File

@ -160,6 +160,8 @@ pub const Node = packed struct(u128) {
logical_or = 66,
multiply = 67,
divide = 68,
shift_left = 69,
shift_right = 70,
};
};
@ -721,6 +723,8 @@ const Analyzer = struct {
logical_or,
multiply,
divide,
shift_left,
shift_right,
};
const operator_precedence = std.EnumArray(PrecedenceOperator, i32).init(.{
@ -733,6 +737,8 @@ const Analyzer = struct {
.logical_or = 40,
.multiply = 70,
.divide = 70,
.shift_left = 50,
.shift_right = 50,
});
const operator_associativity = std.EnumArray(PrecedenceOperator, Associativity).init(.{
@ -745,6 +751,8 @@ const Analyzer = struct {
.logical_or = .left,
.multiply = .left,
.divide = .left,
.shift_left = .left,
.shift_right = .left,
});
const operator_node_id = std.EnumArray(PrecedenceOperator, Node.Id).init(.{
@ -757,6 +765,8 @@ const Analyzer = struct {
.logical_or = .logical_or,
.multiply = .multiply,
.divide = .divide,
.shift_left = .shift_left,
.shift_right = .shift_right,
});
fn expressionPrecedence(analyzer: *Analyzer, minimum_precedence: i32) !Node.Index {
@ -825,6 +835,14 @@ const Analyzer = struct {
.equal => unreachable,
else => .divide,
},
.less => switch (next_token_id) {
.less => .shift_left,
else => unreachable,
},
.greater => switch (next_token_id) {
.greater => .shift_right,
else => unreachable,
},
else => |t| @panic(@tagName(t)),
};
} else {
@ -845,7 +863,7 @@ const Analyzer = struct {
}
const operator_token = analyzer.token_i;
const extra_token = switch (operator) {
const extra_tokens: u32 = switch (operator) {
.add,
.sub,
.logical_and,
@ -853,13 +871,15 @@ const Analyzer = struct {
.logical_or,
.multiply,
.divide,
=> false,
=> 0,
.compare_equal,
.compare_not_equal,
=> true,
.shift_right,
.shift_left,
=> 1,
// else => |t| @panic(@tagName(t)),
};
analyzer.token_i += @as(u32, 1) + @intFromBool(extra_token);
analyzer.token_i += @as(u32, 1) + extra_tokens;
// TODO: fix this
const right = try analyzer.expressionPrecedence(precedence + 1);

2
test/imul/main.nat
View File

@ -1,5 +1,5 @@
const main = fn () s32 {
const a: s32 = 5;
const b: s32 = 4;
return 5 * 4 - a * b;
return a * b - a * b;
}

7
test/shifts/main.nat Normal file
View File

@ -0,0 +1,7 @@
const main = fn() s32 {
const x: u32 = 1;
x = x << 5;
x = x >> 5;
const b: u32 = 1;
return x - b;
}