From 11bddf270c9f96c01768fe3e0d6c64c372300dd0 Mon Sep 17 00:00:00 2001 From: lachsinc Date: Thu, 27 Sep 2018 18:34:59 +1000 Subject: [PATCH] Cleanup debug info 'name' stuff. --- src/ir.cpp | 36 +++++++++++++------------- src/ir_print.cpp | 67 ++++++++++++++++++++++++------------------------ 2 files changed, 51 insertions(+), 52 deletions(-) diff --git a/src/ir.cpp b/src/ir.cpp index 633ee65db..7f494d363 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -1648,7 +1648,7 @@ i32 ir_debug_align_bits(Type *type) { return ir_debug_info_bits(type_align_of(type)); } -irDebugInfo *ir_add_debug_info_field_internal(irModule *module, String name, Type *type, i32 offset, irDebugInfo *scope) { +irDebugInfo *ir_add_debug_info_field_internal(irModule *module, String name, Type *type, i32 offset_bits, irDebugInfo *scope) { // NOTE(lachsinc): Caller is expected to insert the returned value into map themselves. // "scope", if set, should be inserted into map prior to calling to ensure no cyclical dependencies. @@ -1656,7 +1656,7 @@ irDebugInfo *ir_add_debug_info_field_internal(irModule *module, String name, Typ di->DerivedType.name = name; di->DerivedType.tag = irDebugBasicEncoding_member; di->DerivedType.size = ir_debug_size_bits(type); - di->DerivedType.offset = offset; + di->DerivedType.offset = offset_bits; di->DerivedType.scope = scope; // NOTE(lachsinc): It is "safe" to overwrite this base_type after a call to this function, @@ -1731,8 +1731,8 @@ irDebugInfo *ir_add_debug_info_type_dynamic_array(irModule *module, Type *type, map_set(&module->debug_info, hash_type(type), di); // Data pointer type + // TODO(lachsinc): Perhaps lookup/alloc-a-fake Type_Pointer type and go via ir_add_debug_info_type() with it. irDebugInfo *data_ptr_di = ir_alloc_debug_info(irDebugInfo_DerivedType); - // data_ptr_di->DerivedType.name = str_lit("ptr_type_name_todo"); data_ptr_di->DerivedType.tag = irDebugBasicEncoding_pointer_type; data_ptr_di->DerivedType.size = ir_debug_size_bits(t_rawptr); map_set(&module->debug_info, hash_pointer(data_ptr_di), data_ptr_di); @@ -1857,8 +1857,8 @@ irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irD return *existing; } - // Reset entity info if applicable for every type we try add. - // TODO(lachsinc): Confirm this doesn't mess up struct field scope's. + // Reset entity/location info, if applicable, for every type we try add. + // TODO(lachsinc): Confirm this doesn't mess up field's scopes etc. if (type->kind == Type_Named) { e = type->Named.type_name; if (e) { @@ -1962,10 +1962,8 @@ irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irD map_set(&module->debug_info, hash_type(type), di); if (is_type_struct(type)) { - if (type->kind == Type_Named) { - di->CompositeType.name = type->Named.name; - } else { - di->CompositeType.name = str_lit("struct_name_todo"); + if (is_type_named(type)) { + di->CompositeType.name = type->kind == Type_Named ? type->Named.name : type->Basic.name; } di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Struct.fields.count); for_array(field_index, base->Struct.fields) { @@ -1980,8 +1978,9 @@ irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irD // TODO(lachsinc): Add elements for union di->CompositeType.tag = irDebugBasicEncoding_union_type; } else if (is_type_enum(type)) { - GB_ASSERT(type->kind == Type_Named); - di->CompositeType.name = type->Named.name; + if (type->kind == Type_Named) { + di->CompositeType.name = type->Named.name; + } di->CompositeType.base_type = ir_add_debug_info_type(module, type->Named.base->Enum.base_type, e, scope, file); di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Enum.fields.count); for_array(field_index, base->Enum.fields) { @@ -2029,17 +2028,14 @@ irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irD // Data pointer type irDebugInfo *data_ptr_di = ir_alloc_debug_info(irDebugInfo_DerivedType); - if (type->Slice.elem->kind == Type_Named) { - data_ptr_di->DerivedType.name = type->Slice.elem->Named.name; // TODO(lachsinc): Ptr?? - } else if (type->Slice.elem->kind == Type_Basic) { - data_ptr_di->DerivedType.name = type->Slice.elem->Basic.name; // TODO(lachsinc): Ptr?? - } else { - data_ptr_di->DerivedType.name = str_lit("slice_ptr_type_todo"); + Type *elem_type = type->Slice.elem; + if (is_type_named(elem_type)) { + data_ptr_di->DerivedType.name = elem_type->kind == Type_Named ? elem_type->Named.name : elem_type->Basic.name; } data_ptr_di->DerivedType.tag = irDebugBasicEncoding_pointer_type; data_ptr_di->DerivedType.size = ir_debug_size_bits(t_rawptr); map_set(&module->debug_info, hash_pointer(data_ptr_di), data_ptr_di); - data_ptr_di->DerivedType.base_type = ir_add_debug_info_type(module, type->Slice.elem, e, scope, file); + data_ptr_di->DerivedType.base_type = ir_add_debug_info_type(module, elem_type, e, scope, file); irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_rawptr, 0, @@ -2062,6 +2058,10 @@ irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irD } if (is_type_map(type)) { + // TODO(lachsinc): Looks like "generated_struct_type" map.entries.data is just a u8*, we could + // always look at the map header and create the debug info manually (if we + // want struct members to be interpreted as the correct type). + // Also; are hashes meant to be interpreted as bool*'s ?? return ir_add_debug_info_type(module, type->Map.generated_struct_type, e, scope, file); } diff --git a/src/ir_print.cpp b/src/ir_print.cpp index 3499ce410..c5d3eff2f 100644 --- a/src/ir_print.cpp +++ b/src/ir_print.cpp @@ -2082,45 +2082,44 @@ void print_llvm_ir(irGen *ir) { case irDebugInfo_CompositeType: { if (di->CompositeType.tag == irDebugBasicEncoding_array_type) { GB_ASSERT_NOT_NULL(di->CompositeType.base_type); - ir_fprintf(f, "!DICompositeType(" - "tag: DW_TAG_array_type" - ", size: %d" - ", align: %d" - ", baseType: !%d" - ", elements: !{!DISubrange(count: %d)}" - ")", - di->CompositeType.size, - di->CompositeType.align, - di->CompositeType.base_type->id, - di->CompositeType.array_count); + GB_ASSERT(di->CompositeType.array_count > 0); + GB_ASSERT(di->CompositeType.name.len == 0); + GB_ASSERT(di->CompositeType.size > 0); + } + + ir_write_str_lit(f, "!DICompositeType(tag: "); + ir_print_debug_encoding(f, irDebugInfo_CompositeType, di->CompositeType.tag); + if (di->CompositeType.name.len > 0) { + ir_fprintf(f, ", name: \"%.*s\"", LIT(di->CompositeType.name)); + } + if (di->CompositeType.scope != nullptr) { + ir_fprintf(f, ", scope: !%d", di->CompositeType.scope->id); + } + if (di->CompositeType.file != nullptr) { + ir_fprintf(f, ", file: !%d" + ", line: %td", + di->CompositeType.file->id, + di->CompositeType.pos.line); + } + if (di->CompositeType.size > 0) { + ir_fprintf(f, ", size: %d", di->CompositeType.size); + } + if (di->CompositeType.align > 0) { + ir_fprintf(f, ", align: %d", di->CompositeType.align); + } + if (di->CompositeType.base_type != nullptr) { + GB_ASSERT(di->CompositeType.tag != irDebugBasicEncoding_structure_type); + GB_ASSERT(di->CompositeType.tag != irDebugBasicEncoding_union_type); + ir_fprintf(f, ", baseType: !%d", di->CompositeType.base_type->id); + } + if (di->CompositeType.tag == irDebugBasicEncoding_array_type) { + ir_fprintf(f, ", elements: !{!DISubrange(count: %d)}", di->CompositeType.array_count); } else { - ir_fprintf(f, "!DICompositeType(" - "name: \"%.*s\"" - ", size: %d" - ", align: %d" - ", tag: ", - LIT(di->CompositeType.name), - di->CompositeType.size, - di->CompositeType.align); - ir_print_debug_encoding(f, irDebugInfo_CompositeType, di->CompositeType.tag); - if (di->CompositeType.scope != nullptr) { - ir_fprintf(f, ", scope: !%d", di->CompositeType.scope->id); - } - if (di->CompositeType.file != nullptr) { - ir_fprintf(f, ", file: !%d" - ", line: %td", - di->CompositeType.file->id, - di->CompositeType.pos.line); - } - if (di->CompositeType.base_type != nullptr) { - GB_ASSERT(di->CompositeType.tag == irDebugBasicEncoding_enumeration_type); - ir_fprintf(f, ", baseType: !%d", di->CompositeType.base_type->id); - } if (di->CompositeType.elements != nullptr) { ir_fprintf(f, ", elements: !%d", di->CompositeType.elements->id); } - ir_write_byte(f, ')'); } + ir_write_byte(f, ')'); break; } case irDebugInfo_Enumerator: {