diff --git a/src/check_expr.cpp b/src/check_expr.cpp index ef43812c0..8691e8fe0 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -3216,7 +3216,7 @@ Entity *check_selector(CheckerContext *c, Operand *operand, Ast *node, Type *typ } } else if (operand->mode == Addressing_MapIndex) { operand->mode = Addressing_Value; - } else if (sel.indirect || operand->mode != Addressing_Value) { + } else if (sel.indirect || operand->mode != Addressing_Value || operand->mode == Addressing_SoaVariable) { operand->mode = Addressing_Variable; } else { operand->mode = Addressing_Value; @@ -4735,6 +4735,81 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 break; } + case BuiltinProc_soa_struct: { + Operand x = {}; + Operand y = {}; + x = *operand; + if (!is_type_integer(x.type) || x.mode != Addressing_Constant) { + error(call, "Expected a constant integer for 'intrinsics.soa_struct'"); + operand->mode = Addressing_Type; + operand->type = t_invalid; + return false; + } + if (x.value.value_integer.neg) { + error(call, "Negative array element length"); + operand->mode = Addressing_Type; + operand->type = t_invalid; + return false; + } + i64 count = big_int_to_i64(&x.value.value_integer); + + check_expr_or_type(c, &y, ce->args[1]); + if (y.mode != Addressing_Type) { + error(call, "Expected a type 'intrinsics.soa_struct'"); + operand->mode = Addressing_Type; + operand->type = t_invalid; + return false; + } + Type *elem = y.type; + if (!is_type_struct(elem) && !is_type_raw_union(elem)) { + gbString str = type_to_string(elem); + error(call, "Invalid type for 'intrinsics.soa_struct', expected a struct, got '%s'", str); + gb_string_free(str); + operand->mode = Addressing_Type; + operand->type = t_invalid; + return false; + } + + operand->mode = Addressing_Type; + + Type *old_struct = base_type(elem); + Type *soa_struct = alloc_type_struct(); + soa_struct->Struct.fields = array_make(heap_allocator(), old_struct->Struct.fields.count); + soa_struct->Struct.tags = array_make(heap_allocator(), old_struct->Struct.tags.count); + soa_struct->Struct.node = operand->expr; + soa_struct->Struct.is_soa = true; + soa_struct->Struct.soa_elem = elem; + soa_struct->Struct.soa_count = count; + + Scope *scope = create_scope(old_struct->Struct.scope->parent, c->allocator); + soa_struct->Struct.scope = scope; + + for_array(i, old_struct->Struct.fields) { + Entity *old_field = old_struct->Struct.fields[i]; + if (old_field->kind == Entity_Variable) { + Type *array_type = alloc_type_array(old_field->type, count); + Entity *new_field = alloc_entity_field(scope, old_field->token, array_type, false, old_field->Variable.field_src_index); + soa_struct->Struct.fields[i] = new_field; + add_entity(c->checker, scope, nullptr, new_field); + } else { + soa_struct->Struct.fields[i] = old_field; + } + + soa_struct->Struct.tags[i] = old_struct->Struct.tags[i]; + } + + + Token token = {}; + token.string = str_lit("Base_Type"); + Entity *base_type_entity = alloc_entity_type_name(scope, token, elem, EntityState_Resolved); + add_entity(c->checker, scope, nullptr, base_type_entity); + + add_type_info_type(c, soa_struct); + + operand->type = soa_struct; + break; + } + case BuiltinProc_atomic_fence: case BuiltinProc_atomic_fence_acq: case BuiltinProc_atomic_fence_rel: @@ -6640,6 +6715,18 @@ bool check_set_index_data(Operand *o, Type *t, bool indirection, i64 *max_count) o->mode = Addressing_Variable; } return true; + case Type_Struct: + if (t->Struct.is_soa) { + *max_count = t->Struct.soa_count; + o->type = t->Struct.soa_elem; + if (o->mode == Addressing_SoaVariable || o->mode == Addressing_Variable) { + o->mode = Addressing_SoaVariable; + } else { + o->mode = Addressing_Value; + } + return true; + } + return false; } return false; diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 63cb4da8b..8c5293d81 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -293,6 +293,9 @@ Type *check_assignment_variable(CheckerContext *ctx, Operand *lhs, Operand *rhs) break; } + case Addressing_SoaVariable: + break; + default: { if (lhs->expr->kind == Ast_SelectorExpr) { // NOTE(bill): Extra error checks diff --git a/src/checker.cpp b/src/checker.cpp index 184f99ab9..2bd39e800 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -13,6 +13,7 @@ bool is_operand_value(Operand o) { case Addressing_Constant: case Addressing_MapIndex: case Addressing_OptionalOk: + case Addressing_SoaVariable: return true; } return false; @@ -1255,6 +1256,9 @@ void add_type_info_type(CheckerContext *c, Type *t) { break; case Type_Basic: switch (bt->Basic.kind) { + case Basic_cstring: + add_type_info_type(c, t_u8_ptr); + break; case Basic_string: add_type_info_type(c, t_u8_ptr); add_type_info_type(c, t_int); @@ -1274,6 +1278,14 @@ void add_type_info_type(CheckerContext *c, Type *t) { add_type_info_type(c, t_type_info_float); add_type_info_type(c, t_f64); break; + case Basic_quaternion128: + add_type_info_type(c, t_type_info_float); + add_type_info_type(c, t_f32); + break; + case Basic_quaternion256: + add_type_info_type(c, t_type_info_float); + add_type_info_type(c, t_f64); + break; } break; @@ -1328,7 +1340,11 @@ void add_type_info_type(CheckerContext *c, Type *t) { if (bt->Struct.scope != nullptr) { for_array(i, bt->Struct.scope->elements.entries) { Entity *e = bt->Struct.scope->elements.entries[i].value; - add_type_info_type(c, e->type); + if (bt->Struct.is_soa) { + add_type_info_type(c, alloc_type_pointer(e->type)); + } else { + add_type_info_type(c, e->type); + } } } for_array(i, bt->Struct.fields) { diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp index 50d27d715..612abc2b6 100644 --- a/src/checker_builtin_procs.hpp +++ b/src/checker_builtin_procs.hpp @@ -34,6 +34,7 @@ enum BuiltinProcId { // "Intrinsics" BuiltinProc_vector, + BuiltinProc_soa_struct, BuiltinProc_atomic_fence, BuiltinProc_atomic_fence_acq, @@ -159,6 +160,7 @@ BuiltinProc__type_begin, BuiltinProc__type_end, + BuiltinProc_COUNT, }; gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { @@ -195,7 +197,8 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { // "Intrinsics" - {STR_LIT("vector"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, // Type + {STR_LIT("vector"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, // Type + {STR_LIT("soa_struct"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, // Type {STR_LIT("atomic_fence"), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics}, {STR_LIT("atomic_fence_acq"), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics}, diff --git a/src/ir.cpp b/src/ir.cpp index bb3253b7d..74ddaf262 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -483,6 +483,7 @@ enum irAddrKind { irAddr_Map, irAddr_BitField, irAddr_Context, + irAddr_SoaVariable, }; struct irAddr { @@ -500,6 +501,10 @@ struct irAddr { struct { Selection sel; } ctx; + struct { + irValue *index; + Ast *index_expr; + } soa; }; }; @@ -530,6 +535,14 @@ irAddr ir_addr_bit_field(irValue *addr, i32 bit_field_value_index) { return v; } +irAddr ir_addr_soa_variable(irValue *addr, irValue *index, Ast *index_expr) { + irAddr v = {irAddr_SoaVariable, addr}; + v.soa.index = index; + v.soa.index_expr = index_expr; + return v; +} + + enum irDebugEncoding { irDebugBasicEncoding_Invalid = 0, @@ -3397,6 +3410,8 @@ irValue *ir_emit_source_code_location(irProcedure *proc, Ast *node); irValue *ir_emit_ptr_offset(irProcedure *proc, irValue *ptr, irValue *offset); irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *right, Type *type); irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel); +void ir_emit_bounds_check(irProcedure *proc, Token token, irValue *index, irValue *len); + irValue *ir_insert_dynamic_map_key_and_value(irProcedure *proc, irValue *addr, Type *map_type, irValue *map_key, irValue *map_value) { @@ -3532,6 +3547,28 @@ void ir_addr_store(irProcedure *proc, irAddr const &addr, irValue *value) { ir_emit_store(proc, lhs, rhs); } + return; + } else if (addr.kind == irAddr_SoaVariable) { + Type *t = type_deref(ir_type(addr.addr)); + t = base_type(t); + GB_ASSERT(t->kind == Type_Struct && t->Struct.is_soa); + value = ir_emit_conv(proc, value, t->Struct.soa_elem); + + irValue *index = addr.soa.index; + if (index->kind != irValue_Constant) { + Type *t = base_type(type_deref(ir_type(addr.addr))); + GB_ASSERT(t->kind == Type_Struct && t->Struct.is_soa); + i64 count = t->Struct.soa_count; + irValue *len = ir_const_int(count); + ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), index, len); + } + + for_array(i, t->Struct.fields) { + irValue *dst = ir_emit_struct_ep(proc, addr.addr, cast(i32)i); + dst = ir_emit_array_ep(proc, dst, index); + irValue *src = ir_emit_struct_ev(proc, value, cast(i32)i); + ir_emit_store(proc, dst, src); + } return; } @@ -3642,6 +3679,35 @@ irValue *ir_addr_load(irProcedure *proc, irAddr const &addr) { irValue *b = ir_emit_deep_field_gep(proc, a, addr.ctx.sel); return ir_emit_load(proc, b); } + } else if (addr.kind == irAddr_SoaVariable) { + Type *t = type_deref(ir_type(addr.addr)); + t = base_type(t); + GB_ASSERT(t->kind == Type_Struct && t->Struct.is_soa); + Type *elem = t->Struct.soa_elem;; + i32 count = cast(i32)t->Struct.soa_count; + + irValue *res = ir_add_local_generated(proc, elem, true); + + if (addr.soa.index->kind != irValue_Constant) { + irValue *len = ir_const_int(count); + ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), addr.soa.index, len); + } + + for_array(i, t->Struct.fields) { + Entity *field = t->Struct.fields[i]; + Type *base_type = field->type; + GB_ASSERT(base_type->kind == Type_Array); + Type *elem = base_type->Array.elem; + + + irValue *dst = ir_emit_struct_ep(proc, res, cast(i32)i); + irValue *src_ptr = ir_emit_struct_ep(proc, addr.addr, cast(i32)i); + src_ptr = ir_emit_array_ep(proc, src_ptr, addr.soa.index); + irValue *src = ir_emit_load(proc, src_ptr); + ir_emit_store(proc, dst, src); + } + + return ir_emit_load(proc, res); } Type *t = base_type(ir_type(addr.addr)); @@ -7459,6 +7525,28 @@ irAddr ir_build_addr(irProcedure *proc, Ast *expr) { addr.ctx.sel = sel; return addr; + } else if (addr.kind == irAddr_SoaVariable) { + irValue *index = addr.soa.index; + i32 first_index = sel.index[0]; + Selection sub_sel = sel; + sub_sel.index.data += 1; + sub_sel.index.count -= 1; + + irValue *arr = ir_emit_struct_ep(proc, addr.addr, first_index); + + if (addr.soa.index->kind != irValue_Constant) { + Type *t = base_type(type_deref(ir_type(addr.addr))); + GB_ASSERT(t->kind == Type_Struct && t->Struct.is_soa); + i64 count = t->Struct.soa_count; + irValue *len = ir_const_int(count); + ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), addr.soa.index, len); + } + + irValue *item = ir_emit_array_ep(proc, arr, index); + if (sub_sel.index.count > 0) { + item = ir_emit_deep_field_gep(proc, item, sub_sel); + } + return ir_addr(item); } irValue *a = ir_addr_get_ptr(proc, addr); a = ir_emit_deep_field_gep(proc, a, sel); @@ -7515,6 +7603,19 @@ irAddr ir_build_addr(irProcedure *proc, Ast *expr) { bool deref = is_type_pointer(t); t = base_type(type_deref(t)); + if (t->kind == Type_Struct && t->Struct.is_soa) { + // SOA STRUCTURES!!!! + Type *elem = t->Struct.soa_elem; + + irValue *val = ir_build_addr_ptr(proc, ie->expr); + if (deref) { + val = ir_emit_load(proc, val); + } + + irValue *index = ir_build_expr(proc, ie->index); + return ir_addr_soa_variable(val, index, ie->index); + } + GB_ASSERT_MSG(is_type_indexable(t), "%s %s", type_to_string(t), expr_to_string(expr)); if (is_type_map(t)) { diff --git a/src/parser.hpp b/src/parser.hpp index b9e53dbe8..288c944d8 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -21,6 +21,7 @@ enum AddressingMode { // lhs: acts like a Variable // rhs: acts like OptionalOk Addressing_OptionalOk, // rhs: acts like a value with an optional boolean part (for existence check) + Addressing_SoaVariable, // Struct-Of-Arrays indexed variable }; struct TypeAndValue { diff --git a/src/types.cpp b/src/types.cpp index bef69ee30..6fab6643e 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -129,6 +129,9 @@ struct TypeStruct { bool is_raw_union; bool is_polymorphic; bool is_poly_specialized; + bool is_soa; + Type *soa_elem; + i64 soa_count; }; struct TypeUnion {