mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-04-18 20:40:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use a global to store the build context information

Browse Source
This commit is contained in:
Ginger Bill
2017-02-12 21:27:13 +00:00
parent 282f8bb06f
commit bd27c24fab
9 changed files with 195 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
src/build.c → src/build_settings.c
View File

@@ -13,6 +13,11 @@ typedef struct BuildContext {
bool is_dll;
} BuildContext;
gb_global BuildContext build_context = {0};
// TODO(bill): OS dependent versions for the BuildContext
// join_path
// is_dir
@@ -129,25 +134,6 @@ String odin_root_dir(void) {
#error Implement system
#endif
#if defined(GB_SYSTEM_WINDOWS)
String path_to_fullpath(gbAllocator a, String s) {
@@ -216,9 +202,10 @@ String get_fullpath_core(gbAllocator a, String path) {
void init_build_context(BuildContext *bc) {
void init_build_context(void) {
BuildContext *bc = &build_context;
bc->ODIN_VENDOR = str_lit("odin");
bc->ODIN_VERSION = str_lit("0.1.0");
bc->ODIN_VERSION = str_lit("0.1.1");
bc->ODIN_ROOT = odin_root_dir();
#if defined(GB_SYSTEM_WINDOWS)

4
src/check_decl.c
View File

@@ -300,7 +300,7 @@ void check_proc_lit(Checker *c, Entity *e, DeclInfo *d) {
}
if (is_foreign) {
MapEntity *fp = &c->info.foreign_procs;
MapEntity *fp = &c->info.foreigns;
String name = e->token.string;
if (pd->foreign_name.len > 0) {
name = pd->foreign_name;
@@ -355,7 +355,7 @@ void check_proc_lit(Checker *c, Entity *e, DeclInfo *d) {
}
if (is_link_name || is_export) {
MapEntity *fp = &c->info.foreign_procs;
MapEntity *fp = &c->info.foreigns;
e->Procedure.link_name = name;

46
src/check_expr.c
View File

@@ -473,7 +473,6 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls,
// TODO(bill): Cleanup struct field reordering
// TODO(bill): Inline sorting procedure?
gb_global BaseTypeSizes __checker_sizes = {0};
gb_global gbAllocator __checker_allocator = {0};
GB_COMPARE_PROC(cmp_struct_entity_size) {
@@ -487,10 +486,10 @@ GB_COMPARE_PROC(cmp_struct_entity_size) {
GB_ASSERT(y != NULL);
GB_ASSERT(x->kind == Entity_Variable);
GB_ASSERT(y->kind == Entity_Variable);
i64 xa = type_align_of(__checker_sizes, __checker_allocator, x->type);
i64 ya = type_align_of(__checker_sizes, __checker_allocator, y->type);
i64 xs = type_size_of(__checker_sizes, __checker_allocator, x->type);
i64 ys = type_size_of(__checker_sizes, __checker_allocator, y->type);
i64 xa = type_align_of(__checker_allocator, x->type);
i64 ya = type_align_of(__checker_allocator, y->type);
i64 xs = type_size_of(__checker_allocator, x->type);
i64 ys = type_size_of(__checker_allocator, y->type);
if (xa == ya) {
if (xs == ys) {
@@ -545,7 +544,6 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
// NOTE(bill): Hacky thing
// TODO(bill): Probably make an inline sorting procedure rather than use global variables
__checker_sizes = c->sizes;
__checker_allocator = c->allocator;
// NOTE(bill): compound literal order must match source not layout
gb_sort_array(reordered_fields, field_count, cmp_struct_entity_size);
@@ -557,7 +555,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
struct_type->Record.fields = reordered_fields;
}
type_set_offsets(c->sizes, c->allocator, struct_type);
type_set_offsets(c->allocator, struct_type);
if (st->align != NULL) {
if (st->is_packed) {
@@ -584,7 +582,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
}
// NOTE(bill): Success!!!
i64 custom_align = gb_clamp(align, 1, c->sizes.max_align);
i64 custom_align = gb_clamp(align, 1, build_context.max_align);
if (custom_align < align) {
warning_node(st->align, "Custom alignment has been clamped to %lld from %lld", align, custom_align);
}
@@ -1188,7 +1186,7 @@ void check_map_type(Checker *c, Type *type, AstNode *node) {
entry_type->Record.fields_in_src_order = fields;
entry_type->Record.field_count = field_count;
type_set_offsets(c->sizes, a, entry_type);
type_set_offsets(a, entry_type);
type->Map.entry_type = entry_type;
}
@@ -1219,7 +1217,7 @@ void check_map_type(Checker *c, Type *type, AstNode *node) {
generated_struct_type->Record.fields_in_src_order = fields;
generated_struct_type->Record.field_count = field_count;
type_set_offsets(c->sizes, a, generated_struct_type);
type_set_offsets(a, generated_struct_type);
type->Map.generated_struct_type = generated_struct_type;
}
@@ -1576,7 +1574,7 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type
if (out_value) *out_value = v;
i64 i = v.value_integer;
u64 u = *cast(u64 *)&i;
i64 s = 8*type_size_of(c->sizes, c->allocator, type);
i64 s = 8*type_size_of(c->allocator, type);
u64 umax = ~0ull;
if (s < 64) {
umax = (1ull << s) - 1ull;
@@ -1734,7 +1732,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) {
i32 precision = 0;
if (is_type_unsigned(type)) {
precision = cast(i32)(8 * type_size_of(c->sizes, c->allocator, type));
precision = cast(i32)(8 * type_size_of(c->allocator, type));
}
o->value = exact_unary_operator_value(op.kind, o->value, precision);
@@ -2059,7 +2057,7 @@ Operand check_ptr_addition(Checker *c, TokenKind op, Operand *ptr, Operand *offs
if (ptr->mode == Addressing_Constant && offset->mode == Addressing_Constant) {
i64 elem_size = type_size_of(c->sizes, c->allocator, ptr->type);
i64 elem_size = type_size_of(c->allocator, ptr->type);
i64 ptr_val = ptr->value.value_pointer;
i64 offset_val = exact_value_to_integer(offset->value).value_integer;
i64 new_ptr_val = ptr_val;
@@ -2257,7 +2255,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
if (is_type_pointer(type)) {
GB_ASSERT(op.kind == Token_Sub);
i64 bytes = a.value_pointer - b.value_pointer;
i64 diff = bytes/type_size_of(c->sizes, c->allocator, type);
i64 diff = bytes/type_size_of(c->allocator, type);
x->value = make_exact_value_pointer(diff);
return;
}
@@ -2941,7 +2939,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
}
operand->mode = Addressing_Constant;
operand->value = make_exact_value_integer(type_size_of(c->sizes, c->allocator, type));
operand->value = make_exact_value_integer(type_size_of(c->allocator, type));
operand->type = t_untyped_integer;
} break;
@@ -2954,7 +2952,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
}
operand->mode = Addressing_Constant;
operand->value = make_exact_value_integer(type_size_of(c->sizes, c->allocator, operand->type));
operand->value = make_exact_value_integer(type_size_of(c->allocator, operand->type));
operand->type = t_untyped_integer;
break;
@@ -2966,7 +2964,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
return false;
}
operand->mode = Addressing_Constant;
operand->value = make_exact_value_integer(type_align_of(c->sizes, c->allocator, type));
operand->value = make_exact_value_integer(type_align_of(c->allocator, type));
operand->type = t_untyped_integer;
} break;
@@ -2978,7 +2976,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
}
operand->mode = Addressing_Constant;
operand->value = make_exact_value_integer(type_align_of(c->sizes, c->allocator, operand->type));
operand->value = make_exact_value_integer(type_align_of(c->allocator, operand->type));
operand->type = t_untyped_integer;
break;
@@ -3022,7 +3020,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
}
operand->mode = Addressing_Constant;
operand->value = make_exact_value_integer(type_offset_of_from_selection(c->sizes, c->allocator, type, sel));
operand->value = make_exact_value_integer(type_offset_of_from_selection(c->allocator, type, sel));
operand->type = t_untyped_integer;
} break;
@@ -3071,7 +3069,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
operand->mode = Addressing_Constant;
// IMPORTANT TODO(bill): Fix for anonymous fields
operand->value = make_exact_value_integer(type_offset_of_from_selection(c->sizes, c->allocator, type, sel));
operand->value = make_exact_value_integer(type_offset_of_from_selection(c->allocator, type, sel));
operand->type = t_untyped_integer;
} break;
@@ -3303,7 +3301,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
if (operand->mode == Addressing_Constant &&
op.mode == Addressing_Constant) {
i64 ptr = operand->value.value_pointer;
i64 elem_size = type_size_of(c->sizes, c->allocator, ptr_type->Pointer.elem);
i64 elem_size = type_size_of(c->allocator, ptr_type->Pointer.elem);
ptr += elem_size * op.value.value_integer;
operand->value.value_pointer = ptr;
} else {
@@ -3366,7 +3364,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
op.mode == Addressing_Constant) {
u8 *ptr_a = cast(u8 *)operand->value.value_pointer;
u8 *ptr_b = cast(u8 *)op.value.value_pointer;
isize elem_size = type_size_of(c->sizes, c->allocator, ptr_type->Pointer.elem);
isize elem_size = type_size_of(c->allocator, ptr_type->Pointer.elem);
operand->value = make_exact_value_integer((ptr_a - ptr_b) / elem_size);
} else {
operand->mode = Addressing_Value;
@@ -4841,8 +4839,8 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint
goto error;
}
i64 srcz = type_size_of(c->sizes, c->allocator, o->type);
i64 dstz = type_size_of(c->sizes, c->allocator, t);
i64 srcz = type_size_of(c->allocator, o->type);
i64 dstz = type_size_of(c->allocator, t);
if (srcz != dstz) {
gbString expr_str = expr_to_string(o->expr);
gbString type_str = type_to_string(t);

24
src/checker.c
View File

@@ -264,7 +264,7 @@ typedef struct CheckerInfo {
MapScope scopes; // Key: AstNode * | Node -> Scope
MapExprInfo untyped; // Key: AstNode * | Expression -> ExprInfo
MapDeclInfo entities; // Key: Entity *
MapEntity foreign_procs; // Key: String
MapEntity foreigns; // Key: String
MapAstFile files; // Key: String (full path)
MapIsize type_info_map; // Key: Type *
isize type_info_count;
@@ -275,13 +275,11 @@ typedef struct Checker {
CheckerInfo info;
AstFile * curr_ast_file;
BaseTypeSizes sizes;
Scope * global_scope;
Array(ProcedureInfo) procs; // NOTE(bill): Procedures to check
Array(DelayedDecl) delayed_imports;
Array(DelayedDecl) delayed_foreign_libraries;
gbArena arena;
gbArena tmp_arena;
gbAllocator allocator;
@@ -591,7 +589,8 @@ void add_global_string_constant(gbAllocator a, String name, String value) {
}
void init_universal_scope(BuildContext *bc) {
void init_universal_scope(void) {
BuildContext *bc = &build_context;
// NOTE(bill): No need to free these
gbAllocator a = heap_allocator();
universal_scope = make_scope(NULL, a);
@@ -650,7 +649,7 @@ void init_checker_info(CheckerInfo *i) {
map_scope_init(&i->scopes, a);
map_decl_info_init(&i->entities, a);
map_expr_info_init(&i->untyped, a);
map_entity_init(&i->foreign_procs, a);
map_entity_init(&i->foreigns, a);
map_isize_init(&i->type_info_map, a);
map_ast_file_init(&i->files, a);
i->type_info_count = 0;
@@ -664,7 +663,7 @@ void destroy_checker_info(CheckerInfo *i) {
map_scope_destroy(&i->scopes);
map_decl_info_destroy(&i->entities);
map_expr_info_destroy(&i->untyped);
map_entity_destroy(&i->foreign_procs);
map_entity_destroy(&i->foreigns);
map_isize_destroy(&i->type_info_map);
map_ast_file_destroy(&i->files);
}
@@ -675,8 +674,6 @@ void init_checker(Checker *c, Parser *parser, BuildContext *bc) {
c->parser = parser;
init_checker_info(&c->info);
c->sizes.word_size = bc->word_size;
c->sizes.max_align = bc->max_align;
array_init(&c->proc_stack, a);
array_init(&c->procs, a);
@@ -1384,8 +1381,14 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope)
di->entities = entities;
di->type_expr = vd->type;
di->init_expr = vd->values.e[0];
if (vd->flags & VarDeclFlag_thread_local) {
error_node(decl, "#thread_local variable declarations cannot have initialization values");
}
}
for_array(i, vd->names) {
AstNode *name = vd->names.e[i];
AstNode *value = NULL;
@@ -1397,8 +1400,9 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope)
continue;
}
Entity *e = make_entity_variable(c->allocator, c->context.scope, name->Ident, NULL, vd->flags & VarDeclFlag_immutable);
e->Variable.is_thread_local = vd->flags & VarDeclFlag_thread_local;
e->Variable.is_thread_local = (vd->flags & VarDeclFlag_thread_local) != 0;
e->identifier = name;
if (vd->flags & VarDeclFlag_using) {
vd->flags &= ~VarDeclFlag_using; // NOTE(bill): This error will be only caught once
error_node(name, "`using` is not allowed at the file scope");
@@ -1883,7 +1887,7 @@ void check_parsed_files(Checker *c) {
if (e->kind == Entity_TypeName) {
if (e->type != NULL) {
// i64 size = type_size_of(c->sizes, c->allocator, e->type);
i64 align = type_align_of(c->sizes, c->allocator, e->type);
i64 align = type_align_of(c->allocator, e->type);
}
}
}

94
src/ir.c
View File

@@ -17,8 +17,6 @@ typedef Array(irValue *) irValueArray;
typedef struct irModule {
CheckerInfo * info;
BuildContext *build_context;
BaseTypeSizes sizes;
gbArena arena;
gbArena tmp_arena;
gbAllocator allocator;
@@ -326,6 +324,7 @@ typedef struct irValueGlobal {
bool is_constant;
bool is_private;
bool is_thread_local;
bool is_foreign;
bool is_unnamed_addr;
} irValueGlobal;
@@ -1438,9 +1437,9 @@ irValue *ir_gen_map_header(irProcedure *proc, irValue *map_val, Type *map_type)
ir_emit_store(proc, ir_emit_struct_ep(proc, h, 1), v_true);
}
i64 entry_size = type_size_of(proc->module->sizes, a, map_type->Map.entry_type);
i64 entry_align = type_align_of(proc->module->sizes, a, map_type->Map.entry_type);
i64 value_offset = type_offset_of(proc->module->sizes, a, map_type->Map.entry_type, 2);
i64 entry_size = type_size_of(a, map_type->Map.entry_type);
i64 entry_align = type_align_of(a, map_type->Map.entry_type);
i64 value_offset = type_offset_of(a, map_type->Map.entry_type, 2);
ir_emit_store(proc, ir_emit_struct_ep(proc, h, 2), ir_make_const_int(a, entry_size));
ir_emit_store(proc, ir_emit_struct_ep(proc, h, 3), ir_make_const_int(a, entry_align));
ir_emit_store(proc, ir_emit_struct_ep(proc, h, 4), ir_make_const_int(a, value_offset));
@@ -1460,7 +1459,7 @@ irValue *ir_gen_map_key(irProcedure *proc, irValue *key, Type *key_type) {
ir_emit_store(proc, ir_emit_struct_ep(proc, v, 0), ir_emit_conv(proc, p, t_u64));
} else if (is_type_float(t)) {
irValue *bits = NULL;
i64 size = type_size_of(proc->module->sizes, proc->module->allocator, t);
i64 size = type_size_of(proc->module->allocator, t);
switch (8*size) {
case 32: bits = ir_emit_bitcast(proc, key, t_u32); break;
case 64: bits = ir_emit_bitcast(proc, key, t_u64); break;
@@ -1660,7 +1659,7 @@ irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *
irModule *m = proc->module;
Type *ptr_type = base_type(t_left);
GB_ASSERT(!is_type_rawptr(ptr_type));
irValue *elem_size = ir_make_const_int(m->allocator, type_size_of(m->sizes, m->allocator, ptr_type->Pointer.elem));
irValue *elem_size = ir_make_const_int(m->allocator, type_size_of(m->allocator, ptr_type->Pointer.elem));
irValue *x = ir_emit_conv(proc, left, type);
irValue *y = ir_emit_conv(proc, right, type);
irValue *diff = ir_emit_arith(proc, op, x, y, type);
@@ -1675,7 +1674,7 @@ irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *
left = ir_emit_conv(proc, left, type);
if (!is_type_unsigned(ir_type(right))) {
Type *t = t_u64;
if (proc->module->sizes.word_size == 32) {
if (build_context.word_size == 32) {
t = t_u32;
}
right = ir_emit_conv(proc, right, t);
@@ -2189,8 +2188,8 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
if (is_type_integer(src) && is_type_integer(dst)) {
GB_ASSERT(src->kind == Type_Basic &&
dst->kind == Type_Basic);
i64 sz = type_size_of(proc->module->sizes, proc->module->allocator, src);
i64 dz = type_size_of(proc->module->sizes, proc->module->allocator, dst);
i64 sz = type_size_of(proc->module->allocator, src);
i64 dz = type_size_of(proc->module->allocator, dst);
irConvKind kind = irConv_trunc;
if (sz == dz) {
// NOTE(bill): In LLVM, all integers are signed and rely upon 2's compliment
@@ -2216,8 +2215,8 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
// float -> float
if (is_type_float(src) && is_type_float(dst)) {
i64 sz = type_size_of(proc->module->sizes, proc->module->allocator, src);
i64 dz = type_size_of(proc->module->sizes, proc->module->allocator, dst);
i64 sz = type_size_of(proc->module->allocator, src);
i64 dz = type_size_of(proc->module->allocator, dst);
irConvKind kind = irConv_fptrunc;
if (dz >= sz) {
kind = irConv_fpext;
@@ -2432,8 +2431,8 @@ irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t) {
irModule *m = proc->module;
i64 sz = type_size_of(m->sizes, m->allocator, src);
i64 dz = type_size_of(m->sizes, m->allocator, dst);
i64 sz = type_size_of(m->allocator, src);
i64 dz = type_size_of(m->allocator, dst);
GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: `%s` to `%s`", type_to_string(src_type), type_to_string(t));
@@ -2457,7 +2456,7 @@ irValue *ir_emit_down_cast(irProcedure *proc, irValue *value, Type *t) {
Selection sel = lookup_field(proc->module->allocator, t, field_name, false);
irValue *bytes = ir_emit_conv(proc, value, t_u8_ptr);
i64 offset_ = type_offset_of_from_selection(proc->module->sizes, allocator, type_deref(t), sel);
i64 offset_ = type_offset_of_from_selection(allocator, type_deref(t), sel);
irValue *offset = ir_make_const_int(allocator, -offset_);
irValue *head = ir_emit_ptr_offset(proc, bytes, offset);
return ir_emit_conv(proc, head, t);
@@ -3072,8 +3071,8 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
Type *type = type_of_expr(proc->module->info, ce->args.e[0]);
Type *ptr_type = make_type_pointer(allocator, type);
i64 s = type_size_of(proc->module->sizes, allocator, type);
i64 a = type_align_of(proc->module->sizes, allocator, type);
i64 s = type_size_of(allocator, type);
i64 a = type_align_of(allocator, type);
irValue **args = gb_alloc_array(allocator, irValue *, 2);
args[0] = ir_make_const_int(allocator, s);
@@ -3092,8 +3091,8 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
Type *ptr_type = make_type_pointer(allocator, type);
Type *slice_type = make_type_slice(allocator, type);
i64 s = type_size_of(proc->module->sizes, allocator, type);
i64 a = type_align_of(proc->module->sizes, allocator, type);
i64 s = type_size_of(allocator, type);
i64 a = type_align_of(allocator, type);
irValue *elem_size = ir_make_const_int(allocator, s);
irValue *elem_align = ir_make_const_int(allocator, a);
@@ -3207,8 +3206,8 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
if (is_type_dynamic_array(type)) {
Type *elem = type->DynamicArray.elem;
irValue *elem_size = ir_make_const_int(a, type_size_of(proc->module->sizes, a, elem));
irValue *elem_align = ir_make_const_int(a, type_align_of(proc->module->sizes, a, elem));
irValue *elem_size = ir_make_const_int(a, type_size_of(a, elem));
irValue *elem_align = ir_make_const_int(a, type_align_of(a, elem));
ptr = ir_emit_conv(proc, ptr, t_rawptr);
@@ -3257,8 +3256,8 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
GB_ASSERT(is_type_dynamic_array(type));
Type *elem_type = type->DynamicArray.elem;
irValue *elem_size = ir_make_const_int(a, type_size_of(proc->module->sizes, a, elem_type));
irValue *elem_align = ir_make_const_int(a, type_align_of(proc->module->sizes, a, elem_type));
irValue *elem_size = ir_make_const_int(a, type_size_of(a, elem_type));
irValue *elem_align = ir_make_const_int(a, type_align_of(a, elem_type));
array_ptr = ir_emit_conv(proc, array_ptr, t_rawptr);
@@ -3401,7 +3400,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
Type *slice_type = base_type(ir_type(dst_slice));
GB_ASSERT(slice_type->kind == Type_Slice);
Type *elem_type = slice_type->Slice.elem;
i64 size_of_elem = type_size_of(proc->module->sizes, proc->module->allocator, elem_type);
i64 size_of_elem = type_size_of(proc->module->allocator, elem_type);
irValue *dst = ir_emit_conv(proc, ir_slice_elem(proc, dst_slice), t_rawptr);
irValue *src = ir_emit_conv(proc, ir_slice_elem(proc, src_slice), t_rawptr);
@@ -3473,7 +3472,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
return ir_emit_conv(proc, s, tv->type);
}
irValue *slice = ir_add_local_generated(proc, tv->type);
i64 elem_size = type_size_of(proc->module->sizes, proc->module->allocator, t->Slice.elem);
i64 elem_size = type_size_of(proc->module->allocator, t->Slice.elem);
irValue *ptr = ir_emit_conv(proc, ir_slice_elem(proc, s), t_u8_ptr);
irValue *count = ir_slice_count(proc, s);
@@ -4194,8 +4193,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
}
Type *elem = bt->DynamicArray.elem;
gbAllocator a = proc->module->allocator;
irValue *size = ir_make_const_int(a, type_size_of(proc->module->sizes, a, elem));
irValue *align = ir_make_const_int(a, type_align_of(proc->module->sizes, a, elem));
irValue *size = ir_make_const_int(a, type_size_of(a, elem));
irValue *align = ir_make_const_int(a, type_align_of(a, elem));
{
irValue **args = gb_alloc_array(a, irValue *, 4);
args[0] = ir_emit_conv(proc, v, t_rawptr);
@@ -5670,7 +5669,7 @@ void ir_module_add_value(irModule *m, Entity *e, irValue *v) {
map_ir_value_set(&m->values, hash_pointer(e), v);
}
void ir_init_module(irModule *m, Checker *c, BuildContext *build_context) {
void ir_init_module(irModule *m, Checker *c) {
// TODO(bill): Determine a decent size for the arena
isize token_count = c->parser->total_token_count;
isize arena_size = 4 * token_count * gb_size_of(irValue);
@@ -5679,8 +5678,6 @@ void ir_init_module(irModule *m, Checker *c, BuildContext *build_context) {
m->allocator = gb_arena_allocator(&m->arena);
m->tmp_allocator = gb_arena_allocator(&m->tmp_arena);
m->info = &c->info;
m->sizes = c->sizes;
m->build_context = build_context;
map_ir_value_init(&m->values, heap_allocator());
map_ir_value_init(&m->members, heap_allocator());
@@ -5785,7 +5782,7 @@ void ir_destroy_module(irModule *m) {
////////////////////////////////////////////////////////////////
bool ir_gen_init(irGen *s, Checker *c, BuildContext *build_context) {
bool ir_gen_init(irGen *s, Checker *c) {
if (global_error_collector.count != 0) {
return false;
}
@@ -5795,7 +5792,7 @@ bool ir_gen_init(irGen *s, Checker *c, BuildContext *build_context) {
return false;
}
ir_init_module(&s->module, c, build_context);
ir_init_module(&s->module, c);
s->module.generate_debug_info = false;
// TODO(bill): generate appropriate output name
@@ -5974,6 +5971,7 @@ void ir_gen_tree(irGen *s) {
if (!scope->is_global) {
if (e->kind == Entity_Procedure && (e->Procedure.tags & ProcTag_export) != 0) {
} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
// Handle later
} else if (scope->is_init && e->kind == Entity_Procedure && str_eq(name, str_lit("main"))) {
} else {
name = ir_mangle_name(s, e->token.pos.file, e);
@@ -6079,7 +6077,7 @@ void ir_gen_tree(irGen *s) {
}
#if defined(GB_SYSTEM_WINDOWS)
if (m->build_context->is_dll && !has_dll_main) {
if (build_context.is_dll && !has_dll_main) {
// DllMain :: proc(inst: rawptr, reason: u32, reserved: rawptr) -> i32
String name = str_lit("DllMain");
Type *proc_params = make_type_tuple(a);
@@ -6306,7 +6304,7 @@ void ir_gen_tree(irGen *s) {
case Basic_uint: {
tag = ir_emit_conv(proc, ti_ptr, t_type_info_integer_ptr);
bool is_unsigned = (t->Basic.flags & BasicFlag_Unsigned) != 0;
irValue *bits = ir_make_const_int(a, type_size_of(m->sizes, a, t));
irValue *bits = ir_make_const_int(a, type_size_of(a, t));
irValue *is_signed = ir_make_const_bool(a, !is_unsigned);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), bits);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), is_signed);
@@ -6318,7 +6316,7 @@ void ir_gen_tree(irGen *s) {
// case Basic_f128:
{
tag = ir_emit_conv(proc, ti_ptr, t_type_info_float_ptr);
irValue *bits = ir_make_const_int(a, type_size_of(m->sizes, a, t));
irValue *bits = ir_make_const_int(a, type_size_of(a, t));
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), bits);
} break;
@@ -6348,7 +6346,7 @@ void ir_gen_tree(irGen *s) {
irValue *gep = ir_get_type_info_ptr(proc, type_info_data, t->Array.elem);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
isize ez = type_size_of(m->sizes, a, t->Array.elem);
isize ez = type_size_of(a, t->Array.elem);
irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
ir_emit_store(proc, elem_size, ir_make_const_int(a, ez));
@@ -6362,7 +6360,7 @@ void ir_gen_tree(irGen *s) {
irValue *gep = ir_get_type_info_ptr(proc, type_info_data, t->DynamicArray.elem);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
isize ez = type_size_of(m->sizes, a, t->DynamicArray.elem);
isize ez = type_size_of(a, t->DynamicArray.elem);
irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
ir_emit_store(proc, elem_size, ir_make_const_int(a, ez));
} break;
@@ -6372,7 +6370,7 @@ void ir_gen_tree(irGen *s) {
irValue *gep = ir_get_type_info_ptr(proc, type_info_data, t->Slice.elem);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
isize ez = type_size_of(m->sizes, a, t->Slice.elem);
isize ez = type_size_of(a, t->Slice.elem);
irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
ir_emit_store(proc, elem_size, ir_make_const_int(a, ez));
} break;
@@ -6382,10 +6380,10 @@ void ir_gen_tree(irGen *s) {
irValue *gep = ir_get_type_info_ptr(proc, type_info_data, t->Vector.elem);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
isize ez = type_size_of(m->sizes, a, t->Vector.elem);
isize ez = type_size_of(a, t->Vector.elem);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), ir_make_const_int(a, ez));
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), ir_make_const_int(a, t->Vector.count));
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), ir_make_const_int(a, type_align_of(m->sizes, a, t)));
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), ir_make_const_int(a, type_align_of(a, t)));
} break;
case Type_Proc: {
@@ -6413,7 +6411,7 @@ void ir_gen_tree(irGen *s) {
tag = ir_emit_conv(proc, ti_ptr, t_type_info_tuple_ptr);
{
irValue *align = ir_make_const_int(a, type_align_of(m->sizes, a, t));
irValue *align = ir_make_const_int(a, type_align_of(a, t));
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 4), align);
}
@@ -6444,8 +6442,8 @@ void ir_gen_tree(irGen *s) {
tag = ir_emit_conv(proc, ti_ptr, t_type_info_struct_ptr);
{
irValue *size = ir_make_const_int(a, type_size_of(m->sizes, a, t));
irValue *align = ir_make_const_int(a, type_align_of(m->sizes, a, t));
irValue *size = ir_make_const_int(a, type_size_of(a, t));
irValue *align = ir_make_const_int(a, type_align_of(a, t));
irValue *packed = ir_make_const_bool(a, t->Record.struct_is_packed);
irValue *ordered = ir_make_const_bool(a, t->Record.struct_is_ordered);
irValue *custom_align = ir_make_const_bool(a, t->Record.custom_align);
@@ -6460,7 +6458,7 @@ void ir_gen_tree(irGen *s) {
irValue *memory_names = ir_type_info_member_offset(proc, type_info_member_names, t->Record.field_count, &type_info_member_names_index);
irValue *memory_offsets = ir_type_info_member_offset(proc, type_info_member_offsets, t->Record.field_count, &type_info_member_offsets_index);
type_set_offsets(m->sizes, a, t); // NOTE(bill): Just incase the offsets have not been set yet
type_set_offsets(a, t); // NOTE(bill): Just incase the offsets have not been set yet
for (isize source_index = 0; source_index < t->Record.field_count; source_index++) {
// TODO(bill): Order fields in source order not layout order
Entity *f = t->Record.fields_in_src_order[source_index];
@@ -6488,8 +6486,8 @@ void ir_gen_tree(irGen *s) {
ir_emit_comment(proc, str_lit("Type_Info_Union"));
tag = ir_emit_conv(proc, ti_ptr, t_type_info_union_ptr);
{
irValue *size = ir_make_const_int(a, type_size_of(m->sizes, a, t));
irValue *align = ir_make_const_int(a, type_align_of(m->sizes, a, t));
irValue *size = ir_make_const_int(a, type_size_of(a, t));
irValue *align = ir_make_const_int(a, type_align_of(a, t));
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), size);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 4), align);
}
@@ -6498,8 +6496,8 @@ void ir_gen_tree(irGen *s) {
ir_emit_comment(proc, str_lit("Type_Info_RawUnion"));
tag = ir_emit_conv(proc, ti_ptr, t_type_info_raw_union_ptr);
{
irValue *size = ir_make_const_int(a, type_size_of(m->sizes, a, t));
irValue *align = ir_make_const_int(a, type_align_of(m->sizes, a, t));
irValue *size = ir_make_const_int(a, type_size_of(a, t));
irValue *align = ir_make_const_int(a, type_align_of(a, t));
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), size);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 4), align);
}

34
src/ir_print.c
View File

@@ -137,8 +137,7 @@ void ir_print_encoded_global(irFileBuffer *f, String name, bool remove_prefix) {
void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
BaseTypeSizes s = m->sizes;
i64 word_bits = 8*s.word_size;
i64 word_bits = 8*build_context.word_size;
GB_ASSERT_NOT_NULL(t);
t = default_type(t);
GB_ASSERT(is_type_typed(t));
@@ -178,7 +177,7 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
ir_fprintf(f, "]");
return;
case Type_Vector: {
i64 align = type_align_of(s, heap_allocator(), t);
i64 align = type_align_of(heap_allocator(), t);
i64 count = t->Vector.count;
ir_fprintf(f, "{[0 x <%lld x i8>], [%lld x ", align, count);
ir_print_type(f, m, t->Vector.elem);
@@ -228,15 +227,15 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
case TypeRecord_Union: {
// NOTE(bill): The zero size array is used to fix the alignment used in a structure as
// LLVM takes the first element's alignment as the entire alignment (like C)
i64 size_of_union = type_size_of(s, heap_allocator(), t) - s.word_size;
i64 align_of_union = type_align_of(s, heap_allocator(), t);
i64 size_of_union = type_size_of(heap_allocator(), t) - build_context.word_size;
i64 align_of_union = type_align_of(heap_allocator(), t);
ir_fprintf(f, "{[0 x <%lld x i8>], [%lld x i8], i%lld}", align_of_union, size_of_union, word_bits);
} return;
case TypeRecord_RawUnion: {
// NOTE(bill): The zero size array is used to fix the alignment used in a structure as
// LLVM takes the first element's alignment as the entire alignment (like C)
i64 size_of_union = type_size_of(s, heap_allocator(), t);
i64 align_of_union = type_align_of(s, heap_allocator(), t);
i64 size_of_union = type_size_of(heap_allocator(), t);
i64 align_of_union = type_align_of(heap_allocator(), t);
ir_fprintf(f, "{[0 x <%lld x i8>], [%lld x i8]}", align_of_union, size_of_union);
} return;
case TypeRecord_Enum:
@@ -455,7 +454,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type *
break;
}
i64 align = type_align_of(m->sizes, m->allocator, type);
i64 align = type_align_of(m->allocator, type);
i64 count = type->Vector.count;
Type *elem_type = type->Vector.elem;
@@ -681,7 +680,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
Type *type = instr->Local.entity->type;
ir_fprintf(f, "%%%d = alloca ", value->index);
ir_print_type(f, m, type);
ir_fprintf(f, ", align %lld\n", type_align_of(m->sizes, m->allocator, type));
ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
} break;
case irInstr_ZeroInit: {
@@ -714,7 +713,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
ir_print_type(f, m, type);
ir_fprintf(f, "* ");
ir_print_value(f, m, instr->Load.address, type);
ir_fprintf(f, ", align %lld\n", type_align_of(m->sizes, m->allocator, type));
ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
} break;
case irInstr_ArrayElementPtr: {
@@ -1273,7 +1272,7 @@ void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) {
} else {
ir_fprintf(f, "\n");
ir_fprintf(f, "define ");
if (m->build_context->is_dll) {
if (build_context.is_dll) {
// if (proc->tags & (ProcTag_export|ProcTag_dll_export)) {
if (proc->tags & (ProcTag_export)) {
ir_fprintf(f, "dllexport ");
@@ -1449,6 +1448,9 @@ void print_llvm_ir(irGen *ir) {
}
ir_print_encoded_global(f, g->entity->token.string, in_global_scope);
ir_fprintf(f, " = ");
if (g->is_foreign) {
ir_fprintf(f, "external ");
}
if (g->is_thread_local) {
ir_fprintf(f, "thread_local ");
}
@@ -1468,10 +1470,12 @@ void print_llvm_ir(irGen *ir) {
ir_print_type(f, m, g->entity->type);
ir_fprintf(f, " ");
if (g->value != NULL) {
ir_print_value(f, m, g->value, g->entity->type);
} else {
ir_fprintf(f, "zeroinitializer");
if (!g->is_foreign) {
if (g->value != NULL) {
ir_print_value(f, m, g->value, g->entity->type);
} else {
ir_fprintf(f, "zeroinitializer");
}
}
ir_fprintf(f, "\n");
}

9
src/main.c
View File

@@ -4,7 +4,7 @@ extern "C" {
#include "common.c"
#include "timings.c"
#include "build.c"
#include "build_settings.c"
#include "tokenizer.c"
#include "parser.c"
// #include "printer.c"
@@ -145,10 +145,9 @@ int main(int argc, char **argv) {
#if 1
BuildContext build_context = {0};
init_build_context(&build_context);
init_build_context();
init_universal_scope(&build_context);
init_universal_scope();
char *init_filename = NULL;
bool run_output = false;
@@ -222,7 +221,7 @@ int main(int argc, char **argv) {
#if 1
irGen ir_gen = {0};
if (!ir_gen_init(&ir_gen, &checker, &build_context)) {
if (!ir_gen_init(&ir_gen, &checker)) {
return 1;
}
// defer (ssa_gen_destroy(&ir_gen));

14
src/parser.c
View File

@@ -84,9 +84,9 @@ typedef enum ProcCallingConvention {
} ProcCallingConvention;
typedef enum VarDeclFlag {
VarDeclFlag_thread_local = 1<<0,
VarDeclFlag_using = 1<<1,
VarDeclFlag_immutable = 1<<2,
VarDeclFlag_using = 1<<0,
VarDeclFlag_immutable = 1<<1,
VarDeclFlag_thread_local = 1<<2,
} VarDeclFlag;
typedef enum StmtStateFlag {
@@ -493,15 +493,11 @@ Token ast_node_token(AstNode *node) {
case AstNode_ImportDecl: return node->ImportDecl.token;
case AstNode_ForeignLibrary: return node->ForeignLibrary.token;
case AstNode_Field: {
case AstNode_Field:
if (node->Field.names.count > 0) {
return ast_node_token(node->Field.names.e[0]);
} else {
return ast_node_token(node->Field.type);
}
}
return ast_node_token(node->Field.type);
case AstNode_HelperType: return node->HelperType.token;
case AstNode_ProcType: return node->ProcType.token;

161
src/types.c
View File

@@ -178,19 +178,6 @@ typedef struct Type {
bool failure;
} Type;
// NOTE(bill): Internal sizes of certain types
// string: 2*word_size (ptr+len)
// slice: 3*word_size (ptr+len+cap)
// array: count*size_of(elem) aligned
// NOTE(bill): Alignment of structures and other types are to be compatible with C
typedef struct BaseTypeSizes {
i64 word_size;
i64 max_align;
} BaseTypeSizes;
typedef Array(i32) Array_i32;
typedef struct Selection {
@@ -350,6 +337,10 @@ gb_global Type *t_map_header = NULL;
i64 type_size_of (gbAllocator allocator, Type *t);
i64 type_align_of (gbAllocator allocator, Type *t);
i64 type_offset_of(gbAllocator allocator, Type *t, i32 index);
gbString type_to_string(Type *type);
@@ -972,6 +963,8 @@ bool is_type_cte_safe(Type *type) {
case Type_DynamicArray:
return false;
case Type_Map:
return false;
case Type_Vector: // NOTE(bill): This should always to be true but this is for sanity reasons
return is_type_cte_safe(type->Vector.elem);
@@ -1463,12 +1456,8 @@ void type_path_pop(TypePath *tp) {
#define FAILURE_ALIGNMENT 0
i64 type_size_of(BaseTypeSizes s, gbAllocator allocator, Type *t);
i64 type_align_of(BaseTypeSizes s, gbAllocator allocator, Type *t);
i64 type_offset_of(BaseTypeSizes s, gbAllocator allocator, Type *t, i32 index);
i64 type_size_of_internal (BaseTypeSizes s, gbAllocator allocator, Type *t, TypePath *path);
i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypePath *path);
i64 type_size_of_internal (gbAllocator allocator, Type *t, TypePath *path);
i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path);
i64 align_formula(i64 size, i64 align) {
if (align > 0) {
@@ -1478,32 +1467,32 @@ i64 align_formula(i64 size, i64 align) {
return size;
}
i64 type_size_of(BaseTypeSizes s, gbAllocator allocator, Type *t) {
i64 type_size_of(gbAllocator allocator, Type *t) {
if (t == NULL) {
return 0;
}
i64 size;
TypePath path = {0};
type_path_init(&path);
size = type_size_of_internal(s, allocator, t, &path);
size = type_size_of_internal(allocator, t, &path);
type_path_free(&path);
return size;
}
i64 type_align_of(BaseTypeSizes s, gbAllocator allocator, Type *t) {
i64 type_align_of(gbAllocator allocator, Type *t) {
if (t == NULL) {
return 1;
}
i64 align;
TypePath path = {0};
type_path_init(&path);
align = type_align_of_internal(s, allocator, t, &path);
align = type_align_of_internal(allocator, t, &path);
type_path_free(&path);
return align;
}
i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypePath *path) {
i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
if (t->failure) {
return FAILURE_ALIGNMENT;
}
@@ -1513,11 +1502,11 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
case Type_Basic: {
GB_ASSERT(is_type_typed(t));
switch (t->kind) {
case Basic_string: return s.word_size;
case Basic_any: return s.word_size;
case Basic_string: return build_context.word_size;
case Basic_any: return build_context.word_size;
case Basic_int: case Basic_uint: case Basic_rawptr:
return s.word_size;
return build_context.word_size;
}
} break;
@@ -1527,17 +1516,17 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
if (path->failure) {
return FAILURE_ALIGNMENT;
}
i64 align = type_align_of_internal(s, allocator, t->Array.elem, path);
i64 align = type_align_of_internal(allocator, t->Array.elem, path);
type_path_pop(path);
return align;
}
case Type_DynamicArray:
// data, count, capacity, allocator
return s.word_size;
return build_context.word_size;
case Type_Slice:
return s.word_size;
return build_context.word_size;
case Type_Vector: {
Type *elem = t->Vector.elem;
@@ -1545,17 +1534,17 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
if (path->failure) {
return FAILURE_ALIGNMENT;
}
i64 size = type_size_of_internal(s, allocator, t->Vector.elem, path);
i64 size = type_size_of_internal(allocator, t->Vector.elem, path);
type_path_pop(path);
i64 count = gb_max(prev_pow2(t->Vector.count), 1);
i64 total = size * count;
return gb_clamp(total, 1, s.max_align);
return gb_clamp(total, 1, build_context.max_align);
} break;
case Type_Tuple: {
i64 max = 1;
for (isize i = 0; i < t->Tuple.variable_count; i++) {
i64 align = type_align_of_internal(s, allocator, t->Tuple.variables[i]->type, path);
i64 align = type_align_of_internal(allocator, t->Tuple.variables[i]->type, path);
if (max < align) {
max = align;
}
@@ -1565,7 +1554,7 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
case Type_Map: {
if (t->Map.count == 0) { // Dynamic
return type_align_of_internal(s, allocator, t->Map.generated_struct_type, path);
return type_align_of_internal(allocator, t->Map.generated_struct_type, path);
}
GB_PANIC("TODO(bill): Fixed map alignment");
} break;
@@ -1574,19 +1563,19 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
switch (t->Record.kind) {
case TypeRecord_Struct:
if (t->Record.custom_align > 0) {
return gb_clamp(t->Record.custom_align, 1, s.max_align);
return gb_clamp(t->Record.custom_align, 1, build_context.max_align);
}
if (t->Record.field_count > 0) {
// TODO(bill): What is this supposed to be?
if (t->Record.struct_is_packed) {
i64 max = s.word_size;
i64 max = build_context.word_size;
for (isize i = 0; i < t->Record.field_count; i++) {
Type *field_type = t->Record.fields[i]->type;
type_path_push(path, field_type);
if (path->failure) {
return FAILURE_ALIGNMENT;
}
i64 align = type_align_of_internal(s, allocator, field_type, path);
i64 align = type_align_of_internal(allocator, field_type, path);
type_path_pop(path);
if (max < align) {
max = align;
@@ -1599,7 +1588,7 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
if (path->failure) {
return FAILURE_ALIGNMENT;
}
i64 align = type_align_of_internal(s, allocator, field_type, path);
i64 align = type_align_of_internal(allocator, field_type, path);
type_path_pop(path);
return align;
}
@@ -1613,7 +1602,7 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
if (path->failure) {
return FAILURE_ALIGNMENT;
}
i64 align = type_align_of_internal(s, allocator, field_type, path);
i64 align = type_align_of_internal(allocator, field_type, path);
type_path_pop(path);
if (max < align) {
max = align;
@@ -1629,7 +1618,7 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
if (path->failure) {
return FAILURE_ALIGNMENT;
}
i64 align = type_align_of_internal(s, allocator, field_type, path);
i64 align = type_align_of_internal(allocator, field_type, path);
type_path_pop(path);
if (max < align) {
max = align;
@@ -1641,43 +1630,43 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
} break;
}
// return gb_clamp(next_pow2(type_size_of(s, allocator, t)), 1, s.max_align);
// NOTE(bill): Things that are bigger than s.word_size, are actually comprised of smaller types
// return gb_clamp(next_pow2(type_size_of(allocator, t)), 1, build_context.max_align);
// NOTE(bill): Things that are bigger than build_context.word_size, are actually comprised of smaller types
// TODO(bill): Is this correct for 128-bit types (integers)?
return gb_clamp(next_pow2(type_size_of_internal(s, allocator, t, path)), 1, s.word_size);
return gb_clamp(next_pow2(type_size_of_internal(allocator, t, path)), 1, build_context.word_size);
}
i64 *type_set_offsets_of(BaseTypeSizes s, gbAllocator allocator, Entity **fields, isize field_count, bool is_packed) {
i64 *type_set_offsets_of(gbAllocator allocator, Entity **fields, isize field_count, bool is_packed) {
i64 *offsets = gb_alloc_array(allocator, i64, field_count);
i64 curr_offset = 0;
if (is_packed) {
for (isize i = 0; i < field_count; i++) {
offsets[i] = curr_offset;
curr_offset += type_size_of(s, allocator, fields[i]->type);
curr_offset += type_size_of(allocator, fields[i]->type);
}
} else {
for (isize i = 0; i < field_count; i++) {
i64 align = type_align_of(s, allocator, fields[i]->type);
i64 align = type_align_of(allocator, fields[i]->type);
curr_offset = align_formula(curr_offset, align);
offsets[i] = curr_offset;
curr_offset += type_size_of(s, allocator, fields[i]->type);
curr_offset += type_size_of(allocator, fields[i]->type);
}
}
return offsets;
}
bool type_set_offsets(BaseTypeSizes s, gbAllocator allocator, Type *t) {
bool type_set_offsets(gbAllocator allocator, Type *t) {
t = base_type(t);
if (is_type_struct(t)) {
if (!t->Record.struct_are_offsets_set) {
t->Record.struct_offsets = type_set_offsets_of(s, allocator, t->Record.fields, t->Record.field_count, t->Record.struct_is_packed);
t->Record.struct_offsets = type_set_offsets_of(allocator, t->Record.fields, t->Record.field_count, t->Record.struct_is_packed);
t->Record.struct_are_offsets_set = true;
return true;
}
} else if (is_type_tuple(t)) {
if (!t->Tuple.are_offsets_set) {
t->Tuple.offsets = type_set_offsets_of(s, allocator, t->Tuple.variables, t->Tuple.variable_count, false);
t->Tuple.offsets = type_set_offsets_of(allocator, t->Tuple.variables, t->Tuple.variable_count, false);
t->Tuple.are_offsets_set = true;
return true;
}
@@ -1687,7 +1676,7 @@ bool type_set_offsets(BaseTypeSizes s, gbAllocator allocator, Type *t) {
return false;
}
i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypePath *path) {
i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
if (t->failure) {
return FAILURE_SIZE;
}
@@ -1701,11 +1690,11 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
return size;
}
switch (kind) {
case Basic_string: return 2*s.word_size;
case Basic_any: return 2*s.word_size;
case Basic_string: return 2*build_context.word_size;
case Basic_any: return 2*build_context.word_size;
case Basic_int: case Basic_uint: case Basic_rawptr:
return s.word_size;
return build_context.word_size;
}
} break;
@@ -1715,17 +1704,17 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
if (count == 0) {
return 0;
}
align = type_align_of_internal(s, allocator, t->Array.elem, path);
align = type_align_of_internal(allocator, t->Array.elem, path);
if (path->failure) {
return FAILURE_SIZE;
}
size = type_size_of_internal(s, allocator, t->Array.elem, path);
size = type_size_of_internal( allocator, t->Array.elem, path);
alignment = align_formula(size, align);
return alignment*(count-1) + size;
} break;
case Type_DynamicArray:
return 3*s.word_size + type_size_of(s, allocator, t_allocator);
return 3*build_context.word_size + type_size_of(allocator, t_allocator);
case Type_Vector: {
#if 0
@@ -1738,7 +1727,7 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
if (path->failure) {
return FAILURE_SIZE;
}
bit_size = 8*type_size_of_internal(s, allocator, t->Vector.elem, path);
bit_size = 8*type_size_of_internal(allocator, t->Vector.elem, path);
type_path_pop(path);
if (is_type_boolean(t->Vector.elem)) {
bit_size = 1; // NOTE(bill): LLVM can store booleans as 1 bit because a boolean _is_ an `i1`
@@ -1753,11 +1742,11 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
if (count == 0) {
return 0;
}
align = type_align_of_internal(s, allocator, t->Vector.elem, path);
align = type_align_of_internal(allocator, t->Vector.elem, path);
if (path->failure) {
return FAILURE_SIZE;
}
size = type_size_of_internal(s, allocator, t->Vector.elem, path);
size = type_size_of_internal( allocator, t->Vector.elem, path);
alignment = align_formula(size, align);
return alignment*(count-1) + size;
#endif
@@ -1765,11 +1754,11 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
case Type_Slice: // ptr + count
return 2 * s.word_size;
return 2 * build_context.word_size;
case Type_Map: {
if (t->Map.count == 0) { // Dynamic
return type_size_of_internal(s, allocator, t->Map.generated_struct_type, path);
return type_size_of_internal(allocator, t->Map.generated_struct_type, path);
}
GB_PANIC("TODO(bill): Fixed map size");
}
@@ -1780,9 +1769,9 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
if (count == 0) {
return 0;
}
align = type_align_of_internal(s, allocator, t, path);
type_set_offsets(s, allocator, t);
size = t->Tuple.offsets[count-1] + type_size_of_internal(s, allocator, t->Tuple.variables[count-1]->type, path);
align = type_align_of_internal(allocator, t, path);
type_set_offsets(allocator, t);
size = t->Tuple.offsets[count-1] + type_size_of_internal(allocator, t->Tuple.variables[count-1]->type, path);
return align_formula(size, align);
} break;
@@ -1793,44 +1782,44 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
if (count == 0) {
return 0;
}
i64 align = type_align_of_internal(s, allocator, t, path);
i64 align = type_align_of_internal(allocator, t, path);
if (path->failure) {
return FAILURE_SIZE;
}
type_set_offsets(s, allocator, t);
i64 size = t->Record.struct_offsets[count-1] + type_size_of_internal(s, allocator, t->Record.fields[count-1]->type, path);
type_set_offsets(allocator, t);
i64 size = t->Record.struct_offsets[count-1] + type_size_of_internal(allocator, t->Record.fields[count-1]->type, path);
return align_formula(size, align);
} break;
case TypeRecord_Union: {
i64 count = t->Record.field_count;
i64 align = type_align_of_internal(s, allocator, t, path);
i64 align = type_align_of_internal(allocator, t, path);
if (path->failure) {
return FAILURE_SIZE;
}
i64 max = 0;
// NOTE(bill): Zeroth field is invalid
for (isize i = 1; i < count; i++) {
i64 size = type_size_of_internal(s, allocator, t->Record.fields[i]->type, path);
i64 size = type_size_of_internal(allocator, t->Record.fields[i]->type, path);
if (max < size) {
max = size;
}
}
// NOTE(bill): Align to int
isize size = align_formula(max, s.word_size);
size += type_size_of_internal(s, allocator, t_int, path);
isize size = align_formula(max, build_context.word_size);
size += type_size_of_internal(allocator, t_int, path);
return align_formula(size, align);
} break;
case TypeRecord_RawUnion: {
i64 count = t->Record.field_count;
i64 align = type_align_of_internal(s, allocator, t, path);
i64 align = type_align_of_internal(allocator, t, path);
if (path->failure) {
return FAILURE_SIZE;
}
i64 max = 0;
for (isize i = 0; i < count; i++) {
i64 size = type_size_of_internal(s, allocator, t->Record.fields[i]->type, path);
i64 size = type_size_of_internal(allocator, t->Record.fields[i]->type, path);
if (max < size) {
max = size;
}
@@ -1843,18 +1832,18 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
}
// Catch all
return s.word_size;
return build_context.word_size;
}
i64 type_offset_of(BaseTypeSizes s, gbAllocator allocator, Type *t, i32 index) {
i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) {
t = base_type(t);
if (t->kind == Type_Record && t->Record.kind == TypeRecord_Struct) {
type_set_offsets(s, allocator, t);
type_set_offsets(allocator, t);
if (gb_is_between(index, 0, t->Record.field_count-1)) {
return t->Record.struct_offsets[index];
}
} else if (t->kind == Type_Tuple) {
type_set_offsets(s, allocator, t);
type_set_offsets(allocator, t);
if (gb_is_between(index, 0, t->Tuple.variable_count-1)) {
return t->Tuple.offsets[index];
}
@@ -1862,32 +1851,32 @@ i64 type_offset_of(BaseTypeSizes s, gbAllocator allocator, Type *t, i32 index) {
if (t->Basic.kind == Basic_string) {
switch (index) {
case 0: return 0; // data
case 1: return s.word_size; // count
case 1: return build_context.word_size; // count
}
} else if (t->Basic.kind == Basic_any) {
switch (index) {
case 0: return 0; // type_info
case 1: return s.word_size; // data
case 1: return build_context.word_size; // data
}
}
} else if (t->kind == Type_Slice) {
switch (index) {
case 0: return 0; // data
case 1: return 1*s.word_size; // count
case 1: return 1*build_context.word_size; // count
}
} else if (t->kind == Type_DynamicArray) {
switch (index) {
case 0: return 0; // data
case 1: return 1*s.word_size; // count
case 2: return 2*s.word_size; // capacity
case 3: return 3*s.word_size; // allocator
case 1: return 1*build_context.word_size; // count
case 2: return 2*build_context.word_size; // capacity
case 3: return 3*build_context.word_size; // allocator
}
}
return 0;
}
i64 type_offset_of_from_selection(BaseTypeSizes s, gbAllocator allocator, Type *type, Selection sel) {
i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection sel) {
GB_ASSERT(sel.indirect == false);
Type *t = type;
@@ -1895,7 +1884,7 @@ i64 type_offset_of_from_selection(BaseTypeSizes s, gbAllocator allocator, Type *
for_array(i, sel.index) {
isize index = sel.index.e[i];
t = base_type(t);
offset += type_offset_of(s, allocator, t, index);
offset += type_offset_of(allocator, t, index);
if (t->kind == Type_Record && t->Record.kind == TypeRecord_Struct) {
t = t->Record.fields[index]->type;
} else {