Global linkage WIP

Author: LesleyLai

include/mcc/ast.h

@@ -118,7 +118,7 @@ typedef struct VariableDecl {
   const Type* type;
   StorageClass storage_class;
   SourceRange source_range;
-  IdentifierInfo* name;
+  IdentifierInfo* identifier;
   Expr* initializer; // An optional initializer
 } VariableDecl;
 
@@ -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/ast_printer.c

@@ -148,8 +148,8 @@ static void format_var_decl(StringBuffer* output, const VariableDecl* decl,
 {
   string_buffer_printf(output, "%*sVariableDecl ", indent, "");
   format_source_range(output, decl->source_range);
-  string_buffer_printf(output, " %.*s: ", (int)decl->name->name.size,
-                       decl->name->name.start);
+  string_buffer_printf(output, " %.*s: ", (int)decl->identifier->name.size,
+                       decl->identifier->name.start);
   format_storage_class(output, decl->storage_class);
   string_buffer_append(output, str("int\n"));
   if (decl->initializer) { format_expr(output, decl->initializer, indent + 2); }

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
@@ -175,24 +174,24 @@ static Expr* parse_identifier_expr(Parser* parser, Scope* scope)
 
   MCC_ASSERT(token.tag == TOKEN_IDENTIFIER);
 
-  const StringView identifier = str_from_token(parser->src, token);
+  const StringView name = str_from_token(parser->src, token);
 
   // TODO: handle typedef
   Expr* result = ARENA_ALLOC_OBJECT(parser->permanent_arena, Expr);
 
   // If local variable does not exist
-  const IdentifierInfo* variable = lookup_identifier(scope, identifier);
-  if (!variable) {
+  const IdentifierInfo* variable_identifier = lookup_identifier(scope, name);
+  if (!variable_identifier) {
     const StringView error_msg = allocate_printf(
         parser->permanent_arena, "use of undeclared identifier '%.*s'",
-        (int)identifier.size, identifier.start);
+        (int)name.size, name.start);
     parse_error_at(parser, error_msg, token_source_range(token));
   }
 
   // TODO: handle the case wher variable == nullptr
   *result = (Expr){.tag = EXPR_VARIABLE,
                    .source_range = token_source_range(token),
-                   .variable = variable};
+                   .variable = variable_identifier};
   return result;
 }
 
@@ -215,19 +214,18 @@ typedef enum Precedence {
   PREC_PRIMARY
 } Precedence;
 
-static Expr* parse_expr(Parser* parser, struct Scope* scope);
-static Expr* parse_group(Parser* parser, struct Scope* scope);
-static Expr* parse_unary_op(Parser* parser, struct Scope* scope);
+static Expr* parse_expr(Parser* parser, Scope* scope);
+static Expr* parse_group(Parser* parser, Scope* scope);
+static Expr* parse_unary_op(Parser* parser, Scope* scope);
 static Expr* parse_binop_left(Parser* parser, Expr* lhs_expr,
-                              struct Scope* scope); // left associative
+                              Scope* scope); // left associative
 static Expr* parse_assignment(Parser* parser, Expr* lhs_expr,
-                              struct Scope* scope); // right associative
+                              Scope* scope); // right associative
 static Expr* parse_ternary(Parser* parser, Expr* cond, struct Scope* scope);
-static Expr* parse_function_call(Parser* parser, Expr* function,
-                                 struct Scope* scope);
+static Expr* parse_function_call(Parser* parser, Expr* function, Scope* scope);
 
-typedef Expr* (*PrefixParseFn)(Parser*, struct Scope* scope);
-typedef Expr* (*InfixParseFn)(Parser*, Expr*, struct Scope* scope);
+typedef Expr* (*PrefixParseFn)(Parser*, Scope* scope);
+typedef Expr* (*InfixParseFn)(Parser*, Expr*, Scope* scope);
 
 typedef struct ParseRule {
   PrefixParseFn prefix;
@@ -619,21 +617,34 @@ static DeclSpecifier parse_decl_specifiers(Parser* parser)
 
 static FunctionDecl* parse_function_decl(Parser* parser,
                                          DeclSpecifier decl_specifier,
-                                         Token name_token, struct Scope* scope);
+                                         Token name_token, Scope* scope);
 
 static VariableDecl parse_variable_decl(Parser* parser,
                                         DeclSpecifier decl_specifier,
-                                        Token name_token, struct Scope* scope)
+                                        Token name_token, Scope* scope)
 {
   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);
+
+  const bool is_global_variable = scope == parser->symbol_table->global_scope;
+
+  // TODO: properly handle linkage
+  Linkage linkage = LINKAGE_NONE;
+  if (is_global_variable) { linkage = LINKAGE_EXTERNAL; }
+
+  IdentifierInfo* variable =
+      add_identifier(parser->symbol_table, scope, name, IDENT_OBJECT, linkage,
+                     parser->permanent_arena);
   if (!variable) {
-    const StringView error_msg =
-        allocate_printf(parser->permanent_arena, "redefinition of '%.*s'",
-                        (int)name.size, name.start);
-    parse_error_at(parser, error_msg, token_source_range(name_token));
+    if (linkage != LINKAGE_NONE) {
+      variable = lookup_identifier(scope, name);
+      MCC_ASSERT(variable != nullptr);
+
+    } else {
+      const StringView error_msg =
+          allocate_printf(parser->permanent_arena, "redefinition of '%.*s'",
+                          (int)name.size, name.start);
+      parse_error_at(parser, error_msg, token_source_range(name_token));
+    }
   }
 
   Expr* initializer = nullptr;
