ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-07 08:08:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove #relative slices; Replace with #relative multi-pointers

Browse Source
This commit is contained in:
gingerBill
2023-08-05 16:05:39 +01:00
parent afa8eb2d6f
commit c91898a888
29 changed files with 367 additions and 452 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/encoding/json/marshal.odin
+1 -1
View File
@@ -207,7 +207,7 @@ marshal_to_writer :: proc(w: io.Writer, v: any, opt: ^Marshal_Options) -> (err:
case runtime.Type_Info_Relative_Pointer: case runtime.Type_Info_Relative_Pointer:
return .Unsupported_Type return .Unsupported_Type
case runtime.Type_Info_Relative_Slice: case runtime.Type_Info_Relative_Multi_Pointer:
return .Unsupported_Type return .Unsupported_Type
case runtime.Type_Info_Matrix: case runtime.Type_Info_Matrix:
core/fmt/fmt.odin
+3 -24
View File
@@ -2535,32 +2535,11 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
fmt_value(fi, absolute_ptr, verb) fmt_value(fi, absolute_ptr, verb)
case runtime.Type_Info_Relative_Slice: case runtime.Type_Info_Relative_Multi_Pointer:
ptr := reflect.relative_pointer_to_absolute_raw(v.data, info.base_integer.id) ptr := reflect.relative_pointer_to_absolute_raw(v.data, info.base_integer.id)
absolute_ptr := any{ptr, info.pointer.id}
if verb == 'p' { fmt_value(fi, absolute_ptr, verb)
fmt_pointer(fi, ptr, 'p')
} else if ptr == nil {
io.write_string(fi.writer, "[]", &fi.n)
} else {
len_ptr := uintptr(v.data) + uintptr(info.base_integer.size)
len_any := any{rawptr(len_ptr), info.base_integer.id}
len, _ := reflect.as_int(len_any)
slice_type := reflect.type_info_base(info.slice).variant.(runtime.Type_Info_Slice)
fi.record_level += 1
defer fi.record_level -= 1
io.write_byte(fi.writer, '[', &fi.n)
defer io.write_byte(fi.writer, ']', &fi.n)
for i in 0..<len {
if i > 0 { io.write_string(fi.writer, ", ", &fi.n) }
data := uintptr(ptr) + uintptr(i*slice_type.elem_size)
fmt_arg(fi, any{rawptr(data), slice_type.elem.id}, verb)
}
}
case runtime.Type_Info_Matrix: case runtime.Type_Info_Matrix:
fmt_matrix(fi, v, verb, info) fmt_matrix(fi, v, verb, info)
core/odin/doc-format/doc_format.odin
+25 -25
View File
@@ -162,31 +162,31 @@ Attribute :: struct {
} }
Type_Kind :: enum u32le { Type_Kind :: enum u32le {
Invalid = 0, Invalid = 0,
Basic = 1, Basic = 1,
Named = 2, Named = 2,
Generic = 3, Generic = 3,
Pointer = 4, Pointer = 4,
Array = 5, Array = 5,
Enumerated_Array = 6, Enumerated_Array = 6,
Slice = 7, Slice = 7,
Dynamic_Array = 8, Dynamic_Array = 8,
Map = 9, Map = 9,
Struct = 10, Struct = 10,
Union = 11, Union = 11,
Enum = 12, Enum = 12,
Tuple = 13, Tuple = 13,
Proc = 14, Proc = 14,
Bit_Set = 15, Bit_Set = 15,
Simd_Vector = 16, Simd_Vector = 16,
SOA_Struct_Fixed = 17, SOA_Struct_Fixed = 17,
SOA_Struct_Slice = 18, SOA_Struct_Slice = 18,
SOA_Struct_Dynamic = 19, SOA_Struct_Dynamic = 19,
Relative_Pointer = 20, Relative_Pointer = 20,
Relative_Slice = 21, Relative_Multi_Pointer = 21,
Multi_Pointer = 22, Multi_Pointer = 22,
Matrix = 23, Matrix = 23,
Soa_Pointer = 24, Soa_Pointer = 24,
} }
Type_Elems_Cap :: 4 Type_Elems_Cap :: 4
core/reflect/reflect.odin
+59 -60
View File
@@ -8,35 +8,35 @@ _ :: intrinsics
Type_Info :: runtime.Type_Info Type_Info :: runtime.Type_Info
Type_Info_Named :: runtime.Type_Info_Named Type_Info_Named :: runtime.Type_Info_Named
Type_Info_Integer :: runtime.Type_Info_Integer Type_Info_Integer :: runtime.Type_Info_Integer
Type_Info_Rune :: runtime.Type_Info_Rune Type_Info_Rune :: runtime.Type_Info_Rune
Type_Info_Float :: runtime.Type_Info_Float Type_Info_Float :: runtime.Type_Info_Float
Type_Info_Complex :: runtime.Type_Info_Complex Type_Info_Complex :: runtime.Type_Info_Complex
Type_Info_Quaternion :: runtime.Type_Info_Quaternion Type_Info_Quaternion :: runtime.Type_Info_Quaternion
Type_Info_String :: runtime.Type_Info_String Type_Info_String :: runtime.Type_Info_String
Type_Info_Boolean :: runtime.Type_Info_Boolean Type_Info_Boolean :: runtime.Type_Info_Boolean
Type_Info_Any :: runtime.Type_Info_Any Type_Info_Any :: runtime.Type_Info_Any
Type_Info_Type_Id :: runtime.Type_Info_Type_Id Type_Info_Type_Id :: runtime.Type_Info_Type_Id
Type_Info_Pointer :: runtime.Type_Info_Pointer Type_Info_Pointer :: runtime.Type_Info_Pointer
Type_Info_Multi_Pointer :: runtime.Type_Info_Multi_Pointer Type_Info_Multi_Pointer :: runtime.Type_Info_Multi_Pointer
Type_Info_Procedure :: runtime.Type_Info_Procedure Type_Info_Procedure :: runtime.Type_Info_Procedure
Type_Info_Array :: runtime.Type_Info_Array Type_Info_Array :: runtime.Type_Info_Array
Type_Info_Enumerated_Array :: runtime.Type_Info_Enumerated_Array Type_Info_Enumerated_Array :: runtime.Type_Info_Enumerated_Array
Type_Info_Dynamic_Array :: runtime.Type_Info_Dynamic_Array Type_Info_Dynamic_Array :: runtime.Type_Info_Dynamic_Array
Type_Info_Slice :: runtime.Type_Info_Slice Type_Info_Slice :: runtime.Type_Info_Slice
Type_Info_Parameters :: runtime.Type_Info_Parameters Type_Info_Parameters :: runtime.Type_Info_Parameters
Type_Info_Tuple :: runtime.Type_Info_Parameters Type_Info_Tuple :: runtime.Type_Info_Parameters
Type_Info_Struct :: runtime.Type_Info_Struct Type_Info_Struct :: runtime.Type_Info_Struct
Type_Info_Union :: runtime.Type_Info_Union Type_Info_Union :: runtime.Type_Info_Union
Type_Info_Enum :: runtime.Type_Info_Enum Type_Info_Enum :: runtime.Type_Info_Enum
Type_Info_Map :: runtime.Type_Info_Map Type_Info_Map :: runtime.Type_Info_Map
Type_Info_Bit_Set :: runtime.Type_Info_Bit_Set Type_Info_Bit_Set :: runtime.Type_Info_Bit_Set
Type_Info_Simd_Vector :: runtime.Type_Info_Simd_Vector Type_Info_Simd_Vector :: runtime.Type_Info_Simd_Vector
Type_Info_Relative_Pointer :: runtime.Type_Info_Relative_Pointer Type_Info_Relative_Pointer :: runtime.Type_Info_Relative_Pointer
Type_Info_Relative_Slice :: runtime.Type_Info_Relative_Slice Type_Info_Relative_Multi_Pointer :: runtime.Type_Info_Relative_Multi_Pointer
Type_Info_Matrix :: runtime.Type_Info_Matrix Type_Info_Matrix :: runtime.Type_Info_Matrix
Type_Info_Soa_Pointer :: runtime.Type_Info_Soa_Pointer Type_Info_Soa_Pointer :: runtime.Type_Info_Soa_Pointer
Type_Info_Enum_Value :: runtime.Type_Info_Enum_Value Type_Info_Enum_Value :: runtime.Type_Info_Enum_Value
@@ -69,7 +69,7 @@ Type_Kind :: enum {
Bit_Set, Bit_Set,
Simd_Vector, Simd_Vector,
Relative_Pointer, Relative_Pointer,
Relative_Slice, Relative_Multi_Pointer,
Matrix, Matrix,
Soa_Pointer, Soa_Pointer,
} }
@@ -80,34 +80,34 @@ type_kind :: proc(T: typeid) -> Type_Kind {
ti := type_info_of(T) ti := type_info_of(T)
if ti != nil { if ti != nil {
switch _ in ti.variant { switch _ in ti.variant {
case Type_Info_Named: return .Named case Type_Info_Named: return .Named
case Type_Info_Integer: return .Integer case Type_Info_Integer: return .Integer
case Type_Info_Rune: return .Rune case Type_Info_Rune: return .Rune
case Type_Info_Float: return .Float case Type_Info_Float: return .Float
case Type_Info_Complex: return .Complex case Type_Info_Complex: return .Complex
case Type_Info_Quaternion: return .Quaternion case Type_Info_Quaternion: return .Quaternion
case Type_Info_String: return .String case Type_Info_String: return .String
case Type_Info_Boolean: return .Boolean case Type_Info_Boolean: return .Boolean
case Type_Info_Any: return .Any case Type_Info_Any: return .Any
case Type_Info_Type_Id: return .Type_Id case Type_Info_Type_Id: return .Type_Id
case Type_Info_Pointer: return .Pointer case Type_Info_Pointer: return .Pointer
case Type_Info_Multi_Pointer: return .Multi_Pointer case Type_Info_Multi_Pointer: return .Multi_Pointer
case Type_Info_Procedure: return .Procedure case Type_Info_Procedure: return .Procedure
case Type_Info_Array: return .Array case Type_Info_Array: return .Array
case Type_Info_Enumerated_Array: return .Enumerated_Array case Type_Info_Enumerated_Array: return .Enumerated_Array
case Type_Info_Dynamic_Array: return .Dynamic_Array case Type_Info_Dynamic_Array: return .Dynamic_Array
case Type_Info_Slice: return .Slice case Type_Info_Slice: return .Slice
case Type_Info_Parameters: return .Tuple case Type_Info_Parameters: return .Tuple
case Type_Info_Struct: return .Struct case Type_Info_Struct: return .Struct
case Type_Info_Union: return .Union case Type_Info_Union: return .Union
case Type_Info_Enum: return .Enum case Type_Info_Enum: return .Enum
case Type_Info_Map: return .Map case Type_Info_Map: return .Map
case Type_Info_Bit_Set: return .Bit_Set case Type_Info_Bit_Set: return .Bit_Set
case Type_Info_Simd_Vector: return .Simd_Vector case Type_Info_Simd_Vector: return .Simd_Vector
case Type_Info_Relative_Pointer: return .Relative_Pointer case Type_Info_Relative_Pointer: return .Relative_Pointer
case Type_Info_Relative_Slice: return .Relative_Slice case Type_Info_Relative_Multi_Pointer: return .Relative_Multi_Pointer
case Type_Info_Matrix: return .Matrix case Type_Info_Matrix: return .Matrix
case Type_Info_Soa_Pointer: return .Soa_Pointer case Type_Info_Soa_Pointer: return .Soa_Pointer
} }
} }
@@ -1457,8 +1457,6 @@ equal :: proc(a, b: any, including_indirect_array_recursion := false, recursion_
return equal(va, vb, including_indirect_array_recursion, recursion_level+1) return equal(va, vb, including_indirect_array_recursion, recursion_level+1)
case Type_Info_Map: case Type_Info_Map:
return false return false
case Type_Info_Relative_Slice:
return false
case case
Type_Info_Boolean, Type_Info_Boolean,
Type_Info_Integer, Type_Info_Integer,
@@ -1474,6 +1472,7 @@ equal :: proc(a, b: any, including_indirect_array_recursion := false, recursion_
Type_Info_Enum, Type_Info_Enum,
Type_Info_Simd_Vector, Type_Info_Simd_Vector,
Type_Info_Relative_Pointer, Type_Info_Relative_Pointer,
Type_Info_Relative_Multi_Pointer,
Type_Info_Soa_Pointer, Type_Info_Soa_Pointer,
Type_Info_Matrix: Type_Info_Matrix:
return runtime.memory_compare(a.data, b.data, t.size) == 0 return runtime.memory_compare(a.data, b.data, t.size) == 0
core/reflect/types.odin
+7 -8
View File
@@ -165,9 +165,9 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
y := b.variant.(Type_Info_Relative_Pointer) or_return y := b.variant.(Type_Info_Relative_Pointer) or_return
return x.base_integer == y.base_integer && x.pointer == y.pointer return x.base_integer == y.base_integer && x.pointer == y.pointer
case Type_Info_Relative_Slice: case Type_Info_Relative_Multi_Pointer:
y := b.variant.(Type_Info_Relative_Slice) or_return y := b.variant.(Type_Info_Relative_Multi_Pointer) or_return
return x.base_integer == y.base_integer && x.slice == y.slice return x.base_integer == y.base_integer && x.pointer == y.pointer
case Type_Info_Matrix: case Type_Info_Matrix:
y := b.variant.(Type_Info_Matrix) or_return y := b.variant.(Type_Info_Matrix) or_return
@@ -383,9 +383,9 @@ is_relative_pointer :: proc(info: ^Type_Info) -> bool {
return ok return ok
} }
@(require_results) @(require_results)
is_relative_slice :: proc(info: ^Type_Info) -> bool { is_relative_multi_pointer :: proc(info: ^Type_Info) -> bool {
if info == nil { return false } if info == nil { return false }
_, ok := type_info_base(info).variant.(Type_Info_Relative_Slice) _, ok := type_info_base(info).variant.(Type_Info_Relative_Multi_Pointer)
return ok return ok
} }
@@ -395,7 +395,6 @@ is_relative_slice :: proc(info: ^Type_Info) -> bool {
write_typeid_builder :: proc(buf: ^strings.Builder, id: typeid, n_written: ^int = nil) -> (n: int, err: io.Error) { write_typeid_builder :: proc(buf: ^strings.Builder, id: typeid, n_written: ^int = nil) -> (n: int, err: io.Error) {
return write_type_writer(strings.to_writer(buf), type_info_of(id)) return write_type_writer(strings.to_writer(buf), type_info_of(id))
} }
@@ -652,11 +651,11 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info, n_written: ^int = nil) -
io.write_string(w, ") ", &n) or_return io.write_string(w, ") ", &n) or_return
write_type(w, info.pointer, &n) or_return write_type(w, info.pointer, &n) or_return
case Type_Info_Relative_Slice: case Type_Info_Relative_Multi_Pointer:
io.write_string(w, "#relative(", &n) or_return io.write_string(w, "#relative(", &n) or_return
write_type(w, info.base_integer, &n) or_return write_type(w, info.base_integer, &n) or_return
io.write_string(w, ") ", &n) or_return io.write_string(w, ") ", &n) or_return
write_type(w, info.slice, &n) or_return write_type(w, info.pointer, &n) or_return
case Type_Info_Matrix: case Type_Info_Matrix:
io.write_string(w, "matrix[", &n) or_return io.write_string(w, "matrix[", &n) or_return
core/runtime/core.odin
+5 -5
View File
@@ -162,11 +162,11 @@ Type_Info_Simd_Vector :: struct {
count: int, count: int,
} }
Type_Info_Relative_Pointer :: struct { Type_Info_Relative_Pointer :: struct {
pointer: ^Type_Info, pointer: ^Type_Info, // ^T
base_integer: ^Type_Info, base_integer: ^Type_Info,
} }
Type_Info_Relative_Slice :: struct { Type_Info_Relative_Multi_Pointer :: struct {
slice: ^Type_Info, pointer: ^Type_Info, // [^]T
base_integer: ^Type_Info, base_integer: ^Type_Info,
} }
Type_Info_Matrix :: struct { Type_Info_Matrix :: struct {
@@ -219,7 +219,7 @@ Type_Info :: struct {
Type_Info_Bit_Set, Type_Info_Bit_Set,
Type_Info_Simd_Vector, Type_Info_Simd_Vector,
Type_Info_Relative_Pointer, Type_Info_Relative_Pointer,
Type_Info_Relative_Slice, Type_Info_Relative_Multi_Pointer,
Type_Info_Matrix, Type_Info_Matrix,
Type_Info_Soa_Pointer, Type_Info_Soa_Pointer,
}, },
@@ -252,7 +252,7 @@ Typeid_Kind :: enum u8 {
Bit_Set, Bit_Set,
Simd_Vector, Simd_Vector,
Relative_Pointer, Relative_Pointer,
Relative_Slice, Relative_Multi_Pointer,
Matrix, Matrix,
} }
#assert(len(Typeid_Kind) < 32) #assert(len(Typeid_Kind) < 32)
core/runtime/print.odin
+2 -2
View File
@@ -471,11 +471,11 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
print_string(") ") print_string(") ")
print_type(info.pointer) print_type(info.pointer)
case Type_Info_Relative_Slice: case Type_Info_Relative_Multi_Pointer:
print_string("#relative(") print_string("#relative(")
print_type(info.base_integer) print_type(info.base_integer)
print_string(") ") print_string(") ")
print_type(info.slice) print_type(info.pointer)
case Type_Info_Matrix: case Type_Info_Matrix:
print_string("matrix[") print_string("matrix[")
src/check_builtin.cpp
+1 -1
View File
@@ -1748,7 +1748,7 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
mode = Addressing_Constant; mode = Addressing_Constant;
value = exact_value_i64(at->EnumeratedArray.count); value = exact_value_i64(at->EnumeratedArray.count);
type = t_untyped_integer; type = t_untyped_integer;
} else if ((is_type_slice(op_type) || is_type_relative_slice(op_type)) && id == BuiltinProc_len) { } else if (is_type_slice(op_type) && id == BuiltinProc_len) {
mode = Addressing_Value; mode = Addressing_Value;
} else if (is_type_dynamic_array(op_type)) { } else if (is_type_dynamic_array(op_type)) {
mode = Addressing_Value; mode = Addressing_Value;
src/check_expr.cpp
+23 -20
View File
@@ -856,8 +856,8 @@ gb_internal i64 check_distance_between_types(CheckerContext *c, Operand *operand
} }
} }
if (is_type_relative_slice(dst)) { if (is_type_relative_multi_pointer(dst)) {
i64 score = check_distance_between_types(c, operand, dst->RelativeSlice.slice_type); i64 score = check_distance_between_types(c, operand, dst->RelativeMultiPointer.pointer_type);
if (score >= 0) { if (score >= 0) {
return score+2; return score+2;
} }
@@ -1005,8 +1005,8 @@ gb_internal AstPackage *get_package_of_type(Type *type) {
case Type_RelativePointer: case Type_RelativePointer:
type = type->RelativePointer.pointer_type; type = type->RelativePointer.pointer_type;
continue; continue;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
type = type->RelativeSlice.slice_type; type = type->RelativeMultiPointer.pointer_type;
continue; continue;
} }
return nullptr; return nullptr;
@@ -7366,11 +7366,11 @@ gb_internal bool check_set_index_data(Operand *o, Type *t, bool indirection, i64
} }
return true; return true;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
{ {
Type *slice_type = base_type(t->RelativeSlice.slice_type); Type *pointer_type = base_type(t->RelativeMultiPointer.pointer_type);
GB_ASSERT(slice_type->kind == Type_Slice); GB_ASSERT(pointer_type->kind == Type_MultiPointer);
o->type = slice_type->Slice.elem; o->type = pointer_type->MultiPointer.elem;
if (o->mode != Addressing_Constant) { if (o->mode != Addressing_Constant) {
o->mode = Addressing_Variable; o->mode = Addressing_Variable;
} }
@@ -9502,14 +9502,14 @@ gb_internal ExprKind check_index_expr(CheckerContext *c, Operand *o, Ast *node,
if (is_const) { if (is_const) {
if (is_type_array(t)) { if (is_type_array(t)) {
// OKay // Okay
} else if (is_type_slice(t)) { } else if (is_type_slice(t)) {
// Okay // Okay
} else if (is_type_enumerated_array(t)) { } else if (is_type_enumerated_array(t)) {
// Okay // Okay
} else if (is_type_string(t)) { } else if (is_type_string(t)) {
// Okay // Okay
} else if (is_type_relative_slice(t)) { } else if (is_type_relative_multi_pointer(t)) {
// Okay // Okay
} else if (is_type_matrix(t)) { } else if (is_type_matrix(t)) {
// Okay // Okay
@@ -9647,17 +9647,9 @@ gb_internal ExprKind check_slice_expr(CheckerContext *c, Operand *o, Ast *node,
} }
break; break;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
valid = true; valid = true;
o->type = t->RelativeSlice.slice_type; o->type = type_deref(o->type);
if (o->mode != Addressing_Variable) {
gbString str = expr_to_string(node);
error(node, "Cannot relative slice '%s', as value is not addressable", str);
gb_string_free(str);
o->mode = Addressing_Invalid;
o->expr = node;
return kind;
}
break; break;
case Type_EnumeratedArray: case Type_EnumeratedArray:
@@ -9736,8 +9728,19 @@ gb_internal ExprKind check_slice_expr(CheckerContext *c, Operand *o, Ast *node,
x[i:n] -> []T x[i:n] -> []T
*/ */
o->type = alloc_type_slice(t->MultiPointer.elem); o->type = alloc_type_slice(t->MultiPointer.elem);
} else if (t->kind == Type_RelativeMultiPointer && se->high != nullptr) {
/*
x[:] -> [^]T
x[i:] -> [^]T
x[:n] -> []T
x[i:n] -> []T
*/
Type *pointer_type = base_type(t->RelativeMultiPointer.pointer_type);
GB_ASSERT(pointer_type->kind == Type_MultiPointer);
o->type = alloc_type_slice(pointer_type->MultiPointer.elem);
} }
o->mode = Addressing_Value; o->mode = Addressing_Value;
if (is_type_string(t) && max_count >= 0) { if (is_type_string(t) && max_count >= 0) {
src/check_type.cpp
+4 -4
View File
@@ -2778,16 +2778,16 @@ gb_internal bool check_type_internal(CheckerContext *ctx, Ast *e, Type **type, T
Type *relative_type = nullptr; Type *relative_type = nullptr;
Type *base_type = check_type(ctx, rt->type); Type *base_type = check_type(ctx, rt->type);
if (!is_type_pointer(base_type) && !is_type_slice(base_type)) { if (!is_type_pointer(base_type) && !is_type_multi_pointer(base_type)) {
error(rt->type, "#relative types can only be a pointer or slice"); error(rt->type, "#relative types can only be a pointer or multi-pointer");
relative_type = base_type; relative_type = base_type;
} else if (base_integer == nullptr) { } else if (base_integer == nullptr) {
relative_type = base_type; relative_type = base_type;
} else { } else {
if (is_type_pointer(base_type)) { if (is_type_pointer(base_type)) {
relative_type = alloc_type_relative_pointer(base_type, base_integer); relative_type = alloc_type_relative_pointer(base_type, base_integer);
} else if (is_type_slice(base_type)) { } else if (is_type_multi_pointer(base_type)) {
relative_type = alloc_type_relative_slice(base_type, base_integer); relative_type = alloc_type_relative_multi_pointer(base_type, base_integer);
} }
} }
GB_ASSERT(relative_type != nullptr); GB_ASSERT(relative_type != nullptr);
src/checker.cpp
+8 -8
View File
@@ -1969,9 +1969,9 @@ gb_internal void add_type_info_type_internal(CheckerContext *c, Type *t) {
add_type_info_type_internal(c, bt->RelativePointer.base_integer); add_type_info_type_internal(c, bt->RelativePointer.base_integer);
break; break;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
add_type_info_type_internal(c, bt->RelativeSlice.slice_type); add_type_info_type_internal(c, bt->RelativeMultiPointer.pointer_type);
add_type_info_type_internal(c, bt->RelativeSlice.base_integer); add_type_info_type_internal(c, bt->RelativeMultiPointer.base_integer);
break; break;
case Type_Matrix: case Type_Matrix:
@@ -2210,9 +2210,9 @@ gb_internal void add_min_dep_type_info(Checker *c, Type *t) {
add_min_dep_type_info(c, bt->RelativePointer.base_integer); add_min_dep_type_info(c, bt->RelativePointer.base_integer);
break; break;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
add_min_dep_type_info(c, bt->RelativeSlice.slice_type); add_min_dep_type_info(c, bt->RelativeMultiPointer.pointer_type);
add_min_dep_type_info(c, bt->RelativeSlice.base_integer); add_min_dep_type_info(c, bt->RelativeMultiPointer.base_integer);
break; break;
case Type_Matrix: case Type_Matrix:
@@ -2800,7 +2800,7 @@ gb_internal void init_core_type_info(Checker *c) {
t_type_info_bit_set = find_core_type(c, str_lit("Type_Info_Bit_Set")); t_type_info_bit_set = find_core_type(c, str_lit("Type_Info_Bit_Set"));
t_type_info_simd_vector = find_core_type(c, str_lit("Type_Info_Simd_Vector")); t_type_info_simd_vector = find_core_type(c, str_lit("Type_Info_Simd_Vector"));
t_type_info_relative_pointer = find_core_type(c, str_lit("Type_Info_Relative_Pointer")); t_type_info_relative_pointer = find_core_type(c, str_lit("Type_Info_Relative_Pointer"));
t_type_info_relative_slice = find_core_type(c, str_lit("Type_Info_Relative_Slice")); t_type_info_relative_multi_pointer = find_core_type(c, str_lit("Type_Info_Relative_Multi_Pointer"));
t_type_info_matrix = find_core_type(c, str_lit("Type_Info_Matrix")); t_type_info_matrix = find_core_type(c, str_lit("Type_Info_Matrix"));
t_type_info_soa_pointer = find_core_type(c, str_lit("Type_Info_Soa_Pointer")); t_type_info_soa_pointer = find_core_type(c, str_lit("Type_Info_Soa_Pointer"));
@@ -2829,7 +2829,7 @@ gb_internal void init_core_type_info(Checker *c) {
t_type_info_bit_set_ptr = alloc_type_pointer(t_type_info_bit_set); t_type_info_bit_set_ptr = alloc_type_pointer(t_type_info_bit_set);
t_type_info_simd_vector_ptr = alloc_type_pointer(t_type_info_simd_vector); t_type_info_simd_vector_ptr = alloc_type_pointer(t_type_info_simd_vector);
t_type_info_relative_pointer_ptr = alloc_type_pointer(t_type_info_relative_pointer); t_type_info_relative_pointer_ptr = alloc_type_pointer(t_type_info_relative_pointer);
t_type_info_relative_slice_ptr = alloc_type_pointer(t_type_info_relative_slice); t_type_info_relative_multi_pointer_ptr = alloc_type_pointer(t_type_info_relative_multi_pointer);
t_type_info_matrix_ptr = alloc_type_pointer(t_type_info_matrix); t_type_info_matrix_ptr = alloc_type_pointer(t_type_info_matrix);
t_type_info_soa_pointer_ptr = alloc_type_pointer(t_type_info_soa_pointer); t_type_info_soa_pointer_ptr = alloc_type_pointer(t_type_info_soa_pointer);
} }
src/docs_format.cpp
+25 -25
View File
@@ -59,31 +59,31 @@ struct OdinDocPosition {
}; };
enum OdinDocTypeKind : u32 { enum OdinDocTypeKind : u32 {
OdinDocType_Invalid = 0, OdinDocType_Invalid = 0,
OdinDocType_Basic = 1, OdinDocType_Basic = 1,
OdinDocType_Named = 2, OdinDocType_Named = 2,
OdinDocType_Generic = 3, OdinDocType_Generic = 3,
OdinDocType_Pointer = 4, OdinDocType_Pointer = 4,
OdinDocType_Array = 5, OdinDocType_Array = 5,
OdinDocType_EnumeratedArray = 6, OdinDocType_EnumeratedArray = 6,
OdinDocType_Slice = 7, OdinDocType_Slice = 7,
OdinDocType_DynamicArray = 8, OdinDocType_DynamicArray = 8,
OdinDocType_Map = 9, OdinDocType_Map = 9,
OdinDocType_Struct = 10, OdinDocType_Struct = 10,
OdinDocType_Union = 11, OdinDocType_Union = 11,
OdinDocType_Enum = 12, OdinDocType_Enum = 12,
OdinDocType_Tuple = 13, OdinDocType_Tuple = 13,
OdinDocType_Proc = 14, OdinDocType_Proc = 14,
OdinDocType_BitSet = 15, OdinDocType_BitSet = 15,
OdinDocType_SimdVector = 16, OdinDocType_SimdVector = 16,
OdinDocType_SOAStructFixed = 17, OdinDocType_SOAStructFixed = 17,
OdinDocType_SOAStructSlice = 18, OdinDocType_SOAStructSlice = 18,
OdinDocType_SOAStructDynamic = 19, OdinDocType_SOAStructDynamic = 19,
OdinDocType_RelativePointer = 20, OdinDocType_RelativePointer = 20,
OdinDocType_RelativeSlice = 21, OdinDocType_RelativeMultiPointer = 21,
OdinDocType_MultiPointer = 22, OdinDocType_MultiPointer = 22,
OdinDocType_Matrix = 23, OdinDocType_Matrix = 23,
OdinDocType_SoaPointer = 24, OdinDocType_SoaPointer = 24,
}; };
enum OdinDocTypeFlag_Basic : u32 { enum OdinDocTypeFlag_Basic : u32 {
src/docs_writer.cpp
+4 -4
View File
@@ -771,12 +771,12 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
doc_type.types = odin_write_slice(w, types, gb_count_of(types)); doc_type.types = odin_write_slice(w, types, gb_count_of(types));
} }
break; break;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
doc_type.kind = OdinDocType_RelativeSlice; doc_type.kind = OdinDocType_RelativeMultiPointer;
{ {
OdinDocTypeIndex types[2] = {}; OdinDocTypeIndex types[2] = {};
types[0] = odin_doc_type(w, type->RelativeSlice.slice_type); types[0] = odin_doc_type(w, type->RelativeMultiPointer.pointer_type);
types[1] = odin_doc_type(w, type->RelativeSlice.base_integer); types[1] = odin_doc_type(w, type->RelativeMultiPointer.base_integer);
doc_type.types = odin_write_slice(w, types, gb_count_of(types)); doc_type.types = odin_write_slice(w, types, gb_count_of(types));
} }
break; break;
src/error.cpp
+2 -2
View File
@@ -411,7 +411,7 @@ gb_internal void error_line_va(char const *fmt, va_list va) {
gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_list va) { gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_list va) {
mutex_lock(&global_error_collector.mutex); mutex_lock(&global_error_collector.mutex);
global_error_collector.count++; global_error_collector.count.fetch_add(1);
// NOTE(bill): Duplicate error, skip it // NOTE(bill): Duplicate error, skip it
if (pos.line == 0) { if (pos.line == 0) {
error_out_coloured("Error: ", TerminalStyle_Normal, TerminalColour_Red); error_out_coloured("Error: ", TerminalStyle_Normal, TerminalColour_Red);
@@ -425,7 +425,7 @@ gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_li
error_out_va(fmt, va); error_out_va(fmt, va);
} }
mutex_unlock(&global_error_collector.mutex); mutex_unlock(&global_error_collector.mutex);
if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT()) { if (global_error_collector.count.load() > MAX_ERROR_COLLECTOR_COUNT()) {
gb_exit(1); gb_exit(1);
} }
} }
src/llvm_backend.hpp
-1
View File
@@ -69,7 +69,6 @@ enum lbAddrKind {
lbAddr_SoaVariable, lbAddr_SoaVariable,
lbAddr_RelativePointer, lbAddr_RelativePointer,
lbAddr_RelativeSlice,
lbAddr_Swizzle, lbAddr_Swizzle,
lbAddr_SwizzleLarge, lbAddr_SwizzleLarge,
src/llvm_backend_debug.cpp
+5 -12
View File
@@ -442,18 +442,11 @@ gb_internal LLVMMetadataRef lb_debug_type_internal(lbModule *m, Type *type) {
gbString name = type_to_string(type, temporary_allocator()); gbString name = type_to_string(type, temporary_allocator());
return LLVMDIBuilderCreateTypedef(m->debug_builder, base_integer, name, gb_string_length(name), nullptr, 0, nullptr, cast(u32)(8*type_align_of(type))); return LLVMDIBuilderCreateTypedef(m->debug_builder, base_integer, name, gb_string_length(name), nullptr, 0, nullptr, cast(u32)(8*type_align_of(type)));
} }
case Type_RelativeMultiPointer: {
case Type_RelativeSlice: LLVMMetadataRef base_integer = lb_debug_type(m, type->RelativeMultiPointer.base_integer);
{ gbString name = type_to_string(type, temporary_allocator());
unsigned element_count = 0; return LLVMDIBuilderCreateTypedef(m->debug_builder, base_integer, name, gb_string_length(name), nullptr, 0, nullptr, cast(u32)(8*type_align_of(type)));
LLVMMetadataRef elements[2] = {}; }
Type *base_integer = type->RelativeSlice.base_integer;
unsigned base_bits = cast(unsigned)(8*type_size_of(base_integer));
elements[0] = lb_debug_struct_field(m, str_lit("data_offset"), base_integer, 0);
elements[1] = lb_debug_struct_field(m, str_lit("len"), base_integer, base_bits);
gbString name = type_to_string(type, temporary_allocator());
return LLVMDIBuilderCreateStructType(m->debug_builder, nullptr, name, gb_string_length(name), nullptr, 0, 2*base_bits, base_bits, LLVMDIFlagZero, nullptr, elements, element_count, 0, nullptr, "", 0);
}
case Type_Matrix: { case Type_Matrix: {
LLVMMetadataRef subscripts[1] = {}; LLVMMetadataRef subscripts[1] = {};
src/llvm_backend_expr.cpp
+24 -15
View File
@@ -2863,7 +2863,6 @@ gb_internal lbValue lb_build_unary_and(lbProcedure *p, Ast *expr) {
ast_node(ue, UnaryExpr, expr); ast_node(ue, UnaryExpr, expr);
auto tv = type_and_value_of_expr(expr); auto tv = type_and_value_of_expr(expr);
Ast *ue_expr = unparen_expr(ue->expr); Ast *ue_expr = unparen_expr(ue->expr);
if (ue_expr->kind == Ast_IndexExpr && tv.mode == Addressing_OptionalOkPtr && is_type_tuple(tv.type)) { if (ue_expr->kind == Ast_IndexExpr && tv.mode == Addressing_OptionalOkPtr && is_type_tuple(tv.type)) {
Type *tuple = tv.type; Type *tuple = tv.type;
@@ -3803,25 +3802,32 @@ gb_internal lbAddr lb_build_addr_index_expr(lbProcedure *p, Ast *expr) {
lbValue v = {}; lbValue v = {};
LLVMValueRef indices[1] = {index.value}; LLVMValueRef indices[1] = {index.value};
v.value = LLVMBuildGEP2(p->builder, lb_type(p->module, t->MultiPointer.elem), multi_ptr.value, indices, 1, "foo"); v.value = LLVMBuildGEP2(p->builder, lb_type(p->module, t->MultiPointer.elem), multi_ptr.value, indices, 1, "");
v.type = alloc_type_pointer(t->MultiPointer.elem); v.type = alloc_type_pointer(t->MultiPointer.elem);
return lb_addr(v); return lb_addr(v);
} }
case Type_RelativeSlice: { case Type_RelativeMultiPointer: {
lbAddr slice_addr = {}; lbAddr rel_ptr_addr = {};
if (deref) { if (deref) {
slice_addr = lb_addr(lb_build_expr(p, ie->expr)); lbValue rel_ptr_ptr = lb_build_expr(p, ie->expr);
rel_ptr_addr = lb_addr(rel_ptr_ptr);
} else { } else {
slice_addr = lb_build_addr(p, ie->expr); rel_ptr_addr = lb_build_addr(p, ie->expr);
} }
lbValue slice = lb_addr_load(p, slice_addr); lbValue rel_ptr = lb_relative_pointer_to_pointer(p, rel_ptr_addr);
lbValue elem = lb_slice_elem(p, slice); lbValue index = lb_build_expr(p, ie->index);
lbValue index = lb_emit_conv(p, lb_build_expr(p, ie->index), t_int); index = lb_emit_conv(p, index, t_int);
lbValue len = lb_slice_len(p, slice); lbValue v = {};
lb_emit_bounds_check(p, ast_token(ie->index), index, len);
lbValue v = lb_emit_ptr_offset(p, elem, index); Type *pointer_type = base_type(t->RelativeMultiPointer.pointer_type);
GB_ASSERT(pointer_type->kind == Type_MultiPointer);
Type *elem = pointer_type->MultiPointer.elem;
LLVMValueRef indices[1] = {index.value};
v.value = LLVMBuildGEP2(p->builder, lb_type(p->module, elem), rel_ptr.value, indices, 1, "");
v.type = alloc_type_pointer(elem);
return lb_addr(v); return lb_addr(v);
} }
@@ -3925,8 +3931,11 @@ gb_internal lbAddr lb_build_addr_slice_expr(lbProcedure *p, Ast *expr) {
return slice; return slice;
} }
case Type_RelativeSlice: case Type_RelativePointer:
GB_PANIC("TODO(bill): Type_RelativeSlice should be handled above already on the lb_addr_load"); GB_PANIC("TODO(bill): Type_RelativePointer should be handled above already on the lb_addr_load");
break;
case Type_RelativeMultiPointer:
GB_PANIC("TODO(bill): Type_RelativeMultiPointer should be handled above already on the lb_addr_load");
break; break;
case Type_DynamicArray: { case Type_DynamicArray: {
@@ -3996,7 +4005,7 @@ gb_internal lbAddr lb_build_addr_slice_expr(lbProcedure *p, Ast *expr) {
} }
case Type_Basic: { case Type_Basic: {
GB_ASSERT(type == t_string); GB_ASSERT_MSG(type == t_string, "got %s", type_to_string(type));
lbValue len = lb_string_len(p, base); lbValue len = lb_string_len(p, base);
if (high.value == nullptr) high = len; if (high.value == nullptr) high = len;
src/llvm_backend_general.cpp
+85 -118
View File
@@ -349,9 +349,10 @@ gb_internal lbAddr lb_addr(lbValue addr) {
if (addr.type != nullptr && is_type_relative_pointer(type_deref(addr.type))) { if (addr.type != nullptr && is_type_relative_pointer(type_deref(addr.type))) {
GB_ASSERT(is_type_pointer(addr.type)); GB_ASSERT(is_type_pointer(addr.type));
v.kind = lbAddr_RelativePointer; v.kind = lbAddr_RelativePointer;
} else if (addr.type != nullptr && is_type_relative_slice(type_deref(addr.type))) { } else if (addr.type != nullptr && is_type_relative_multi_pointer(type_deref(addr.type))) {
GB_ASSERT(is_type_pointer(addr.type)); GB_ASSERT(is_type_pointer(addr.type) ||
v.kind = lbAddr_RelativeSlice; is_type_multi_pointer(addr.type));
v.kind = lbAddr_RelativePointer;
} }
return v; return v;
} }
@@ -424,6 +425,43 @@ gb_internal Type *lb_addr_type(lbAddr const &addr) {
return type_deref(addr.addr.type); return type_deref(addr.addr.type);
} }
gb_internal lbValue lb_relative_pointer_to_pointer(lbProcedure *p, lbAddr const &addr) {
GB_ASSERT(addr.kind == lbAddr_RelativePointer);
Type *t = base_type(lb_addr_type(addr));
GB_ASSERT(is_type_relative_pointer(t) || is_type_relative_multi_pointer(t));
Type *pointer_type = nullptr;
Type *base_integer = nullptr;
if (t->kind == Type_RelativePointer) {
pointer_type = t->RelativePointer.pointer_type;
base_integer = t->RelativePointer.base_integer;
} else if (t->kind == Type_RelativeMultiPointer) {
pointer_type = t->RelativeMultiPointer.pointer_type;
base_integer = t->RelativeMultiPointer.base_integer;
}
lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
lbValue offset = lb_emit_conv(p, ptr, alloc_type_pointer(base_integer));
offset = lb_emit_load(p, offset);
if (!is_type_unsigned(base_integer)) {
offset = lb_emit_conv(p, offset, t_i64);
}
offset = lb_emit_conv(p, offset, t_uintptr);
lbValue absolute_ptr = lb_emit_arith(p, Token_Add, ptr, offset, t_uintptr);
absolute_ptr = lb_emit_conv(p, absolute_ptr, pointer_type);
lbValue cond = lb_emit_comp(p, Token_CmpEq, offset, lb_const_nil(p->module, base_integer));
// NOTE(bill): nil check
lbValue nil_ptr = lb_const_nil(p->module, pointer_type);
lbValue final_ptr = lb_emit_select(p, cond, nil_ptr, absolute_ptr);
return final_ptr;
}
gb_internal lbValue lb_addr_get_ptr(lbProcedure *p, lbAddr const &addr) { gb_internal lbValue lb_addr_get_ptr(lbProcedure *p, lbAddr const &addr) {
if (addr.addr.value == nullptr) { if (addr.addr.value == nullptr) {
GB_PANIC("Illegal addr -> nullptr"); GB_PANIC("Illegal addr -> nullptr");
@@ -434,28 +472,8 @@ gb_internal lbValue lb_addr_get_ptr(lbProcedure *p, lbAddr const &addr) {
case lbAddr_Map: case lbAddr_Map:
return lb_internal_dynamic_map_get_ptr(p, addr.addr, addr.map.key); return lb_internal_dynamic_map_get_ptr(p, addr.addr, addr.map.key);
case lbAddr_RelativePointer: { case lbAddr_RelativePointer:
Type *rel_ptr = base_type(lb_addr_type(addr)); return lb_relative_pointer_to_pointer(p, addr);
GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
lbValue offset = lb_emit_conv(p, ptr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
offset = lb_emit_load(p, offset);
if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
offset = lb_emit_conv(p, offset, t_i64);
}
offset = lb_emit_conv(p, offset, t_uintptr);
lbValue absolute_ptr = lb_emit_arith(p, Token_Add, ptr, offset, t_uintptr);
absolute_ptr = lb_emit_conv(p, absolute_ptr, rel_ptr->RelativePointer.pointer_type);
lbValue cond = lb_emit_comp(p, Token_CmpEq, offset, lb_const_nil(p->module, rel_ptr->RelativePointer.base_integer));
// NOTE(bill): nil check
lbValue nil_ptr = lb_const_nil(p->module, rel_ptr->RelativePointer.pointer_type);
lbValue final_ptr = lb_emit_select(p, cond, nil_ptr, absolute_ptr);
return final_ptr;
}
case lbAddr_SoaVariable: case lbAddr_SoaVariable:
// TODO(bill): FIX THIS HACK // TODO(bill): FIX THIS HACK
@@ -477,6 +495,9 @@ gb_internal lbValue lb_addr_get_ptr(lbProcedure *p, lbAddr const &addr) {
gb_internal lbValue lb_build_addr_ptr(lbProcedure *p, Ast *expr) { gb_internal lbValue lb_build_addr_ptr(lbProcedure *p, Ast *expr) {
lbAddr addr = lb_build_addr(p, expr); lbAddr addr = lb_build_addr(p, expr);
if (addr.kind == lbAddr_RelativePointer) {
return addr.addr;
}
return lb_addr_get_ptr(p, addr); return lb_addr_get_ptr(p, addr);
} }
@@ -685,9 +706,20 @@ gb_internal void lb_addr_store(lbProcedure *p, lbAddr addr, lbValue value) {
if (addr.kind == lbAddr_RelativePointer) { if (addr.kind == lbAddr_RelativePointer) {
Type *rel_ptr = base_type(lb_addr_type(addr)); Type *rel_ptr = base_type(lb_addr_type(addr));
GB_ASSERT(rel_ptr->kind == Type_RelativePointer); GB_ASSERT(rel_ptr->kind == Type_RelativePointer ||
rel_ptr->kind == Type_RelativeMultiPointer);
Type *pointer_type = nullptr;
Type *base_integer = nullptr;
value = lb_emit_conv(p, value, rel_ptr->RelativePointer.pointer_type); if (rel_ptr->kind == Type_RelativePointer) {
pointer_type = rel_ptr->RelativePointer.pointer_type;
base_integer = rel_ptr->RelativePointer.base_integer;
} else if (rel_ptr->kind == Type_RelativeMultiPointer) {
pointer_type = rel_ptr->RelativeMultiPointer.pointer_type;
base_integer = rel_ptr->RelativeMultiPointer.base_integer;
}
value = lb_emit_conv(p, value, pointer_type);
GB_ASSERT(is_type_pointer(addr.addr.type)); GB_ASSERT(is_type_pointer(addr.addr.type));
lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr); lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
@@ -696,54 +728,20 @@ gb_internal void lb_addr_store(lbProcedure *p, lbAddr addr, lbValue value) {
offset.value = LLVMBuildSub(p->builder, val_ptr.value, ptr.value, ""); offset.value = LLVMBuildSub(p->builder, val_ptr.value, ptr.value, "");
offset.type = t_uintptr; offset.type = t_uintptr;
if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) { if (!is_type_unsigned(base_integer)) {
offset = lb_emit_conv(p, offset, t_i64); offset = lb_emit_conv(p, offset, t_i64);
} }
offset = lb_emit_conv(p, offset, rel_ptr->RelativePointer.base_integer); offset = lb_emit_conv(p, offset, base_integer);
lbValue offset_ptr = lb_emit_conv(p, addr.addr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer)); lbValue offset_ptr = lb_emit_conv(p, addr.addr, alloc_type_pointer(base_integer));
offset = lb_emit_select(p, offset = lb_emit_select(p,
lb_emit_comp(p, Token_CmpEq, val_ptr, lb_const_nil(p->module, t_uintptr)), lb_emit_comp(p, Token_CmpEq, val_ptr, lb_const_nil(p->module, t_uintptr)),
lb_const_nil(p->module, rel_ptr->RelativePointer.base_integer), lb_const_nil(p->module, base_integer),
offset offset
); );
LLVMBuildStore(p->builder, offset.value, offset_ptr.value); LLVMBuildStore(p->builder, offset.value, offset_ptr.value);
return; return;
} else if (addr.kind == lbAddr_RelativeSlice) {
Type *rel_ptr = base_type(lb_addr_type(addr));
GB_ASSERT(rel_ptr->kind == Type_RelativeSlice);
value = lb_emit_conv(p, value, rel_ptr->RelativeSlice.slice_type);
GB_ASSERT(is_type_pointer(addr.addr.type));
lbValue ptr = lb_emit_conv(p, lb_emit_struct_ep(p, addr.addr, 0), t_uintptr);
lbValue val_ptr = lb_emit_conv(p, lb_slice_elem(p, value), t_uintptr);
lbValue offset = {};
offset.value = LLVMBuildSub(p->builder, val_ptr.value, ptr.value, "");
offset.type = t_uintptr;
if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
offset = lb_emit_conv(p, offset, t_i64);
}
offset = lb_emit_conv(p, offset, rel_ptr->RelativePointer.base_integer);
lbValue offset_ptr = lb_emit_conv(p, addr.addr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
offset = lb_emit_select(p,
lb_emit_comp(p, Token_CmpEq, val_ptr, lb_const_nil(p->module, t_uintptr)),
lb_const_nil(p->module, rel_ptr->RelativePointer.base_integer),
offset
);
LLVMBuildStore(p->builder, offset.value, offset_ptr.value);
lbValue len = lb_slice_len(p, value);
len = lb_emit_conv(p, len, rel_ptr->RelativePointer.base_integer);
lbValue len_ptr = lb_emit_struct_ep(p, addr.addr, 1);
LLVMBuildStore(p->builder, len.value, len_ptr.value);
return;
} else if (addr.kind == lbAddr_Map) { } else if (addr.kind == lbAddr_Map) {
lb_internal_dynamic_map_set(p, addr.addr, addr.map.type, addr.map.key, value, p->curr_stmt); lb_internal_dynamic_map_set(p, addr.addr, addr.map.type, addr.map.key, value, p->curr_stmt);
return; return;
@@ -1020,67 +1018,43 @@ gb_internal lbValue lb_addr_load(lbProcedure *p, lbAddr const &addr) {
if (addr.kind == lbAddr_RelativePointer) { if (addr.kind == lbAddr_RelativePointer) {
Type *rel_ptr = base_type(lb_addr_type(addr)); Type *rel_ptr = base_type(lb_addr_type(addr));
GB_ASSERT(rel_ptr->kind == Type_RelativePointer); Type *base_integer = nullptr;
Type *pointer_type = nullptr;
GB_ASSERT(rel_ptr->kind == Type_RelativePointer ||
rel_ptr->kind == Type_RelativeMultiPointer);
if (rel_ptr->kind == Type_RelativePointer) {
base_integer = rel_ptr->RelativePointer.base_integer;
pointer_type = rel_ptr->RelativePointer.pointer_type;
} else if (rel_ptr->kind == Type_RelativeMultiPointer) {
base_integer = rel_ptr->RelativeMultiPointer.base_integer;
pointer_type = rel_ptr->RelativeMultiPointer.pointer_type;
}
lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr); lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
lbValue offset = lb_emit_conv(p, ptr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer)); lbValue offset = lb_emit_conv(p, ptr, alloc_type_pointer(base_integer));
offset = lb_emit_load(p, offset); offset = lb_emit_load(p, offset);
if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) { if (!is_type_unsigned(base_integer)) {
offset = lb_emit_conv(p, offset, t_i64); offset = lb_emit_conv(p, offset, t_i64);
} }
offset = lb_emit_conv(p, offset, t_uintptr); offset = lb_emit_conv(p, offset, t_uintptr);
lbValue absolute_ptr = lb_emit_arith(p, Token_Add, ptr, offset, t_uintptr); lbValue absolute_ptr = lb_emit_arith(p, Token_Add, ptr, offset, t_uintptr);
absolute_ptr = lb_emit_conv(p, absolute_ptr, rel_ptr->RelativePointer.pointer_type); absolute_ptr = lb_emit_conv(p, absolute_ptr, pointer_type);
lbValue cond = lb_emit_comp(p, Token_CmpEq, offset, lb_const_nil(p->module, rel_ptr->RelativePointer.base_integer)); lbValue cond = lb_emit_comp(p, Token_CmpEq, offset, lb_const_nil(p->module, base_integer));
// NOTE(bill): nil check // NOTE(bill): nil check
lbValue nil_ptr = lb_const_nil(p->module, rel_ptr->RelativePointer.pointer_type); lbValue nil_ptr = lb_const_nil(p->module, pointer_type);
lbValue final_ptr = {}; lbValue final_ptr = {};
final_ptr.type = absolute_ptr.type; final_ptr.type = absolute_ptr.type;
final_ptr.value = LLVMBuildSelect(p->builder, cond.value, nil_ptr.value, absolute_ptr.value, ""); final_ptr.value = LLVMBuildSelect(p->builder, cond.value, nil_ptr.value, absolute_ptr.value, "");
return lb_emit_load(p, final_ptr); if (rel_ptr->kind == Type_RelativeMultiPointer) {
return final_ptr;
} else if (addr.kind == lbAddr_RelativeSlice) {
Type *rel_ptr = base_type(lb_addr_type(addr));
GB_ASSERT(rel_ptr->kind == Type_RelativeSlice);
lbValue offset_ptr = lb_emit_struct_ep(p, addr.addr, 0);
lbValue ptr = lb_emit_conv(p, offset_ptr, t_uintptr);
lbValue offset = lb_emit_load(p, offset_ptr);
if (!is_type_unsigned(rel_ptr->RelativeSlice.base_integer)) {
offset = lb_emit_conv(p, offset, t_i64);
} }
offset = lb_emit_conv(p, offset, t_uintptr); return lb_emit_load(p, final_ptr);
lbValue absolute_ptr = lb_emit_arith(p, Token_Add, ptr, offset, t_uintptr);
Type *slice_type = base_type(rel_ptr->RelativeSlice.slice_type);
GB_ASSERT(rel_ptr->RelativeSlice.slice_type->kind == Type_Slice);
Type *slice_elem = slice_type->Slice.elem;
Type *slice_elem_ptr = alloc_type_pointer(slice_elem);
absolute_ptr = lb_emit_conv(p, absolute_ptr, slice_elem_ptr);
lbValue cond = lb_emit_comp(p, Token_CmpEq, offset, lb_const_nil(p->module, rel_ptr->RelativeSlice.base_integer));
// NOTE(bill): nil check
lbValue nil_ptr = lb_const_nil(p->module, slice_elem_ptr);
lbValue data = {};
data.type = absolute_ptr.type;
data.value = LLVMBuildSelect(p->builder, cond.value, nil_ptr.value, absolute_ptr.value, "");
lbValue len = lb_emit_load(p, lb_emit_struct_ep(p, addr.addr, 1));
len = lb_emit_conv(p, len, t_int);
lbAddr slice = lb_add_local_generated(p, slice_type, false);
lb_fill_slice(p, slice, data, len);
return lb_addr_load(p, slice);
} else if (addr.kind == lbAddr_Map) { } else if (addr.kind == lbAddr_Map) {
Type *map_type = base_type(type_deref(addr.addr.type)); Type *map_type = base_type(type_deref(addr.addr.type));
@@ -2139,17 +2113,10 @@ gb_internal LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
case Type_RelativePointer: case Type_RelativePointer:
return lb_type_internal(m, type->RelativePointer.base_integer); return lb_type_internal(m, type->RelativePointer.base_integer);
case Type_RelativeMultiPointer:
return lb_type_internal(m, type->RelativeMultiPointer.base_integer);
case Type_RelativeSlice:
{
LLVMTypeRef base_integer = lb_type_internal(m, type->RelativeSlice.base_integer);
unsigned field_count = 2;
LLVMTypeRef *fields = gb_alloc_array(permanent_allocator(), LLVMTypeRef, field_count);
fields[0] = base_integer;
fields[1] = base_integer;
return LLVMStructTypeInContext(ctx, fields, field_count, false);
}
case Type_Matrix: case Type_Matrix:
{ {
src/llvm_backend_proc.cpp
+2 -2
View File
@@ -1710,7 +1710,7 @@ gb_internal lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValu
return lb_string_len(p, v); return lb_string_len(p, v);
} else if (is_type_array(t)) { } else if (is_type_array(t)) {
GB_PANIC("Array lengths are constant"); GB_PANIC("Array lengths are constant");
} else if (is_type_slice(t) || is_type_relative_slice(t)) { } else if (is_type_slice(t)) {
return lb_slice_len(p, v); return lb_slice_len(p, v);
} else if (is_type_dynamic_array(t)) { } else if (is_type_dynamic_array(t)) {
return lb_dynamic_array_len(p, v); return lb_dynamic_array_len(p, v);
@@ -1735,7 +1735,7 @@ gb_internal lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValu
GB_PANIC("Unreachable"); GB_PANIC("Unreachable");
} else if (is_type_array(t)) { } else if (is_type_array(t)) {
GB_PANIC("Array lengths are constant"); GB_PANIC("Array lengths are constant");
} else if (is_type_slice(t) || is_type_relative_slice(t)) { } else if (is_type_slice(t)) {
return lb_slice_len(p, v); return lb_slice_len(p, v);
} else if (is_type_dynamic_array(t)) { } else if (is_type_dynamic_array(t)) {
return lb_dynamic_array_cap(p, v); return lb_dynamic_array_cap(p, v);
src/llvm_backend_type.cpp
+7 -5
View File
@@ -57,7 +57,7 @@ gb_internal lbValue lb_typeid(lbModule *m, Type *type) {
case Type_BitSet: kind = Typeid_Bit_Set; break; case Type_BitSet: kind = Typeid_Bit_Set; break;
case Type_SimdVector: kind = Typeid_Simd_Vector; break; case Type_SimdVector: kind = Typeid_Simd_Vector; break;
case Type_RelativePointer: kind = Typeid_Relative_Pointer; break; case Type_RelativePointer: kind = Typeid_Relative_Pointer; break;
case Type_RelativeSlice: kind = Typeid_Relative_Slice; break; case Type_RelativeMultiPointer: kind = Typeid_Relative_Multi_Pointer; break;
case Type_SoaPointer: kind = Typeid_SoaPointer; break; case Type_SoaPointer: kind = Typeid_SoaPointer; break;
} }
@@ -857,12 +857,13 @@ gb_internal void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup
lb_emit_store(p, tag, res); lb_emit_store(p, tag, res);
} }
break; break;
case Type_RelativeSlice:
case Type_RelativeMultiPointer:
{ {
tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_relative_slice_ptr); tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_relative_multi_pointer_ptr);
LLVMValueRef vals[2] = { LLVMValueRef vals[2] = {
lb_type_info(m, t->RelativeSlice.slice_type).value, lb_type_info(m, t->RelativeMultiPointer.pointer_type).value,
lb_type_info(m, t->RelativeSlice.base_integer).value, lb_type_info(m, t->RelativeMultiPointer.base_integer).value,
}; };
lbValue res = {}; lbValue res = {};
@@ -871,6 +872,7 @@ gb_internal void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup
lb_emit_store(p, tag, res); lb_emit_store(p, tag, res);
} }
break; break;
case Type_Matrix: case Type_Matrix:
{ {
tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_matrix_ptr); tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_matrix_ptr);
src/llvm_backend_utility.cpp
+1 -6
View File
@@ -1124,11 +1124,6 @@ gb_internal lbValue lb_emit_struct_ep(lbProcedure *p, lbValue s, i32 index) {
} }
} else if (is_type_array(t)) { } else if (is_type_array(t)) {
return lb_emit_array_epi(p, s, index); return lb_emit_array_epi(p, s, index);
} else if (is_type_relative_slice(t)) {
switch (index) {
case 0: result_type = t->RelativeSlice.base_integer; break;
case 1: result_type = t->RelativeSlice.base_integer; break;
}
} else if (is_type_soa_pointer(t)) { } else if (is_type_soa_pointer(t)) {
switch (index) { switch (index) {
case 0: result_type = alloc_type_pointer(t->SoaPointer.elem); break; case 0: result_type = alloc_type_pointer(t->SoaPointer.elem); break;
@@ -1547,7 +1542,7 @@ gb_internal lbValue lb_slice_elem(lbProcedure *p, lbValue slice) {
return lb_emit_struct_ev(p, slice, 0); return lb_emit_struct_ev(p, slice, 0);
} }
gb_internal lbValue lb_slice_len(lbProcedure *p, lbValue slice) { gb_internal lbValue lb_slice_len(lbProcedure *p, lbValue slice) {
GB_ASSERT(is_type_slice(slice.type) || is_type_relative_slice(slice.type)); GB_ASSERT(is_type_slice(slice.type));
return lb_emit_struct_ev(p, slice, 1); return lb_emit_struct_ev(p, slice, 1);
} }
gb_internal lbValue lb_dynamic_array_elem(lbProcedure *p, lbValue da) { gb_internal lbValue lb_dynamic_array_elem(lbProcedure *p, lbValue da) {
src/parser.cpp
+5 -1
View File
@@ -2235,7 +2235,11 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) {
return parse_check_directive_for_statement(operand, name, StateFlag_no_type_assert); return parse_check_directive_for_statement(operand, name, StateFlag_no_type_assert);
} else if (name.string == "relative") { } else if (name.string == "relative") {
Ast *tag = ast_basic_directive(f, token, name); Ast *tag = ast_basic_directive(f, token, name);
tag = parse_call_expr(f, tag); if (f->curr_token.kind != Token_OpenParen) {
syntax_error(tag, "expected #relative(<integer type>) <type>");
} else {
tag = parse_call_expr(f, tag);
}
Ast *type = parse_type(f); Ast *type = parse_type(f);
return ast_relative_type(f, tag, type); return ast_relative_type(f, tag, type);
} else if (name.string == "force_inline" || } else if (name.string == "force_inline" ||
src/tilde_builtin.cpp
-4
View File
@@ -44,8 +44,6 @@ gb_internal cgValue cg_builtin_len(cgProcedure *p, cgValue value) {
case Type_Struct: case Type_Struct:
GB_ASSERT(is_type_soa_struct(t)); GB_ASSERT(is_type_soa_struct(t));
break; break;
case Type_RelativeSlice:
break;
} }
GB_PANIC("TODO(bill): cg_builtin_len %s", type_to_string(t)); GB_PANIC("TODO(bill): cg_builtin_len %s", type_to_string(t));
@@ -106,8 +104,6 @@ gb_internal cgValue cg_builtin_cap(cgProcedure *p, cgValue value) {
case Type_Struct: case Type_Struct:
GB_ASSERT(is_type_soa_struct(t)); GB_ASSERT(is_type_soa_struct(t));
break; break;
case Type_RelativeSlice:
break;
} }
GB_PANIC("TODO(bill): cg_builtin_cap %s", type_to_string(t)); GB_PANIC("TODO(bill): cg_builtin_cap %s", type_to_string(t));
src/tilde_const.cpp
+3 -3
View File
@@ -255,9 +255,9 @@ gb_internal i64 cg_global_const_calculate_region_count_from_basic_type(Type *typ
return 1; return 1;
case Type_RelativePointer: case Type_RelativePointer:
return 1; case Type_RelativeMultiPointer:
case Type_RelativeSlice: return 2; // allows for offsets
return 1; // technically 1
case Type_Matrix: case Type_Matrix:
return 1; return 1;
src/tilde_debug.cpp
+2 -14
View File
@@ -457,20 +457,8 @@ gb_internal TB_DebugType *cg_debug_type_internal(cgModule *m, Type *type) {
return tb_debug_create_array(m->mod, cg_debug_type(m, type->SimdVector.elem), type->SimdVector.count); return tb_debug_create_array(m->mod, cg_debug_type(m, type->SimdVector.elem), type->SimdVector.count);
case Type_RelativePointer: case Type_RelativePointer:
return cg_debug_type(m, type->RelativePointer.base_integer); return cg_debug_type(m, type->RelativePointer.base_integer);
case Type_RelativeSlice: case Type_RelativeMultiPointer:
{ return cg_debug_type(m, type->RelativeMultiPointer.base_integer);
String name = {};
TB_DebugType *record = tb_debug_create_struct(m->mod, name.len, cast(char const *)name.text);
TB_DebugType *base_integer = cg_debug_type(m, type->RelativeSlice.base_integer);
TB_CharUnits bi_size = cast(TB_CharUnits)type_size_of(type->RelativeSlice.base_integer);
TB_DebugType **fields = tb_debug_record_begin(record, 2);
fields[0] = tb_debug_create_field(m->mod, base_integer, -1, "data", 0*bi_size);
fields[1] = tb_debug_create_field(m->mod, base_integer, -1, "len", 1*bi_size);
tb_debug_record_end(record, size, align);
return record;
}
case Type_Matrix: case Type_Matrix:
{ {
i64 count = matrix_type_total_internal_elems(type); i64 count = matrix_type_total_internal_elems(type);
src/tilde_expr.cpp
+13 -17
View File
@@ -1469,8 +1469,8 @@ gb_internal cgAddr cg_build_addr_slice_expr(cgProcedure *p, Ast *expr) {
return slice; return slice;
} }
case Type_RelativeSlice: case Type_RelativeMultiPointer:
GB_PANIC("TODO(bill): Type_RelativeSlice should be handled above already on the cg_addr_load"); GB_PANIC("TODO(bill): Type_RelativeMultiPointer should be handled above already on the cg_addr_load");
break; break;
case Type_DynamicArray: { case Type_DynamicArray: {
@@ -3598,22 +3598,18 @@ gb_internal cgAddr cg_build_addr_index_expr(cgProcedure *p, Ast *expr) {
return cg_addr(v); return cg_addr(v);
} }
case Type_RelativeSlice: { case Type_RelativeMultiPointer: {
GB_PANIC("TODO(bill): relative slice"); cgValue multi_ptr = {};
// lbAddr slice_addr = {}; multi_ptr = cg_build_expr(p, ie->expr);
// if (deref) { if (deref) {
// slice_addr = lb_addr(lb_build_expr(p, ie->expr)); multi_ptr = cg_emit_load(p, multi_ptr);
// } else { }
// slice_addr = lb_build_addr(p, ie->expr); cgValue index = cg_build_expr(p, ie->index);
// } index = cg_emit_conv(p, index, t_int);
// lbValue slice = lb_addr_load(p, slice_addr);
// lbValue elem = lb_slice_elem(p, slice); cgValue v = cg_emit_ptr_offset(p, multi_ptr, index);
// lbValue index = lb_emit_conv(p, lb_build_expr(p, ie->index), t_int); v.type = alloc_type_pointer(type_deref(v.type, true));
// lbValue len = lb_slice_len(p, slice); return cg_addr(v);
// lb_emit_bounds_check(p, ast_token(ie->index), index, len);
// lbValue v = lb_emit_ptr_offset(p, elem, index);
// return lb_addr(v);
} }
case Type_DynamicArray: { case Type_DynamicArray: {
src/tilde_stmt.cpp
-15
View File
@@ -530,21 +530,6 @@ gb_internal cgValue cg_emit_struct_ep(cgProcedure *p, cgValue s, i64 index) {
} }
case Type_Array: case Type_Array:
return cg_emit_array_epi(p, s, index); return cg_emit_array_epi(p, s, index);
case Type_RelativeSlice:
{
Type *bi = t->RelativeSlice.base_integer;
i64 sz = type_size_of(bi);
switch (index) {
case 0:
case 1:
result_type = bi;
offset = sz * index;
break;
default:
goto error_case;
}
}
break;
case Type_SoaPointer: case Type_SoaPointer:
switch (index) { switch (index) {
case 0: result_type = alloc_type_pointer(t->SoaPointer.elem); break; case 0: result_type = alloc_type_pointer(t->SoaPointer.elem); break;
src/tilde_type_info.cpp
+23 -23
View File
@@ -75,24 +75,24 @@ gb_internal u64 cg_typeid_as_u64(cgModule *m, Type *type) {
if (flags & BasicFlag_String) kind = Typeid_String; if (flags & BasicFlag_String) kind = Typeid_String;
if (flags & BasicFlag_Rune) kind = Typeid_Rune; if (flags & BasicFlag_Rune) kind = Typeid_Rune;
} break; } break;
case Type_Pointer: kind = Typeid_Pointer; break; case Type_Pointer: kind = Typeid_Pointer; break;
case Type_MultiPointer: kind = Typeid_Multi_Pointer; break; case Type_MultiPointer: kind = Typeid_Multi_Pointer; break;
case Type_Array: kind = Typeid_Array; break; case Type_Array: kind = Typeid_Array; break;
case Type_Matrix: kind = Typeid_Matrix; break; case Type_Matrix: kind = Typeid_Matrix; break;
case Type_EnumeratedArray: kind = Typeid_Enumerated_Array; break; case Type_EnumeratedArray: kind = Typeid_Enumerated_Array; break;
case Type_Slice: kind = Typeid_Slice; break; case Type_Slice: kind = Typeid_Slice; break;
case Type_DynamicArray: kind = Typeid_Dynamic_Array; break; case Type_DynamicArray: kind = Typeid_Dynamic_Array; break;
case Type_Map: kind = Typeid_Map; break; case Type_Map: kind = Typeid_Map; break;
case Type_Struct: kind = Typeid_Struct; break; case Type_Struct: kind = Typeid_Struct; break;
case Type_Enum: kind = Typeid_Enum; break; case Type_Enum: kind = Typeid_Enum; break;
case Type_Union: kind = Typeid_Union; break; case Type_Union: kind = Typeid_Union; break;
case Type_Tuple: kind = Typeid_Tuple; break; case Type_Tuple: kind = Typeid_Tuple; break;
case Type_Proc: kind = Typeid_Procedure; break; case Type_Proc: kind = Typeid_Procedure; break;
case Type_BitSet: kind = Typeid_Bit_Set; break; case Type_BitSet: kind = Typeid_Bit_Set; break;
case Type_SimdVector: kind = Typeid_Simd_Vector; break; case Type_SimdVector: kind = Typeid_Simd_Vector; break;
case Type_RelativePointer: kind = Typeid_Relative_Pointer; break; case Type_RelativePointer: kind = Typeid_Relative_Pointer; break;
case Type_RelativeSlice: kind = Typeid_Relative_Slice; break; case Type_RelativeMultiPointer: kind = Typeid_Relative_Multi_Pointer; break;
case Type_SoaPointer: kind = Typeid_SoaPointer; break; case Type_SoaPointer: kind = Typeid_SoaPointer; break;
} }
if (is_type_cstring(type)) { if (is_type_cstring(type)) {
@@ -935,15 +935,15 @@ gb_internal void cg_setup_type_info_data(cgModule *m) {
cg_global_const_type_info_ptr(m, t->RelativePointer.base_integer, global, offset+base_integer_offset); cg_global_const_type_info_ptr(m, t->RelativePointer.base_integer, global, offset+base_integer_offset);
} }
break; break;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
{ {
tag_type = t_type_info_relative_slice; tag_type = t_type_info_relative_multi_pointer;
i64 slice_offset = type_offset_of(tag_type, 0); i64 pointer_offset = type_offset_of(tag_type, 0);
i64 base_integer_offset = type_offset_of(tag_type, 1); i64 base_integer_offset = type_offset_of(tag_type, 1);
cg_global_const_type_info_ptr(m, t->RelativeSlice.slice_type, global, offset+slice_offset); cg_global_const_type_info_ptr(m, t->RelativePointer.pointer_type, global, offset+pointer_offset);
cg_global_const_type_info_ptr(m, t->RelativeSlice.base_integer, global, offset+base_integer_offset); cg_global_const_type_info_ptr(m, t->RelativePointer.base_integer, global, offset+base_integer_offset);
} }
break; break;
case Type_Matrix: case Type_Matrix:
src/types.cpp
+28 -27
View File
@@ -267,8 +267,8 @@ struct TypeProc {
Type *pointer_type; \ Type *pointer_type; \
Type *base_integer; \ Type *base_integer; \
}) \ }) \
TYPE_KIND(RelativeSlice, struct { \ TYPE_KIND(RelativeMultiPointer, struct { \
Type *slice_type; \ Type *pointer_type; \
Type *base_integer; \ Type *base_integer; \
}) \ }) \
TYPE_KIND(Matrix, struct { \ TYPE_KIND(Matrix, struct { \
@@ -349,7 +349,7 @@ enum Typeid_Kind : u8 {
Typeid_Bit_Set, Typeid_Bit_Set,
Typeid_Simd_Vector, Typeid_Simd_Vector,
Typeid_Relative_Pointer, Typeid_Relative_Pointer,
Typeid_Relative_Slice, Typeid_Relative_Multi_Pointer,
Typeid_Matrix, Typeid_Matrix,
Typeid_SoaPointer, Typeid_SoaPointer,
}; };
@@ -635,7 +635,7 @@ gb_global Type *t_type_info_map = nullptr;
gb_global Type *t_type_info_bit_set = nullptr; gb_global Type *t_type_info_bit_set = nullptr;
gb_global Type *t_type_info_simd_vector = nullptr; gb_global Type *t_type_info_simd_vector = nullptr;
gb_global Type *t_type_info_relative_pointer = nullptr; gb_global Type *t_type_info_relative_pointer = nullptr;
gb_global Type *t_type_info_relative_slice = nullptr; gb_global Type *t_type_info_relative_multi_pointer = nullptr;
gb_global Type *t_type_info_matrix = nullptr; gb_global Type *t_type_info_matrix = nullptr;
gb_global Type *t_type_info_soa_pointer = nullptr; gb_global Type *t_type_info_soa_pointer = nullptr;
@@ -664,7 +664,7 @@ gb_global Type *t_type_info_map_ptr = nullptr;
gb_global Type *t_type_info_bit_set_ptr = nullptr; gb_global Type *t_type_info_bit_set_ptr = nullptr;
gb_global Type *t_type_info_simd_vector_ptr = nullptr; gb_global Type *t_type_info_simd_vector_ptr = nullptr;
gb_global Type *t_type_info_relative_pointer_ptr = nullptr; gb_global Type *t_type_info_relative_pointer_ptr = nullptr;
gb_global Type *t_type_info_relative_slice_ptr = nullptr; gb_global Type *t_type_info_relative_multi_pointer_ptr = nullptr;
gb_global Type *t_type_info_matrix_ptr = nullptr; gb_global Type *t_type_info_matrix_ptr = nullptr;
gb_global Type *t_type_info_soa_pointer_ptr = nullptr; gb_global Type *t_type_info_soa_pointer_ptr = nullptr;
@@ -737,6 +737,7 @@ gb_internal Type * bit_set_to_int(Type *t);
gb_internal bool are_types_identical(Type *x, Type *y); gb_internal bool are_types_identical(Type *x, Type *y);
gb_internal bool is_type_pointer(Type *t); gb_internal bool is_type_pointer(Type *t);
gb_internal bool is_type_multi_pointer(Type *t);
gb_internal bool is_type_soa_pointer(Type *t); gb_internal bool is_type_soa_pointer(Type *t);
gb_internal bool is_type_proc(Type *t); gb_internal bool is_type_proc(Type *t);
gb_internal bool is_type_slice(Type *t); gb_internal bool is_type_slice(Type *t);
@@ -1035,12 +1036,12 @@ gb_internal Type *alloc_type_relative_pointer(Type *pointer_type, Type *base_int
return t; return t;
} }
gb_internal Type *alloc_type_relative_slice(Type *slice_type, Type *base_integer) { gb_internal Type *alloc_type_relative_multi_pointer(Type *pointer_type, Type *base_integer) {
GB_ASSERT(is_type_slice(slice_type)); GB_ASSERT(is_type_multi_pointer(pointer_type));
GB_ASSERT(is_type_integer(base_integer)); GB_ASSERT(is_type_integer(base_integer));
Type *t = alloc_type(Type_RelativeSlice); Type *t = alloc_type(Type_RelativeMultiPointer);
t->RelativeSlice.slice_type = slice_type; t->RelativeMultiPointer.pointer_type = pointer_type;
t->RelativeSlice.base_integer = base_integer; t->RelativeMultiPointer.base_integer = base_integer;
return t; return t;
} }
@@ -1551,9 +1552,9 @@ gb_internal bool is_type_relative_pointer(Type *t) {
t = base_type(t); t = base_type(t);
return t->kind == Type_RelativePointer; return t->kind == Type_RelativePointer;
} }
gb_internal bool is_type_relative_slice(Type *t) { gb_internal bool is_type_relative_multi_pointer(Type *t) {
t = base_type(t); t = base_type(t);
return t->kind == Type_RelativeSlice; return t->kind == Type_RelativeMultiPointer;
} }
gb_internal bool is_type_u8_slice(Type *t) { gb_internal bool is_type_u8_slice(Type *t) {
@@ -1970,7 +1971,7 @@ gb_internal bool is_type_indexable(Type *t) {
return true; return true;
case Type_EnumeratedArray: case Type_EnumeratedArray:
return true; return true;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
return true; return true;
case Type_Matrix: case Type_Matrix:
return true; return true;
@@ -1989,7 +1990,7 @@ gb_internal bool is_type_sliceable(Type *t) {
return true; return true;
case Type_EnumeratedArray: case Type_EnumeratedArray:
return false; return false;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
return true; return true;
case Type_Matrix: case Type_Matrix:
return false; return false;
@@ -2195,12 +2196,12 @@ gb_internal bool is_type_polymorphic(Type *t, bool or_specialized=false) {
} }
break; break;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
if (is_type_polymorphic(t->RelativeSlice.slice_type, or_specialized)) { if (is_type_polymorphic(t->RelativeMultiPointer.pointer_type, or_specialized)) {
return true; return true;
} }
if (t->RelativeSlice.base_integer != nullptr && if (t->RelativeMultiPointer.base_integer != nullptr &&
is_type_polymorphic(t->RelativeSlice.base_integer, or_specialized)) { is_type_polymorphic(t->RelativeMultiPointer.base_integer, or_specialized)) {
return true; return true;
} }
break; break;
@@ -2258,7 +2259,7 @@ gb_internal bool type_has_nil(Type *t) {
return false; return false;
case Type_RelativePointer: case Type_RelativePointer:
case Type_RelativeSlice: case Type_RelativeMultiPointer:
return true; return true;
} }
return false; return false;
@@ -2425,7 +2426,7 @@ gb_internal bool is_type_load_safe(Type *type) {
return true; return true;
case Type_RelativePointer: case Type_RelativePointer:
case Type_RelativeSlice: case Type_RelativeMultiPointer:
return true; return true;
case Type_Pointer: case Type_Pointer:
@@ -3629,8 +3630,8 @@ gb_internal i64 type_align_of_internal(Type *t, TypePath *path) {
case Type_RelativePointer: case Type_RelativePointer:
return type_align_of_internal(t->RelativePointer.base_integer, path); return type_align_of_internal(t->RelativePointer.base_integer, path);
case Type_RelativeSlice: case Type_RelativeMultiPointer:
return type_align_of_internal(t->RelativeSlice.base_integer, path); return type_align_of_internal(t->RelativeMultiPointer.base_integer, path);
case Type_SoaPointer: case Type_SoaPointer:
return build_context.int_size; return build_context.int_size;
@@ -3912,8 +3913,8 @@ gb_internal i64 type_size_of_internal(Type *t, TypePath *path) {
case Type_RelativePointer: case Type_RelativePointer:
return type_size_of_internal(t->RelativePointer.base_integer, path); return type_size_of_internal(t->RelativePointer.base_integer, path);
case Type_RelativeSlice: case Type_RelativeMultiPointer:
return 2*type_size_of_internal(t->RelativeSlice.base_integer, path); return type_size_of_internal(t->RelativeMultiPointer.base_integer, path);
} }
// Catch all // Catch all
@@ -4466,11 +4467,11 @@ gb_internal gbString write_type_to_string(gbString str, Type *type, bool shortha
str = gb_string_append_fmt(str, ") "); str = gb_string_append_fmt(str, ") ");
str = write_type_to_string(str, type->RelativePointer.pointer_type); str = write_type_to_string(str, type->RelativePointer.pointer_type);
break; break;
case Type_RelativeSlice: case Type_RelativeMultiPointer:
str = gb_string_append_fmt(str, "#relative("); str = gb_string_append_fmt(str, "#relative(");
str = write_type_to_string(str, type->RelativeSlice.base_integer); str = write_type_to_string(str, type->RelativePointer.base_integer);
str = gb_string_append_fmt(str, ") "); str = gb_string_append_fmt(str, ") ");
str = write_type_to_string(str, type->RelativeSlice.slice_type); str = write_type_to_string(str, type->RelativePointer.pointer_type);
break; break;
case Type_Matrix: case Type_Matrix: