DIScope::getContext is a wrapper function that calls the specific getContext
method on each subclass. When we switch DIType::getContext to return DIScopeRef
instead of DIScope, DIScope::getContext can no longer return a DIScope without
a type identifier map.
DIScope::getContext is only used by DwarfDebug, so we move it to DwarfDebug
to have easy access to the type identifier map.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190330
91177308-0d34-0410-b5e6-
96231b3b80d8
public:
explicit DIScope(const MDNode *N = 0) : DIDescriptor (N) {}
- /// Gets the parent scope for this scope node or returns a
- /// default constructed scope.
- DIScope getContext() const;
StringRef getFilename() const;
StringRef getDirectory() const;
/// Return true if the type is appropriately scoped to be contained inside
/// its own type unit.
-static bool isTypeUnitScoped(DIType Ty) {
+static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
DIScope Parent = Ty.getContext();
while (Parent) {
// Don't generate a hash for anything scoped inside a function.
if (Parent.isSubprogram())
return false;
- Parent = Parent.getContext();
+ Parent = DD->getScopeContext(Parent);
}
return true;
}
/// Return true if the type should be split out into a type unit.
-static bool shouldCreateTypeUnit(DICompositeType CTy) {
+static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
uint16_t Tag = CTy.getTag();
switch (Tag) {
// If this is a class, structure, union, or enumeration type
// that is not a declaration, is a type definition, and not scoped
// inside a function then separate this out as a type unit.
- if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy))
+ if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy, DD))
return 0;
return 1;
default:
}
// If this is a type applicable to a type unit it then add it to the
// list of types we'll compute a hash for later.
- if (shouldCreateTypeUnit(CTy))
+ if (shouldCreateTypeUnit(CTy, DD))
DD->addTypeUnitType(&Buffer);
}
DIScope DwarfDebug::resolve(DIScopeRef SRef) const {
return SRef.resolve(TypeIdentifierMap);
}
+
+// If the current node has a parent scope then return that,
+// else return an empty scope.
+DIScope DwarfDebug::getScopeContext(DIScope S) const {
+
+ if (S.isType())
+ return DIType(S).getContext();
+
+ if (S.isSubprogram())
+ return DISubprogram(S).getContext();
+
+ if (S.isLexicalBlock())
+ return DILexicalBlock(S).getContext();
+
+ if (S.isLexicalBlockFile())
+ return DILexicalBlockFile(S).getContext();
+
+ if (S.isNameSpace())
+ return DINameSpace(S).getContext();
+
+ assert((S.isFile() || S.isCompileUnit()) && "Unhandled type of scope.");
+ return DIScope();
+}
/// or another context nested inside a subprogram.
bool isSubprogramContext(const MDNode *Context);
+ /// Gets the parent scope for this scope node or returns a
+ /// default constructed scope.
+ DIScope getScopeContext(DIScope S) const;
};
} // End of namespace llvm
return getField(DbgNode, 4);
}
-// If the current node has a parent scope then return that,
-// else return an empty scope.
-DIScope DIScope::getContext() const {
-
- if (isType())
- return DIType(DbgNode).getContext();
-
- if (isSubprogram())
- return DISubprogram(DbgNode).getContext();
-
- if (isLexicalBlock())
- return DILexicalBlock(DbgNode).getContext();
-
- if (isLexicalBlockFile())
- return DILexicalBlockFile(DbgNode).getContext();
-
- if (isNameSpace())
- return DINameSpace(DbgNode).getContext();
-
- assert((isFile() || isCompileUnit()) && "Unhandled type of scope.");
- return DIScope();
-}
-
StringRef DIScope::getFilename() const {
if (!DbgNode)
return StringRef();