From 2c8958f4549d6076385d80c73f2830306728b081 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Mon, 4 Jan 2016 03:52:37 -0700 Subject: [PATCH] import segregation for types See #3 --- src/analyze.cpp | 33 ++++++++++++++++++++------------- src/analyze.hpp | 2 +- src/codegen.cpp | 35 ++++++++++++++++++----------------- 3 files changed, 39 insertions(+), 31 deletions(-) diff --git a/src/analyze.cpp b/src/analyze.cpp index bb56c171c7..8a30968376 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -142,15 +142,16 @@ TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool entry->data.pointer.child_type = child_type; entry->data.pointer.is_const = is_const; - g->type_table.put(&entry->name, entry); *parent_pointer = entry; return entry; } } -static TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) { +static TypeTableEntry *get_maybe_type(CodeGen *g, ImportTableEntry *import, TypeTableEntry *child_type) { if (child_type->maybe_parent) { - return child_type->maybe_parent; + TypeTableEntry *entry = child_type->maybe_parent; + import->type_table.put(&entry->name, entry); + return entry; } else { TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdMaybe); // create a struct with a boolean whether this is the null value @@ -193,16 +194,20 @@ static TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) { entry->data.maybe.child_type = child_type; - g->type_table.put(&entry->name, entry); + import->type_table.put(&entry->name, entry); child_type->maybe_parent = entry; return entry; } } -static TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, uint64_t array_size) { +static TypeTableEntry *get_array_type(CodeGen *g, ImportTableEntry *import, + TypeTableEntry *child_type, uint64_t array_size) +{ auto existing_entry = child_type->arrays_by_size.maybe_get(array_size); if (existing_entry) { - return existing_entry->value; + TypeTableEntry *entry = existing_entry->value; + import->type_table.put(&entry->name, entry); + return entry; } else { TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArray); entry->type_ref = LLVMArrayType(child_type->type_ref, array_size); @@ -217,7 +222,7 @@ static TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, ui entry->data.array.child_type = child_type; entry->data.array.len = array_size; - g->type_table.put(&entry->name, entry); + import->type_table.put(&entry->name, entry); child_type->arrays_by_size.put(array_size, entry); return entry; } @@ -231,7 +236,7 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry case AstNodeTypeTypePrimitive: { Buf *name = &node->data.type.primitive_name; - auto table_entry = g->type_table.maybe_get(name); + auto table_entry = import->type_table.maybe_get(name); if (table_entry) { type_node->entry = table_entry->value; } else { @@ -268,7 +273,8 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry if (size_node->type == NodeTypeNumberLiteral && is_num_lit_unsigned(size_node->data.number_literal.kind)) { - type_node->entry = get_array_type(g, child_type, size_node->data.number_literal.data.x_uint); + type_node->entry = get_array_type(g, import, child_type, + size_node->data.number_literal.data.x_uint); } else { add_node_error(g, size_node, buf_create_from_str("array size must be literal unsigned integer")); @@ -287,7 +293,7 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry } else if (child_type->id == TypeTableEntryIdInvalid) { return child_type; } - type_node->entry = get_maybe_type(g, child_type); + type_node->entry = get_maybe_type(g, import, child_type); return type_node->entry; } case AstNodeTypeTypeCompilerExpr: @@ -651,7 +657,7 @@ static void preview_types(CodeGen *g, ImportTableEntry *import, AstNode *node) { StructDeclNode *struct_codegen = &node->codegen_node->data.struct_decl_node; Buf *name = &node->data.struct_decl.name; - auto table_entry = g->type_table.maybe_get(name); + auto table_entry = import->type_table.maybe_get(name); if (table_entry) { struct_codegen->type_entry = table_entry->value; add_node_error(g, node, @@ -667,7 +673,7 @@ static void preview_types(CodeGen *g, ImportTableEntry *import, AstNode *node) { buf_init_from_buf(&entry->name, name); // put off adding the debug type until we do the full struct body // this type is incomplete until we do another pass - g->type_table.put(&entry->name, entry); + import->type_table.put(&entry->name, entry); struct_codegen->type_entry = entry; } break; @@ -1809,7 +1815,8 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import, if (node->data.string_literal.c) { return_type = g->builtin_types.entry_c_string_literal; } else { - return_type = get_array_type(g, g->builtin_types.entry_u8, buf_len(&node->data.string_literal.buf)); + return_type = get_array_type(g, import, g->builtin_types.entry_u8, + buf_len(&node->data.string_literal.buf)); } break; case NodeTypeCharLiteral: diff --git a/src/analyze.hpp b/src/analyze.hpp index 6d614f7928..85b5a73ba0 100644 --- a/src/analyze.hpp +++ b/src/analyze.hpp @@ -110,6 +110,7 @@ struct ImportTableEntry { // reminder: hash tables must be initialized before use HashMap fn_table; + HashMap type_table; }; struct LabelTableEntry { @@ -151,7 +152,6 @@ struct CodeGen { // reminder: hash tables must be initialized before use HashMap str_table; - HashMap type_table; HashMap link_table; HashMap import_table; diff --git a/src/codegen.cpp b/src/codegen.cpp index b929671eaf..4fe1373f92 100644 --- a/src/codegen.cpp +++ b/src/codegen.cpp @@ -20,7 +20,6 @@ CodeGen *codegen_create(Buf *root_source_dir) { CodeGen *g = allocate(1); g->str_table.init(32); - g->type_table.init(32); g->link_table.init(32); g->import_table.init(32); g->build_type = CodeGenBuildTypeDebug; @@ -1695,7 +1694,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_unsigned()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_bool = entry; } { @@ -1707,7 +1705,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_unsigned()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_u8 = entry; } { @@ -1720,7 +1717,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_unsigned()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_u16 = entry; } { @@ -1733,7 +1729,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_unsigned()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_u32 = entry; } { @@ -1746,7 +1741,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_unsigned()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_u64 = entry; } g->builtin_types.entry_c_string_literal = get_pointer_to_type(g, g->builtin_types.entry_u8, true); @@ -1760,7 +1754,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_signed()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_i8 = entry; } { @@ -1773,7 +1766,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_signed()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_i16 = entry; } { @@ -1786,7 +1778,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_signed()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_i32 = entry; } { @@ -1799,7 +1790,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_signed()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_i64 = entry; } { @@ -1812,7 +1802,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_signed()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_isize = entry; } { @@ -1825,7 +1814,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_unsigned()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_usize = entry; } { @@ -1837,7 +1825,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_float()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_f32 = entry; } { @@ -1849,7 +1836,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_float()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_f64 = entry; } { @@ -1859,7 +1845,6 @@ static void define_builtin_types(CodeGen *g) { entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name), entry->size_in_bits, entry->align_in_bits, LLVMZigEncoding_DW_ATE_unsigned()); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_void = entry; } { @@ -1867,7 +1852,6 @@ static void define_builtin_types(CodeGen *g) { entry->type_ref = LLVMVoidType(); buf_init_from_str(&entry->name, "unreachable"); entry->di_type = g->builtin_types.entry_void->di_type; - g->type_table.put(&entry->name, entry); g->builtin_types.entry_unreachable = entry; } { @@ -1903,7 +1887,6 @@ static void define_builtin_types(CodeGen *g) { "string", g->dummy_di_file, 0, entry->size_in_bits, entry->align_in_bits, 0, nullptr, di_element_types, element_count, 0, nullptr, ""); - g->type_table.put(&entry->name, entry); g->builtin_types.entry_string = entry; } } @@ -2033,6 +2016,24 @@ static ImportTableEntry *codegen_add_code(CodeGen *g, Buf *abs_full_path, import_entry->line_offsets = tokenization.line_offsets; import_entry->path = full_path; import_entry->fn_table.init(32); + import_entry->type_table.init(32); + import_entry->type_table.put(&g->builtin_types.entry_bool->name, g->builtin_types.entry_bool); + import_entry->type_table.put(&g->builtin_types.entry_u8->name, g->builtin_types.entry_u8); + import_entry->type_table.put(&g->builtin_types.entry_u16->name, g->builtin_types.entry_u16); + import_entry->type_table.put(&g->builtin_types.entry_u32->name, g->builtin_types.entry_u32); + import_entry->type_table.put(&g->builtin_types.entry_u64->name, g->builtin_types.entry_u64); + import_entry->type_table.put(&g->builtin_types.entry_i8->name, g->builtin_types.entry_i8); + import_entry->type_table.put(&g->builtin_types.entry_i16->name, g->builtin_types.entry_i16); + import_entry->type_table.put(&g->builtin_types.entry_i32->name, g->builtin_types.entry_i32); + import_entry->type_table.put(&g->builtin_types.entry_i64->name, g->builtin_types.entry_i64); + import_entry->type_table.put(&g->builtin_types.entry_isize->name, g->builtin_types.entry_isize); + import_entry->type_table.put(&g->builtin_types.entry_usize->name, g->builtin_types.entry_usize); + import_entry->type_table.put(&g->builtin_types.entry_f32->name, g->builtin_types.entry_f32); + import_entry->type_table.put(&g->builtin_types.entry_f64->name, g->builtin_types.entry_f64); + import_entry->type_table.put(&g->builtin_types.entry_void->name, g->builtin_types.entry_void); + import_entry->type_table.put(&g->builtin_types.entry_unreachable->name, g->builtin_types.entry_unreachable); + import_entry->type_table.put(&g->builtin_types.entry_string->name, g->builtin_types.entry_string); + import_entry->root = ast_parse(source_code, tokenization.tokens, import_entry, g->err_color); assert(import_entry->root); if (g->verbose) {