Global linkage WIP

Author: LesleyLai

include/mcc/ast.h

@@ -229,12 +229,8 @@ typedef struct BlockItem {
 typedef struct TranslationUnit {
   uint32_t decl_count;
   Decl* decls;
-  Scope* global_scope;
 
-  // Besides stored in the scopes, the identifiers of functions in a translation
-  // unit are also refered to in a separate hash table. This is useful because
-  // each named only map to one instance of a function no matter the scope
-  HashMap functions;
+  struct SymbolTable* symbol_table;
 } TranslationUnit;
 
 StringView string_from_ast(const TranslationUnit* tu, Arena* permanent_arena);

src/frontend/parser.c

@@ -29,8 +29,7 @@ typedef struct Parser {
 
   struct ErrorVec errors;
 
-  struct Scope* global_scope;
-  HashMap functions;
+  SymbolTable* symbol_table;
 } Parser;
 
 #pragma region source range operations
@@ -627,8 +626,9 @@ static VariableDecl parse_variable_decl(Parser* parser,
 {
   const StringView name = str_from_token(parser->src, name_token);
   // TODO: handle different linkages
-  IdentifierInfo* variable = add_identifier(
-      scope, name, IDENT_OBJECT, LINKAGE_NONE, parser->permanent_arena);
+  IdentifierInfo* variable =
+      add_identifier(parser->symbol_table, scope, name, IDENT_OBJECT,
+                     LINKAGE_NONE, parser->permanent_arena);
   if (!variable) {
     const StringView error_msg =
         allocate_printf(parser->permanent_arena, "redefinition of '%.*s'",
@@ -937,8 +937,9 @@ static IdentifierInfo* parse_parameter(Parser* parser, Scope* scope)
       parse_advance(parser);
     }
 
-    IdentifierInfo* name = add_identifier(
-        scope, identifier, IDENT_OBJECT, LINKAGE_NONE, parser->permanent_arena);
+    IdentifierInfo* name =
+        add_identifier(parser->symbol_table, scope, identifier, IDENT_OBJECT,
+                       LINKAGE_NONE, parser->permanent_arena);
     // TODO: error handling
     MCC_ASSERT(name != nullptr);
     return name;
@@ -1006,8 +1007,9 @@ static FunctionDecl* parse_function_decl(Parser* parser,
                                          Token name_token, Scope* scope)
 {
   StringView name = str_from_token(parser->src, name_token);
-  IdentifierInfo* function_ident = add_identifier(
-      scope, name, IDENT_FUNCTION, LINKAGE_EXTERNAL, parser->permanent_arena);
+  IdentifierInfo* function_ident =
+      add_identifier(parser->symbol_table, scope, name, IDENT_FUNCTION,
+                     LINKAGE_EXTERNAL, parser->permanent_arena);
 
   if (!function_ident) {
     function_ident = lookup_identifier(scope, name);
@@ -1021,11 +1023,8 @@ static FunctionDecl* parse_function_decl(Parser* parser,
     }
   }
 
-  hashmap_try_insert(&parser->functions, name, function_ident,
-                     parser->permanent_arena);
-
   Scope* function_scope =
-      new_scope(parser->global_scope, parser->permanent_arena);
+      new_scope(parser->symbol_table->global_scope, parser->permanent_arena);
   const Parameters parameters = parse_parameter_list(parser, function_scope);
 
   Block* body = NULL;
@@ -1065,7 +1064,7 @@ static TranslationUnit* parse_translation_unit(Parser* parser)
   struct DeclVec decl_vec = {};
 
   while (parser_current_token(parser).tag != TOKEN_EOF) {
-    Decl decl = parse_decl(parser, parser->global_scope);
+    Decl decl = parse_decl(parser, parser->symbol_table->global_scope);
     DYNARRAY_PUSH_BACK(&decl_vec, Decl, &parser->scratch_arena, decl);
   }
 
@@ -1077,12 +1076,9 @@ static TranslationUnit* parse_translation_unit(Parser* parser)
 
   TranslationUnit* tu =
       ARENA_ALLOC_OBJECT(parser->permanent_arena, TranslationUnit);
-  *tu = (TranslationUnit){
-      .decl_count = decl_count,
-      .decls = decls,
-      .global_scope = parser->global_scope,
-      .functions = parser->functions,
-  };
+  *tu = (TranslationUnit){.decl_count = decl_count,
+                          .decls = decls,
+                          .symbol_table = parser->symbol_table};
   parse_consume(parser, TOKEN_EOF, "Expect end of the file");
 
   return tu;
@@ -1091,12 +1087,17 @@ static TranslationUnit* parse_translation_unit(Parser* parser)
 ParseResult parse(const char* src, Tokens tokens, Arena* permanent_arena,
                   Arena scratch_arena)
 {
+  SymbolTable* symbol_table = ARENA_ALLOC_OBJECT(permanent_arena, SymbolTable);
+  *symbol_table = (SymbolTable){
+      .global_symbols = (HashMap){},
+      .global_scope = new_scope(nullptr, permanent_arena),
+  };
+
   Parser parser = {.src = src,
                    .tokens = tokens,
                    .permanent_arena = permanent_arena,
                    .scratch_arena = scratch_arena,
-                   .global_scope = new_scope(nullptr, permanent_arena),
-                   .functions = (HashMap){}};
+                   .symbol_table = symbol_table};
 
   TranslationUnit* tu = parse_translation_unit(&parser);
 

src/frontend/symbol_table.c

@@ -27,10 +27,11 @@ IdentifierInfo* lookup_identifier(const Scope* scope, StringView name)
   return lookup_identifier(scope->parent, name);
 }
 
-IdentifierInfo* add_identifier(Scope* scope, StringView name,
-                               IdentifierKind kind, Linkage linkage,
-                               Arena* arena)
+IdentifierInfo* add_identifier(SymbolTable* symbol_table, Scope* scope,
+                               StringView name, IdentifierKind kind,
+                               Linkage linkage, Arena* arena)
 {
+
   // check variable in current scope
   if (hashmap_lookup(&scope->identifiers, name) != nullptr) { return nullptr; }
 
@@ -64,5 +65,10 @@ IdentifierInfo* add_identifier(Scope* scope, StringView name,
   const bool insert_succeed =
       hashmap_try_insert(&scope->identifiers, name, variable, arena);
   MCC_ASSERT(insert_succeed);
+
+  if (linkage != LINKAGE_NONE) {
+    hashmap_try_insert(&symbol_table->global_symbols, name, variable, arena);
+  }
+
   return variable;
 }

src/frontend/symbol_table.h

@@ -45,14 +45,26 @@ typedef struct IdentifierInfo {
 // Represents a block scope
 typedef struct Scope Scope;
 
+// Represents a symbol table in a C translation unit, tracking both scoped and
+// global symbols. In C, identifiers with linkage can be referenced across
+// multiple scopes while remaining unique within a program. To account for this,
+// a pointer to global symbols are stored separately in addition to their
+// respective scopes.
+typedef struct SymbolTable {
+  // Tracks globally visible symbols (those with external or internal linkage)
+  HashMap global_symbols;
+  // Represents the global scope of the translation unit.
+  Scope* global_scope;
+} SymbolTable;
+
 Scope* new_scope(Scope* parent, Arena* arena);
 
 IdentifierInfo* lookup_identifier(const Scope* scope, StringView name);
 
 // Return nullptr if a variable of the same name already exist in the same scope
 // Otherwise we add it to the current scope
-IdentifierInfo* add_identifier(Scope* scope, StringView name,
-                               IdentifierKind kind, Linkage linkage,
-                               Arena* arena);
+IdentifierInfo* add_identifier(SymbolTable* symbol_table, Scope* scope,
+                               StringView name, IdentifierKind kind,
+                               Linkage linkage, Arena* arena);
 
 #endif // MCC_SYMBOL_TABLE_H

src/frontend/type_check.c

@@ -18,7 +18,7 @@ struct ErrorVec {
 typedef struct Context {
   struct ErrorVec errors;
   Arena* permanent_arena;
-  HashMap functions;
+  SymbolTable* symbol_table;
 } Context;
 
 #pragma region error reporter
@@ -336,7 +336,7 @@ static bool type_check_function_decl(FunctionDecl* decl, Context* context)
 {
   StringView function_name = decl->name->name;
   IdentifierInfo* function_ident =
-      hashmap_lookup(&context->functions, function_name);
+      hashmap_lookup(&context->symbol_table->global_symbols, function_name);
 
   if (function_ident->type == nullptr) {
     function_ident->type =
@@ -370,7 +370,7 @@ static bool type_check_function_decl(FunctionDecl* decl, Context* context)
 ErrorsView type_check(TranslationUnit* ast, Arena* permanent_arena)
 {
   Context context = {.permanent_arena = permanent_arena,
-                     .functions = ast->functions};
+                     .symbol_table = ast->symbol_table};
 
   for (uint32_t i = 0; i < ast->decl_count; ++i) {
     type_check_decl(&ast->decls[i], &context);

src/x86/x86.c

@@ -40,8 +40,6 @@ static X86FunctionDef x86_generate_function(const IRFunctionDef* ir_function,
 X86Program x86_generate_assembly(IRProgram* ir, Arena* permanent_arena,
                                  Arena scratch_arena)
 {
-  // TODO: fix this
-
   const size_t top_level_count = ir->top_level_count;
   X86TopLevel* top_levels =
       ARENA_ALLOC_ARRAY(permanent_arena, X86TopLevel, top_level_count);

tests/test_data/basics/globals/invalid/global_redefinition.c

@@ -0,0 +1,8 @@
+int x = 42;
+int x = 42;
+
+int main(void)
+{
+  int foo = 1;
+  return foo + x;
+}

tests/test_data/basics/globals/invalid/global_redefinition.stderr.approved.txt

@@ -0,0 +1,4 @@
+{{filename}}:2:5: Error: redefinition of 'x'
+2 | int x = 42;
+  |     ^
+

tests/test_data/basics/globals/invalid/test_config.toml

@@ -0,0 +1,3 @@
+command = "{mcc} --parse {filename}"
+return_code = 1
+snapshot_test_stderr = true