llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
llvm::DIFile *Unit) {
- TypedefNameDecl *TD = Ty->getDecl();
// We don't set size information, but do specify where the typedef was
// declared.
- SourceLocation Loc = TD->getLocation();
-
- llvm::DIScope *TDContext = getDeclarationLexicalScope(*TD, QualType(Ty, 0));
+ SourceLocation Loc = Ty->getDecl()->getLocation();
// Typedefs are derived from some other type.
return DBuilder.createTypedef(
getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
- TDContext);
+ getContextDescriptor(cast<Decl>(Ty->getDecl()->getDeclContext())));
}
llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
return T;
}
-void CGDebugInfo::recordDeclarationLexicalScope(const Decl &D) {
- assert(LexicalBlockMap.find(&D) == LexicalBlockMap.end() &&
- "D is already mapped to lexical block scope");
- if (!LexicalBlockStack.empty())
- LexicalBlockMap[&D] = LexicalBlockStack.back();
-}
-
-llvm::DIScope *CGDebugInfo::getDeclarationLexicalScope(const Decl &D,
- QualType Ty) {
- auto I = LexicalBlockMap.find(&D);
- if (I != LexicalBlockMap.end()) {
- RetainedTypes.push_back(Ty.getAsOpaquePtr());
- return I->second;
- } else
- return getContextDescriptor(cast<Decl>(D.getDeclContext()));
-}
-
void CGDebugInfo::completeType(const EnumDecl *ED) {
if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
return;
unsigned Line = getLineNumber(RD->getLocation());
StringRef RDName = getClassName(RD);
- llvm::DIScope *RDContext = getDeclarationLexicalScope(*RD, QualType(Ty, 0));
+ llvm::DIScope *RDContext =
+ getContextDescriptor(cast<Decl>(RD->getDeclContext()));
// If we ended up creating the type during the context chain construction,
// just return that.
// outside the class by putting it in the global scope.
if (DC->isRecord())
DC = CGM.getContext().getTranslationUnitDecl();
-
- if (VD->isStaticLocal()) {
- // Get context for static locals (that are technically globals) the same way
- // we do for "local" locals -- by using current lexical block.
- assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
- VDContext = LexicalBlockStack.back();
- } else
- VDContext = getContextDescriptor(dyn_cast<Decl>(DC));
+ VDContext = getContextDescriptor(dyn_cast<Decl>(DC));
}
llvm::DISubprogram *
// LexicalBlockStack - Keep track of our current nested lexical block.
std::vector<llvm::TypedTrackingMDRef<llvm::DIScope>> LexicalBlockStack;
-
- /// \brief Map of AST declaration to its lexical block scope.
- llvm::DenseMap<const Decl *, llvm::TypedTrackingMDRef<llvm::DIScope>>
- LexicalBlockMap;
-
llvm::DenseMap<const Decl *, llvm::TrackingMDRef> RegionMap;
// FnBeginRegionCount - Keep track of LexicalBlockStack counter at the
// beginning of a function. This is used to pop unbalanced regions at
/// debug info.
llvm::DIType *getOrCreateInterfaceType(QualType Ty, SourceLocation Loc);
- /// \brief Map AST declaration to its lexical block scope if available.
- void recordDeclarationLexicalScope(const Decl &D);
-
- /// \brief Get lexical scope of AST declaration.
- llvm::DIScope *getDeclarationLexicalScope(const Decl &D, QualType Ty);
-
void completeType(const EnumDecl *ED);
void completeType(const RecordDecl *RD);
void completeRequiredType(const RecordDecl *RD);
case Decl::UsingShadow:
llvm_unreachable("Declaration should not be in declstmts!");
case Decl::Function: // void X();
+ case Decl::Record: // struct/union/class X;
case Decl::Enum: // enum X;
case Decl::EnumConstant: // enum ? { X = ? }
+ case Decl::CXXRecord: // struct/union/class X; [C++]
case Decl::StaticAssert: // static_assert(X, ""); [C++0x]
case Decl::Label: // __label__ x;
case Decl::Import:
// None of these decls require codegen support.
return;
- case Decl::CXXRecord: // struct/union/class X; [C++]
- case Decl::Record: // struct/union/class X;
- if (CGDebugInfo *DI = getDebugInfo())
- DI->recordDeclarationLexicalScope(D);
- return;
-
case Decl::NamespaceAlias:
if (CGDebugInfo *DI = getDebugInfo())
DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(D));
const TypedefNameDecl &TD = cast<TypedefNameDecl>(D);
QualType Ty = TD.getUnderlyingType();
- if (CGDebugInfo *DI = getDebugInfo())
- DI->recordDeclarationLexicalScope(D);
-
if (Ty->isVariablyModifiedType())
EmitVariablyModifiedType(Ty);
}
+++ /dev/null
-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -g %s -o - | FileCheck %s
-
-int foo(int x) {
- if(x)
- {
- class X {
- public:
- char z;
- X(int y) : z(y) {}
- };
- {
- X a(x);
- return a.z;
- }
- }
- return 0;
-}
-
-// CHECK: !{{[0-9]+}} = !DICompositeType(tag: DW_TAG_class_type, name: "X", scope: [[LBScope:![0-9]+]],
-// CHECK: [[LBScope]] = distinct !DILexicalBlock(scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 5)
-
+++ /dev/null
-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -g %s -o - | FileCheck %s
-
-int foo(int x) {
- if(x)
- {
- static int bar = 0;
- {
- int a = bar++;
- return a;
- }
- }
- return 0;
-}
-
-// CHECK: !{{[0-9]+}} = !DIGlobalVariable(name: "bar", scope: [[LBScope:![0-9]+]],
-// CHECK: [[LBScope]] = distinct !DILexicalBlock(scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 5)
-
+++ /dev/null
-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -g %s -o - | FileCheck %s
-
-int main() {
- static int X = 10;
- {
- static bool X = false;
- return (int) X;
- }
- return X;
-}
-
-// CHECK: [[FuncScope:![0-9]+]] = !DISubprogram(name: "main",
-// CHECK: !{{[0-9]+}} = !DIGlobalVariable(name: "X", scope: [[FuncScope:![0-9]+]],
-// CHECK: !{{[0-9]+}} = !DIGlobalVariable(name: "X", scope: [[LBScope:![0-9]+]],
-// CHECK: [[LBScope]] = distinct !DILexicalBlock(scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 5)
-
+++ /dev/null
-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -g %s -o - | FileCheck %s
-
-int foo(int x) {
- if(x)
- {
- typedef char X;
- {
- X a = x;
- return a;
- }
- }
- return 0;
-}
-
-// CHECK: !{{[0-9]+}} = !DIDerivedType(tag: DW_TAG_typedef, name: "X", scope: [[LBScope:![0-9]+]],
-// CHECK: [[LBScope]] = distinct !DILexicalBlock(scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 5)
-