From 6cbb6bef0b817ba24ccbbf68d6192567bdc246ad Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Thu, 22 Jun 2017 16:14:02 +0100 Subject: [PATCH] Wrap hashing functions --- src/check_expr.cpp | 6 ++++- src/check_stmt.cpp | 2 +- src/checker.cpp | 66 ++++++++++++++++++++++++---------------------- src/ir.cpp | 29 ++++++++------------ src/map.cpp | 16 +++++------ 5 files changed, 59 insertions(+), 60 deletions(-) diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 317822b84..c8366422f 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -1321,6 +1321,10 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) { Type *new_type = original_type; + if (build_context.ODIN_ARCH == "x86") { + return new_type; + } + if (build_context.ODIN_OS == "windows") { // NOTE(bill): Changing the passing parameter value type is to match C's ABI // IMPORTANT TODO(bill): This only matches the ABI on MSVC at the moment @@ -3491,7 +3495,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h } // NOTE(bill): Check to see if it's imported - if (map_get(&import_scope->implicit, hash_pointer(procs[i]))) { + if (map_get(&import_scope->implicit, hash_entity(procs[i]))) { gb_swap(Entity *, procs[i], procs[overload_count-1]); overload_count--; i--; // NOTE(bill): Counteract the post event diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 3337aa13b..104733e67 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1489,7 +1489,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { GB_PANIC("Unknown type to type match statement"); } - HashKey key = hash_pointer(y.type); + HashKey key = hash_type(y.type); bool *found = map_get(&seen, key); if (found) { TokenPos pos = cc->token.pos; diff --git a/src/checker.cpp b/src/checker.cpp index 5e9572cdd..c2318f9d2 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -302,11 +302,12 @@ struct Checker { }; -struct DelayedEntity { - AstNode * ident; - Entity * entity; - DeclInfo * decl; -}; + +HashKey hash_node (AstNode *node) { return hash_ptr_and_id(node, 0); } +HashKey hash_ast_file (AstFile *file) { return hash_pointer(file); } +HashKey hash_entity (Entity *e) { return hash_pointer(e); } +HashKey hash_type (Type *t) { return hash_pointer(t); } +HashKey hash_decl_info(DeclInfo *decl) { return hash_pointer(decl); } // CheckerInfo API TypeAndValue type_and_value_of_expr (CheckerInfo *i, AstNode *expr); @@ -404,10 +405,11 @@ void destroy_scope(Scope *scope) { // NOTE(bill): No need to free scope as it "should" be allocated in an arena (except for the global scope) } + void add_scope(Checker *c, AstNode *node, Scope *scope) { GB_ASSERT(node != NULL); GB_ASSERT(scope != NULL); - map_set(&c->info.scopes, hash_pointer(node), scope); + map_set(&c->info.scopes, hash_node(node), scope); } @@ -578,7 +580,7 @@ void check_scope_usage(Checker *c, Scope *scope) { void add_dependency(DeclInfo *d, Entity *e) { - map_set(&d->deps, hash_pointer(e), cast(bool)true); + map_set(&d->deps, hash_entity(e), cast(bool)true); } void add_declaration_dependency(Checker *c, Entity *e) { @@ -586,7 +588,7 @@ void add_declaration_dependency(Checker *c, Entity *e) { return; } if (c->context.decl != NULL) { - DeclInfo **found = map_get(&c->info.entities, hash_pointer(e)); + DeclInfo **found = map_get(&c->info.entities, hash_entity(e)); if (found) { add_dependency(c->context.decl, e); } @@ -772,11 +774,11 @@ void destroy_checker(Checker *c) { Entity *entity_of_ident(CheckerInfo *i, AstNode *identifier) { if (identifier->kind == AstNode_Ident) { - Entity **found = map_get(&i->definitions, hash_pointer(identifier)); + Entity **found = map_get(&i->definitions, hash_node(identifier)); if (found) { return *found; } - found = map_get(&i->uses, hash_pointer(identifier)); + found = map_get(&i->uses, hash_node(identifier)); if (found) { return *found; } @@ -786,7 +788,7 @@ Entity *entity_of_ident(CheckerInfo *i, AstNode *identifier) { TypeAndValue type_and_value_of_expr(CheckerInfo *i, AstNode *expr) { TypeAndValue result = {}; - TypeAndValue *found = map_get(&i->types, hash_pointer(expr)); + TypeAndValue *found = map_get(&i->types, hash_node(expr)); if (found) result = *found; return result; } @@ -807,7 +809,7 @@ Type *type_of_expr(CheckerInfo *i, AstNode *expr) { } Entity *implicit_entity_of_node(CheckerInfo *i, AstNode *clause) { - Entity **found = map_get(&i->implicits, hash_pointer(clause)); + Entity **found = map_get(&i->implicits, hash_node(clause)); if (found != NULL) { return *found; } @@ -815,13 +817,13 @@ Entity *implicit_entity_of_node(CheckerInfo *i, AstNode *clause) { } bool is_entity_implicitly_imported(Entity *import_name, Entity *e) { GB_ASSERT(import_name->kind == Entity_ImportName); - return map_get(&import_name->ImportName.scope->implicit, hash_pointer(e)) != NULL; + return map_get(&import_name->ImportName.scope->implicit, hash_entity(e)) != NULL; } DeclInfo *decl_info_of_entity(CheckerInfo *i, Entity *e) { if (e != NULL) { - DeclInfo **found = map_get(&i->entities, hash_pointer(e)); + DeclInfo **found = map_get(&i->entities, hash_entity(e)); if (found != NULL) { return *found; } @@ -841,20 +843,20 @@ AstFile *ast_file_of_filename(CheckerInfo *i, String filename) { return NULL; } Scope *scope_of_node(CheckerInfo *i, AstNode *node) { - Scope **found = map_get(&i->scopes, hash_pointer(node)); + Scope **found = map_get(&i->scopes, hash_node(node)); if (found) { return *found; } return NULL; } ExprInfo *check_get_expr_info(CheckerInfo *i, AstNode *expr) { - return map_get(&i->untyped, hash_pointer(expr)); + return map_get(&i->untyped, hash_node(expr)); } void check_set_expr_info(CheckerInfo *i, AstNode *expr, ExprInfo info) { - map_set(&i->untyped, hash_pointer(expr), info); + map_set(&i->untyped, hash_node(expr), info); } void check_remove_expr_info(CheckerInfo *i, AstNode *expr) { - map_remove(&i->untyped, hash_pointer(expr)); + map_remove(&i->untyped, hash_node(expr)); } @@ -863,7 +865,7 @@ isize type_info_index(CheckerInfo *info, Type *type) { type = default_type(type); isize entry_index = -1; - HashKey key = hash_pointer(type); + HashKey key = hash_type(type); isize *found_entry_index = map_get(&info->type_info_map, key); if (found_entry_index) { entry_index = *found_entry_index; @@ -891,7 +893,7 @@ isize type_info_index(CheckerInfo *info, Type *type) { void add_untyped(CheckerInfo *i, AstNode *expression, bool lhs, AddressingMode mode, Type *basic_type, ExactValue value) { - map_set(&i->untyped, hash_pointer(expression), make_expr_info(lhs, mode, basic_type, value)); + map_set(&i->untyped, hash_node(expression), make_expr_info(lhs, mode, basic_type, value)); } void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode, Type *type, ExactValue value) { @@ -918,7 +920,7 @@ void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode tv.type = type; tv.value = value; tv.mode = mode; - map_set(&i->types, hash_pointer(expression), tv); + map_set(&i->types, hash_node(expression), tv); } void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity) { @@ -927,7 +929,7 @@ void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity) if (identifier->Ident.string == "_") { return; } - HashKey key = hash_pointer(identifier); + HashKey key = hash_node(identifier); map_set(&i->definitions, key, entity); } else { // NOTE(bill): Error should handled elsewhere @@ -977,7 +979,7 @@ void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) { if (identifier->kind != AstNode_Ident) { return; } - HashKey key = hash_pointer(identifier); + HashKey key = hash_node(identifier); map_set(&c->info.uses, key, entity); add_declaration_dependency(c, entity); // TODO(bill): Should this be here? } @@ -988,14 +990,14 @@ void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclIn GB_ASSERT(e != NULL && d != NULL); GB_ASSERT(identifier->Ident.string == e->token.string); add_entity(c, e->scope, identifier, e); - map_set(&c->info.entities, hash_pointer(e), d); + map_set(&c->info.entities, hash_entity(e), d); } void add_implicit_entity(Checker *c, AstNode *node, Entity *e) { GB_ASSERT(node != NULL); GB_ASSERT(e != NULL); - map_set(&c->info.implicits, hash_pointer(node), e); + map_set(&c->info.implicits, hash_node(node), e); } @@ -1014,7 +1016,7 @@ void add_type_info_type(Checker *c, Type *t) { return; // Could be nil } - if (map_get(&c->info.type_info_map, hash_pointer(t)) != NULL) { + if (map_get(&c->info.type_info_map, hash_type(t)) != NULL) { // Types have already been added return; } @@ -1035,7 +1037,7 @@ void add_type_info_type(Checker *c, Type *t) { ti_index = c->info.type_info_count; c->info.type_info_count++; } - map_set(&c->info.type_info_map, hash_pointer(t), ti_index); + map_set(&c->info.type_info_map, hash_type(t), ti_index); @@ -1153,7 +1155,7 @@ void check_procedure_later(Checker *c, AstFile *file, Token token, DeclInfo *dec info.type = type; info.body = body; info.tags = tags; - map_set(&c->procs, hash_pointer(decl), info); + map_set(&c->procs, hash_decl_info(decl), info); } void push_procedure(Checker *c, Type *type) { @@ -1188,10 +1190,10 @@ void add_dependency_to_map(Map *map, CheckerInfo *info, Entity *entity if (entity == NULL) { return; } - if (map_get(map, hash_pointer(entity)) != NULL) { + if (map_get(map, hash_entity(entity)) != NULL) { return; } - map_set(map, hash_pointer(entity), entity); + map_set(map, hash_entity(entity), entity); DeclInfo *decl = decl_info_of_entity(info, entity); @@ -1230,7 +1232,7 @@ Map generate_minimum_dependency_map(CheckerInfo *info, Entity *start) } bool is_entity_in_dependency_map(Map *map, Entity *e) { - return map_get(map, hash_pointer(e)) != NULL; + return map_get(map, hash_entity(e)) != NULL; } @@ -2097,7 +2099,7 @@ void check_import_entities(Checker *c, Map *file_scopes) { // 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_pointer(e), true); + map_set(&parent_scope->implicit, hash_entity(e), true); } } } else { diff --git a/src/ir.cpp b/src/ir.cpp index b9a2029d9..dc1bd2142 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -813,7 +813,7 @@ String ir_get_global_name(irModule *m, irValue *v) { irValueGlobal *g = &v->Global; Entity *e = g->entity; String name = e->token.string; - String *found = map_get(&m->entity_names, hash_pointer(e)); + String *found = map_get(&m->entity_names, hash_entity(e)); if (found != NULL) { name = *found; } @@ -1274,7 +1274,7 @@ irValue *ir_add_local(irProcedure *proc, Entity *e, AstNode *expr) { // } if (expr != NULL && proc->entity != NULL) { - irDebugInfo *di = *map_get(&proc->module->debug_info, hash_pointer(proc->entity)); + irDebugInfo *di = *map_get(&proc->module->debug_info, hash_entity(proc->entity)); ir_emit(proc, ir_instr_debug_declare(proc, di, expr, e, true, instr)); } @@ -1406,7 +1406,7 @@ irDebugInfo *ir_add_debug_info_file(irProcedure *proc, AstFile *file) { di->File.filename = filename; di->File.directory = directory; - map_set(&proc->module->debug_info, hash_pointer(file), di); + map_set(&proc->module->debug_info, hash_ast_file(file), di); return di; } @@ -1423,7 +1423,7 @@ irDebugInfo *ir_add_debug_info_proc(irProcedure *proc, Entity *entity, String na di->Proc.file = file; di->Proc.pos = entity->token.pos; - map_set(&proc->module->debug_info, hash_pointer(entity), di); + map_set(&proc->module->debug_info, hash_entity(entity), di); return di; } @@ -3539,7 +3539,7 @@ void ir_mangle_add_sub_type_name(irModule *m, Entity *field, String parent) { "%.*s.%.*s", LIT(parent), LIT(cn)); String child = {text, new_name_len-1}; - map_set(&m->entity_names, hash_pointer(field), child); + map_set(&m->entity_names, hash_entity(field), child); ir_gen_global_type_name(m, field, child); } @@ -4387,7 +4387,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { return ir_value_nil(proc->module->allocator, tv.type); } - irValue **found = map_get(&proc->module->values, hash_pointer(e)); + irValue **found = map_get(&proc->module->values, hash_entity(e)); if (found) { irValue *v = *found; if (v->kind == irValue_Proc) { @@ -4795,7 +4795,7 @@ irValue *ir_get_using_variable(irProcedure *proc, Entity *e) { Entity *parent = e->using_parent; Selection sel = lookup_field(proc->module->allocator, parent->type, name, false); GB_ASSERT(sel.entity != NULL); - irValue **pv = map_get(&proc->module->values, hash_pointer(parent)); + irValue **pv = map_get(&proc->module->values, hash_entity(parent)); irValue *v = NULL; if (pv != NULL) { v = *pv; @@ -4808,13 +4808,6 @@ irValue *ir_get_using_variable(irProcedure *proc, Entity *e) { return ir_emit_deep_field_gep(proc, v, sel); } -// irValue *ir_add_using_variable(irProcedure *proc, Entity *e) { -// irValue *var = ir_get_using_variable(proc, e); -// map_set(&proc->module->values, hash_pointer(e), var); -// return var; -// } - - bool ir_is_elem_const(irModule *m, AstNode *elem, Type *elem_type) { if (base_type(elem_type) == t_any) { return false; @@ -4832,7 +4825,7 @@ irAddr ir_build_addr_from_entity(irProcedure *proc, Entity *e, AstNode *expr) { GB_ASSERT(e->kind != Entity_Constant); irValue *v = NULL; - irValue **found = map_get(&proc->module->values, hash_pointer(e)); + irValue **found = map_get(&proc->module->values, hash_entity(e)); if (found) { v = *found; } else if (e->kind == Entity_Variable && e->flags & EntityFlag_Using) { @@ -5942,7 +5935,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { irValue *value = ir_value_type_name(proc->module->allocator, name, e->type); - map_set(&proc->module->entity_names, hash_pointer(e), name); + map_set(&proc->module->entity_names, hash_entity(e), name); ir_gen_global_type_name(proc->module, e, name); } } break; @@ -6959,7 +6952,7 @@ void ir_build_proc(irValue *value, irProcedure *parent) { AstFile *f = ast_file_of_filename(info, filename); irDebugInfo *di_file = NULL; - irDebugInfo **di_file_found = map_get(&m->debug_info, hash_pointer(f)); + irDebugInfo **di_file_found = map_get(&m->debug_info, hash_ast_file(f)); if (di_file_found) { di_file = *di_file_found; GB_ASSERT(di_file->kind == irDebugInfo_File); @@ -7011,7 +7004,7 @@ void ir_build_proc(irValue *value, irProcedure *parent) { void ir_module_add_value(irModule *m, Entity *e, irValue *v) { - map_set(&m->values, hash_pointer(e), v); + map_set(&m->values, hash_entity(e), v); } void ir_init_module(irModule *m, Checker *c) { diff --git a/src/map.cpp b/src/map.cpp index 5ff296e7b..7732bcfe4 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -14,11 +14,11 @@ struct MapFindResult { enum HashKeyKind { HashKey_Default, HashKey_String, - HashKey_Pointer, - HashKey_PointerAndId, + HashKey_Ptr, + HashKey_PtrAndId, }; -struct PointerAndId { +struct PtrAndId { void *ptr; u32 id; }; @@ -30,7 +30,7 @@ struct HashKey { union { String string; // if String, s.len > 0 void * ptr; - PointerAndId ptr_and_id; + PtrAndId ptr_and_id; }; }; @@ -51,13 +51,13 @@ gb_inline HashKey hash_string(String s) { } gb_inline HashKey hash_pointer(void *ptr) { - HashKey h = {HashKey_Pointer}; + HashKey h = {HashKey_Ptr}; h.key = cast(u64)cast(uintptr)ptr; h.ptr = ptr; return h; } gb_inline HashKey hash_ptr_and_id(void *ptr, u32 id) { - HashKey h = {HashKey_PointerAndId}; + HashKey h = {HashKey_PtrAndId}; h.key = cast(u64)cast(uintptr)ptr; h.ptr_and_id.ptr = ptr; h.ptr_and_id.id = id; @@ -72,8 +72,8 @@ bool hash_key_equal(HashKey a, HashKey b) { return a.string == b.string; } return false; - } else if (a.kind == HashKey_PointerAndId) { - if (b.kind == HashKey_PointerAndId) { + } else if (a.kind == HashKey_PtrAndId) { + if (b.kind == HashKey_PtrAndId) { return a.ptr_and_id.id == b.ptr_and_id.id; } return false;