From: David Blaikie Date: Tue, 6 May 2014 18:35:21 +0000 (+0000) Subject: Reapply: DebugInfo: Emit the definition of enums when the definition preceeds the... X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=0cb2626cb56ec10c82dc76b241b1cd035951847c;p=clang Reapply: DebugInfo: Emit the definition of enums when the definition preceeds the declaration and initial use. Reverting r208106 to reapply r208065 with a fix for the regression. The issue was that the enum tried to be built even if the declaration hadn't been constructed for debug info - presenting problems for enum templates and typedefs of enums with names for linkage purposes. Original commit message: This regressed a little further 208055 though it was already a little broken. While the requiresCompleteType optimization should be implemented here. Future (possibly near future) work. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@208114 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/CGDebugInfo.cpp b/lib/CodeGen/CGDebugInfo.cpp index cd966a0e7f..b62cc2546f 100644 --- a/lib/CodeGen/CGDebugInfo.cpp +++ b/lib/CodeGen/CGDebugInfo.cpp @@ -1427,6 +1427,21 @@ llvm::DIType CGDebugInfo::getOrCreateInterfaceType(QualType D, return T; } +void CGDebugInfo::completeType(const EnumDecl *ED) { + if (DebugKind <= CodeGenOptions::DebugLineTablesOnly) + return; + QualType Ty = CGM.getContext().getEnumType(ED); + void* TyPtr = Ty.getAsOpaquePtr(); + auto I = TypeCache.find(TyPtr); + if (I == TypeCache.end() || + !llvm::DIType(cast(static_cast(I->second))) + .isForwardDecl()) + return; + llvm::DIType Res = CreateTypeDefinition(Ty->castAs()); + assert(!Res.isForwardDecl()); + TypeCache[TyPtr] = Res; +} + void CGDebugInfo::completeType(const RecordDecl *RD) { if (DebugKind > CodeGenOptions::LimitedDebugInfo || !CGM.getLangOpts().CPlusPlus) @@ -1915,6 +1930,20 @@ llvm::DIType CGDebugInfo::CreateEnumType(const EnumType *Ty) { return RetTy; } + return CreateTypeDefinition(Ty); +} + +llvm::DIType CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) { + const EnumDecl *ED = Ty->getDecl(); + uint64_t Size = 0; + uint64_t Align = 0; + if (!ED->getTypeForDecl()->isIncompleteType()) { + Size = CGM.getContext().getTypeSize(ED->getTypeForDecl()); + Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl()); + } + + SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU); + // Create DIEnumerator elements for each enumerator. SmallVector Enumerators; ED = ED->getDefinition(); diff --git a/lib/CodeGen/CGDebugInfo.h b/lib/CodeGen/CGDebugInfo.h index 700e3358de..f7640bc28d 100644 --- a/lib/CodeGen/CGDebugInfo.h +++ b/lib/CodeGen/CGDebugInfo.h @@ -135,6 +135,7 @@ class CGDebugInfo { llvm::DIType CreateType(const MemberPointerType *Ty, llvm::DIFile F); llvm::DIType CreateType(const AtomicType *Ty, llvm::DIFile F); llvm::DIType CreateEnumType(const EnumType *Ty); + llvm::DIType CreateTypeDefinition(const EnumType *Ty); llvm::DIType CreateSelfType(const QualType &QualTy, llvm::DIType Ty); llvm::DIType getTypeOrNull(const QualType); llvm::DICompositeType getOrCreateMethodType(const CXXMethodDecl *Method, @@ -295,6 +296,7 @@ public: llvm::DIType getOrCreateInterfaceType(QualType Ty, SourceLocation Loc); + void completeType(const EnumDecl *ED); void completeType(const RecordDecl *RD); void completeRequiredType(const RecordDecl *RD); void completeClassData(const RecordDecl *RD); diff --git a/lib/CodeGen/CodeGenTypes.cpp b/lib/CodeGen/CodeGenTypes.cpp index b7f37462a6..9be633c1c9 100644 --- a/lib/CodeGen/CodeGenTypes.cpp +++ b/lib/CodeGen/CodeGenTypes.cpp @@ -242,6 +242,10 @@ void CodeGenTypes::UpdateCompletedType(const TagDecl *TD) { if (!ConvertType(ED->getIntegerType())->isIntegerTy(32)) TypeCache.clear(); } + // If necessary, provide the full definition of a type only used with a + // declaration so far. + if (CGDebugInfo *DI = CGM.getModuleDebugInfo()) + DI->completeType(ED); return; } diff --git a/test/CodeGen/debug-info-enum.c b/test/CodeGen/debug-info-enum.c new file mode 100644 index 0000000000..acf3f52408 --- /dev/null +++ b/test/CodeGen/debug-info-enum.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s + +// CHECK: metadata [[TEST3_ENUMS:![0-9]*]], {{[^,]*}}, null, null, null} ; [ DW_TAG_enumeration_type ] [e] +// CHECK: [[TEST3_ENUMS]] = metadata !{metadata [[TEST3_E:![0-9]*]]} +// CHECK: [[TEST3_E]] = {{.*}}, metadata !"E", i64 -1} ; [ DW_TAG_enumerator ] [E :: -1] + +enum e; +void func(enum e *p) { +} +enum e { E = -1 }; diff --git a/test/CodeGenCXX/debug-info-enum-class.cpp b/test/CodeGenCXX/debug-info-enum-class.cpp index 0f4b09afb5..f0b97ccd2c 100644 --- a/test/CodeGenCXX/debug-info-enum-class.cpp +++ b/test/CodeGenCXX/debug-info-enum-class.cpp @@ -12,7 +12,6 @@ D d; // CHECK: ; [ DW_TAG_enumeration_type ] [A] [line 3, size 32, align 32, offset 0] [def] [from int] // CHECK: ; [ DW_TAG_enumeration_type ] [B] [line 4, size 64, align 64, offset 0] [def] [from long unsigned int] // CHECK: ; [ DW_TAG_enumeration_type ] [C] [line 5, size 32, align 32, offset 0] [def] [from ] -// CHECK: ; [ DW_TAG_enumeration_type ] [D] [line 6, size 16, align 16, offset 0] [decl] [from ] namespace PR14029 { // Make sure this doesn't crash/assert. @@ -27,3 +26,54 @@ namespace PR14029 { }; Test t; } + +namespace test2 { +// FIXME: this should just be a declaration under -fno-standalone-debug +// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST2:![0-9]*]], {{.*}}, metadata [[TEST_ENUMS:![0-9]*]], {{[^,]*}}, null, null, metadata !"_ZTSN5test21EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: [[TEST2]] = {{.*}} ; [ DW_TAG_namespace ] [test2] +// CHECK: [[TEST_ENUMS]] = metadata !{metadata [[TEST_E:![0-9]*]]} +// CHECK: [[TEST_E]] = {{.*}}, metadata !"e", i64 0} ; [ DW_TAG_enumerator ] [e :: 0] +enum E : int; +void func(E *) { +} +enum E : int { e }; +} + +namespace test3 { +// FIXME: this should just be a declaration under -fno-standalone-debug +// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST3:![0-9]*]], {{.*}}, metadata [[TEST_ENUMS]], {{[^,]*}}, null, null, metadata !"_ZTSN5test31EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: [[TEST3]] = {{.*}} ; [ DW_TAG_namespace ] [test3] +enum E : int { e }; +void func(E *) { +} +} + +namespace test4 { +// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST4:![0-9]*]], {{.*}}, metadata [[TEST_ENUMS]], {{[^,]*}}, null, null, metadata !"_ZTSN5test41EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: [[TEST4]] = {{.*}} ; [ DW_TAG_namespace ] [test4] +enum E : int; +void f1(E *) { +} +enum E : int { e }; +void f2(E) { +} +} + +// CHECK: ; [ DW_TAG_enumeration_type ] [D] [line 6, size 16, align 16, offset 0] [decl] [from ] + +namespace test5 { +// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST5:![0-9]*]], {{.*}}, null, {{[^,]*}}, null, null, metadata !"_ZTSN5test51EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: [[TEST5]] = {{.*}} ; [ DW_TAG_namespace ] [test5] +enum E : int; +void f1(E *) { +} +} + +namespace test6 { +// Ensure typedef'd enums aren't manifest by debug info generation. +// This could cause "typedef changes linkage of anonymous type, but linkage was +// already computed" errors. +// CHECK-NOT: test7 +typedef enum { +} E; +} diff --git a/test/CodeGenCXX/debug-info-enum.cpp b/test/CodeGenCXX/debug-info-enum.cpp index 7e02edef5a..810c3ee7ae 100644 --- a/test/CodeGenCXX/debug-info-enum.cpp +++ b/test/CodeGenCXX/debug-info-enum.cpp @@ -34,3 +34,12 @@ void func() { e x; } } + +namespace test4 { +// Don't try to build debug info for a dependent enum. +// CHECK-NOT: test4 +template +struct S { + enum e { E = T::v }; +}; +}