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

Better testing system

Browse Source
This commit is contained in:
David Gonzalez Martin 2025-02-20 20:52:21 -06:00
parent 38c4ab99be
commit 322c2aaa8b
31 changed files with 413 additions and 1001660 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/ci.yml vendored
View File

@ -62,6 +62,8 @@ jobs:
os: [ ubuntu-24.04 ]
BIRTH_ZIG_BUILD_TYPE: ${{ fromJSON(needs.generate-config.outputs.BIRTH_ZIG_BUILD_TYPES) }}
SYSTEM_LLVM: [ true, false ]
TEST_BUILD_MODE: [ debug_none, debug_fast, debug_size, soft_optimize, optimize_for_speed, optimize_for_size, aggressively_optimize_for_speed, aggressively_optimize_for_size ]
HAS_DEBUG_INFO: [ true, false ]
runs-on: ${{ matrix.os }}
env:
BIRTH_LINUX_IMAGE: ${{ needs.generate-config.outputs.BIRTH_LINUX_IMAGE }}
@ -77,6 +79,6 @@ jobs:
run: sudo apt-get update && sudo apt-get install -y llvm-dev liblld-dev
- name: Build and test
run: |
zig build test --summary all -Doptimize=${{matrix.BIRTH_ZIG_BUILD_TYPE}} -Dsystem_llvm=${{matrix.SYSTEM_LLVM}}
zig build test --summary all -Doptimize=${{matrix.BIRTH_ZIG_BUILD_TYPE}} -Dsystem_llvm=${{matrix.SYSTEM_LLVM}} -Dtest_build_mode=${{matrix.TEST_BUILD_MODE}} -Dhas_debug_info=${{matrix.HAS_DEBUG_INFO}}
zig build install -Doptimize=${{matrix.BIRTH_ZIG_BUILD_TYPE}} -Dsystem_llvm=${{matrix.SYSTEM_LLVM}}
ldd zig-out/bin/bloat-buster

16
build.zig
View File

