X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FDebugInfo.cpp;h=87984a097592b6d24e004eb5eeeb1dc0536ad1fe;hb=2c46deb1d07f4588ee70059cdd4c7145f81bc8e8;hp=fc9324949d0d960e8f0afd53fbcd0191fd5f65a7;hpb=dc1363f5af47542a602c80e726749bc06d8ef3f8;p=oota-llvm.git diff --git a/lib/IR/DebugInfo.cpp b/lib/IR/DebugInfo.cpp index fc9324949d0..87984a09759 100644 --- a/lib/IR/DebugInfo.cpp +++ b/lib/IR/DebugInfo.cpp @@ -246,11 +246,12 @@ bool DIDescriptor::isScope() const { case dwarf::DW_TAG_lexical_block: case dwarf::DW_TAG_subprogram: case dwarf::DW_TAG_namespace: + case dwarf::DW_TAG_file_type: return true; default: break; } - return false; + return isType(); } /// isTemplateTypeParameter - Return true if the specified tag is @@ -419,12 +420,44 @@ static bool fieldIsMDNode(const MDNode *DbgNode, unsigned Elt) { return true; } +/// Check if a field at position Elt of a MDNode is a MDString. +static bool fieldIsMDString(const MDNode *DbgNode, unsigned Elt) { + Value *Fld = getField(DbgNode, Elt); + return !Fld || isa(Fld); +} + +/// Check if a value can be a reference to a type. +static bool isTypeRef(const Value *Val) { + return !Val || + (isa(Val) && !cast(Val)->getString().empty()) || + (isa(Val) && DIType(cast(Val)).isType()); +} + +/// Check if a field at position Elt of a MDNode can be a reference to a type. +static bool fieldIsTypeRef(const MDNode *DbgNode, unsigned Elt) { + Value *Fld = getField(DbgNode, Elt); + return isTypeRef(Fld); +} + +/// Check if a value can be a ScopeRef. +static bool isScopeRef(const Value *Val) { + return !Val || + (isa(Val) && !cast(Val)->getString().empty()) || + (isa(Val) && DIScope(cast(Val)).isScope()); +} + +/// Check if a field at position Elt of a MDNode can be a ScopeRef. +static bool fieldIsScopeRef(const MDNode *DbgNode, unsigned Elt) { + Value *Fld = getField(DbgNode, Elt); + return isScopeRef(Fld); +} + /// Verify - Verify that a type descriptor is well formed. bool DIType::Verify() const { if (!isType()) return false; // Make sure Context @ field 2 is MDNode. - if (!fieldIsMDNode(DbgNode, 2)) + if (!fieldIsScopeRef(DbgNode, 2)) return false; // FIXME: Sink this into the various subclass verifies. @@ -464,8 +497,8 @@ bool DIDerivedType::Verify() const { if (!fieldIsMDNode(DbgNode, 9)) return false; if (getTag() == dwarf::DW_TAG_ptr_to_member_type) - // Make sure ClassType @ field 10 is MDNode. - if (!fieldIsMDNode(DbgNode, 10)) + // Make sure ClassType @ field 10 is a TypeRef. + if (!fieldIsTypeRef(DbgNode, 10)) return false; return isDerivedType() && DbgNode->getNumOperands() >= 10 && @@ -480,7 +513,11 @@ bool DICompositeType::Verify() const { // Make sure DerivedFrom @ field 9 and ContainingType @ field 12 are MDNodes. if (!fieldIsMDNode(DbgNode, 9)) return false; - if (!fieldIsMDNode(DbgNode, 12)) + if (!fieldIsTypeRef(DbgNode, 12)) + return false; + + // Make sure the type identifier at field 14 is MDString, it can be null. + if (!fieldIsMDString(DbgNode, 14)) return false; // If this is an array type verify that we have a DIType in the derived type @@ -489,7 +526,7 @@ bool DICompositeType::Verify() const { if (!DIType(getTypeDerivedFrom())) return false; - return DbgNode->getNumOperands() >= 10 && DbgNode->getNumOperands() <= 14; + return DbgNode->getNumOperands() == 15; } /// Verify - Verify that a subprogram descriptor is well formed. @@ -503,7 +540,7 @@ bool DISubprogram::Verify() const { if (!fieldIsMDNode(DbgNode, 7)) return false; // Containing type @ field 12. - if (!fieldIsMDNode(DbgNode, 12)) + if (!fieldIsTypeRef(DbgNode, 12)) return false; return DbgNode->getNumOperands() == 20; } @@ -635,22 +672,72 @@ MDNode *DIDerivedType::getObjCProperty() const { return getNodeField(DbgNode, 10); } +MDString *DICompositeType::getIdentifier() const { + return cast_or_null(getField(DbgNode, 14)); +} + +#ifndef NDEBUG +static void VerifySubsetOf(const MDNode *LHS, const MDNode *RHS) { + for (unsigned i = 0; i != LHS->getNumOperands(); ++i) { + // Skip the 'empty' list (that's a single i32 0, rather than truly empty). + if (i == 0 && isa(LHS->getOperand(i))) + continue; + const MDNode *E = cast(LHS->getOperand(i)); + bool found = false; + for (unsigned j = 0; !found && j != RHS->getNumOperands(); ++j) + found = E == RHS->getOperand(j); + assert(found && "Losing a member during member list replacement"); + } +} +#endif + /// \brief Set the array of member DITypes. void DICompositeType::setTypeArray(DIArray Elements, DIArray TParams) { - assert((!TParams || DbgNode->getNumOperands() == 14) && + assert((!TParams || DbgNode->getNumOperands() == 15) && "If you're setting the template parameters this should include a slot " "for that!"); TrackingVH N(*this); - N->replaceOperandWith(10, Elements); + if (Elements) { +#ifndef NDEBUG + // Check that the new list of members contains all the old members as well. + if (const MDNode *El = cast_or_null(N->getOperand(10))) + VerifySubsetOf(El, Elements); +#endif + N->replaceOperandWith(10, Elements); + } if (TParams) N->replaceOperandWith(13, TParams); DbgNode = N; } +void DICompositeType::addMember(DIDescriptor D) { + SmallVector M; + DIArray OrigM = getTypeArray(); + unsigned Elements = OrigM.getNumElements(); + if (Elements == 1 && !OrigM.getElement(0)) + Elements = 0; + M.reserve(Elements + 1); + for (unsigned i = 0; i != Elements; ++i) + M.push_back(OrigM.getElement(i)); + M.push_back(D); + setTypeArray(DIArray(MDNode::get(DbgNode->getContext(), M))); +} + +/// Generate a reference to this DIType. Uses the type identifier instead +/// of the actual MDNode if possible, to help type uniquing. +DIScopeRef DIScope::generateRef() { + if (!isCompositeType()) + return DIScopeRef(*this); + DICompositeType DTy(DbgNode); + if (!DTy.getIdentifier()) + return DIScopeRef(*this); + return DIScopeRef(DTy.getIdentifier()); +} + /// \brief Set the containing type. void DICompositeType::setContainingType(DICompositeType ContainingType) { TrackingVH N(*this); - N->replaceOperandWith(12, ContainingType); + N->replaceOperandWith(12, ContainingType.generateRef()); DbgNode = N; } @@ -700,25 +787,25 @@ Value *DITemplateValueParameter::getValue() const { // If the current node has a parent scope then return that, // else return an empty scope. -DIScope DIScope::getContext() const { +DIScopeRef DIScope::getContext() const { if (isType()) return DIType(DbgNode).getContext(); if (isSubprogram()) - return DISubprogram(DbgNode).getContext(); + return DIScopeRef(DISubprogram(DbgNode).getContext()); if (isLexicalBlock()) - return DILexicalBlock(DbgNode).getContext(); + return DIScopeRef(DILexicalBlock(DbgNode).getContext()); if (isLexicalBlockFile()) - return DILexicalBlockFile(DbgNode).getContext(); + return DIScopeRef(DILexicalBlockFile(DbgNode).getContext()); if (isNameSpace()) - return DINameSpace(DbgNode).getContext(); + return DIScopeRef(DINameSpace(DbgNode).getContext()); assert((isFile() || isCompileUnit()) && "Unhandled type of scope."); - return DIScope(); + return DIScopeRef(NULL); } StringRef DIScope::getFilename() const { @@ -861,17 +948,30 @@ DICompositeType llvm::getDICompositeType(DIType T) { return DICompositeType(); } -/// isSubprogramContext - Return true if Context is either a subprogram -/// or another context nested inside a subprogram. -bool llvm::isSubprogramContext(const MDNode *Context) { - if (!Context) - return false; - DIDescriptor D(Context); - if (D.isSubprogram()) - return true; - if (D.isType()) - return isSubprogramContext(DIType(Context).getContext()); - return false; +/// Update DITypeIdentifierMap by going through retained types of each CU. +DITypeIdentifierMap llvm::generateDITypeIdentifierMap( + const NamedMDNode *CU_Nodes) { + DITypeIdentifierMap Map; + for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) { + DICompileUnit CU(CU_Nodes->getOperand(CUi)); + DIArray Retain = CU.getRetainedTypes(); + for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) { + if (!Retain.getElement(Ti).isCompositeType()) + continue; + DICompositeType Ty(Retain.getElement(Ti)); + if (MDString *TypeId = Ty.getIdentifier()) { + // Definition has priority over declaration. + // Try to insert (TypeId, Ty) to Map. + std::pair P = + Map.insert(std::make_pair(TypeId, Ty)); + // If TypeId already exists in Map and this is a definition, replace + // whatever we had (declaration or definition) with the definition. + if (!P.second && !Ty.isForwardDecl()) + P.first->second = Ty; + } + } + } + return Map; } //===----------------------------------------------------------------------===// @@ -885,11 +985,13 @@ void DebugInfoFinder::reset() { TYs.clear(); Scopes.clear(); NodesSeen.clear(); + TypeIdentifierMap.clear(); } /// processModule - Process entire module and collect debug info. void DebugInfoFinder::processModule(const Module &M) { if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) { + TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes); for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { DICompileUnit CU(CU_Nodes->getOperand(i)); addCompileUnit(CU); @@ -910,6 +1012,18 @@ void DebugInfoFinder::processModule(const Module &M) { DIArray RetainedTypes = CU.getRetainedTypes(); for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) processType(DIType(RetainedTypes.getElement(i))); + DIArray Imports = CU.getImportedEntities(); + for (unsigned i = 0, e = Imports.getNumElements(); i != e; ++i) { + DIImportedEntity Import = DIImportedEntity( + Imports.getElement(i)); + DIDescriptor Entity = Import.getEntity(); + if (Entity.isType()) + processType(DIType(Entity)); + else if (Entity.isSubprogram()) + processSubprogram(DISubprogram(Entity)); + else if (Entity.isNameSpace()) + processScope(DINameSpace(Entity).getContext()); + } // FIXME: We really shouldn't be bailing out after visiting just one CU return; } @@ -927,7 +1041,7 @@ void DebugInfoFinder::processLocation(DILocation Loc) { void DebugInfoFinder::processType(DIType DT) { if (!addType(DT)) return; - processScope(DT.getContext()); + processScope(DT.getContext().resolve(TypeIdentifierMap)); if (DT.isCompositeType()) { DICompositeType DCT(DT); processType(DCT.getTypeDerivedFrom()); @@ -992,6 +1106,19 @@ void DebugInfoFinder::processSubprogram(DISubprogram SP) { return; processScope(SP.getContext()); processType(SP.getType()); + DIArray TParams = SP.getTemplateParams(); + for (unsigned I = 0, E = TParams.getNumElements(); I != E; ++I) { + DIDescriptor Element = TParams.getElement(I); + if (Element.isTemplateTypeParameter()) { + DITemplateTypeParameter TType(Element); + processScope(TType.getContext()); + processType(TType.getType()); + } else if (Element.isTemplateValueParameter()) { + DITemplateValueParameter TVal(Element); + processScope(TVal.getContext()); + processType(TVal.getType()); + } + } } /// processDeclare - Process DbgDeclareInst. @@ -1304,3 +1431,28 @@ void DIVariable::printExtendedName(raw_ostream &OS) const { } } } + +/// Specialize constructor to make sure it has the correct type. +template <> +DIRef::DIRef(const Value *V) : Val(V) { + assert(isScopeRef(V) && "DIScopeRef should be a MDString or MDNode"); +} +template <> +DIRef::DIRef(const Value *V) : Val(V) { + assert(isTypeRef(V) && "DITypeRef should be a MDString or MDNode"); +} + +/// Specialize getFieldAs to handle fields that are references to DIScopes. +template <> +DIScopeRef DIDescriptor::getFieldAs(unsigned Elt) const { + return DIScopeRef(getField(DbgNode, Elt)); +} +/// Specialize getFieldAs to handle fields that are references to DITypes. +template <> +DITypeRef DIDescriptor::getFieldAs(unsigned Elt) const { + return DITypeRef(getField(DbgNode, Elt)); +} + +DIScopeRef DIType::getContext() const { + return getFieldAs(2); +}