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

Merge pull request #21 from birth-software/shifts

Browse Source 
implement shifts
This commit is contained in:
David 2023-11-13 20:50:18 -06:00 committed by GitHub
commit 20fe6c8f97
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
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;
}