class DIType;
class DIArray;
class DIGlobalVariable;
- class DIImportedModule;
+ class DIImportedEntity;
class DINameSpace;
class DIVariable;
class DISubrange;
/// @param Context The scope this module is imported into
/// @param NS The namespace being imported here
/// @param Line Line number
- DIImportedModule createImportedModule(DIScope Context, DINameSpace NS,
+ DIImportedEntity createImportedModule(DIScope Context, DINameSpace NS,
unsigned Line);
+ /// \brief Create a descriptor for an imported function.
+ /// @param Context The scope this module is imported into
+ /// @param Decl The declaration (or definition) of a function, type, or
+ /// variable
+ /// @param Line Line number
+ DIImportedEntity createImportedDeclaration(DIScope Context,
+ DIDescriptor Decl,
+ unsigned Line);
+
/// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
/// @param Storage llvm::Value of the variable
/// @param VarInfo Variable's debug info descriptor.
bool isTemplateTypeParameter() const;
bool isTemplateValueParameter() const;
bool isObjCProperty() const;
- bool isImportedModule() const;
+ bool isImportedEntity() const;
/// print - print descriptor.
void print(raw_ostream &OS) const;
DIArray getRetainedTypes() const;
DIArray getSubprograms() const;
DIArray getGlobalVariables() const;
- DIArray getImportedModules() const;
+ DIArray getImportedEntities() const;
StringRef getSplitDebugFilename() const { return getStringField(12); }
};
/// \brief An imported module (C++ using directive or similar).
- class DIImportedModule : public DIDescriptor {
+ class DIImportedEntity : public DIDescriptor {
friend class DIDescriptor;
void printInternal(raw_ostream &OS) const;
public:
- explicit DIImportedModule(const MDNode *N) : DIDescriptor(N) { }
+ explicit DIImportedEntity(const MDNode *N) : DIDescriptor(N) { }
DIScope getContext() const { return getFieldAs<DIScope>(1); }
- DINameSpace getNameSpace() const { return getFieldAs<DINameSpace>(2); }
+ DIDescriptor getEntity() const { return getFieldAs<DIDescriptor>(2); }
unsigned getLineNumber() const { return getUnsignedField(3); }
bool Verify() const;
};
TheCU->addGlobalName(SP.getName(), SubprogramDie);
}
-void DwarfDebug::constructImportedModuleDIE(CompileUnit *TheCU,
+void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
const MDNode *N) {
- DIImportedModule Module(N);
+ DIImportedEntity Module(N);
if (!Module.Verify())
return;
if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
void DwarfDebug::constructImportedModuleDIE(CompileUnit *TheCU, const MDNode *N,
DIE *Context) {
- DIImportedModule Module(N);
+ DIImportedEntity Module(N);
if (!Module.Verify())
return;
return constructImportedModuleDIE(TheCU, Module, Context);
}
void DwarfDebug::constructImportedModuleDIE(CompileUnit *TheCU,
- const DIImportedModule &Module,
+ const DIImportedEntity &Module,
DIE *Context) {
assert(Module.Verify() &&
"Use one of the MDNode * overloads to handle invalid metadata");
assert(Context && "Should always have a context for an imported_module");
- DIE *IMDie = new DIE(dwarf::DW_TAG_imported_module);
+ DIE *IMDie = new DIE(Module.getTag());
TheCU->insertDIE(Module, IMDie);
- DIE *NSDie = TheCU->getOrCreateNameSpace(Module.getNameSpace());
+ DIE *EntityDie;
+ DIDescriptor Entity = Module.getEntity();
+ if (Entity.isNameSpace())
+ EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
+ else if (Entity.isSubprogram())
+ EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
+ else
+ return;
unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
Module.getContext().getDirectory(),
TheCU->getUniqueID());
TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
- TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, NSDie);
+ TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, EntityDie);
Context->addChild(IMDie);
}
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
DICompileUnit CUNode(CU_Nodes->getOperand(i));
CompileUnit *CU = constructCompileUnit(CUNode);
- DIArray ImportedModules = CUNode.getImportedModules();
- for (unsigned i = 0, e = ImportedModules.getNumElements(); i != e; ++i)
+ DIArray ImportedEntities = CUNode.getImportedEntities();
+ for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
ScopesWithImportedEntities.push_back(std::make_pair(
- DIImportedModule(ImportedModules.getElement(i)).getContext(),
- ImportedModules.getElement(i)));
+ DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
+ ImportedEntities.getElement(i)));
std::sort(ScopesWithImportedEntities.begin(),
ScopesWithImportedEntities.end(), CompareFirst());
DIArray GVs = CUNode.getGlobalVariables();
CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
// Emit imported_modules last so that the relevant context is already
// available.
- for (unsigned i = 0, e = ImportedModules.getNumElements(); i != e; ++i)
- constructImportedModuleDIE(CU, ImportedModules.getElement(i));
+ for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
+ constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
// If we're splitting the dwarf out now that we've got the entire
// CU then construct a skeleton CU based upon it.
if (useSplitDwarf()) {
/// \brief Construct subprogram DIE.
void constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N);
- /// \brief Construct import_module DIE.
- void constructImportedModuleDIE(CompileUnit *TheCU, const MDNode *N);
+ /// \brief Construct imported_module or imported_declaration DIE.
+ void constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N);
/// \brief Construct import_module DIE.
void constructImportedModuleDIE(CompileUnit *TheCU, const MDNode *N,
/// \brief Construct import_module DIE.
void constructImportedModuleDIE(CompileUnit *TheCU,
- const DIImportedModule &Module,
+ const DIImportedEntity &Module,
DIE *Context);
/// \brief Register a source line with debug info. Returns the unique
NMD->addOperand(TheCU);
}
-DIImportedModule DIBuilder::createImportedModule(DIScope Context,
+DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
DINameSpace NS,
unsigned Line) {
Value *Elts[] = {
NS,
ConstantInt::get(Type::getInt32Ty(VMContext), Line),
};
- DIImportedModule M(MDNode::get(VMContext, Elts));
+ DIImportedEntity M(MDNode::get(VMContext, Elts));
+ assert(M.Verify() && "Imported module should be valid");
+ AllImportedModules.push_back(M);
+ return M;
+}
+
+DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
+ DIDescriptor Decl,
+ unsigned Line) {
+ Value *Elts[] = {
+ GetTagConstant(VMContext, dwarf::DW_TAG_imported_declaration),
+ Context,
+ Decl,
+ ConstantInt::get(Type::getInt32Ty(VMContext), Line),
+ };
+ DIImportedEntity M(MDNode::get(VMContext, Elts));
assert(M.Verify() && "Imported module should be valid");
AllImportedModules.push_back(M);
return M;
DIObjCProperty(DbgNode).Verify() ||
DITemplateTypeParameter(DbgNode).Verify() ||
DITemplateValueParameter(DbgNode).Verify() ||
- DIImportedModule(DbgNode).Verify());
+ DIImportedEntity(DbgNode).Verify());
}
static Value *getField(const MDNode *DbgNode, unsigned Elt) {
return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property;
}
-/// \brief Return true if the specified tag is DW_TAG_imported_module.
-bool DIDescriptor::isImportedModule() const {
- return DbgNode && getTag() == dwarf::DW_TAG_imported_module;
+/// \brief Return true if the specified tag is DW_TAG_imported_module or
+/// DW_TAG_imported_declaration.
+bool DIDescriptor::isImportedEntity() const {
+ return DbgNode && (getTag() == dwarf::DW_TAG_imported_module ||
+ getTag() == dwarf::DW_TAG_imported_declaration);
}
//===----------------------------------------------------------------------===//
}
/// \brief Verify that the imported module descriptor is well formed.
-bool DIImportedModule::Verify() const {
- return isImportedModule() && DbgNode->getNumOperands() == 4;
+bool DIImportedEntity::Verify() const {
+ return isImportedEntity() && DbgNode->getNumOperands() == 4;
}
/// getOriginalTypeSize - If this type is derived from a base type then
return DIArray();
}
-DIArray DICompileUnit::getImportedModules() const {
+DIArray DICompileUnit::getImportedEntities() const {
if (!DbgNode || DbgNode->getNumOperands() < 13)
return DIArray();