ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-06-22 21:54:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

Relative pointers

Browse Source
This commit is contained in:
gingerBill
2020-05-15 17:37:00 +01:00
parent 8b066b2456
commit ff92eb9112
14 changed files with 534 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/fmt/fmt.odin
+112
View File
@@ -8,6 +8,7 @@ import "core:unicode/utf8"
import "core:strconv"
import "core:strings"
import "core:reflect"
import "intrinsics"
@private
@@ -1712,6 +1713,117 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
case runtime.Type_Info_Opaque:
fmt_opaque(fi, v);
case runtime.Type_Info_Relative_Pointer:
ptr_any := any{v.data, info.base_integer.id};
ptr: rawptr;
switch i in &ptr_any {
case u8: ptr = handle_relative_pointer(&i);
case u16: ptr = handle_relative_pointer(&i);
case u32: ptr = handle_relative_pointer(&i);
case u64: ptr = handle_relative_pointer(&i);
case i8: ptr = handle_relative_pointer(&i);
case i16: ptr = handle_relative_pointer(&i);
case i32: ptr = handle_relative_pointer(&i);
case i64: ptr = handle_relative_pointer(&i);
case u16le: ptr = handle_relative_pointer(&i);
case u32le: ptr = handle_relative_pointer(&i);
case u64le: ptr = handle_relative_pointer(&i);
case i16le: ptr = handle_relative_pointer(&i);
case i32le: ptr = handle_relative_pointer(&i);
case i64le: ptr = handle_relative_pointer(&i);
case u16be: ptr = handle_relative_pointer(&i);
case u32be: ptr = handle_relative_pointer(&i);
case u64be: ptr = handle_relative_pointer(&i);
case i16be: ptr = handle_relative_pointer(&i);
case i32be: ptr = handle_relative_pointer(&i);
case i64be: ptr = handle_relative_pointer(&i);
}
absolute_ptr := any{ptr, info.pointer.id};
fmt_value(fi, absolute_ptr, verb);
case runtime.Type_Info_Relative_Slice:
ptr_any := any{v.data, info.base_integer.id};
ptr: rawptr;
switch i in &ptr_any {
case u8: ptr = handle_relative_pointer(&i);
case u16: ptr = handle_relative_pointer(&i);
case u32: ptr = handle_relative_pointer(&i);
case u64: ptr = handle_relative_pointer(&i);
case i8: ptr = handle_relative_pointer(&i);
case i16: ptr = handle_relative_pointer(&i);
case i32: ptr = handle_relative_pointer(&i);
case i64: ptr = handle_relative_pointer(&i);
case u16le: ptr = handle_relative_pointer(&i);
case u32le: ptr = handle_relative_pointer(&i);
case u64le: ptr = handle_relative_pointer(&i);
case i16le: ptr = handle_relative_pointer(&i);
case i32le: ptr = handle_relative_pointer(&i);
case i64le: ptr = handle_relative_pointer(&i);
case u16be: ptr = handle_relative_pointer(&i);
case u32be: ptr = handle_relative_pointer(&i);
case u64be: ptr = handle_relative_pointer(&i);
case i16be: ptr = handle_relative_pointer(&i);
case i32be: ptr = handle_relative_pointer(&i);
case i64be: ptr = handle_relative_pointer(&i);
}
if verb == 'p' {
fmt_pointer(fi, ptr, 'p');
} else if ptr == nil {
strings.write_string(fi.buf, "[]");
} else {
len_ptr := uintptr(v.data) + uintptr(info.base_integer.size);
len_any := any{rawptr(len_ptr), info.base_integer.id};
len: int = 0;
switch i in len_any {
case u8: len = int(i);
case u16: len = int(i);
case u32: len = int(i);
case u64: len = int(i);
case i8: len = int(i);
case i16: len = int(i);
case i32: len = int(i);
case i64: len = int(i);
case u16le: len = int(i);
case u32le: len = int(i);
case u64le: len = int(i);
case i16le: len = int(i);
case i32le: len = int(i);
case i64le: len = int(i);
case u16be: len = int(i);
case u32be: len = int(i);
case u64be: len = int(i);
case i16be: len = int(i);
case i32be: len = int(i);
case i64be: len = int(i);
}
slice_type := reflect.type_info_base(info.slice).variant.(runtime.Type_Info_Slice);
strings.write_byte(fi.buf, '[');
defer strings.write_byte(fi.buf, ']');
for i in 0..<len {
if i > 0 do strings.write_string(fi.buf, ", ");
data := uintptr(ptr) + uintptr(i*slice_type.elem_size);
fmt_arg(fi, any{rawptr(data), slice_type.elem.id}, verb);
}
}
}
handle_relative_pointer :: proc(ptr: ^$T) -> rawptr where intrinsics.type_is_integer(T) {
if ptr^ == 0 {
return nil;
}
when intrinsics.type_is_unsigned(T) {
return rawptr(uintptr(ptr) + uintptr(ptr^));
} else {
return rawptr(uintptr(ptr) + uintptr(i64(ptr^)));
}
}
}
core/reflect/reflect.odin
+6
View File
@@ -30,6 +30,8 @@ Type_Info_Bit_Field :: runtime.Type_Info_Bit_Field;
Type_Info_Bit_Set :: runtime.Type_Info_Bit_Set;
Type_Info_Opaque :: runtime.Type_Info_Opaque;
Type_Info_Simd_Vector :: runtime.Type_Info_Simd_Vector;
Type_Info_Relative_Pointer :: runtime.Type_Info_Relative_Pointer;
Type_Info_Relative_Slice :: runtime.Type_Info_Relative_Slice;
Type_Kind :: enum {
@@ -60,6 +62,8 @@ Type_Kind :: enum {
Bit_Set,
Opaque,
Simd_Vector,
Relative_Pointer,
Relative_Slice,
}
@@ -92,6 +96,8 @@ type_kind :: proc(T: typeid) -> Type_Kind {
case Type_Info_Bit_Set: return .Bit_Set;
case Type_Info_Opaque: return .Opaque;
case Type_Info_Simd_Vector: return .Simd_Vector;
case Type_Info_Relative_Pointer: return .Relative_Pointer;
case Type_Info_Relative_Slice: return .Relative_Slice;
}
}
core/reflect/types.odin
+33
View File
@@ -184,6 +184,16 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
y, ok := b.variant.(Type_Info_Simd_Vector);
if !ok do return false;
return x.count == y.count && x.elem == y.elem;
case Type_Info_Relative_Pointer:
y, ok := b.variant.(Type_Info_Relative_Pointer);
if !ok do return false;
return x.base_integer == y.base_integer && x.pointer == y.pointer;
case Type_Info_Relative_Slice:
y, ok := b.variant.(Type_Info_Relative_Slice);
if !ok do return false;
return x.base_integer == y.base_integer && x.slice == y.slice;
}
return false;
@@ -322,6 +332,16 @@ is_simd_vector :: proc(info: ^Type_Info) -> bool {
_, ok := type_info_base(info).variant.(Type_Info_Simd_Vector);
return ok;
}
is_relative_pointer :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
_, ok := type_info_base(info).variant.(Type_Info_Relative_Pointer);
return ok;
}
is_relative_slice :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
_, ok := type_info_base(info).variant.(Type_Info_Relative_Slice);
return ok;
}
@@ -567,6 +587,19 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
write_byte(buf, ']');
write_type(buf, info.elem);
}
case Type_Info_Relative_Pointer:
write_string(buf, "#relative(");
write_type(buf, info.base_integer);
write_string(buf, ") ");
write_type(buf, info.pointer);
case Type_Info_Relative_Slice:
write_string(buf, "#relative(");
write_type(buf, info.base_integer);
write_string(buf, ") ");
write_type(buf, info.slice);
}
}
core/runtime/core.odin
+14 -1
View File
@@ -143,7 +143,15 @@ Type_Info_Simd_Vector :: struct {
elem_size: int,
count: int,
is_x86_mmx: bool,
}
};
Type_Info_Relative_Pointer :: struct {
pointer: ^Type_Info,
base_integer: ^Type_Info,
};
Type_Info_Relative_Slice :: struct {
slice: ^Type_Info,
base_integer: ^Type_Info,
};
Type_Info :: struct {
size: int,
@@ -176,6 +184,8 @@ Type_Info :: struct {
Type_Info_Bit_Set,
Type_Info_Opaque,
Type_Info_Simd_Vector,
Type_Info_Relative_Pointer,
Type_Info_Relative_Slice,
},
}
@@ -205,6 +215,9 @@ Typeid_Kind :: enum u8 {
Bit_Field,
Bit_Set,
Opaque,
Simd_Vector,
Relative_Pointer,
Relative_Slice,
}
#assert(len(Typeid_Kind) < 32);
core/runtime/internal.odin
+12
View File
@@ -442,6 +442,18 @@ print_type :: proc(fd: os.Handle, ti: ^Type_Info) {
os.write_byte(fd, ']');
print_type(fd, info.elem);
}
case Type_Info_Relative_Pointer:
os.write_string(fd, "#relative(");
print_type(fd, info.base_integer);
os.write_string(fd, ") ");
print_type(fd, info.pointer);
case Type_Info_Relative_Slice:
os.write_string(fd, "#relative(");
print_type(fd, info.base_integer);
os.write_string(fd, ") ");
print_type(fd, info.slice);
}
}
src/check_expr.cpp
+39 -3
View File
@@ -599,6 +599,20 @@ i64 check_distance_between_types(CheckerContext *c, Operand *operand, Type *type
}
}
if (is_type_relative_pointer(dst)) {
i64 score = check_distance_between_types(c, operand, dst->RelativePointer.pointer_type);
if (score >= 0) {
return score+2;
}
}
if (is_type_relative_slice(dst)) {
i64 score = check_distance_between_types(c, operand, dst->RelativeSlice.slice_type);
if (score >= 0) {
return score+2;
}
}
if (is_type_proc(dst)) {
if (are_types_identical(src, dst)) {
return 3;
@@ -3620,7 +3634,7 @@ Entity *check_selector(CheckerContext *c, Operand *operand, Ast *node, Type *typ
case Entity_Constant:
operand->value = entity->Constant.value;
operand->mode = Addressing_Constant;
if (operand->value.kind == ExactValue_Procedure) {
if (operand->value.kind == ExactValue_Procedure) {
Entity *proc = strip_entity_wrapping(operand->value.value_procedure);
if (proc != nullptr) {
operand->mode = Addressing_Value;
@@ -5923,7 +5937,7 @@ bool check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize lhs_count,
isize count = tuple->variables.count;
tuple_index += add_dependencies_from_unpacking(c, lhs, lhs_count, tuple_index, count);
add_type_and_value(c->info, val.expr, val.mode, val.type, val.value);
} else {
for_array(j, tuple->variables) {
@@ -9205,7 +9219,7 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type
o->mode = Addressing_Invalid;
o->expr = node;
return kind;
}
}
GB_ASSERT(e->identifier != nullptr);
Ast *proc_ident = clone_ast(e->identifier);
@@ -9480,6 +9494,22 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type
if (t->kind == Type_Pointer && !is_type_empty_union(t->Pointer.elem)) {
o->mode = Addressing_Variable;
o->type = t->Pointer.elem;
} else if (t->kind == Type_RelativePointer) {
if (o->mode != Addressing_Variable) {
gbString str = expr_to_string(o->expr);
gbString typ = type_to_string(o->type);
error(o->expr, "Cannot dereference relative pointer '%s' of type '%s' as it does not have a variable addressing mode", str, typ);
gb_string_free(typ);
gb_string_free(str);
}
// NOTE(bill): This is required because when dereferencing, the original type has been lost
add_type_info_type(c, o->type);
Type *ptr_type = base_type(t->RelativePointer.pointer_type);
GB_ASSERT(ptr_type->kind == Type_Pointer);
o->mode = Addressing_Variable;
o->type = ptr_type->Pointer.elem;
} else {
gbString str = expr_to_string(o->expr);
gbString typ = type_to_string(o->type);
@@ -10001,6 +10031,12 @@ gbString write_expr_to_string(gbString str, Ast *node) {
}
str = gb_string_append_rune(str, '}');
case_end;
case_ast_node(rt, RelativeType, node);
str = write_expr_to_string(str, rt->tag);
str = gb_string_appendc(str, "" );
str = write_expr_to_string(str, rt->type);
case_end;
}
return str;
src/check_type.cpp
+42 -2
View File
@@ -329,7 +329,7 @@ void add_polymorphic_record_entity(CheckerContext *ctx, Ast *node, Type *named_t
auto *found_gen_types = map_get(&ctx->checker->info.gen_types, hash_pointer(original_type));
if (found_gen_types) {
array_add(found_gen_types, e);
array_add(found_gen_types, e);
} else {
auto array = array_make<Entity *>(heap_allocator());
array_add(&array, e);
@@ -2501,7 +2501,7 @@ bool check_procedure_type(CheckerContext *ctx, Type *type, Ast *proc_type_node,
c->curr_proc_sig = type;
c->in_proc_sig = true;
ProcCallingConvention cc = pt->calling_convention;
if (cc == ProcCC_ForeignBlockDefault) {
cc = ProcCC_CDecl;
@@ -3284,6 +3284,46 @@ bool check_type_internal(CheckerContext *ctx, Ast *e, Type **type, Type *named_t
return true;
case_end;
case_ast_node(rt, RelativeType, e);
GB_ASSERT(rt->tag->kind == Ast_CallExpr);
ast_node(ce, CallExpr, rt->tag);
Type *base_integer = nullptr;
if (ce->args.count != 1) {
error(rt->type, "#relative expected 1 type argument, got %td", ce->args.count);
} else {
base_integer = check_type(ctx, ce->args[0]);
if (!is_type_integer(base_integer)) {
error(rt->type, "#relative base types must be an integer");
base_integer = nullptr;
} else if (type_size_of(base_integer) > 64) {
error(rt->type, "#relative base integer types be less than or equal to 64-bits");
base_integer = nullptr;
}
}
Type *relative_type = nullptr;
Type *base_type = check_type(ctx, rt->type);
if (!is_type_pointer(base_type) && !is_type_slice(base_type)) {
error(rt->type, "#relative types can only be a pointer or slice");
relative_type = base_type;
} else if (base_integer == nullptr) {
relative_type = base_type;
} else {
if (is_type_pointer(base_type)) {
relative_type = alloc_type_relative_pointer(base_type, base_integer);
} else if (is_type_slice(base_type)) {
relative_type = alloc_type_relative_slice(base_type, base_integer);
}
}
GB_ASSERT(relative_type != nullptr);
*type = relative_type;
set_base_type(named_type, *type);
return true;
case_end;
case_ast_node(ot, OpaqueType, e);
Type *elem = strip_opaque_type(check_type_expr(ctx, ot->type, nullptr));
*type = alloc_type_opaque(elem);
src/checker.cpp
+24
View File
@@ -1430,6 +1430,16 @@ void add_type_info_type(CheckerContext *c, Type *t) {
add_type_info_type(c, bt->SimdVector.elem);
break;
case Type_RelativePointer:
add_type_info_type(c, bt->RelativePointer.pointer_type);
add_type_info_type(c, bt->RelativePointer.base_integer);
break;
case Type_RelativeSlice:
add_type_info_type(c, bt->RelativeSlice.slice_type);
add_type_info_type(c, bt->RelativeSlice.base_integer);
break;
default:
GB_PANIC("Unhandled type: %*.s %d", LIT(type_strings[bt->kind]), bt->kind);
break;
@@ -1626,6 +1636,16 @@ void add_min_dep_type_info(Checker *c, Type *t) {
add_min_dep_type_info(c, bt->SimdVector.elem);
break;
case Type_RelativePointer:
add_min_dep_type_info(c, bt->RelativePointer.pointer_type);
add_min_dep_type_info(c, bt->RelativePointer.base_integer);
break;
case Type_RelativeSlice:
add_min_dep_type_info(c, bt->RelativeSlice.slice_type);
add_min_dep_type_info(c, bt->RelativeSlice.base_integer);
break;
default:
GB_PANIC("Unhandled type: %*.s", LIT(type_strings[bt->kind]));
break;
@@ -2055,6 +2075,8 @@ 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_opaque = find_core_type(c, str_lit("Type_Info_Opaque"));
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_slice = find_core_type(c, str_lit("Type_Info_Relative_Slice"));
t_type_info_named_ptr = alloc_type_pointer(t_type_info_named);
t_type_info_integer_ptr = alloc_type_pointer(t_type_info_integer);
@@ -2081,6 +2103,8 @@ void init_core_type_info(Checker *c) {
t_type_info_bit_set_ptr = alloc_type_pointer(t_type_info_bit_set);
t_type_info_opaque_ptr = alloc_type_pointer(t_type_info_opaque);
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_slice_ptr = alloc_type_pointer(t_type_info_relative_slice);
}
void init_mem_allocator(Checker *c) {
src/ir.cpp
+3 -3
View File
@@ -20,7 +20,7 @@ struct irModule {
PtrSet<Entity *> min_dep_set;
Map<irValue *> values; // Key: Entity *
StringMap<irValue *> members;
StringMap<irValue *> members;
Map<String> entity_names; // Key: Entity * of the typename
Map<irDebugInfo *> debug_info; // Key: Unique pointer
Map<irValue *> anonymous_proc_lits; // Key: Ast *
@@ -7399,7 +7399,7 @@ irValue *ir_build_expr_internal(irProcedure *proc, Ast *expr) {
// HACK TODO(bill): This is hack but it should be safe in virtually all cases
irValue *v = ir_typeid(proc->module, tv.type);
return ir_emit_conv(proc, v, t_typeid);
}
}
if (tv.value.kind != ExactValue_Invalid) {
// NOTE(bill): Edge case
@@ -11514,7 +11514,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
case Basic_f64le:
case Basic_f32be:
case Basic_f64be:
{
{
tag = ir_emit_conv(proc, variant_ptr, t_type_info_float_ptr);
// NOTE(bill): This is matches the runtime layout
src/llvm_backend.cpp
+152 -21
View File
@@ -56,6 +56,10 @@ LLVMValueRef llvm_cstring(lbModule *m, String const &str) {
lbAddr lb_addr(lbValue addr) {
lbAddr v = {lbAddr_Default, addr};
if (is_type_relative_pointer(type_deref(addr.type))) {
GB_ASSERT(is_type_pointer(addr.type));
v.kind = lbAddr_RelativePointer;
}
return v;
}
@@ -160,7 +164,29 @@ void lb_addr_store(lbProcedure *p, lbAddr const &addr, lbValue value) {
value.value = LLVMConstNull(lb_type(p->module, t));
}
if (addr.kind == lbAddr_AtomOp_index_set) {
if (addr.kind == lbAddr_RelativePointer) {
Type *rel_ptr = base_type(lb_addr_type(addr));
GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
value = lb_emit_conv(p, value, rel_ptr->RelativePointer.pointer_type);
GB_ASSERT(is_type_pointer(addr.addr.type));
lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
lbValue val_ptr = lb_emit_conv(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));
LLVMBuildStore(p->builder, offset.value, offset_ptr.value);
return;
} else if (addr.kind == lbAddr_AtomOp_index_set) {
lbValue ptr = addr.addr;
lbValue index = addr.index_set.index;
Ast *node = addr.index_set.node;
@@ -341,7 +367,34 @@ lbValue lb_emit_load(lbProcedure *p, lbValue value) {
lbValue lb_addr_load(lbProcedure *p, lbAddr const &addr) {
GB_ASSERT(addr.addr.value != nullptr);
if (addr.kind == lbAddr_Map) {
if (addr.kind == lbAddr_RelativePointer) {
Type *rel_ptr = base_type(lb_addr_type(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 = {};
final_ptr.type = absolute_ptr.type;
final_ptr.value = LLVMBuildSelect(p->builder, cond.value, nil_ptr.value, absolute_ptr.value, "");
return lb_emit_load(p, final_ptr);
} else if (addr.kind == lbAddr_Map) {
Type *map_type = base_type(addr.map.type);
lbAddr v = lb_add_local_generated(p, map_type->Map.lookup_result_type, true);
lbValue h = lb_gen_map_header(p, addr.addr, map_type);
@@ -1181,6 +1234,20 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
return LLVMX86MMXTypeInContext(ctx);
}
return LLVMVectorType(lb_type(m, type->SimdVector.elem), cast(unsigned)type->SimdVector.count);
case Type_RelativePointer:
return lb_type_internal(m, type->RelativePointer.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(heap_allocator(), LLVMTypeRef, field_count);
fields[0] = base_integer;
fields[1] = base_integer;
return LLVMStructTypeInContext(ctx, fields, field_count, false);
}
}
GB_PANIC("Invalid type %s", type_to_string(type));
@@ -3970,7 +4037,7 @@ void lb_build_stmt(lbProcedure *p, Ast *node) {
}
lb_emit_defer_stmts(p, lbDeferExit_Return, nullptr);
LLVMBuildRet(p->builder, res.value);
}
case_end;
@@ -4323,19 +4390,23 @@ lbValue lb_typeid(lbModule *m, Type *type, Type *typeid_type) {
if (flags & BasicFlag_String) kind = Typeid_String;
if (flags & BasicFlag_Rune) kind = Typeid_Rune;
} break;
case Type_Pointer: kind = Typeid_Pointer; break;
case Type_Array: kind = Typeid_Array; break;
case Type_Pointer: kind = Typeid_Pointer; break;
case Type_Array: kind = Typeid_Array; break;
case Type_EnumeratedArray: kind = Typeid_Enumerated_Array; break;
case Type_Slice: kind = Typeid_Slice; break;
case Type_DynamicArray: kind = Typeid_Dynamic_Array; break;
case Type_Map: kind = Typeid_Map; break;
case Type_Struct: kind = Typeid_Struct; break;
case Type_Enum: kind = Typeid_Enum; break;
case Type_Union: kind = Typeid_Union; break;
case Type_Tuple: kind = Typeid_Tuple; break;
case Type_Proc: kind = Typeid_Procedure; break;
case Type_BitField: kind = Typeid_Bit_Field; break;
case Type_BitSet: kind = Typeid_Bit_Set; break;
case Type_Slice: kind = Typeid_Slice; break;
case Type_DynamicArray: kind = Typeid_Dynamic_Array; break;
case Type_Map: kind = Typeid_Map; break;
case Type_Struct: kind = Typeid_Struct; break;
case Type_Enum: kind = Typeid_Enum; break;
case Type_Union: kind = Typeid_Union; break;
case Type_Tuple: kind = Typeid_Tuple; break;
case Type_Proc: kind = Typeid_Procedure; break;
case Type_BitField: kind = Typeid_Bit_Field; break;
case Type_BitSet: kind = Typeid_Bit_Set; break;
case Type_Opaque: kind = Typeid_Opaque; break;
case Type_SimdVector: kind = Typeid_Simd_Vector; break;
case Type_RelativePointer: kind = Typeid_Relative_Pointer; break;
case Type_RelativeSlice: kind = Typeid_Relative_Slice; break;
}
if (is_type_cstring(type)) {
@@ -4495,7 +4566,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value) {
res.value = LLVMConstArray(lb_type(m, elem), elems, cast(unsigned)count);
return res;
}
}
switch (value.kind) {
case ExactValue_Invalid:
@@ -9723,6 +9794,10 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
case_end;
case_ast_node(de, DerefExpr, expr);
if (is_type_relative_pointer(type_of_expr(de->expr))) {
lbAddr addr = lb_build_addr(p, de->expr);
return addr;
}
lbValue addr = lb_build_expr(p, de->expr);
return lb_addr(addr);
case_end;
@@ -11192,6 +11267,36 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da
lb_emit_store(p, tag, res);
}
break;
case Type_RelativePointer:
{
tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_relative_pointer_ptr);
LLVMValueRef vals[2] = {
lb_get_type_info_ptr(m, t->RelativePointer.pointer_type).value,
lb_get_type_info_ptr(m, t->RelativePointer.base_integer).value,
};
lbValue res = {};
res.type = type_deref(tag.type);
res.value = LLVMConstNamedStruct(lb_type(m, res.type), vals, gb_count_of(vals));
lb_emit_store(p, tag, res);
}
break;
case Type_RelativeSlice:
{
tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_relative_slice_ptr);
LLVMValueRef vals[2] = {
lb_get_type_info_ptr(m, t->RelativeSlice.slice_type).value,
lb_get_type_info_ptr(m, t->RelativeSlice.base_integer).value,
};
lbValue res = {};
res.type = type_deref(tag.type);
res.value = LLVMConstNamedStruct(lb_type(m, res.type), vals, gb_count_of(vals));
lb_emit_store(p, tag, res);
}
break;
}
@@ -11554,6 +11659,25 @@ void lb_generate_code(lbGenerator *gen) {
LLVMAddMergedLoadStoreMotionPass(default_function_pass_manager);
LLVMAddPromoteMemoryToRegisterPass(default_function_pass_manager);
// LLVMAddUnifyFunctionExitNodesPass(default_function_pass_manager);
if (build_context.optimization_level >= 2) {
LLVMAddAggressiveInstCombinerPass(default_function_pass_manager);
LLVMAddEarlyCSEPass(default_function_pass_manager);
LLVMAddEarlyCSEMemSSAPass(default_function_pass_manager);
LLVMAddLowerExpectIntrinsicPass(default_function_pass_manager);
LLVMAddAlignmentFromAssumptionsPass(default_function_pass_manager);
LLVMAddLoopRotatePass(default_function_pass_manager);
LLVMAddDeadStoreEliminationPass(default_function_pass_manager);
LLVMAddScalarizerPass(default_function_pass_manager);
LLVMAddReassociatePass(default_function_pass_manager);
LLVMAddAddDiscriminatorsPass(default_function_pass_manager);
LLVMAddPromoteMemoryToRegisterPass(default_function_pass_manager);
LLVMAddCorrelatedValuePropagationPass(default_function_pass_manager);
LLVMAddSLPVectorizePass(default_function_pass_manager);
LLVMAddLoopVectorizePass(default_function_pass_manager);
}
}
LLVMPassManagerRef default_function_pass_manager_without_memcpy = LLVMCreateFunctionPassManagerForModule(mod);
@@ -11784,10 +11908,12 @@ void lb_generate_code(lbGenerator *gen) {
for_array(i, m->procedures_to_generate) {
lbProcedure *p = m->procedures_to_generate[i];
if (p->body != nullptr) { // Build Procedure
if (p->flags & lbProcedureFlag_WithoutMemcpyPass) {
LLVMRunFunctionPassManager(default_function_pass_manager_without_memcpy, p->value);
} else {
LLVMRunFunctionPassManager(default_function_pass_manager, p->value);
for (i32 i = 0; i <= build_context.optimization_level; i++) {
if (p->flags & lbProcedureFlag_WithoutMemcpyPass) {
LLVMRunFunctionPassManager(default_function_pass_manager_without_memcpy, p->value);
} else {
LLVMRunFunctionPassManager(default_function_pass_manager, p->value);
}
}
}
}
@@ -11799,7 +11925,12 @@ void lb_generate_code(lbGenerator *gen) {
defer (LLVMDisposePassManager(module_pass_manager));
LLVMAddAlwaysInlinerPass(module_pass_manager);
LLVMAddStripDeadPrototypesPass(module_pass_manager);
// LLVMAddConstantMergePass(module_pass_manager);
// if (build_context.optimization_level >= 2) {
// LLVMAddArgumentPromotionPass(module_pass_manager);
// LLVMAddConstantMergePass(module_pass_manager);
// LLVMAddGlobalDCEPass(module_pass_manager);
// LLVMAddDeadArgEliminationPass(module_pass_manager);
// }
LLVMPassManagerBuilderRef pass_manager_builder = LLVMPassManagerBuilderCreate();
defer (LLVMPassManagerBuilderDispose(pass_manager_builder));
src/llvm_backend.hpp
+5 -3
View File
@@ -28,6 +28,8 @@ enum lbAddrKind {
lbAddr_Context,
lbAddr_SoaVariable,
lbAddr_RelativePointer,
lbAddr_AtomOp_index_set,
};
@@ -68,11 +70,11 @@ struct lbModule {
Map<LLVMTypeRef> types; // Key: Type *
Map<lbValue> values; // Key: Entity *
StringMap<lbValue> members;
StringMap<lbProcedure *> procedures;
StringMap<lbValue> members;
StringMap<lbProcedure *> procedures;
Map<Entity *> procedure_values; // Key: LLVMValueRef
StringMap<LLVMValueRef> const_strings;
StringMap<LLVMValueRef> const_strings;
Map<lbProcedure *> anonymous_proc_lits; // Key: Ast *
src/parser.cpp
+16 -1
View File
@@ -87,6 +87,7 @@ Token ast_token(Ast *node) {
case Ast_OpaqueType: return node->OpaqueType.token;
case Ast_PolyType: return node->PolyType.token;
case Ast_ProcType: return node->ProcType.token;
case Ast_RelativeType: return ast_token(node->RelativeType.tag);
case Ast_PointerType: return node->PointerType.token;
case Ast_ArrayType: return node->ArrayType.token;
case Ast_DynamicArrayType: return node->DynamicArrayType.token;
@@ -343,6 +344,10 @@ Ast *clone_ast(Ast *node) {
n->ProcType.params = clone_ast(n->ProcType.params);
n->ProcType.results = clone_ast(n->ProcType.results);
break;
case Ast_RelativeType:
n->RelativeType.tag = clone_ast(n->RelativeType.tag);
n->RelativeType.type = clone_ast(n->RelativeType.type);
break;
case Ast_PointerType:
n->PointerType.type = clone_ast(n->PointerType.type);
break;
@@ -922,7 +927,12 @@ Ast *ast_proc_type(AstFile *f, Token token, Ast *params, Ast *results, u64 tags,
return result;
}
Ast *ast_relative_type(AstFile *f, Ast *tag, Ast *type) {
Ast *result = alloc_ast_node(f, Ast_RelativeType);
result->RelativeType.tag = tag;
result->RelativeType.type = type;
return result;
}
Ast *ast_pointer_type(AstFile *f, Token token, Ast *type) {
Ast *result = alloc_ast_node(f, Ast_PointerType);
result->PointerType.token = token;
@@ -1825,6 +1835,11 @@ Ast *parse_operand(AstFile *f, bool lhs) {
syntax_error(token, "#bounds_check and #no_bounds_check cannot be applied together");
}
return operand;
} else if (name.string == "relative") {
Ast *tag = ast_basic_directive(f, token, name.string);
tag = parse_call_expr(f, tag);
Ast *type = parse_type(f);
return ast_relative_type(f, tag, type);
} else {
operand = ast_tag_expr(f, token, name, parse_expr(f, false));
}
src/parser.hpp
+4
View File
@@ -497,6 +497,10 @@ AST_KIND(_TypeBegin, "", bool) \
Token token; \
Ast *type; \
}) \
AST_KIND(RelativeType, "relative type", struct { \
Ast *tag; \
Ast *type; \
}) \
AST_KIND(ArrayType, "array type", struct { \
Token token; \
Ast *count; \
src/types.cpp
+72 -6
View File
@@ -126,7 +126,7 @@ enum StructSoaKind {
enum TypeAtomOpKind {
TypeAtomOp_Invalid,
TypeAtomOp_index_get,
TypeAtomOp_index_set,
TypeAtomOp_slice,
@@ -151,7 +151,7 @@ struct TypeStruct {
i64 custom_align;
Entity * names;
TypeAtomOpTable *atom_op_table;
Type * soa_elem;
@@ -290,8 +290,14 @@ struct TypeProc {
Type *elem; \
bool is_x86_mmx; \
}) \
TYPE_KIND(RelativePointer, struct { \
Type *pointer_type; \
Type *base_integer; \
}) \
TYPE_KIND(RelativeSlice, struct { \
Type *slice_type; \
Type *base_integer; \
})
enum TypeKind {
@@ -358,6 +364,10 @@ enum Typeid_Kind : u8 {
Typeid_Map,
Typeid_Bit_Field,
Typeid_Bit_Set,
Typeid_Opaque,
Typeid_Simd_Vector,
Typeid_Relative_Pointer,
Typeid_Relative_Slice,
};
@@ -611,6 +621,8 @@ gb_global Type *t_type_info_bit_field = nullptr;
gb_global Type *t_type_info_bit_set = nullptr;
gb_global Type *t_type_info_opaque = 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_slice = nullptr;
gb_global Type *t_type_info_named_ptr = nullptr;
gb_global Type *t_type_info_integer_ptr = nullptr;
@@ -637,6 +649,8 @@ gb_global Type *t_type_info_bit_field_ptr = nullptr;
gb_global Type *t_type_info_bit_set_ptr = nullptr;
gb_global Type *t_type_info_opaque_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_slice_ptr = nullptr;
gb_global Type *t_allocator = nullptr;
gb_global Type *t_allocator_ptr = nullptr;
@@ -661,6 +675,9 @@ void init_map_internal_types(Type *type);
Type * bit_set_to_int(Type *t);
bool are_types_identical(Type *x, Type *y);
bool is_type_pointer(Type *t);
bool is_type_slice(Type *t);
bool is_type_integer(Type *t);
bool type_ptr_set_exists(PtrSet<Type *> *s, Type *t) {
if (ptr_set_exists(s, t)) {
@@ -837,9 +854,23 @@ Type *alloc_type_enum() {
return t;
}
Type *alloc_type_relative_pointer(Type *pointer_type, Type *base_integer) {
GB_ASSERT(is_type_pointer(pointer_type));
GB_ASSERT(is_type_integer(base_integer));
Type *t = alloc_type(Type_RelativePointer);
t->RelativePointer.pointer_type = pointer_type;
t->RelativePointer.base_integer = base_integer;
return t;
}
Type *alloc_type_relative_slice(Type *slice_type, Type *base_integer) {
GB_ASSERT(is_type_slice(slice_type));
GB_ASSERT(is_type_integer(base_integer));
Type *t = alloc_type(Type_RelativeSlice);
t->RelativeSlice.slice_type = slice_type;
t->RelativeSlice.base_integer = base_integer;
return t;
}
Type *alloc_type_named(String name, Type *base, Entity *type_name) {
Type *t = alloc_type(Type_Named);
@@ -1197,6 +1228,14 @@ bool is_type_generic(Type *t) {
return t->kind == Type_Generic;
}
bool is_type_relative_pointer(Type *t) {
t = base_type(t);
return t->kind == Type_RelativePointer;
}
bool is_type_relative_slice(Type *t) {
t = base_type(t);
return t->kind == Type_RelativeSlice;
}
Type *core_array_type(Type *t) {
@@ -1756,6 +1795,10 @@ bool type_has_nil(Type *t) {
return false;
case Type_Opaque:
return true;
case Type_RelativePointer:
case Type_RelativeSlice:
return true;
}
return false;
}
@@ -2865,6 +2908,11 @@ i64 type_align_of_internal(Type *t, TypePath *path) {
// IMPORTANT TODO(bill): Figure out the alignment of vector types
return gb_clamp(next_pow2(type_size_of_internal(t, path)), 1, build_context.max_align);
}
case Type_RelativePointer:
return type_align_of_internal(t->RelativePointer.base_integer, path);
case Type_RelativeSlice:
return type_align_of_internal(t->RelativeSlice.base_integer, path);
}
// return gb_clamp(next_pow2(type_size_of(t)), 1, build_context.max_align);
@@ -3138,6 +3186,11 @@ i64 type_size_of_internal(Type *t, TypePath *path) {
Type *elem = t->SimdVector.elem;
return count * type_size_of_internal(elem, path);
}
case Type_RelativePointer:
return type_size_of_internal(t->RelativePointer.base_integer, path);
case Type_RelativeSlice:
return 2*type_size_of_internal(t->RelativeSlice.base_integer, path);
}
// Catch all
@@ -3536,6 +3589,19 @@ gbString write_type_to_string(gbString str, Type *type) {
str = write_type_to_string(str, type->SimdVector.elem);
}
break;
case Type_RelativePointer:
str = gb_string_append_fmt(str, "#relative(");
str = write_type_to_string(str, type->RelativePointer.base_integer);
str = gb_string_append_fmt(str, ") ");
str = write_type_to_string(str, type->RelativePointer.pointer_type);
break;
case Type_RelativeSlice:
str = gb_string_append_fmt(str, "#relative(");
str = write_type_to_string(str, type->RelativeSlice.base_integer);
str = gb_string_append_fmt(str, ") ");
str = write_type_to_string(str, type->RelativeSlice.slice_type);
break;
}
return str;