diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/check_expr.cpp | 172 | ||||
| -rw-r--r-- | src/ir.cpp | 93 |
2 files changed, 174 insertions, 91 deletions
diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 3d4dd9147..e69f45434 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -1233,7 +1233,82 @@ bool check_custom_align(Checker *c, AstNode *node, i64 *align_) { return false; } -void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Operand> *poly_operands) { + +Entity *find_polymorphic_struct_entity(Checker *c, Type *original_type, isize param_count, Array<Operand> ordered_operands) { + auto *found_gen_types = map_get(&c->info.gen_types, hash_pointer(original_type)); + + if (found_gen_types != nullptr) { + for_array(i, *found_gen_types) { + Entity *e = (*found_gen_types)[i]; + Type *t = base_type(e->type); + TypeTuple *tuple = &t->Struct.polymorphic_params->Tuple; + bool ok = true; + GB_ASSERT(param_count == tuple->variables.count); + for (isize j = 0; j < param_count; j++) { + Entity *p = tuple->variables[j]; + Operand o = ordered_operands[j]; + if (p->kind == Entity_TypeName) { + if (is_type_polymorphic(o.type)) { + // NOTE(bill): Do not add polymorphic version to the gen_types + ok = false; + } + if (!are_types_identical(o.type, p->type)) { + ok = false; + } + } else if (p->kind == Entity_Constant) { + if (!are_types_identical(o.type, p->type)) { + ok = false; + } + if (!compare_exact_values(Token_CmpEq, o.value, p->Constant.value)) { + ok = false; + } + } else { + GB_PANIC("Unknown entity kind"); + } + } + if (ok) { + return e; + } + } + } + return nullptr; +} + + +void add_polymorphic_struct_entity(Checker *c, AstNode *node, Type *original_type, Type *named_type) { + GB_ASSERT(is_type_named(named_type)); + gbAllocator a = heap_allocator(); + + Entity *e = nullptr; + { + Token token = ast_node_token(node); + token.kind = Token_String; + token.string = named_type->Named.name; + + AstNode *node = gb_alloc_item(a, AstNode); + node->kind = AstNode_Ident; + node->Ident.token = token; + + e = make_entity_type_name(a, c->context.scope, token, named_type); + add_entity(c, c->context.scope, node, e); + add_entity_use(c, node, e); + } + + named_type->Named.type_name = e; + + + auto *found_gen_types = map_get(&c->info.gen_types, hash_pointer(original_type)); + if (found_gen_types) { + array_add(found_gen_types, e); + } else { + Array<Entity *> array = {}; + array_init(&array, heap_allocator()); + array_add(&array, e); + map_set(&c->info.gen_types, hash_pointer(original_type), array); + } +} + +void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Operand> *poly_operands, Type *named_type = nullptr) { GB_ASSERT(is_type_struct(struct_type)); ast_node(st, StructType, node); @@ -1402,20 +1477,21 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera } } + struct_type->Struct.scope = c->context.scope; + struct_type->Struct.is_packed = st->is_packed; + struct_type->Struct.is_ordered = st->is_ordered; + struct_type->Struct.polymorphic_params = polymorphic_params; + struct_type->Struct.is_polymorphic = is_polymorphic; + struct_type->Struct.is_poly_specialized = is_poly_specialized; + Array<Entity *> fields = {}; if (!is_polymorphic) { fields = check_struct_fields(c, node, st->fields, min_field_count, context); } - struct_type->Struct.scope = c->context.scope; - struct_type->Struct.is_packed = st->is_packed; - struct_type->Struct.is_ordered = st->is_ordered; struct_type->Struct.fields = fields; struct_type->Struct.fields_in_src_order = fields; - struct_type->Struct.polymorphic_params = polymorphic_params; - struct_type->Struct.is_polymorphic = is_polymorphic; - struct_type->Struct.is_poly_specialized = is_poly_specialized; if (!struct_type->Struct.is_raw_union) { @@ -3107,7 +3183,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) *type = make_type_struct(c->allocator); set_base_type(named_type, *type); check_open_scope(c, e); - check_struct_type(c, *type, e, nullptr); + check_struct_type(c, *type, e, nullptr, named_type); check_close_scope(c); (*type)->Struct.node = e; return true; @@ -6907,85 +6983,27 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As // TODO(bill): Check for previous types gbAllocator a = c->allocator; - auto *found_gen_types = map_get(&c->info.gen_types, hash_pointer(original_type)); - - if (found_gen_types != nullptr) { - for_array(i, *found_gen_types) { - Entity *e = (*found_gen_types)[i]; - Type *t = base_type(e->type); - TypeTuple *tuple = &t->Struct.polymorphic_params->Tuple; - bool ok = true; - GB_ASSERT(param_count == tuple->variables.count); - for (isize j = 0; j < param_count; j++) { - Entity *p = tuple->variables[j]; - Operand o = ordered_operands[j]; - if (p->kind == Entity_TypeName) { - if (is_type_polymorphic(o.type)) { - // NOTE(bill): Do not add polymorphic version to the gen_types - ok = false; - } - if (!are_types_identical(o.type, p->type)) { - ok = false; - } - } else if (p->kind == Entity_Constant) { - if (!are_types_identical(o.type, p->type)) { - ok = false; - } - if (!compare_exact_values(Token_CmpEq, o.value, p->Constant.value)) { - ok = false; - } - } else { - GB_PANIC("Unknown entity kind"); - } - } - if (ok) { - operand->mode = Addressing_Type; - operand->type = e->type; - return err; - } - } + Entity *found_entity = find_polymorphic_struct_entity(c, original_type, param_count, ordered_operands); + if (found_entity) { + operand->mode = Addressing_Type; + operand->type = found_entity->type; + return err; } String generated_name = make_string_c(expr_to_string(call)); Type *named_type = make_type_named(a, generated_name, nullptr, nullptr); - Type *struct_type = make_type_struct(a); AstNode *node = clone_ast_node(a, st->node); - set_base_type(named_type, struct_type); - check_open_scope(c, node); - check_struct_type(c, struct_type, node, &ordered_operands); - check_close_scope(c); + Type *struct_type = make_type_struct(a); struct_type->Struct.node = node; struct_type->Struct.polymorphic_parent = original_type; + set_base_type(named_type, struct_type); - Entity *e = nullptr; - - { - Token token = ast_node_token(node); - token.kind = Token_String; - token.string = generated_name; - - AstNode *node = gb_alloc_item(a, AstNode); - node->kind = AstNode_Ident; - node->Ident.token = token; - - e = make_entity_type_name(a, st->scope->parent, token, named_type); - add_entity(c, st->scope->parent, node, e); - add_entity_use(c, node, e); - } - - named_type->Named.type_name = e; + check_open_scope(c, node); + check_struct_type(c, struct_type, node, &ordered_operands, named_type); + check_close_scope(c); - if (!struct_type->Struct.is_polymorphic) { - if (found_gen_types) { - array_add(found_gen_types, e); - } else { - Array<Entity *> array = {}; - array_init(&array, heap_allocator()); - array_add(&array, e); - map_set(&c->info.gen_types, hash_pointer(original_type), array); - } - } + add_polymorphic_struct_entity(c, node, original_type, named_type); operand->mode = Addressing_Type; operand->type = named_type; diff --git a/src/ir.cpp b/src/ir.cpp index 743e97071..4901de4ca 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -7276,11 +7276,11 @@ void ir_end_procedure_body(irProcedure *proc) { void ir_insert_code_before_proc(irProcedure* proc, irProcedure *parent) { - if (parent == nullptr) { - if (proc->name == "main") { - ir_emit_startup_runtime(proc); - } - } + // if (parent == nullptr) { + // if (proc->name == "main") { + // ir_emit_startup_runtime(proc); + // } + // } } void ir_build_proc(irValue *value, irProcedure *parent) { @@ -7728,7 +7728,7 @@ void ir_gen_tree(irGen *s) { if (e->kind == Entity_Procedure && (e->Procedure.tags & ProcTag_export) != 0) { } else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) { // Handle later - } else if (scope->is_init && e->kind == Entity_Procedure && name == "main") { + // } else if (scope->is_init && e->kind == Entity_Procedure && name == "main") { } else { name = ir_mangle_name(s, e->token.pos.file, e); } @@ -7807,7 +7807,7 @@ void ir_gen_tree(irGen *s) { #if defined(GB_SYSTEM_WINDOWS) if (build_context.is_dll && !has_dll_main) { - // proc DllMain(inst: rawptr, reason: u32, reserved: rawptr) -> i32 + // DllMain :: proc(inst: rawptr, reason: u32, reserved: rawptr) -> i32 String name = str_lit("DllMain"); Type *proc_params = make_type_tuple(a); Type *proc_results = make_type_tuple(a); @@ -7840,7 +7840,7 @@ void ir_gen_tree(irGen *s) { Entity *e = make_entity_procedure(a, nullptr, make_token_ident(name), proc_type, 0); irValue *p = ir_value_procedure(a, m, e, proc_type, nullptr, body, name); - map_set(&m->values, hash_pointer(e), p); + map_set(&m->values, hash_entity(e), p); map_set(&m->members, hash_string(name), p); irProcedure *proc = &p->Proc; @@ -7860,12 +7860,10 @@ void ir_gen_tree(irGen *s) { ir_start_block(proc, then); { - String main_name = str_lit("main"); - irValue **found = map_get(&m->members, hash_string(main_name)); + irValue **found = map_get(&m->values, hash_entity(entry_point)); + ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime)); if (found != nullptr) { ir_emit_call(proc, *found, nullptr, 0); - } else { - ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime)); } } @@ -7878,6 +7876,73 @@ void ir_gen_tree(irGen *s) { ir_end_procedure_body(proc); } #endif + if (!(build_context.is_dll && !has_dll_main)) { + // main :: proc(argc: i32, argv: ^^u8) -> i32 + String name = str_lit("main"); + Type *proc_params = make_type_tuple(a); + Type *proc_results = make_type_tuple(a); + + Scope *proc_scope = gb_alloc_item(a, Scope); + + array_init_count(&proc_params->Tuple.variables, a, 2); + array_init_count(&proc_results->Tuple.variables, a, 1); + + Type *char_ptr_ptr = make_type_pointer(a, make_type_pointer(a, t_u8)); + proc_params->Tuple.variables[0] = make_entity_param(a, proc_scope, make_token_ident(str_lit("argc")), t_i32, false, false); + proc_params->Tuple.variables[1] = make_entity_param(a, proc_scope, make_token_ident(str_lit("argv")), char_ptr_ptr, false, false); + + + proc_results->Tuple.variables[0] = make_entity_param(a, proc_scope, empty_token, t_i32, false, false); + + + Type *proc_type = make_type_proc(a, proc_scope, + proc_params, 2, + proc_results, 1, false, ProcCC_C); + + // TODO(bill): make this more robust + proc_type->Proc.abi_compat_params = gb_alloc_array(a, Type *, proc_params->Tuple.variables.count); + for_array(i, proc_params->Tuple.variables) { + proc_type->Proc.abi_compat_params[i] = proc_params->Tuple.variables[i]->type; + } + proc_type->Proc.abi_compat_result_type = proc_results->Tuple.variables[0]->type; + + AstNode *body = gb_alloc_item(a, AstNode); + Entity *e = make_entity_procedure(a, nullptr, make_token_ident(name), proc_type, 0); + irValue *p = ir_value_procedure(a, m, e, proc_type, nullptr, body, name); + + map_set(&m->values, hash_entity(e), p); + map_set(&m->members, hash_string(name), p); + + irProcedure *proc = &p->Proc; + proc->tags = ProcTag_no_inline; // TODO(bill): is no_inline a good idea? + e->Procedure.link_name = name; + + ir_begin_procedure_body(proc); + + // NOTE(bill): https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx + // DLL_PROCESS_ATTACH == 1 + + irValue *argc = ir_emit_load(proc, *map_get(&proc->module->values, hash_entity(proc_params->Tuple.variables[0]))); + irValue *argv = ir_emit_load(proc, *map_get(&proc->module->values, hash_entity(proc_params->Tuple.variables[1]))); + + irValue *global_argc = ir_find_global_variable(proc, str_lit("__argc__")); + irValue *global_argv = ir_find_global_variable(proc, str_lit("__argv__")); + + ir_emit_store(proc, global_argc, argc); + ir_emit_store(proc, global_argv, argv); + + ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime)); + { + irValue **found = map_get(&proc->module->values, hash_entity(entry_point)); + if (found != nullptr) { + ir_emit_call(proc, *found, nullptr, 0); + } + } + + ir_emit_return(proc, v_zero32); + ir_end_procedure_body(proc); + } + #if 0 && defined(GB_SYSTEM_WINDOWS) if (!m->build_context->is_dll && !has_win_main) { // proc WinMain(inst, prev: rawptr, cmd_line: ^byte, cmd_show: i32) -> i32 @@ -7911,7 +7976,7 @@ void ir_gen_tree(irGen *s) { m->entry_point_entity = e; - map_set(&m->values, hash_pointer(e), p); + map_set(&m->values, hash_entity(e), p); map_set(&m->members, hash_string(name), p); irProcedure *proc = &p->Proc; @@ -7935,7 +8000,7 @@ void ir_gen_tree(irGen *s) { Entity *e = make_entity_procedure(a, nullptr, make_token_ident(name), proc_type, 0); irValue *p = ir_value_procedure(a, m, e, proc_type, nullptr, body, name); - map_set(&m->values, hash_pointer(e), p); + map_set(&m->values, hash_entity(e), p); map_set(&m->members, hash_string(name), p); |