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

Basic struct

Browse Source
This commit is contained in:
David Gonzalez Martin 2025-02-24 09:07:25 -06:00
parent 774551e795
commit 36fc4807bb
8 changed files with 1043 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
src/LLVM.zig
View File

@ -497,6 +497,16 @@ pub const Context = opaque {
pub fn create_basic_block(context: *Context, name: []const u8, parent: *Function) *BasicBlock {
return api.llvm_context_create_basic_block(context, String.from_slice(name), parent);
}
pub fn create_forward_declared_struct_type(context: *Context, name: []const u8) *Type.Struct {
return api.llvm_context_create_forward_declared_struct_type(context, String.from_slice(name));
}
pub fn create_struct_type(context: *Context, element_types: []const *Type, name: []const u8) *Type.Struct {
const is_packed = false;
return api.llvm_context_create_struct_type(context, element_types.ptr, @intCast(element_types.len), String.from_slice(name), is_packed);
}
pub const get_struct_type = api.llvm_context_get_struct_type;
};
pub const BasicBlock = opaque {
@ -640,6 +650,14 @@ pub const Builder = opaque {
pub fn create_call(builder: *Builder, function_type: *Type.Function, function_value: *Value, arguments: []const *Value) *Value {
return api.LLVMBuildCall2(builder, function_type, function_value, arguments.ptr, @intCast(arguments.len), "");
}
pub fn create_struct_gep(builder: *Builder, struct_type: *Type.Struct, pointer: *Value, index: c_uint) *Value {
return api.LLVMBuildStructGEP2(builder, struct_type, pointer, index, "");
}
pub fn create_insert_value(builder: *Builder, aggregate: *Value, element: *Value, index: c_uint) *Value {
return api.LLVMBuildInsertValue(builder, aggregate, element, index, "");
}
};
pub const GlobalValue = opaque {
@ -682,6 +700,8 @@ pub const Function = opaque {
pub const set_calling_convention = api.LLVMSetFunctionCallConv;
pub const get_calling_convention = api.LLVMGetFunctionCallConv;
pub const get_arguments = api.LLVMGetParams;
};
pub const Constant = opaque {
@ -696,34 +716,84 @@ pub const Constant = opaque {
};
};
pub const Argument = opaque {
pub fn to_value(argument: *Argument) *Value {
return @ptrCast(argument);
}
};
pub const Value = opaque {
pub const get_type = api.LLVMTypeOf;
pub const get_kind = api.LLVMGetValueKind;
pub fn is_constant(value: *Value) bool {
return api.LLVMIsConstant(value) != 0;
}
pub const is_instruction = api.llvm_value_is_instruction;
pub fn to_constant(value: *Value) *Constant {
assert(value.is_constant());
return @ptrCast(value);
}
pub fn to_instruction(value: *Value) *Instruction {
assert(value.is_instruction());
assert(value.get_kind() == .Instruction);
return @ptrCast(value);
}
pub fn to_function(value: *Value) *Function {
assert(value.get_kind() == .Function);
return @ptrCast(value);
}
pub fn get_calling_convention(value: *Value) CallingConvention {
if (value.is_instruction()) {
const instruction = value.to_instruction();
return instruction.get_calling_convention();
} else {
const function = @as(*Function, @ptrCast(value));
return function.get_calling_convention();
const kind = value.get_kind();
switch (kind) {
.Instruction => {
const instruction = value.to_instruction();
return instruction.get_calling_convention();
},
.Function => {
const function = value.to_function();
return function.get_calling_convention();
},
else => unreachable,
}
}
pub const Kind = enum(c_uint) {
Argument,
BasicBlock,
MemoryUse,
MemoryDef,
MemoryPhi,
Function,
GlobalAlias,
GlobalIFunc,
GlobalVariable,
BlockAddress,
ConstantExpr,
ConstantArray,
ConstantStruct,
ConstantVector,
UndefValue,
ConstantAggregateZero,
ConstantDataArray,
ConstantDataVector,
ConstantInt,
ConstantFP,
ConstantPointerNull,
ConstantTokenNone,
MetadataAsValue,
InlineAsm,
Instruction,
PoisonValue,
ConstantTargetNone,
ConstantPtrAuth,
};
};
pub const Instruction = opaque {
@ -769,6 +839,10 @@ pub const DI = struct {
return api.LLVMDIBuilderCreateAutoVariable(builder, scope, name.ptr, name.len, file, line, auto_type, @intFromBool(always_preserve), flags, alignment_in_bits);
}
pub fn create_parameter_variable(builder: *DI.Builder, scope: *DI.Scope, name: []const u8, argument_number: c_uint, file: *DI.File, line: c_uint, parameter_type: *DI.Type, always_preserve: bool, flags: DI.Flags) *DI.LocalVariable {
return api.LLVMDIBuilderCreateParameterVariable(builder, scope, name.ptr, name.len, argument_number, file, line, parameter_type, @intFromBool(always_preserve), flags);
}
pub const insert_declare_record_at_end = api.LLVMDIBuilderInsertDeclareRecordAtEnd;
pub fn create_global_variable(builder: *DI.Builder, scope: *DI.Scope, name: []const u8, linkage_name: []const u8, file: *DI.File, line: c_uint, global_type: *DI.Type, local_to_unit: bool, expression: *DI.Expression, align_in_bits: u32) *DI.GlobalVariableExpression {
@ -777,6 +851,23 @@ pub const DI = struct {
}
pub const create_lexical_block = api.LLVMDIBuilderCreateLexicalBlock;
pub fn create_replaceable_composite_type(builder: *DI.Builder, tag: c_uint, name: []const u8, scope: *DI.Scope, file: *DI.File, line: c_uint) *DI.Type.Composite {
return api.LLVMDIBuilderCreateReplaceableCompositeType(builder, tag, name.ptr, name.len, scope, file, line, 0, 0, 0, .{}, null, 0);
}
pub fn create_struct_type(builder: *DI.Builder, scope: *DI.Scope, name: []const u8, file: *DI.File, line: c_uint, bit_size: u64, align_in_bits: u32, flags: DI.Flags, members: []const *DI.Type.Derived) *DI.Type.Composite {
const derived_from: ?*DI.Type = null;
const runtime_language: c_uint = 0;
const vtable_holder: ?*DI.Metadata = null;
const unique_id_pointer: ?[*]const u8 = null;
const unique_id_length: usize = 0;
return api.LLVMDIBuilderCreateStructType(builder, scope, name.ptr, name.len, file, line, bit_size, align_in_bits, flags, derived_from, members.ptr, @intCast(members.len), runtime_language, vtable_holder, unique_id_pointer, unique_id_length);
}
pub fn create_member_type(builder: *DI.Builder, scope: *DI.Scope, name: []const u8, file: *DI.File, line: c_uint, bit_size: u64, align_in_bits: u32, bit_offset: u64, flags: DI.Flags, member_type: *DI.Type) *DI.Type.Derived {
return api.LLVMDIBuilderCreateMemberType(builder, scope, name.ptr, name.len, file, line, bit_size, align_in_bits, bit_offset, flags, member_type);
}
};
pub const create_debug_location = api.LLVMDIBuilderCreateDebugLocation;
@ -802,7 +893,19 @@ pub const DI = struct {
pub const Record = opaque {};
pub const Type = opaque {
pub const Subroutine = opaque {};
pub const Subroutine = opaque {
pub fn to_type(subroutine: *Subroutine) *DI.Type {
return @ptrCast(subroutine);
}
};
pub const Composite = opaque {
pub fn to_type(composite: *Composite) *DI.Type {
return @ptrCast(composite);
}
pub const replace_all_uses_with = api.LLVMMetadataReplaceAllUsesWith;
};
pub const Derived = opaque {};
};
pub const Flags = packed struct(u32) {
@ -851,17 +954,46 @@ 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 const Kind = enum(c_uint) {
Void,
Half,
Float,
Double,
X86_FP80,
FP128,
PPC_FP128,
Label,
Integer,
Function,
Struct,
Array,
Pointer,
Vector,
Metadata,
X86_MMX,
Token,
ScalableVector,
BFloat,
X86_AMX,
TargetExt,
};
pub fn to_function(t: *Type) *Type.Function {
assert(t.is_function());
return @ptrCast(t);
pub const get_kind = api.LLVMGetTypeKind;
pub const get_poison = api.LLVMGetPoison;
pub fn to_integer(ty: *Type) *Type.Integer {
assert(ty.get_kind() == .Integer);
return @ptrCast(ty);
}
pub fn to_integer(t: *Type) *Type.Integer {
assert(t.is_integer());
return @ptrCast(t);
pub fn to_function(ty: *Type) *Type.Function {
assert(ty.get_kind() == .Function);
return @ptrCast(ty);
}
pub fn to_struct(ty: *Type) *Type.Struct {
assert(ty.get_kind() == .Struct);
return @ptrCast(ty);
}
pub const Function = opaque {
@ -882,6 +1014,17 @@ pub const Type = opaque {
}
pub const get_bit_count = api.llvm_integer_type_get_bit_count;
};
pub const Struct = opaque {
pub fn to_type(struct_type: *Type.Struct) *Type {
return @ptrCast(struct_type);
}
pub fn set_body(struct_type: *Type.Struct, element_types: []const *Type) void {
const is_packed = false;
api.LLVMStructSetBody(struct_type, element_types.ptr, @intCast(element_types.len), @intFromBool(is_packed));
}
};
};
pub const Dwarf = struct {

1075
src/converter.zig
View File

File diff suppressed because it is too large Load Diff

4
src/converter_test.zig
View File

@ -156,3 +156,7 @@ test "simple_branch" {
test "basic_call" {
try invsrc(@src());
}
test "struct" {
try invsrc(@src());
}

17
src/lib.zig
View File

@ -39,6 +39,23 @@ pub fn align_forward_u32(value: u32, alignment: u32) u32 {
return align_forward(u32, value, alignment);
}
pub fn is_power_of_two(value: anytype) bool {
return (value & (value - 1)) == 0;
}
pub fn next_power_of_two(n: u64) u64 {
var result = n;
result -= 1;
result |= result >> 1;
result |= result >> 2;
result |= result >> 4;
result |= result >> 8;
result |= result >> 16;
result |= result >> 32;
result += 1;
return result;
}
const ValueFromFlag = enum {
sub,
cmov,

24
src/llvm.cpp
View File

@ -53,24 +53,6 @@ EXPORT Module* llvm_context_create_module(LLVMContext& context, BBLLVMString nam
return new Module(name.string_ref(), context);
}
EXPORT bool llvm_value_is_instruction(Value* value)
{
auto result = isa<Instruction>(value);
return result;
}
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 unsigned llvm_integer_type_get_bit_count(const IntegerType& integer_type)
{
auto result = integer_type.getBitWidth();
@ -94,6 +76,12 @@ EXPORT Function* llvm_module_create_function(Module* module, FunctionType* funct
return function;
}
EXPORT StructType* llvm_context_create_forward_declared_struct_type(LLVMContext& context, BBLLVMString name)
{
auto* struct_type = StructType::create(context, name.string_ref());
return struct_type;
}
EXPORT StructType* llvm_context_create_struct_type(LLVMContext& context, Type** type_pointer, size_t type_count, BBLLVMString name, bool is_packed)
{
auto types = ArrayRef<Type*>(type_pointer, type_count);

17
src/llvm_api.zig
View File

@ -20,6 +20,8 @@ pub extern fn LLVMGetFunctionCallConv(function: *llvm.Function) llvm.CallingConv
pub extern fn LLVMSetInstructionCallConv(instruction: *llvm.Instruction, calling_convention: llvm.CallingConvention) void;
pub extern fn LLVMGetInstructionCallConv(instruction: *llvm.Instruction) llvm.CallingConvention;
pub extern fn LLVMGetParams(function: *llvm.Function, argument_buffer: [*]*llvm.Argument) void;
pub extern fn llvm_function_to_string(function: *llvm.Function) *llvm.String;
pub extern fn llvm_function_verify(function: *llvm.Function, error_message: *llvm.String) bool;
pub extern fn llvm_module_verify(module: *llvm.Module, error_message: *llvm.String) bool;
@ -49,6 +51,8 @@ pub extern fn llvm_builder_create_alloca(builder: *llvm.Builder, ty: *llvm.Type,
pub extern fn LLVMBuildStore(builder: *llvm.Builder, value: *llvm.Value, pointer: *llvm.Value) *llvm.Value;
pub extern fn LLVMBuildLoad2(builder: *llvm.Builder, ty: *llvm.Type, pointer: *llvm.Value, name: [*:0]const u8) *llvm.Value;
pub extern fn LLVMBuildCall2(builder: *llvm.Builder, ty: *llvm.Type.Function, pointer: *llvm.Value, argument_pointer: [*]const *llvm.Value, argument_count: c_uint, name: [*:0]const u8) *llvm.Value;
pub extern fn LLVMBuildStructGEP2(builder: *llvm.Builder, struct_type: *llvm.Type.Struct, pointer: *llvm.Value, index: c_uint, name: [*:0]const u8) *llvm.Value;
pub extern fn LLVMBuildInsertValue(builder: *llvm.Builder, aggregate: *llvm.Value, element: *llvm.Value, index: c_uint, name: [*:0]const u8) *llvm.Value;
pub extern fn LLVMSetCurrentDebugLocation2(builder: *llvm.Builder, location: ?*llvm.DI.Location) void;
@ -83,6 +87,8 @@ pub extern fn LLVMCountParamTypes(function_type: *llvm.Type.Function) c_uint;
pub extern fn LLVMGetParamTypes(function_type: *llvm.Type.Function, types: [*]*llvm.Type) void;
// Types: struct
pub extern fn LLVMStructSetBody(struct_type: *llvm.Type.Struct, element_type_pointer: [*]const *llvm.Type, element_type_count: c_uint, is_packed: Bool) void;
pub extern fn llvm_context_create_forward_declared_struct_type(context: *llvm.Context, name: llvm.String) *llvm.Type.Struct;
pub extern fn llvm_context_create_struct_type(context: *llvm.Context, element_types_pointer: [*]const *llvm.Type, element_type_count: usize, name: llvm.String, is_packed: bool) *llvm.Type.Struct;
pub extern fn llvm_context_get_struct_type(context: *llvm.Context, element_types_pointer: [*]const *llvm.Type, element_type_count: usize, is_packed: bool) *llvm.Type.Struct;
@ -96,14 +102,15 @@ 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;
pub extern fn LLVMGetTypeKind(ty: *llvm.Type) llvm.Type.Kind;
pub extern fn llvm_integer_type_get_bit_count(integer_type: *llvm.Type.Integer) c_uint;
// VALUES
pub extern fn LLVMGetPoison(type: *llvm.Type) *llvm.Value;
pub extern fn LLVMConstInt(type: *llvm.Type.Integer, value: c_ulonglong, sign_extend: Bool) *llvm.Constant.Integer;
pub extern fn LLVMGetValueKind(value: *llvm.Value) llvm.Value.Kind;
pub extern fn LLVMIsConstant(value: *llvm.Value) Bool;
// Debug info API
@ -119,9 +126,15 @@ pub extern fn LLVMDIBuilderCreateDebugLocation(context: *llvm.Context, line: c_u
pub extern fn LLVMDIBuilderCreateBasicType(builder: *llvm.DI.Builder, name_pointer: [*]const u8, name_length: usize, bit_count: u64, dwarf_type: llvm.Dwarf.Type, flags: llvm.DI.Flags) *llvm.DI.Type;
pub extern fn LLVMDIBuilderCreateAutoVariable(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, file: *llvm.DI.File, line: c_uint, type: *llvm.DI.Type, always_preserve: Bool, flags: llvm.DI.Flags, align_in_bits: u32) *llvm.DI.LocalVariable;
pub extern fn LLVMDIBuilderInsertDeclareRecordAtEnd(builder: *llvm.DI.Builder, storage: *llvm.Value, local_variable: *llvm.DI.LocalVariable, expression: *llvm.DI.Expression, debug_location: *llvm.DI.Location, basic_block: *llvm.BasicBlock) *llvm.DI.Record;
pub extern fn LLVMDIBuilderCreateParameterVariable(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, argument_number: c_uint, file: *llvm.DI.File, line: c_uint, type: *llvm.DI.Type, always_preserve: Bool, flags: llvm.DI.Flags) *llvm.DI.LocalVariable;
pub extern fn LLVMDIBuilderCreateGlobalVariableExpression(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, linkage_name_pointer: [*]const u8, linkage_name_length: usize, file: *llvm.DI.File, line: c_uint, global_type: *llvm.DI.Type, local_to_unit: Bool, expression: *llvm.DI.Expression, declaration: ?*llvm.DI.Metadata, align_in_bits: u32) *llvm.DI.GlobalVariableExpression;
pub extern fn llvm_global_variable_add_debug_info(global_variable: *llvm.GlobalVariable, debug_global_variable: *llvm.DI.GlobalVariableExpression) void;
pub extern fn LLVMDIBuilderCreateLexicalBlock(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, file: *llvm.DI.File, line: c_uint, column: c_uint) *llvm.DI.LexicalBlock;
pub extern fn LLVMDIBuilderCreateReplaceableCompositeType(builder: *llvm.DI.Builder, tag: c_uint, name_pointer: [*]const u8, name_length: usize, scope: *llvm.DI.Scope, file: *llvm.DI.File, line: c_uint, runtime_language: c_uint, bit_size: u64, align_in_bits: u32, flags: llvm.DI.Flags, unique_identifier_pointer: ?[*]const u8, unique_identifier_length: usize) *llvm.DI.Type.Composite;
pub extern fn LLVMDIBuilderCreateStructType(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, file: *llvm.DI.File, line: c_uint, bit_size: u64, align_in_bits: u32, flags: llvm.DI.Flags, derived_from: ?*llvm.DI.Type, member_pointer: [*]const *llvm.DI.Type.Derived, member_length: c_uint, runtime_language: c_uint, vtable_holder: ?*llvm.DI.Metadata, unique_id_pointer: ?[*]const u8, unique_id_length: usize) *llvm.DI.Type.Composite;
pub extern fn LLVMDIBuilderCreateMemberType(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, file: *llvm.DI.File, line: c_uint, bit_size: u64, align_in_bits: u32, bit_offset: u64, flags: llvm.DI.Flags, member_type: *llvm.DI.Type) *llvm.DI.Type.Derived;
pub extern fn LLVMMetadataReplaceAllUsesWith(forward: *llvm.DI.Type.Composite, complete: *llvm.DI.Type.Composite) void;
// Target
pub extern fn llvm_default_target_triple() llvm.String;

4
src/main.nat
View File

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

20
tests/struct.bbb Normal file
View File

@ -0,0 +1,20 @@
Foo = struct {
x: s32,
y: s32,
z: s32,
};
foo = fn(arg: Foo) s32 {
return arg.z;
}
[export] main = fn [cc(c)] () s32
{
>a: Foo = {
.x = 2,
.y = 1,
.z = 0,
};
return foo(a);
}