@@ -646,11 +657,11 @@ static VariableDecl parse_variable_decl(Parser* parser,
   // TODO: handle the case where variable == nullptr
   return (VariableDecl){.type = decl_specifier.type,
                         .storage_class = decl_specifier.storage_class,
-                        .name = variable,
+                        .identifier = variable,
                         .initializer = initializer};
 }
 
-static Decl parse_decl(Parser* parser, struct Scope* scope)
+static Decl parse_decl(Parser* parser, Scope* scope)
 {
   const DeclSpecifier decl_specifier = parse_decl_specifiers(parser);
   const Token name_token = parse_identifier(parser);
@@ -937,8 +948,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 +1018,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 +1034,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 +1075,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 +1087,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 +1098,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,13 +27,10 @@ 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)
+static IdentifierInfo* add_identifier_to_scope(Scope* scope, StringView name,
+                                               IdentifierKind kind,
+                                               Linkage linkage, Arena* arena)
 {
-  // check variable in current scope
-  if (hashmap_lookup(&scope->identifiers, name) != nullptr) { return nullptr; }
-
   // lookup variable in parent scopes
   const IdentifierInfo* parent_variable = nullptr;
   if (scope->parent) {
@@ -64,5 +61,23 @@ IdentifierInfo* add_identifier(Scope* scope, StringView name,
   const bool insert_succeed =
       hashmap_try_insert(&scope->identifiers, name, variable, arena);
   MCC_ASSERT(insert_succeed);
+
   return variable;
 }
+
+IdentifierInfo* add_identifier(SymbolTable* symbol_table, Scope* scope,
+                               StringView name, IdentifierKind kind,
+                               Linkage linkage, Arena* arena)
+{
+  // check identifier in current scope
+  if (hashmap_lookup(&scope->identifiers, name) != nullptr) { return nullptr; }
+
+  IdentifierInfo* ident_info =
+      add_identifier_to_scope(scope, name, kind, linkage, arena);
+
+  if (linkage != LINKAGE_NONE) {
+    hashmap_try_insert(&symbol_table->global_symbols, name, ident_info, arena);
+  }
+
+  return ident_info;
+}

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
@@ -114,6 +114,15 @@ static void report_multiple_definition(FunctionDecl* decl, Context* context)
                       (int)decl->name->name.size, decl->name->name.start);
   error_at(msg, decl->source_range, context);
 }
+
+static void report_redefinition_of_var(VariableDecl* decl, Context* context)
+{
+  StringView msg = allocate_printf(
+      context->permanent_arena, "redefinition of '%.*s'",
+      (int)decl->identifier->name.size, decl->identifier->name.start);
+  error_at(msg, decl->source_range, context);
+}
+
 #pragma endregion
 
 [[nodiscard]]
@@ -280,13 +289,15 @@ static bool type_check_stmt(Stmt* stmt, Context* context)
 [[nodiscard]] static bool type_check_variable_decl(VariableDecl* decl,
                                                    Context* context)
 {
-  decl->name->type = typ_int;
+  decl->identifier->type = typ_int;
 
   if (decl->initializer) {
-    // TODO: handle redefinition of static/global variables
-    MCC_ASSERT(decl->name->has_definition == false);
+    if (decl->identifier->has_definition) {
+      report_redefinition_of_var(decl, context);
+      return false;
+    }
 
-    decl->name->has_definition = true;
+    decl->identifier->has_definition = true;
 
     if (!type_check_expr(decl->initializer, context)) { return false; }
 
@@ -336,7 +347,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 +381,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/ir/ir_generator.c

@@ -440,7 +440,7 @@ static void emit_ir_instructions_from_decl(const VariableDecl* decl,
         emit_ir_instructions_from_expr(decl->initializer, context);
     push_instruction(
         context,
-        ir_unary_instr(IR_COPY, ir_variable(decl->name->rewrote_name), value));
+        ir_unary_instr(IR_COPY, ir_variable(decl->identifier->rewrote_name), value));
   }
 }
 
@@ -757,7 +757,7 @@ IRGenerationResult ir_generate(const TranslationUnit* ast,
       *top_level = (IRTopLevel){
           .tag = IR_TOP_LEVEL_VARIABLE,
           .variable =
-              (IRGlobalVariable){.name = decl->var.name->name, .value = value},
+              (IRGlobalVariable){.name = decl->var.identifier->name, .value = value},
       };
       DYNARRAY_PUSH_BACK(&top_level_vec, IRTopLevel*, &scratch_arena,
                          top_level);