@ -284,6 +284,17 @@ var target: std.Build.ResolvedTarget = undefined;
var optimize: std.builtin.OptimizeMode = undefined;
var env: std.process.EnvMap = undefined;
const BuildMode = enum {
debug_none,
debug_fast,
debug_size,
soft_optimize,
optimize_for_speed,
optimize_for_size,
aggressively_optimize_for_speed,
aggressively_optimize_for_size,
};
pub fn build(b: *std.Build) !void {
env = try std.process.getEnvMap(b.allocator);
target = b.standardTargetOptions(.{});
@ -291,7 +302,12 @@ pub fn build(b: *std.Build) !void {
system_llvm = b.option(bool, "system_llvm", "Link against system LLVM libraries") orelse true;
const path = env.get("PATH") orelse unreachable;
const test_build_mode = b.option(BuildMode, "test_build_mode", "Test build mode") orelse .debug_none;
const has_debug_info = b.option(bool, "has_debug_info", "Has debug information") orelse true;
const configuration = b.addOptions();
configuration.addOption(BuildMode, "test_build_mode", test_build_mode);
configuration.addOption(u1, "has_debug_info", @intFromBool(has_debug_info));
const exe_mod = b.createModule(.{
.root_source_file = b.path("src/main.zig"),

252
src/LLVM.zig
View File

@ -369,7 +369,7 @@ pub const MCTargetOptions = extern struct {
}
};
const OptimizationLevel = enum(u3) {
pub const OptimizationLevel = enum(u3) {
O0 = 0,
O1 = 1,
O2 = 2,
@ -490,7 +490,7 @@ const targets = [@typeInfo(Architecture).@"enum".fields.len]type{
pub const Context = opaque {
pub const create = api.LLVMContextCreate;
pub fn create_module(context: *Context, name: [:0]const u8) *Module {
pub fn create_module(context: *Context, name: []const u8) *Module {
return api.llvm_context_create_module(context, String.from_slice(name));
}
pub const create_builder = api.LLVMCreateBuilderInContext;
@ -546,7 +546,23 @@ pub const Builder = opaque {
}
};
pub const GlobalValue = opaque {
pub const get_type = api.LLVMGlobalGetValueType;
};
pub const Function = opaque {
pub fn get_type(function: *Function) *Type.Function {
return function.to_global_value().get_type().to_function();
}
pub fn to_value(function: *Function) *Value {
return @ptrCast(function);
}
pub fn to_global_value(function: *Function) *GlobalValue {
return @ptrCast(function);
}
pub fn verify(function: *Function) VerifyResult {
var result: VerifyResult = undefined;
var string: String = undefined;
@ -568,7 +584,9 @@ pub const Constant = opaque {
};
};
pub const Value = opaque {};
pub const Value = opaque {
pub const get_type = api.LLVMTypeOf;
};
pub const DI = struct {
pub const Builder = opaque {
@ -618,9 +636,22 @@ pub const DI = struct {
};
pub const Type = opaque {
pub const is_function = api.llvm_type_is_function;
pub const is_integer = api.llvm_type_is_integer;
pub fn to_function(t: *Type) *Type.Function {
assert(t.is_function());
return @ptrCast(t);
}
pub fn to_integer(t: *Type) *Type.Integer {
assert(t.is_integer());
return @ptrCast(t);
}
pub const Function = opaque {
pub fn get(return_type: *Type, parameter_types: []const *Type, is_var_args: c_int) *Type.Function {
return api.LLVMFunctionType(return_type, parameter_types.ptr, @intCast(parameter_types.len), is_var_args);
pub const get_return_type = api.LLVMGetReturnType;
pub fn get(return_type: *Type, parameter_types: []const *Type, is_var_args: bool) *Type.Function {
return api.LLVMFunctionType(return_type, parameter_types.ptr, @intCast(parameter_types.len), @intFromBool(is_var_args));
}
};
@ -722,7 +753,7 @@ pub const Thread = struct {
}
};
const Global = struct {
pub const Global = struct {
threads: []Thread,
host_triple: []const u8,
host_cpu_model: []const u8,
@ -730,8 +761,12 @@ const Global = struct {
};
pub var global: Global = undefined;
pub var initialized = false;
// This is meant to call globally, only once per execution
pub fn initialize_all() void {
assert(!initialized);
defer initialized = true;
inline for (targets) |target| {
target.initialize(.{});
}
@ -759,142 +794,141 @@ const LldArgvBuilder = struct {
}
};
test "experiment" {
const std = @import("std");
var tmp_dir = std.testing.tmpDir(.{});
defer tmp_dir.cleanup();
const allocator = std.testing.allocator;
pub const ModuleBuilder = struct {
module: *Module,
builder: *Builder,
const object_file_path = try std.mem.joinZ(allocator, "/", &.{ ".zig-cache", "tmp", &tmp_dir.sub_path, "foo.o" });
// Zig stuf... sigh
defer allocator.free(object_file_path);
const executable_file_path = try std.mem.joinZ(allocator, "/", &.{ ".zig-cache", "tmp", &tmp_dir.sub_path, "foo" });
defer allocator.free(executable_file_path);
pub fn initialize(thread: *Thread, module_name: []const u8) ModuleBuilder {
const module = thread.context.create_module(module_name);
const builder = thread.context.create_builder();
lib.GlobalState.initialize();
initialize_all();
return .{
.module = module,
.builder = builder,
};
}
};
pub const FunctionBuilder = struct {
function: *Function,
current_basic_block: *BasicBlock,
};
pub fn default_initialize() *Thread {
assert(lib.GlobalState.initialized);
if (!initialized) {
initialize_all();
}
const thread = &global.threads[0];
thread.initialize();
const module = thread.context.create_module("first_module");
const builder = thread.context.create_builder();
// const di_builder = module.create_di_builder();
const return_type = thread.i32.type;
const return_value = thread.i32.zero;
// const return_value = thread.
const function_type = Type.Function.get(return_type.to_type(), &.{}, 0);
const function = module.create_function(.{
.type = function_type,
.linkage = .ExternalLinkage,
.name = "main",
});
const entry_basic_block = thread.context.create_basic_block("entry", function);
builder.position_at_end(entry_basic_block);
builder.create_ret(return_value.to_value());
const function_verify = function.verify();
if (!function_verify.success) {
return error.function_failed_to_verify;
}
const module_verify = module.verify();
if (!module_verify.success) {
return error.module_failed_to_verify;
}
if (!builtin.is_test) {
const module_string = module.to_string();
lib.print_string(module_string);
}
return thread;
}
var error_message: String = undefined;
const target_machine = Target.Machine.create(.{
.target_options = Target.Options.default(),
.cpu_triple = String.from_slice(global.host_triple),
.cpu_model = String.from_slice(global.host_cpu_model),
.cpu_features = String.from_slice(global.host_cpu_features),
.optimization_level = .none,
.relocation_model = .default,
.code_model = .none,
.jit = false,
}, &error_message) orelse {
return error.target_machine_creation_failed;
};
pub const GenerateObject = struct {
path: []const u8,
target_triple: []const u8,
cpu_model: []const u8,
cpu_features: []const u8,
target_options: Target.Options,
};
pub const ObjectGenerate = struct {
path: []const u8,
optimization_level: ?OptimizationLevel,
debug_info: u1,
optimize_when_possible: u1,
};
pub fn object_generate(module: *Module, target_machine: *Target.Machine, generate: ObjectGenerate) CodeGenerationPipelineResult {
module.set_target(target_machine);
module.run_optimization_pipeline(target_machine, OptimizationPipelineOptions.default(.{ .optimization_level = .O3, .debug_info = 1 }));
if (generate.optimization_level) |optimization_level| {
module.run_optimization_pipeline(target_machine, OptimizationPipelineOptions.default(.{ .optimization_level = optimization_level, .debug_info = generate.debug_info }));
}
const result = module.run_code_generation_pipeline(target_machine, CodeGenerationPipelineOptions{
.output_file_path = String.from_slice(object_file_path),
.output_file_path = String.from_slice(generate.path),
.output_dwarf_file_path = .{},
.flags = .{
.code_generation_file_type = .object_file,
.optimize_when_possible = 1,
.optimize_when_possible = generate.optimize_when_possible,
.verify_module = @intFromBool(lib.optimization_mode == .Debug or lib.optimization_mode == .ReleaseSafe),
},
});
switch (result) {
.success => {},
.failed_to_create_file => {
lib.print_string_stderr(object_file_path);
lib.print_string_stderr("\n");
return error.failed_to_create_file;
},
.failed_to_add_emit_passes => return error.failed_to_add_emit_passes,
}
return result;
}
pub const LinkOptions = struct {
objects: []const [:0]const u8,
output_path: [:0]const u8,
};
pub fn link(arena: *Arena, options: LinkOptions) lld.Result {
var arg_builder = LldArgvBuilder{};
arg_builder.add("ld.lld");
arg_builder.add("--error-limit=0");
arg_builder.add("-o");
arg_builder.add(executable_file_path);
const objects: []const [*:0]const u8 = &.{object_file_path};
for (objects) |object| {
arg_builder.add(options.output_path);
for (options.objects) |object| {
arg_builder.add(object);
}
const library_paths = [_][:0]const u8{ "/usr/lib", "/usr/lib/x86_64-linux-gnu" };
inline for (library_paths) |library_path| {
const scrt1_object_directory_path = inline for (library_paths) |library_path| {
const scrt1_path = library_path ++ "/" ++ "Scrt1.o";
const file = lib.os.File.open(scrt1_path, .{ .read = 1 }, .{});
if (file.is_valid()) {
file.close();
arg_builder.add("-L" ++ library_path);
const link_libcpp = false;
if (link_libcpp) {
arg_builder.add("-lstdc++");
}
const link_libc = true;
const dynamic_linker = true;
if (dynamic_linker) {
arg_builder.add("-dynamic-linker");
arg_builder.add("/usr/lib/ld-linux-x86-64.so.2");
}
if (link_libc) {
arg_builder.add(scrt1_path);
arg_builder.add("-lc");
}
const lld_args = arg_builder.flush();
const lld_result = api.lld_elf_link(lld_args.ptr, lld_args.len, true, false);
const success = lld_result.success and lld_result.stderr.length == 0;
if (!success) {
if (lld_result.stdout.length != 0) {
lib.print_string_stderr(lld_result.stdout.to_slice() orelse unreachable);
}
if (lld_result.stderr.length != 0) {
lib.print_string_stderr(lld_result.stderr.to_slice() orelse unreachable);
}
return error.linking_failed;
}
break;
break library_path;
}
} else {
lib.print_string_stderr("Failed to find directory for Scrt1.o\n");
lib.os.abort();
};
arg_builder.add(arena.join_string(&.{ "-L", scrt1_object_directory_path }));
const link_libcpp = false;
if (link_libcpp) {
arg_builder.add("-lstdc++");
}
const link_libc = true;
const dynamic_linker = true;
if (dynamic_linker) {
arg_builder.add("-dynamic-linker");
arg_builder.add("/usr/lib/ld-linux-x86-64.so.2");
}
if (link_libc) {
const scrt1_path = arena.join_string(&.{ scrt1_object_directory_path, "/Scrt1.o" });
arg_builder.add(scrt1_path);
arg_builder.add("-lc");
}
const lld_args = arg_builder.flush();
const lld_result = api.lld_elf_link(lld_args.ptr, lld_args.len, true, false);
const success = lld_result.success and lld_result.stderr.length == 0;
if (!success) {
for (lld_args) |lld_arg| {
lib.print_string_stderr(lib.cstring.to_slice(lld_arg.?));
lib.print_string_stderr(" ");
}
lib.print_string_stderr("\n");
if (lld_result.stdout.length != 0) {
lib.print_string_stderr(lld_result.stdout.to_slice() orelse unreachable);
}
if (lld_result.stderr.length != 0) {
lib.print_string_stderr(lld_result.stderr.to_slice() orelse unreachable);
}
}
return lld_result;
}

226
src/converter.zig
View File

@ -1,6 +1,9 @@
const lib = @import("lib.zig");
const llvm = @import("LLVM.zig");
const assert = lib.assert;
const os = lib.os;
const Arena = lib.Arena;
const llvm = @import("LLVM.zig");
const configuration = @import("configuration");
const LexerResult = struct {
token: Token,
@ -73,6 +76,34 @@ const Converter = struct {
}
}
pub fn parse_type(noalias converter: *Converter, noalias thread: *llvm.Thread, noalias module_builder: *llvm.ModuleBuilder) *llvm.Type {
_ = module_builder;
const identifier = converter.parse_identifier();
var integer_type = identifier.len > 1 and identifier[0] == 's' or identifier[0] == 'u';
if (integer_type) {
for (identifier[1..]) |ch| {
integer_type = integer_type and is_decimal_ch(ch);
}
}
if (integer_type) {
const bit_count = lib.parse.integer_decimal(identifier[1..]);
const llvm_int_type = switch (bit_count) {
// TODO: consider u1?
0 => converter.report_error(),
8 => thread.i8.type,
16 => thread.i16.type,
32 => thread.i32.type,
64 => thread.i64.type,
else => converter.report_error(),
};
const llvm_type = llvm_int_type.to_type();
return llvm_type;
} else {
os.abort();
}
}
pub fn parse_identifier(noalias converter: *Converter) []const u8 {
const start = converter.offset;
@ -115,7 +146,7 @@ const Converter = struct {
}
}
fn parse_integer(noalias converter: *Converter) void {
fn parse_integer(noalias converter: *Converter, expected_type: *llvm.Type) *llvm.Value {
const start = converter.offset;
const integer_start_ch = converter.content[start];
assert(!is_space(integer_start_ch));
@ -142,7 +173,12 @@ const Converter = struct {
converter.report_error();
},
// Zero literal
else => {},
else => {
const integer_type = expected_type.to_integer();
const sign_extend = false;
const integer_value = integer_type.get_constant(0, @intFromBool(sign_extend));
return integer_value.to_value();
},
}
},
// TODO: decimal number
@ -157,7 +193,8 @@ const Converter = struct {
}
}
fn parse_block(noalias converter: *Converter) void {
fn parse_block(noalias converter: *Converter, thread: *llvm.Thread, module_builder: *llvm.ModuleBuilder, function_builder: *llvm.FunctionBuilder) void {
_ = thread;
converter.skip_space();
converter.expect_character(left_brace);
@ -180,7 +217,8 @@ const Converter = struct {
if (string_to_enum(StatementStartKeyword, statement_start_identifier)) |statement_start_keyword| {
switch (statement_start_keyword) {
.@"return" => {
converter.parse_value();
const return_value = converter.parse_value(function_builder.function.get_type().get_return_type());
module_builder.builder.create_ret(return_value);
},
else => unreachable,
}
@ -202,7 +240,7 @@ const Converter = struct {
converter.expect_character(right_brace);
}
fn parse_value(noalias converter: *Converter) void {
fn parse_value(noalias converter: *Converter, expected_type: *llvm.Type) *llvm.Value {
converter.skip_space();
const start = converter.offset;
@ -210,7 +248,8 @@ const Converter = struct {
if (is_identifier_start_ch(value_start_ch)) {
converter.report_error();
} else if (is_decimal_ch(value_start_ch)) {
converter.parse_integer();
const value = converter.parse_integer(expected_type);
return value;
} else {
converter.report_error();
}
@ -226,12 +265,59 @@ const StatementStartKeyword = enum {
foooooooooo,
};
pub noinline fn convert(_content: []const u8) void {
pub const BuildMode = enum {
debug_none,
debug_fast,
debug_size,
soft_optimize,
optimize_for_speed,
optimize_for_size,
aggressively_optimize_for_speed,
aggressively_optimize_for_size,
fn to_llvm_ir(build_mode: BuildMode) llvm.OptimizationLevel {
return switch (build_mode) {
.debug_none => unreachable,
.debug_fast, .debug_size => .O0,
.soft_optimize => .O1,
.optimize_for_speed => .O2,
.optimize_for_size => .Os,
.aggressively_optimize_for_speed => .O3,
.aggressively_optimize_for_size => .Oz,
};
}
fn to_llvm_machine(build_mode: BuildMode) llvm.CodeGenerationOptimizationLevel {
return switch (build_mode) {
.debug_none => .none,
.debug_fast, .debug_size => .none,
.soft_optimize => .less,
.optimize_for_speed => .default,
.optimize_for_size => .default,
.aggressively_optimize_for_speed => .aggressive,
.aggressively_optimize_for_size => .aggressive,
};
}
};
const ConvertOptions = struct {
content: []const u8,
path: [:0]const u8,
object: [:0]const u8,
executable: [:0]const u8,
build_mode: BuildMode,
name: []const u8,
};
pub noinline fn convert(options: ConvertOptions) void {
var converter = Converter{
.content = _content,
.content = options.content,
.offset = 0,
};
const thread = llvm.default_initialize();
var module_builder_memory = llvm.ModuleBuilder.initialize(thread, options.name);
const module_builder = &module_builder_memory;
while (true) {
converter.skip_space();
@ -249,7 +335,7 @@ pub noinline fn convert(_content: []const u8) void {
const global_keyword = string_to_enum(GlobalKeyword, global_keyword_string) orelse converter.report_error();
switch (global_keyword) {
.@"export" => is_export = false,
.@"export" => is_export = true,
else => converter.report_error(),
}
@ -265,7 +351,6 @@ pub noinline fn convert(_content: []const u8) void {
}
const global_name = converter.parse_identifier();
_ = global_name;
converter.skip_space();
@ -332,26 +417,119 @@ pub noinline fn convert(_content: []const u8) void {
converter.skip_space();
const return_type = converter.parse_identifier();
_ = return_type;
const return_type = converter.parse_type(thread, module_builder);
const function_type = llvm.Type.Function.get(return_type, &.{}, false);
converter.parse_block();
const function = module_builder.module.create_function(.{
.name = global_name,
.linkage = switch (is_export) {
true => .ExternalLinkage,
false => .InternalLinkage,
},
.type = function_type,
});
const entry_block = thread.context.create_basic_block("entry", function);
module_builder.builder.position_at_end(entry_block);
var function_builder = llvm.FunctionBuilder{
.function = function,
.current_basic_block = entry_block,
};
converter.parse_block(thread, module_builder, &function_builder);
if (lib.optimization_mode == .Debug) {
const verify_result = function.verify();
if (!verify_result.success) {
os.abort();
}
}
},
else => converter.report_error(),
}
}
if (lib.optimization_mode == .Debug) {
const verify_result = module_builder.module.verify();
if (!verify_result.success) {
os.abort();
}
if (!lib.is_test) {
const module_string = module_builder.module.to_string();
lib.print_string_stderr(module_string);
}
}
var error_message: llvm.String = undefined;
const target_machine = llvm.Target.Machine.create(.{
.target_options = llvm.Target.Options.default(),
.cpu_triple = llvm.String.from_slice(llvm.global.host_triple),
.cpu_model = llvm.String.from_slice(llvm.global.host_cpu_model),
.cpu_features = llvm.String.from_slice(llvm.global.host_cpu_features),
.optimization_level = options.build_mode.to_llvm_machine(),
.relocation_model = .default,
.code_model = .none,
.jit = false,
}, &error_message) orelse {
os.abort();
};
const object_generate_result = llvm.object_generate(module_builder.module, target_machine, .{
.optimize_when_possible = @intFromBool(@intFromEnum(options.build_mode) > @intFromEnum(BuildMode.soft_optimize)),
.debug_info = configuration.has_debug_info,
.optimization_level = if (options.build_mode != .debug_none) options.build_mode.to_llvm_ir() else null,
.path = options.object,
});
switch (object_generate_result) {
.success => {
const result = llvm.link(lib.global.arena, .{
.output_path = options.executable,
.objects = &.{options.object},
});
switch (result.success) {
true => {},
false => os.abort(),
}
},
else => os.abort(),
}
}
pub fn parser_experiment() void {
const strlit =
\\[export] main = fn [cc(c)] () s32
\\{
\\ return 0;
\\}
;
convert(strlit);
fn get_test_build_mode() BuildMode {
return @enumFromInt(@intFromEnum(configuration.test_build_mode));
}
test "parse" {
parser_experiment();
test "minimal" {
invoke("minimal", get_test_build_mode());
}
pub fn invoke(name: []const u8, build_mode: BuildMode) void {
const std = @import("std");
if (!lib.GlobalState.initialized) {
lib.GlobalState.initialize();
}
var tmp_dir = if (lib.is_test) std.testing.tmpDir(.{}) else {};
defer {
if (lib.is_test) {
tmp_dir.cleanup();
}
}
const object_path = lib.global.arena.join_string(if (lib.is_test) &.{ ".zig-cache/tmp/", &tmp_dir.sub_path, "/", name, ".o" } else &.{ name, ".o" });
const executable_path = lib.global.arena.join_string(if (lib.is_test) &.{ ".zig-cache/tmp/", &tmp_dir.sub_path, "/", name, ".o" } else &.{name});
const file_path = lib.global.arena.join_string(&.{ "tests/", name, ".bbb" });
const file_content = lib.file.read(lib.global.arena, file_path);
convert(.{
.path = file_path,
.content = file_content,
.object = object_path,
.executable = executable_path,
.build_mode = build_mode,
.name = name,
});
}

22
src/lib.zig
View File

@ -1,4 +1,5 @@
const builtin = @import("builtin");
pub const is_test = builtin.is_test;
pub const optimization_mode = builtin.mode;
const VariableArguments = @import("std").builtin.VaList;
extern "c" fn IsDebuggerPresent() bool;
@ -523,6 +524,22 @@ pub const string = struct {
}
};
pub const cstring = struct {
pub fn length(pointer: [*:0]const u8) usize {
var it = pointer;
while (it[0] != 0) {
it += 1;
}
const result = it - pointer;
return result;
}
pub fn to_slice(pointer: [*:0]const u8) [:0]const u8 {
return pointer[0..length(pointer) :0];
}
};
pub const Arena = struct {
reserved_size: u64,
position: u64,
@ -2456,7 +2473,10 @@ pub const GlobalState = struct {
arena: *Arena,
thread_count: usize,
pub var initialized = false;
pub fn initialize() void {
assert(!initialized);
defer initialized = true;
const thread_count = os.get_cpu_count();
global = .{
.arena = Arena.initialize_default(2 * MB),
@ -2467,7 +2487,7 @@ pub const GlobalState = struct {
pub var global: GlobalState = undefined;
pub const parse = struct {
fn integer_decimal(str: []const u8) u64 {
pub fn integer_decimal(str: []const u8) u64 {
var value: u64 = 0;
for (str) |ch| {

17
src/llvm.cpp
View File

@ -32,7 +32,7 @@ typedef uint64_t u64;
#include "llvm/Support/FileSystem.h"
#include "lld/Common/Driver.h"
#include "lld/Common/CommonLinkerContext.h"
using namespace llvm;
@ -53,6 +53,18 @@ EXPORT Module* llvm_context_create_module(LLVMContext& context, BBLLVMString nam
return new Module(name.string_ref(), context);
}
EXPORT bool llvm_type_is_function(const Type& type)
{
auto result = type.isFunctionTy();
return result;
}
EXPORT bool llvm_type_is_integer(const Type& type)
{
auto result = type.isIntegerTy();
return result;
}
EXPORT Value* llvm_builder_create_add(IRBuilder<>& builder, Value* left, Value* right, bool nuw, bool nsw)
{
auto* result = builder.CreateAdd(left, right, "", nuw, nsw);
@ -990,6 +1002,9 @@ fn LLDResult lld_api_generic(lld_api_args(), LinkerFunction linker_function)
result.stderr_string = { stderr_pointer, stderr_length };
}
// TODO: should we only call it on success?
lld::CommonLinkerContext::destroy();
return result;
}

6
src/llvm_api.zig
View File

@ -20,6 +20,9 @@ pub extern fn llvm_module_to_string(module: *llvm.Module) llvm.String;
pub extern fn LLVMPositionBuilderAtEnd(builder: *llvm.Builder, basic_block: *llvm.BasicBlock) void;
pub extern fn LLVMBuildRet(builder: *llvm.Builder, value: ?*llvm.Value) void;
pub extern fn LLVMTypeOf(value: *llvm.Value) *llvm.Type;
pub extern fn LLVMGlobalGetValueType(value: *llvm.GlobalValue) *llvm.Type;
// TYPES
// Types: integers
pub extern fn LLVMInt1TypeInContext(context: *llvm.Context) *llvm.Type.Integer;
@ -58,6 +61,9 @@ pub extern fn LLVMPointerTypeInContext(context: *llvm.Context, address_space: c_
pub extern fn LLVMVectorType(element_type: *llvm.Type, element_count: c_uint) *llvm.Type.FixedVector;
pub extern fn LLVMScalableVectorType(element_type: *llvm.Type, element_count: c_uint) *llvm.Type.ScalableVector;
pub extern fn llvm_type_is_function(ty: *llvm.Type) bool;
pub extern fn llvm_type_is_integer(ty: *llvm.Type) bool;
// VALUES
pub extern fn LLVMConstInt(type: *llvm.Type.Integer, value: c_ulonglong, sign_extend: Bool) *llvm.Constant.Integer;

3
src/main.zig
View File

@ -140,12 +140,11 @@ pub const panic = struct {
var global_persistent_arena: *Arena = undefined;
pub fn main() callconv(.C) c_int {
converter.parser_experiment();
return 0;
}
comptime {
if (!@import("builtin").is_test) {
if (!lib.is_test) {
@export(&main, .{
.name = "main",
});

4
tests/add_sub.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 1 - 1 + 1 - 1;
}

4
tests/and.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 1 & 0;
}

166
tests/break_continue.nat
View File

@ -1,166 +0,0 @@
fn fn0(arg: s32) s32
{
>a = arg;
while (a < 10)
{
a = a + 1;
if (a == 5)
{
break;
}
if (a == 6)
{
break;
}
}
return a;
}
fn fn1(arg: s32) s32
{
>a: s32 = 1;
>i = arg;
while (i < 10)
{
i = i + 1;
if (i == 5)
{
continue;
}
if (i == 7)
{
continue;
}
a = a + 1;
}
return a;
}
fn fn2(arg: s32) s32
{
>i = arg;
while (i < 10)
{
i = i + 1;
if (i == 5)
{
continue;
}
if (i == 6)
{
break;
}
}
return i;
}
fn fn3(arg: s32) s32
{
>i = arg;
while (i < 10)
{
i = i + 1;
if (i == 6)
{
break;
}
}
return i;
}
fn fn4(arg: s32) s32
{
>i = arg;
while (i < 10)
{
i = i + 1;
if (i == 5)
{
continue;
}
if (i == 6)
{
continue;
}
}
return i;
}
fn fn5(arg: s32) s32
{
>i = arg;
while (i < 10)
{
i = i + 1;
if (i == 5)
{
continue;
}
}
return i;
}
fn fn6(arg: s32) s32
{
>i = arg;
while (i < 10)
{
>a = i + 2;
if (a > 4)
{
break;
}
}
return i;
}
fn fn7(arg: s32) s32
{
>i = arg;
while (i < 10)
{
break;
}
return i;
}
fn fn8(arg: s32) s32
{
>a: s32 = 1;
while (1)
{
a = a + 1;
if (a < 10)
{
continue;
}
break;
}
return a;
}
fn[cc(.c)] main[export]() s32
{
return fn0(0) +
fn1(1) +
fn2(2) +
fn3(3) +
fn4(4) +
fn5(5) +
fn6(6) +
fn7(7) +
fn8(8);
}

4
tests/comparison.nat
View File

@ -1,4 +0,0 @@
fn main (argc: s32) s32
{
return argc != 1;
}

4
tests/constant_prop.nat
View File

@ -1,4 +0,0 @@
fn[cc(.c)] main [export] () s32
{
return 2 + 4 - 1 - 5;
}

4
tests/div.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 0 / 1;
}

4
tests/first.nat
View File

@ -1,4 +0,0 @@
fn main () s32
{
return 0;
}

10
tests/function_call_args.nat
View File

@ -1,10 +0,0 @@
fn foo(arg: s32) s32
{
return arg;
}
fn[cc(.c)] main [export] () s32
{
>arg: s32 = 6;
return foo(arg) - arg;
}

131
tests/if.nat
View File

@ -1,131 +0,0 @@
fn if0(arg: s32) s32
{
>a: s32 = 1;
if (arg == 1)
{
a = arg + 2;
}
else
{
a = arg - 3;
}
return a;
}
fn if1(arg: s32) s32
{
>c: s32 = 3;
>b: s32 = 2;
if (arg == 1)
{
b = 3;
c = 4;
}
return c;
}
fn if2(arg: s32) s32
{
if (arg == 1)
{
return 3;
}
else
{
return 4;
}
}
fn if3(arg: s32) s32
{
>a: s32 = arg + 1;
>b: s32 = 0;
if (arg == 1)
{
b = a;
}
else
{
b = a + 1;
}
return a + b;
}
fn if4(arg: s32) s32
{
>a: s32 = arg + 1;
>b: s32 = arg + 2;
if (arg == 1)
{
b = b + a;
}
else
{
a = b + 1;
}
return a + b;
}
fn if5(arg: s32) s32
{
>a: s32 = 1;
if (arg == 1)
{
if (arg == 2)
{
a = 2;
}
else
{
a = 3;
}
}
else if (arg == 3)
{
a = 4;
}
else
{
a = 5;
}
return a;
}
fn if6(arg: s32) s32
{
>a: s32 = 0;
>b: s32 = 0;
if (arg)
{
a = 1;
}
if (arg == 0)
{
b = 2;
}
return arg + a + b;
}
fn if7(arg: s32) s32
{
>a: s32 = arg == 2;
if (arg == 1)
{
a = arg == 3;
}
return a;
}
fn[cc(.c)] main[export] () s32
{
return if0(3) + if1(1) - 4 + if2(1) - 3 + if3(1) - 4 + if4(0) - 5 + if5(4) - 5 + if6(0) - 2 + if7(0);
}

1000001
tests/million_simple_functions.nat
View File

File diff suppressed because it is too large Load Diff

5
tests/minimal.bbb Normal file
View File

@ -0,0 +1,5 @@
[export] main = fn [cc(c)] () s32
{
return 0;
}

4
tests/mul.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 1 * 0;
}

4
tests/or.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 0 | 0;
}

10
tests/return_mod_scope.nat
View File

@ -1,10 +0,0 @@
fn main() s32
{
>a: s32 = 1;
{
a = 0;
}
return a;
}

5
tests/return_var.nat
View File

@ -1,5 +0,0 @@
fn main() s32
{
>a: s32 = 0;
return a;
}

4
tests/shift_left.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 0 << 1;
}

4
tests/shift_right.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 1 >> 1;
}

4
tests/simple_arg.nat
View File

@ -1,4 +0,0 @@
fn main(argument_count: s32) s32
{
return argument_count - 1;
}

9
tests/simple_variable_declaration.nat
View File

@ -1,9 +0,0 @@
fn[cc(.c)] main [export] () s32
{
>a: s32 = 2;
>b: s32 = 2;
{
>c: s32 = a - b;
return c;
}
}

1001
tests/thousand_simple_functions.nat
View File

File diff suppressed because it is too large Load Diff

5
tests/unsigned.nat
View File

@ -1,5 +0,0 @@
fn main() s32
{
>a: u32 = 0;
return a;
}

136
tests/while.nat
View File

@ -1,136 +0,0 @@
fn while0(arg: s32) s32
{
>a: s32 = arg;
while (a < 10)
{
a = a + 1;
}
return a;
}
fn while1(arg: s32) s32
{
>a: s32 = 1;
if (arg)
{
}
else
{
while (a < 10)
{
a = a + 1;
}
}
return a;
}
fn while2(arg: s32) s32
{
>sum: s32 = 0;
>i: s32 = 0;
while (i < arg)
{
i = i + 1;
>j: s32 = 0;
while (j < arg)
{
sum = sum + j;
j = j + 1;
}
}
return sum;
}
fn while3(arg: s32) s32
{
>a: s32 = 1;
>b: s32 = 2;
while (a < 10)
{
if (a == 2)
{
a = 3;
}
else
{
b = 4;
}
}
return b;
}
fn while4(arg: s32) s32
{
>a: s32 = 1;
>b: s32 = 2;
while (a < 10)
{
if (a == 2)
{
a = 3;
}
else
{
b = 4;
}
b = b + 1;
a = a + 1;
}
return b;
}
fn while5(arg: s32) s32
{
>a: s32 = 1;
while (a < 10)
{
a = a + 1;
a = a + 2;
}
return a;
}
fn while6(arg: s32) s32
{
>a: s32 = 1;
while (arg)
{
a = 2;
}
return a;
}
fn while7(arg: s32) s32
{
>a: s32 = 1;
while (a < 10)
{
>b: s32 = a + 1;
a = b + 2;
}
return a;
}
fn[cc(.c)] main[export]() s32
{
return while0(0) +
while1(1) +
while2(2) +
while3(3) +
while4(4) +
while5(5) +
while6(6) +
while7(7);
}

4
tests/xor.nat
View File

@ -1,4 +0,0 @@
fn main() s32
{
return 0 ^ 0;
}