Fix debug information for subscopes being very incorrect.

Author: Pascal Beyer

src/ast.c

@@ -679,10 +679,9 @@ struct ast_scope{
     u32 amount_of_compound_types;
     u32 current_max_amount_of_compound_types;
 
-    // These are indices into the `function->line_information` array
-    // and are used to determine which region of code holds which declarations.
-    u32 start_line_index;
-    u32 end_line_index;
+    // These are offsets into the ir until code generation, then they are offsets into the function.
+    u32 start_offset;
+    u32 end_offset;
 };
 
 static struct token *get_initializer_token(struct ast_declaration *decl){

src/coff_writer.c

@@ -3146,7 +3146,7 @@ func void print_coff(struct string output_file_path, struct memory_arena *arena,
 
             // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
 
-            codeview_emit_debug_info_for_function(function, &module_stream, /*relocation_arena (used by obj_writer.c)*/null, /*debug_symbol_base (used by obj_writer.c)*/null, text_section_id);
+            codeview_emit_debug_info_for_function(function, &module_stream, /*relocation_arena (used by obj_writer.c)*/null, module_stream.base, text_section_id);
 
             // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

src/emit_x64.c

@@ -2614,16 +2614,49 @@ void emit_code_for_function__internal(struct context *context, struct ast_functi
     smm line_information_size = current_function->line_information.size;
     smm line_information_at = 0;
 
+    // @cleanup: Is there a good way to fold that to the stuff below?
+    u32 **scope_offsets = push_data(&context->scratch, u32 *, 0);
+    for(struct ast_scope *scope = current_function->scope; scope; ){
+        *push_uninitialized_struct(&context->scratch, u32 *) = &scope->start_offset;
+        
+        if(scope->subscopes.first){
+            scope = scope->subscopes.first;
+        }else{
+            while(1){
+                *push_uninitialized_struct(&context->scratch, u32 *) = &scope->end_offset;
+                if(scope->subscopes.next){
+                    scope = scope->subscopes.next;
+                    break;
+                }
+                
+                if(scope->flags & SCOPE_FLAG_is_function_scope){
+                    scope = null;
+                    break;
+                }else{
+                    scope = scope->parent;
+                }
+            }
+        }
+    }
+    smm amount_of_scopes = push_data(&context->scratch, u32 *, 0) - scope_offsets;
+    smm scope_at = 0;
+    
     for(u8 *ir_arena_at = current_function->start_in_ir_arena; ir_arena_at < current_function->end_in_ir_arena; ){
         struct ir *ir = (struct ir *)ir_arena_at;
 
-        if((line_information_at < line_information_size) && (line_information[line_information_at].offset == (u32)(ir_arena_at - current_function->start_in_ir_arena))){
+        u32 current_offset = (u32)(ir_arena_at - current_function->start_in_ir_arena);
+        
+        if((line_information_at < line_information_size) && (line_information[line_information_at].offset == current_offset)){
             // :function_line_information
             // 
             // Here we remap the offset from pointing into the ir_arena to pointing into the emit_pool.
             line_information[line_information_at++].offset = to_s32(get_bytes_emitted(context));
         }
 
+        while(scope_at < amount_of_scopes && *scope_offsets[scope_at] == current_offset){
+            *scope_offsets[scope_at++] = to_s32(get_bytes_emitted(context));
+        }
+        
         enum ir_kind ir_kind = ir->kind;
 
         switch(ir_kind){
@@ -4701,6 +4734,14 @@ void emit_code_for_function__internal(struct context *context, struct ast_functi
 
     assert_that_no_registers_are_allocated(context);
 
+    u32 ir_size = (u32)(current_function->end_in_ir_arena - current_function->start_in_ir_arena);
+    u32 asm_size = to_s32(get_bytes_emitted(context));
+    
+    while(scope_at < amount_of_scopes){
+        assert(*scope_offsets[scope_at] == ir_size);
+        *scope_offsets[scope_at++] = asm_size;
+    }
+    
     assert(emit_location_stack_at == 0);
 
     if(line_information_at < line_information_size){

src/main.c

@@ -3412,6 +3412,8 @@ func void worker_parse_function(struct context *context, struct work_queue_entry
 
     function->end_in_ir_arena = arena_current(&context->ir_arena);
 
+    scope->end_offset = (u32)(function->end_in_ir_arena - function->start_in_ir_arena);
+    
     context->current_function = null;
 }
 

src/obj_writer.c

@@ -709,35 +709,25 @@ struct debug_symbols_relocation_info{
 
 void codeview_emit_debug_information_for_function__recursive(struct ast_function *function, struct memory_arena *arena, struct ast_scope *scope, struct memory_arena *relocation_arena, u8 *debug_symbols_base, u16 text_section_id, u32 parent_pointer){
 
+    struct codeview_block32{
+        u16 length;
+        u16 kind;
+        u32 pointer_to_parent; // filled in by the linker
+        u32 pointer_to_end;    // filled in by the linker
+        u32 scope_size;
+        u32 offset_in_section;
+        u16 section;
+    } *block = null;
+    
     if(scope->amount_of_declarations){
 
         if(function->scope != scope){
-            struct codeview_block32{
-                u16 length;
-                u16 kind;
-                u32 pointer_to_parent; // filled in by the linker
-                u32 pointer_to_end;    // filled in by the linker
-                u32 scope_size;
-                u32 offset_in_section;
-                u16 section;
-            } *block = push_struct(arena, struct codeview_block32);
+            block = push_struct(arena, struct codeview_block32);
             block->length = sizeof(*block) - 2;
             block->kind   = /*S_BLOCK32*/0x1103;
 
-            if(scope->start_line_index == -1){
-                // Function is empty.
-                block->scope_size = 0;
-                block->offset_in_section = 0; // ?
-            }else{
-                
-                u32 start_offset = function->line_information.data[scope->start_line_index].offset;
-                u32 end_offset   = scope->end_line_index < function->line_information.size ? function->line_information.data[scope->end_line_index].offset : (u32)function->byte_size_without_prolog;
-                
-                
-                // @cleanup: Does this correctly include function->size_of_prologue?
-                block->scope_size = end_offset - start_offset;
-                block->offset_in_section = start_offset; // relocated by relocation.
-            }
+            block->scope_size = scope->end_offset - scope->start_offset;
+            block->offset_in_section = (u32)(scope->start_offset + function->size_of_prolog); // relocated by relocation.
 
             block->section = 0; // filled in by relocation.
 
@@ -750,7 +740,7 @@ void codeview_emit_debug_information_for_function__recursive(struct ast_function
                 block->section = text_section_id;
                 block->pointer_to_parent = parent_pointer;
 
-                parent_pointer = (u32)(arena_current(arena) - debug_symbols_base);
+                parent_pointer = (u32)((u8 *)block - debug_symbols_base);
             }
         }
 
@@ -808,6 +798,10 @@ void codeview_emit_debug_information_for_function__recursive(struct ast_function
     }
 
     if(scope->amount_of_declarations && function->scope != scope){
+        if(block && !relocation_arena){
+            block->pointer_to_end = (u32)(arena_current(arena) - debug_symbols_base);
+        }
+        
         *push_struct(arena, u16) = /*length*/2;
         *push_struct(arena, u16) = /*S_END*/6;
     }

src/parse.c

@@ -837,23 +837,22 @@ func void maybe_insert_cast_from_void_pointer(struct expr *lhs, struct expr *rhs
 
 func struct ast_scope *parser_push_new_scope(struct context *context, struct token *token, enum scope_flags flags){
 
+    struct ast_scope *parent = context->current_scope;
+    
     struct ast_scope *scope = push_uninitialized_struct(context->arena, struct ast_scope);
     scope->flags = flags;
     scope->token = token;
+    scope->start_offset = (u32)(arena_current(&context->ir_arena) - context->current_function->start_in_ir_arena); // kinda dumb, this is not true for function scopes. Maybe this function should not be called for function scopes.
+    scope->parent = parent;
 
-    struct ast_scope *parent = context->current_scope;
-    if(parent){
-        if(parent->subscopes.last){ // @note: sll_push_back does not work because of the `subscopes` member.
-            parent->subscopes.last->subscopes.next = scope;
-            parent->subscopes.last = scope;
-        }else{
-            parent->subscopes.first = scope;
-            parent->subscopes.last  = scope;
-        }
-        parent->subscopes.count += 1;
-        
-        scope->parent = parent;
+    if(parent->subscopes.last){ // @note: sll_push_back does not work because of the `subscopes` member.
+        parent->subscopes.last->subscopes.next = scope;
+        parent->subscopes.last = scope;
+    }else{
+        parent->subscopes.first = scope;
+        parent->subscopes.last  = scope;
     }
+    parent->subscopes.count += 1;
 
     context->current_scope = scope;
 
@@ -862,6 +861,7 @@ func struct ast_scope *parser_push_new_scope(struct context *context, struct tok
 
 func void parser_scope_pop(struct context *context, struct ast_scope *scope){
     assert(context->current_scope == scope);
+    scope->end_offset = (u32)(arena_current(&context->ir_arena) - context->current_function->start_in_ir_arena);
     context->current_scope = context->current_scope->parent;
 }
 
@@ -8803,8 +8803,12 @@ func struct declaration_list parse_declaration_list(struct context *context, str
                     return ret;
                 }
 
-                scope = parser_push_new_scope(context, get_current_token(context), SCOPE_FLAG_is_function_scope);
-                parser_scope_pop(context, scope);
+                // @note: We don't want to use the general `parser_push_new_scope` function, as it is not designed for function scopes,
+                //        and we would not want to add this scope to the scopes of the current function anyway (if it is local).
+                scope = push_struct(context->arena, struct ast_scope);
+                scope->flags = SCOPE_FLAG_is_function_scope;
+                scope->parent = context->current_scope;
+                scope->token = get_current_token(context);
 
                 ret.is_function_definition = scope;
 
@@ -9821,8 +9825,6 @@ func void parse_imperative_scope(struct context *context){
     struct ast_scope *scope = context->current_scope;
     assert(scope);
 
-    scope->start_line_index = (u32)context->current_function->line_information.size;
-    
     // Keep parsing inputs even after an error has occurred!
     while(true){
         // Statements only occur at function scope, so there should not be any sleeping.
@@ -9861,10 +9863,6 @@ func void parse_imperative_scope(struct context *context){
         }
     }
 
-    scope->end_line_index = (u32)context->current_function->line_information.size;
-    if(scope->start_line_index > scope->end_line_index){
-        scope->start_line_index = scope->end_line_index;
-    }
 }
 
 func struct declarator_return parse_declarator(struct context* context, struct ast_type *_initial_type, enum ast_kind *_initial_defined_type, enum declarator_kind_flags declarator_kind_flags){