mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-05-21 03:13:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

transmute(type)x; Minor code clean up

Browse Source
This commit is contained in:
Ginger Bill
2017-07-30 14:52:42 +01:00
parent 655931f0ea
commit 62a72f0163
16 changed files with 808 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/build_settings.cpp
View File

@@ -160,6 +160,7 @@ String odin_root_dir(void) {
}
array_init_count(&path_buf, heap_allocator(), 300);
defer (array_free(&path_buf));
len = 0;
for (;;) {
@@ -179,7 +180,10 @@ String odin_root_dir(void) {
tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
defer (gb_temp_arena_memory_end(tmp));
text = gb_alloc_array(string_buffer_allocator, u8, len + 1);
gb_memmove(text, &path_buf[0], len);
path = make_string(text, len);
@@ -194,10 +198,6 @@ String odin_root_dir(void) {
global_module_path = path;
global_module_path_set = true;
gb_temp_arena_memory_end(tmp);
array_free(&path_buf);
return path;
}
#endif
@@ -267,7 +267,7 @@ String get_fullpath_core(gbAllocator a, String path) {
}
String const ODIN_VERSION = str_lit("0.6.0-dev");
String const ODIN_VERSION = str_lit("0.6.0");
void init_build_context(void) {
BuildContext *bc = &build_context;

16
src/check_decl.cpp
View File

@@ -319,14 +319,12 @@ bool are_signatures_similar_enough(Type *a_, Type *b_) {
if (is_type_integer(x) && is_type_integer(y)) {
GB_ASSERT(x->kind == Type_Basic);
GB_ASSERT(y->kind == Type_Basic);
if (x->Basic.size == y->Basic.size) {
continue;
}
i64 sx = type_size_of(heap_allocator(), x);
i64 sy = type_size_of(heap_allocator(), y);
if (sx == sy) continue;
}
if (!are_types_identical(x, y)) {
return false;
}
if (!are_types_identical(x, y)) return false;
}
for (isize i = 0; i < a->result_count; i++) {
Type *x = base_type(a->results->Tuple.variables[i]->type);
@@ -338,9 +336,9 @@ bool are_signatures_similar_enough(Type *a_, Type *b_) {
if (is_type_integer(x) && is_type_integer(y)) {
GB_ASSERT(x->kind == Type_Basic);
GB_ASSERT(y->kind == Type_Basic);
if (x->Basic.size == y->Basic.size) {
continue;
}
i64 sx = type_size_of(heap_allocator(), x);
i64 sy = type_size_of(heap_allocator(), y);
if (sx == sy) continue;
}
if (!are_types_identical(x, y)) {

57
src/check_expr.cpp
View File

@@ -2121,6 +2121,10 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
type = determine_type_from_polymorphic(c, type, op);
if (type == t_invalid) {
success = false;
} else if (!c->context.no_polymorphic_errors) {
// NOTE(bill): The type should be determined now and thus, no need to determine the type any more
is_type_polymorphic_type = false;
// is_type_polymorphic_type = is_type_polymorphic(base_type(type));
}
}
@@ -3959,6 +3963,43 @@ void check_cast(Checker *c, Operand *x, Type *type) {
x->type = type;
}
bool check_transmute(Checker *c, AstNode *node, Operand *o, Type *t) {
if (o->mode == Addressing_Constant) {
gbString expr_str = expr_to_string(o->expr);
error(o->expr, "Cannot transmute a constant expression: `%s`", expr_str);
gb_string_free(expr_str);
o->mode = Addressing_Invalid;
o->expr = node;
return false;
}
if (is_type_untyped(o->type)) {
gbString expr_str = expr_to_string(o->expr);
error(o->expr, "Cannot transmute untyped expression: `%s`", expr_str);
gb_string_free(expr_str);
o->mode = Addressing_Invalid;
o->expr = node;
return false;
}
i64 srcz = type_size_of(c->allocator, o->type);
i64 dstz = type_size_of(c->allocator, t);
if (srcz != dstz) {
gbString expr_str = expr_to_string(o->expr);
gbString type_str = type_to_string(t);
error(o->expr, "Cannot transmute `%s` to `%s`, %lld vs %lld bytes", expr_str, type_str, srcz, dstz);
gb_string_free(type_str);
gb_string_free(expr_str);
o->mode = Addressing_Invalid;
o->expr = node;
return false;
}
o->mode = Addressing_Value;
o->type = t;
return true;
}
bool check_binary_vector_expr(Checker *c, Token op, Operand *x, Operand *y) {
if (is_type_vector(x->type) && !is_type_vector(y->type)) {
if (check_is_assignable_to(c, y, x->type)) {
@@ -4870,7 +4911,6 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
case BuiltinProc_align_of:
case BuiltinProc_offset_of:
case BuiltinProc_type_info_of:
case BuiltinProc_transmute:
// NOTE(bill): The first arg may be a Type, this will be checked case by case
break;
default:
@@ -5891,6 +5931,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
}
} break;
#if 0
case BuiltinProc_transmute: {
Operand op = {};
check_expr_or_type(c, &op, ce->args[0]);
@@ -5940,6 +5981,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
o->mode = Addressing_Value;
o->type = t;
} break;
#endif
}
return true;
@@ -7814,7 +7856,18 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
Type *type = o->type;
check_expr_base(c, o, tc->expr, type);
if (o->mode != Addressing_Invalid) {
check_cast(c, o, type);
switch (tc->token.kind) {
case Token_transmute:
check_transmute(c, node, o, type);
break;
case Token_cast:
check_cast(c, o, type);
break;
default:
error(node, "Invalid AST: Invalid casting expression");
o->mode = Addressing_Invalid;
break;
}
}
return Expr_Expr;
case_end;

50
src/checker.cpp
View File

@@ -61,8 +61,6 @@ enum BuiltinProcId {
BuiltinProc_abs,
BuiltinProc_clamp,
BuiltinProc_transmute,
BuiltinProc_DIRECTIVE, // NOTE(bill): This is used for specialized hash-prefixed procedures
BuiltinProc_COUNT,
@@ -107,8 +105,6 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
{STR_LIT("abs"), 1, false, Expr_Expr},
{STR_LIT("clamp"), 3, false, Expr_Expr},
{STR_LIT("transmute"), 2, false, Expr_Expr},
{STR_LIT(""), 0, true, Expr_Expr}, // DIRECTIVE
};
@@ -2172,33 +2168,37 @@ void check_import_entities(Checker *c, Map<Scope *> *file_scopes) {
scope->has_been_imported = true;
if (id->import_name.string == ".") {
// NOTE(bill): Add imported entities to this file's scope
for_array(elem_index, scope->elements.entries) {
Entity *e = scope->elements.entries[elem_index].value;
if (e->scope == parent_scope) {
continue;
}
if (!is_entity_kind_exported(e->kind)) {
continue;
}
if (id->is_import) {
if (is_entity_exported(e)) {
// TODO(bill): Should these entities be imported but cause an error when used?
bool ok = add_entity(c, parent_scope, e->identifier, e);
if (ok) {
map_set(&parent_scope->implicit, hash_entity(e), true);
}
if (parent_scope->is_global) {
error(id->import_name, "#shared_global_scope imports cannot use .");
} else {
// NOTE(bill): Add imported entities to this file's scope
for_array(elem_index, scope->elements.entries) {
Entity *e = scope->elements.entries[elem_index].value;
if (e->scope == parent_scope) {
continue;
}
if (!is_entity_kind_exported(e->kind)) {
continue;
}
if (id->is_import) {
if (is_entity_exported(e)) {
// TODO(bill): Should these entities be imported but cause an error when used?
bool ok = add_entity(c, parent_scope, e->identifier, e);
if (ok) {
map_set(&parent_scope->implicit, hash_entity(e), true);
}
}
} else {
add_entity(c, parent_scope, e->identifier, e);
}
} else {
add_entity(c, parent_scope, e->identifier, e);
}
}
} else {
String import_name = path_to_entity_name(id->import_name.string, id->fullpath);
if (is_blank_ident(import_name)) {
error(token, "File name, %.*s, cannot be as an import name as it is not a valid identifier", LIT(id->import_name.string));
error(token, "File name, %.*s, cannot be use as an import name as it is not a valid identifier", LIT(id->import_name.string));
} else {
GB_ASSERT(id->import_name.pos.line != 0);
id->import_name.string = import_name;

87
src/ir.cpp
View File

@@ -2435,52 +2435,69 @@ irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) {
Type *t = base_type(ir_type(s));
Type *result_type = nullptr;
if (is_type_struct(t)) {
switch (t->kind) {
case Type_Basic:
switch (t->Basic.kind) {
case Basic_string:
switch (index) {
case 0: result_type = t_u8_ptr; break;
case 1: result_type = t_int; break;
}
break;
case Basic_any:
switch (index) {
case 0: result_type = t_rawptr; break;
case 1: result_type = t_type_info_ptr; break;
}
break;
case Basic_complex64: case Basic_complex128:
{
Type *ft = base_complex_elem_type(t);
switch (index) {
case 0: result_type = ft; break;
case 1: result_type = ft; break;
}
} break;
}
break;
case Type_Struct:
result_type = t->Struct.fields[index]->type;
} else if (is_type_union(t)) {
break;
case Type_Union:
GB_ASSERT(index == -1);
return ir_emit_union_tag_value(proc, s);
} else if (is_type_tuple(t)) {
case Type_Tuple:
GB_ASSERT(t->Tuple.variables.count > 0);
result_type = t->Tuple.variables[index]->type;
} else if (is_type_complex(t)) {
Type *ft = base_complex_elem_type(t);
switch (index) {
case 0: result_type = ft; break;
case 1: result_type = ft; break;
}
} else if (is_type_slice(t)) {
break;
case Type_Slice:
switch (index) {
case 0: result_type = make_type_pointer(a, t->Slice.elem); break;
case 1: result_type = t_int; break;
case 2: result_type = t_int; break;
}
} else if (is_type_string(t)) {
switch (index) {
case 0: result_type = t_u8_ptr; break;
case 1: result_type = t_int; break;
}
} else if (is_type_any(t)) {
switch (index) {
case 0: result_type = t_rawptr; break;
case 1: result_type = t_type_info_ptr; break;
}
} else if (is_type_dynamic_array(t)) {
break;
case Type_DynamicArray:
switch (index) {
case 0: result_type = make_type_pointer(a, t->DynamicArray.elem); break;
case 1: result_type = t_int; break;
case 2: result_type = t_int; break;
case 3: result_type = t_allocator; break;
}
} else if (is_type_map(t)) {
break;
case Type_Map: {
generate_map_internal_types(a, t);
Type *gst = t->Map.generated_struct_type;
switch (index) {
case 0: result_type = gst->Struct.fields[0]->type; break;
case 1: result_type = gst->Struct.fields[1]->type; break;
}
} else {
} break;
default:
GB_PANIC("TODO(bill): struct_ev type: %s, %d", type_to_string(ir_type(s)), index);
break;
}
GB_ASSERT(result_type != nullptr);
@@ -2492,6 +2509,7 @@ irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) {
irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) {
GB_ASSERT(sel.index.count > 0);
Type *type = type_deref(ir_type(e));
gbAllocator a = proc->module->allocator;
for_array(i, sel.index) {
i32 index = cast(i32)sel.index[i];
@@ -2502,21 +2520,23 @@ irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) {
}
type = core_type(type);
if (is_type_raw_union(type)) {
type = type->Struct.fields[index]->type;
e = ir_emit_conv(proc, e, make_type_pointer(proc->module->allocator, type));
e = ir_emit_conv(proc, e, make_type_pointer(a, type));
} else if (type->kind == Type_Union) {
GB_ASSERT(index == -1);
type = t_type_info_ptr;
e = ir_emit_struct_ep(proc, e, index);
} else if (type->kind == Type_Struct) {
type = type->Struct.fields[index]->type;
e = ir_emit_struct_ep(proc, e, index);
if (type->Struct.is_raw_union) {
} else {
e = ir_emit_struct_ep(proc, e, index);
}
} else if (type->kind == Type_Tuple) {
type = type->Tuple.variables[index]->type;
e = ir_emit_struct_ep(proc, e, index);
}else if (type->kind == Type_Basic) {
} else if (type->kind == Type_Basic) {
switch (type->Basic.kind) {
case Basic_any: {
if (index == 0) {
@@ -3867,11 +3887,6 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
return ir_type_info(proc, t);
} break;
case BuiltinProc_transmute: {
irValue *x = ir_build_expr(proc, ce->args[1]);
return ir_emit_transmute(proc, x, tv.type);
}
case BuiltinProc_len: {
irValue *v = ir_build_expr(proc, ce->args[0]);
Type *t = base_type(ir_type(v));
@@ -4694,7 +4709,13 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) {
case_ast_node(tc, TypeCast, expr);
irValue *e = ir_build_expr(proc, tc->expr);
return ir_emit_conv(proc, e, tv.type);
switch (tc->token.kind) {
case Token_cast:
return ir_emit_conv(proc, e, tv.type);
case Token_transmute:
return ir_emit_transmute(proc, e, tv.type);
}
GB_PANIC("Invalid AST TypeCast");
case_end;
case_ast_node(ue, UnaryExpr, expr);

28
src/ir_print.cpp
View File

@@ -275,7 +275,7 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
case Type_DynamicArray:
ir_fprintf(f, "{");
ir_print_type(f, m, t->DynamicArray.elem);
ir_fprintf(f, "*, i%lld, i%lld,", word_bits, word_bits);
ir_fprintf(f, "*, i%lld, i%lld, ", word_bits, word_bits);
ir_print_type(f, m, t_allocator);
ir_fprintf(f, "}");
return;
@@ -523,7 +523,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type *
if (!has_defaults) {
ir_fprintf(f, "zeroinitializer");
} else {
ir_print_compound_element(f, m, empty_exact_value, type);
ir_print_exact_value(f, m, empty_exact_value, type);
}
break;
}
@@ -881,9 +881,6 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
case irInstr_Store: {
Type *type = type_deref(ir_type(instr->Store.address));
ir_fprintf(f, "store ");
if (instr->Store.atomic) {
ir_fprintf(f, "atomic ");
}
ir_print_type(f, m, type);
ir_fprintf(f, " ");
ir_print_value(f, m, instr->Store.value, type);
@@ -891,29 +888,17 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
ir_print_type(f, m, type);
ir_fprintf(f, "* ");
ir_print_value(f, m, instr->Store.address, type);
if (instr->Store.atomic) {
// TODO(bill): Do ordering
ir_fprintf(f, " unordered");
ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
}
ir_fprintf(f, "\n");
} break;
case irInstr_Load: {
Type *type = instr->Load.type;
ir_fprintf(f, "%%%d = load ", value->index);
// if (is_type_atomic(type)) {
// ir_fprintf(f, "atomic ");
// }
ir_print_type(f, m, type);
ir_fprintf(f, ", ");
ir_print_type(f, m, type);
ir_fprintf(f, "* ");
ir_print_value(f, m, instr->Load.address, type);
// if (is_type_atomic(type)) {
// TODO(bill): Do ordering
// ir_fprintf(f, " unordered");
// }
ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
} break;
@@ -1409,7 +1394,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
if (param_index > 0) ir_fprintf(f, ", ");
ir_print_type(f, m, t_context_ptr);
ir_fprintf(f, " noalias nonnull");
ir_fprintf(f, " noalias nonnull ");
ir_print_value(f, m, call->context_ptr, t_context_ptr);
}
ir_fprintf(f, ")\n");
@@ -1568,26 +1553,27 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
#endif
case irInstr_DebugDeclare: {
/* irInstrDebugDeclare *dd = &instr->DebugDeclare;
irInstrDebugDeclare *dd = &instr->DebugDeclare;
Type *vt = ir_type(dd->value);
irDebugInfo *di = dd->debug_info;
Entity *e = dd->entity;
String name = e->token.string;
TokenPos pos = e->token.pos;
// gb_printf("debug_declare %.*s\n", LIT(dd->entity->token.string));
ir_fprintf(f, "; ");
ir_fprintf(f, "call void @llvm.dbg.declare(");
ir_fprintf(f, "metadata ");
ir_print_type(f, m, vt);
ir_fprintf(f, " ");
ir_print_value(f, m, dd->value, vt);
ir_fprintf(f, ", metadata !DILocalVariable(name: \"");
ir_print_escape_string(f, name, false);
ir_print_escape_string(f, name, false, false);
ir_fprintf(f, "\", scope: !%d, line: %td)", di->id, pos.line);
ir_fprintf(f, ", metadata !DIExpression()");
ir_fprintf(f, ")");
ir_fprintf(f, ", !dbg !DILocation(line: %td, column: %td, scope: !%d)", pos.line, pos.column, di->id);
ir_fprintf(f, "\n"); */
ir_fprintf(f, "\n");
} break;
}
}

7
src/parser.cpp
View File

@@ -2850,6 +2850,13 @@ AstNode *parse_unary_expr(AstFile *f, bool lhs) {
Token close = expect_token(f, Token_CloseParen);
return ast_type_cast(f, token, type, parse_unary_expr(f, lhs));
} break;
case Token_transmute: {
Token token = expect_token(f, Token_transmute);
Token open = expect_token_after(f, Token_OpenParen, "transmute");
AstNode *type = parse_type(f);
Token close = expect_token(f, Token_CloseParen);
return ast_type_cast(f, token, type, parse_unary_expr(f, lhs));
} break;
}
AstNode *operand = parse_operand(f, lhs);

1
src/tokenizer.cpp
View File

@@ -114,6 +114,7 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
TOKEN_KIND(Token_static, "static"), \
TOKEN_KIND(Token_dynamic, "dynamic"), \
TOKEN_KIND(Token_cast, "cast"), \
TOKEN_KIND(Token_transmute, "transmute"), \
TOKEN_KIND(Token_using, "using"), \
TOKEN_KIND(Token_context, "context"), \
TOKEN_KIND(Token_push_context, "push_context"), \

17
src/types.cpp
View File

@@ -2141,7 +2141,7 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) {
t = base_type(t);
if (t->kind == Type_Struct && !t->Struct.is_raw_union) {
if (t->kind == Type_Struct) {
type_set_offsets(allocator, t);
if (gb_is_between(index, 0, t->Struct.fields.count-1)) {
return t->Struct.offsets[index];
@@ -2155,7 +2155,7 @@ i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) {
if (t->Basic.kind == Basic_string) {
switch (index) {
case 0: return 0; // data
case 1: return build_context.word_size; // count
case 1: return build_context.word_size; // len
}
} else if (t->Basic.kind == Basic_any) {
switch (index) {
@@ -2166,16 +2166,21 @@ i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) {
} else if (t->kind == Type_Slice) {
switch (index) {
case 0: return 0; // data
case 1: return 1*build_context.word_size; // count
case 2: return 2*build_context.word_size; // capacity
case 1: return 1*build_context.word_size; // len
case 2: return 2*build_context.word_size; // cap
}
} else if (t->kind == Type_DynamicArray) {
switch (index) {
case 0: return 0; // data
case 1: return 1*build_context.word_size; // count
case 2: return 2*build_context.word_size; // capacity
case 1: return 1*build_context.word_size; // len
case 2: return 2*build_context.word_size; // cap
case 3: return 3*build_context.word_size; // allocator
}
} else if (t->kind == Type_Union) {
i64 s = type_size_of(allocator, t);
switch (index) {
case -1: return align_formula(t->Union.variant_block_size, build_context.word_size); // __type_info
}
}
return 0;
}