#include "llvm/Support/Dwarf.h"
#include "llvm/ADT/UniqueVector.h"
+#include "llvm/GlobalValue.h"
#include "llvm/Pass.h"
#include "llvm/User.h"
//===----------------------------------------------------------------------===//
// Forward declarations.
+class Constant;
class DebugInfoDesc;
class GlobalVariable;
class Module;
// DebugInfoDesc type identifying tags.
// FIXME - Change over with gcc4.
+ DI_TAG_anchor = 0,
#if 1
DI_TAG_compile_unit = DW_TAG_compile_unit,
DI_TAG_global_variable = DW_TAG_variable,
DI_TAG_subprogram = DW_TAG_subprogram
#else
- DI_TAG_compile_unit = 1,
+ DI_TAG_compile_unit,
DI_TAG_global_variable,
DI_TAG_subprogram
#endif
/// Return NULL if not a recognized Tag.
static DebugInfoDesc *DescFactory(unsigned Tag);
+ /// getLinkage - get linkage appropriate for this type of descriptor.
+ ///
+ virtual GlobalValue::LinkageTypes getLinkage() const;
+
//===--------------------------------------------------------------------===//
// Subclasses should supply the following static methods.
/// ApplyToFields - Target the vistor to the fields of the descriptor.
///
- virtual void ApplyToFields(DIVisitor *Visitor) = 0;
+ virtual void ApplyToFields(DIVisitor *Visitor);
- /// TypeString - Return a string used to compose globalnames and labels.
+ /// getDescString - Return a string used to compose global names and labels.
///
- virtual const char *TypeString() const = 0;
+ virtual const char *getDescString() const = 0;
+
+ /// getTypeString - Return a string used to label this descriptor's type.
+ ///
+ virtual const char *getTypeString() const = 0;
#ifndef NDEBUG
virtual void dump() = 0;
};
+//===----------------------------------------------------------------------===//
+/// AnchorDesc - Descriptors of this class act as markers for identifying
+/// descriptors of certain groups.
+class AnchorDesc : public DebugInfoDesc {
+private:
+ std::string Name; // Anchor type string.
+
+public:
+ AnchorDesc()
+ : DebugInfoDesc(DI_TAG_anchor)
+ , Name("")
+ {}
+ AnchorDesc(const std::string &N)
+ : DebugInfoDesc(DI_TAG_anchor)
+ , Name(N)
+ {}
+
+ // Accessors
+ const std::string &getName() const { return Name; }
+
+ // Implement isa/cast/dyncast.
+ static bool classof(const AnchorDesc *) { return true; }
+ static bool classof(const DebugInfoDesc *D) {
+ return D->getTag() == DI_TAG_anchor;
+ }
+
+ /// getLinkage - get linkage appropriate for this type of descriptor.
+ ///
+ virtual GlobalValue::LinkageTypes getLinkage() const;
+
+ /// ApplyToFields - Target the visitor to the fields of the AnchorDesc.
+ ///
+ virtual void ApplyToFields(DIVisitor *Visitor);
+
+ /// getDescString - Return a string used to compose global names and labels.
+ ///
+ virtual const char *getDescString() const;
+
+ /// getTypeString - Return a string used to label this descriptor's type.
+ ///
+ virtual const char *getTypeString() const;
+
+#ifndef NDEBUG
+ virtual void dump();
+#endif
+};
+
+//===----------------------------------------------------------------------===//
+/// AnchoredDesc - This class manages anchors for a variety of top level
+/// descriptors.
+class AnchoredDesc : public DebugInfoDesc {
+private:
+ AnchorDesc *Anchor; // Anchor for all descriptors of the
+ // same type.
+
+protected:
+
+ AnchoredDesc(unsigned T);
+
+public:
+ // Accessors.
+ AnchorDesc *getAnchor() const { return Anchor; }
+ void setAnchor(AnchorDesc *A) { Anchor = A; }
+
+ //===--------------------------------------------------------------------===//
+ // Subclasses should supply the following virtual methods.
+
+ /// ApplyToFields - Target the visitor to the fields of the AnchoredDesc.
+ ///
+ virtual void ApplyToFields(DIVisitor *Visitor);
+};
+
//===----------------------------------------------------------------------===//
/// CompileUnitDesc - This class packages debug information associated with a
/// source/header file.
-class CompileUnitDesc : public DebugInfoDesc {
+class CompileUnitDesc : public AnchoredDesc {
private:
unsigned DebugVersion; // LLVM debug version when produced.
unsigned Language; // Language number (ex. DW_LANG_C89.)
std::string FileName; // Source file name.
std::string Directory; // Source file directory.
std::string Producer; // Compiler string.
- GlobalVariable *TransUnit; // Translation unit - ignored.
public:
- CompileUnitDesc()
- : DebugInfoDesc(DI_TAG_compile_unit)
- , DebugVersion(LLVMDebugVersion)
- , Language(0)
- , FileName("")
- , Directory("")
- , Producer("")
- , TransUnit(NULL)
- {}
+ CompileUnitDesc();
// Accessors
unsigned getDebugVersion() const { return DebugVersion; }
void setFileName(const std::string &FN) { FileName = FN; }
void setDirectory(const std::string &D) { Directory = D; }
void setProducer(const std::string &P) { Producer = P; }
+
// FIXME - Need translation unit getter/setter.
// Implement isa/cast/dyncast.
///
virtual void ApplyToFields(DIVisitor *Visitor);
- /// TypeString - Return a string used to compose globalnames and labels.
+ /// getDescString - Return a string used to compose global names and labels.
+ ///
+ virtual const char *getDescString() const;
+
+ /// getTypeString - Return a string used to label this descriptor's type.
+ ///
+ virtual const char *getTypeString() const;
+
+ /// getAnchorString - Return a string used to label this descriptor's anchor.
///
- virtual const char *TypeString() const;
+ virtual const char *getAnchorString() const;
#ifndef NDEBUG
virtual void dump();
};
//===----------------------------------------------------------------------===//
-/// GlobalVariableDesc - This class packages debug information associated with a
-/// GlobalVariable.
-class GlobalVariableDesc : public DebugInfoDesc {
+/// GlobalDesc - This class is the base descriptor for global functions and
+/// variables.
+class GlobalDesc : public AnchoredDesc {
private:
DebugInfoDesc *Context; // Context debug descriptor.
std::string Name; // Global name.
- GlobalVariable *TransUnit; // Translation unit - ignored.
// FIXME - Use a descriptor.
GlobalVariable *TyDesc; // Type debug descriptor.
bool IsStatic; // Is the global a static.
bool IsDefinition; // Is the global defined in context.
- GlobalVariable *Global; // llvm global.
+protected:
+ GlobalDesc(unsigned T);
+
public:
- GlobalVariableDesc()
- : DebugInfoDesc(DI_TAG_global_variable)
- , Context(0)
- , Name("")
- , TransUnit(NULL)
- , TyDesc(NULL)
- , IsStatic(false)
- , IsDefinition(false)
- , Global(NULL)
- {}
-
// Accessors
DebugInfoDesc *getContext() const { return Context; }
const std::string &getName() const { return Name; }
bool isStatic() const { return IsStatic; }
bool isDefinition() const { return IsDefinition; }
- GlobalVariable *getGlobalVariable() const { return Global; }
+ void setContext(DebugInfoDesc *C) { Context = C; }
void setName(const std::string &N) { Name = N; }
void setIsStatic(bool IS) { IsStatic = IS; }
void setIsDefinition(bool ID) { IsDefinition = ID; }
+
+ /// ApplyToFields - Target the visitor to the fields of the GlobalDesc.
+ ///
+ virtual void ApplyToFields(DIVisitor *Visitor);
+};
+
+//===----------------------------------------------------------------------===//
+/// GlobalVariableDesc - This class packages debug information associated with a
+/// GlobalVariable.
+class GlobalVariableDesc : public GlobalDesc {
+private:
+ GlobalVariable *Global; // llvm global.
+
+public:
+ GlobalVariableDesc();
+
+ // Accessors.
+ GlobalVariable *getGlobalVariable() const { return Global; }
void setGlobalVariable(GlobalVariable *GV) { Global = GV; }
- // FIXME - Other getters/setters.
// Implement isa/cast/dyncast.
static bool classof(const GlobalVariableDesc *) { return true; }
/// GlobalVariableDesc.
virtual void ApplyToFields(DIVisitor *Visitor);
- /// TypeString - Return a string used to compose globalnames and labels.
+ /// getDescString - Return a string used to compose global names and labels.
///
- virtual const char *TypeString() const;
+ virtual const char *getDescString() const;
+ /// getTypeString - Return a string used to label this descriptor's type.
+ ///
+ virtual const char *getTypeString() const;
+
+ /// getAnchorString - Return a string used to label this descriptor's anchor.
+ ///
+ virtual const char *getAnchorString() const;
+
#ifndef NDEBUG
virtual void dump();
#endif
//===----------------------------------------------------------------------===//
/// SubprogramDesc - This class packages debug information associated with a
/// subprogram/function.
-class SubprogramDesc : public DebugInfoDesc {
+class SubprogramDesc : public GlobalDesc {
private:
DebugInfoDesc *Context; // Context debug descriptor.
std::string Name; // Subprogram name.
- GlobalVariable *TransUnit; // Translation unit - ignored.
// FIXME - Use a descriptor.
GlobalVariable *TyDesc; // Type debug descriptor.
bool IsStatic; // Is the subprogram a static.
bool IsDefinition; // Is the subprogram defined in context.
public:
- SubprogramDesc()
- : DebugInfoDesc(DI_TAG_subprogram)
- , Context(0)
- , Name("")
- , TransUnit(NULL)
- , TyDesc(NULL)
- , IsStatic(false)
- , IsDefinition(false)
- {}
+ SubprogramDesc();
// Accessors
DebugInfoDesc *getContext() const { return Context; }
const std::string &getName() const { return Name; }
bool isStatic() const { return IsStatic; }
bool isDefinition() const { return IsDefinition; }
+ void setContext(DebugInfoDesc *C) { Context = C; }
void setName(const std::string &N) { Name = N; }
void setIsStatic(bool IS) { IsStatic = IS; }
void setIsDefinition(bool ID) { IsDefinition = ID; }
///
virtual void ApplyToFields(DIVisitor *Visitor);
- /// TypeString - Return a string used to compose globalnames and labels.
+ /// getDescString - Return a string used to compose global names and labels.
///
- virtual const char *TypeString() const;
+ virtual const char *getDescString() const;
+ /// getTypeString - Return a string used to label this descriptor's type.
+ ///
+ virtual const char *getTypeString() const;
+
+ /// getAnchorString - Return a string used to label this descriptor's anchor.
+ ///
+ virtual const char *getAnchorString() const;
+
#ifndef NDEBUG
virtual void dump();
#endif
/// into DebugInfoDesc objects.
class DIDeserializer {
private:
- Module *M; // Definition space module.
unsigned DebugVersion; // Version of debug information in use.
std::map<GlobalVariable *, DebugInfoDesc *> GlobalDescs;
// Previously defined gloabls.
public:
- DIDeserializer() : M(NULL), DebugVersion(LLVMDebugVersion) {}
+ DIDeserializer() : DebugVersion(LLVMDebugVersion) {}
~DIDeserializer() {}
// Accessors
- Module *getModule() const { return M; };
- void setModule(Module *module) { M = module; }
unsigned getDebugVersion() const { return DebugVersion; }
/// Deserialize - Reconstitute a GlobalVariable into it's component
// Types per Tag. Created lazily.
std::map<DebugInfoDesc *, GlobalVariable *> DescGlobals;
// Previously defined descriptors.
- std::map<const std::string, GlobalVariable*> StringCache;
+ std::map<const std::string, Constant *> StringCache;
// Previously defined strings.
+
public:
- DISerializer() : M(NULL) {}
+ DISerializer()
+ : M(NULL)
+ , StrPtrTy(NULL)
+ , EmptyStructPtrTy(NULL)
+ , TagTypes()
+ , DescGlobals()
+ , StringCache()
+ {}
~DISerializer() {}
// Accessors
/// getString - Construct the string as constant string global.
///
- GlobalVariable *getString(const std::string &String);
+ Constant *getString(const std::string &String);
/// Serialize - Recursively cast the specified descriptor into a
/// GlobalVariable so that it can be serialized to a .bc or .ll file.
/// Verify - Return true if the GlobalVariable appears to be a valid
/// serialization of a DebugInfoDesc.
+ bool Verify(Value *V);
bool Verify(GlobalVariable *GV);
};
class MachineDebugInfo : public ImmutablePass {
private:
// Use the same serializer/deserializer/verifier for the module.
- DISerializer SR;
DIDeserializer DR;
- DIVerifier VR;
// CompileUnits - Uniquing vector for compile units.
UniqueVector<CompileUnitDesc *> CompileUnits;
///
bool doFinalization();
+ /// Deserialize - Convert a Value to a debug information descriptor.
+ ///
+ DebugInfoDesc *Deserialize(Value *V);
+
+ /// Verify - Verify that a Value is debug information descriptor.
+ ///
+ bool Verify(Value *V);
+
/// AnalyzeModule - Scan the module for global debug information.
///
void AnalyzeModule(Module &M);
static std::vector<GlobalVariable*>
getGlobalVariablesUsing(Module &M, const std::string &RootName) {
std::vector<GlobalVariable*> Result; // GlobalVariables matching criteria.
+
+ std::vector<const Type*> FieldTypes;
+ FieldTypes.push_back(Type::UIntTy);
+ FieldTypes.push_back(PointerType::get(Type::SByteTy));
// Get the GlobalVariable root.
GlobalVariable *UseRoot = M.getGlobalVariable(RootName,
- StructType::get(std::vector<const Type*>()));
+ StructType::get(FieldTypes));
// If present and linkonce then scan for users.
if (UseRoot && UseRoot->hasLinkOnceLinkage()) {
// Check constant.
return dyn_cast<ConstantUInt>(CI->getOperand(i));
}
-
-//===----------------------------------------------------------------------===//
-
-/// TagFromGlobal - Returns the Tag number from a debug info descriptor
-/// GlobalVariable.
-unsigned DebugInfoDesc::TagFromGlobal(GlobalVariable *GV) {
- ConstantUInt *C = getUIntOperand(GV, 0);
- return C ? (unsigned)C->getValue() : (unsigned)DIInvalid;
-}
-
-/// DescFactory - Create an instance of debug info descriptor based on Tag.
-/// Return NULL if not a recognized Tag.
-DebugInfoDesc *DebugInfoDesc::DescFactory(unsigned Tag) {
- switch (Tag) {
- case DI_TAG_compile_unit: return new CompileUnitDesc();
- case DI_TAG_global_variable: return new GlobalVariableDesc();
- case DI_TAG_subprogram: return new SubprogramDesc();
- default: break;
- }
- return NULL;
-}
-
//===----------------------------------------------------------------------===//
/// ApplyToFields - Target the visitor to each field of the debug information
unsigned Count; // Running count of fields.
public:
- DICountVisitor() : DIVisitor(), Count(1) {}
+ DICountVisitor() : DIVisitor(), Count(0) {}
// Accessors.
unsigned getCount() const { return Count; }
DIDeserializeVisitor(DIDeserializer &D, GlobalVariable *GV)
: DIVisitor()
, DR(D)
- , I(1)
+ , I(0)
, CI(cast<ConstantStruct>(GV->getInitializer()))
{}
/// Apply - Set the value of each of the fields.
///
virtual void Apply(int &Field) {
- Elements.push_back(ConstantUInt::get(Type::IntTy, Field));
+ Elements.push_back(ConstantSInt::get(Type::IntTy, Field));
}
virtual void Apply(unsigned &Field) {
Elements.push_back(ConstantUInt::get(Type::UIntTy, Field));
}
virtual void Apply(GlobalVariable *&Field) {
const PointerType *EmptyTy = SR.getEmptyStructPtrType();
- Elements.push_back(ConstantExpr::getCast(Field, EmptyTy));
+ if (Field) {
+ Elements.push_back(ConstantExpr::getCast(Field, EmptyTy));
+ } else {
+ Elements.push_back(ConstantPointerNull::get(EmptyTy));
+ }
}
};
: DIVisitor()
, VR(V)
, IsValid(true)
- , I(1)
+ , I(0)
, CI(cast<ConstantStruct>(GV->getInitializer()))
{
}
}
};
+
+//===----------------------------------------------------------------------===//
+
+/// TagFromGlobal - Returns the Tag number from a debug info descriptor
+/// GlobalVariable.
+unsigned DebugInfoDesc::TagFromGlobal(GlobalVariable *GV) {
+ ConstantUInt *C = getUIntOperand(GV, 0);
+ return C ? (unsigned)C->getValue() : (unsigned)DIInvalid;
+}
+
+/// DescFactory - Create an instance of debug info descriptor based on Tag.
+/// Return NULL if not a recognized Tag.
+DebugInfoDesc *DebugInfoDesc::DescFactory(unsigned Tag) {
+ switch (Tag) {
+ case DI_TAG_anchor: return new AnchorDesc();
+ case DI_TAG_compile_unit: return new CompileUnitDesc();
+ case DI_TAG_global_variable: return new GlobalVariableDesc();
+ case DI_TAG_subprogram: return new SubprogramDesc();
+ default: break;
+ }
+ return NULL;
+}
+
+/// getLinkage - get linkage appropriate for this type of descriptor.
+///
+GlobalValue::LinkageTypes DebugInfoDesc::getLinkage() const {
+ return GlobalValue::InternalLinkage;
+}
+
+/// ApplyToFields - Target the vistor to the fields of the descriptor.
+///
+void DebugInfoDesc::ApplyToFields(DIVisitor *Visitor) {
+ Visitor->Apply(Tag);
+}
+
+//===----------------------------------------------------------------------===//
+
+/// getLinkage - get linkage appropriate for this type of descriptor.
+///
+GlobalValue::LinkageTypes AnchorDesc::getLinkage() const {
+ return GlobalValue::LinkOnceLinkage;
+}
+
+/// ApplyToFields - Target the visitor to the fields of the TransUnitDesc.
+///
+void AnchorDesc::ApplyToFields(DIVisitor *Visitor) {
+ DebugInfoDesc::ApplyToFields(Visitor);
+
+ Visitor->Apply(Name);
+}
+
+/// getDescString - Return a string used to compose global names and labels.
+///
+const char *AnchorDesc::getDescString() const {
+ return Name.c_str();
+}
+
+/// getTypeString - Return a string used to label this descriptors type.
+///
+const char *AnchorDesc::getTypeString() const {
+ return "llvm.dbg.anchor.type";
+}
+
+#ifndef NDEBUG
+void AnchorDesc::dump() {
+ std::cerr << getDescString() << " "
+ << "Tag(" << getTag() << "), "
+ << "Name(" << Name << ")\n";
+}
+#endif
+
+//===----------------------------------------------------------------------===//
+
+AnchoredDesc::AnchoredDesc(unsigned T)
+: DebugInfoDesc(T)
+, Anchor(NULL)
+{}
+
+/// ApplyToFields - Target the visitor to the fields of the AnchoredDesc.
+///
+void AnchoredDesc::ApplyToFields(DIVisitor *Visitor) {
+ DebugInfoDesc::ApplyToFields(Visitor);
+
+ Visitor->Apply((DebugInfoDesc *&)Anchor);
+}
+
//===----------------------------------------------------------------------===//
+CompileUnitDesc::CompileUnitDesc()
+: AnchoredDesc(DI_TAG_compile_unit)
+, DebugVersion(LLVMDebugVersion)
+, Language(0)
+, FileName("")
+, Directory("")
+, Producer("")
+{}
+
/// DebugVersionFromGlobal - Returns the version number from a compile unit
/// GlobalVariable.
unsigned CompileUnitDesc::DebugVersionFromGlobal(GlobalVariable *GV) {
- ConstantUInt *C = getUIntOperand(GV, 1);
+ ConstantUInt *C = getUIntOperand(GV, 2);
return C ? (unsigned)C->getValue() : (unsigned)DIInvalid;
}
/// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc.
///
void CompileUnitDesc::ApplyToFields(DIVisitor *Visitor) {
+ AnchoredDesc::ApplyToFields(Visitor);
+
Visitor->Apply(DebugVersion);
Visitor->Apply(Language);
Visitor->Apply(FileName);
Visitor->Apply(Directory);
Visitor->Apply(Producer);
- Visitor->Apply(TransUnit);
}
-/// TypeString - Return a string used to compose globalnames and labels.
+/// getDescString - Return a string used to compose global names and labels.
+///
+const char *CompileUnitDesc::getDescString() const {
+ return "llvm.dbg.compile_unit";
+}
+
+/// getTypeString - Return a string used to label this descriptors type.
///
-const char *CompileUnitDesc::TypeString() const {
- return "compile_unit";
+const char *CompileUnitDesc::getTypeString() const {
+ return "llvm.dbg.compile_unit.type";
+}
+
+/// getAnchorString - Return a string used to label this descriptor's anchor.
+///
+const char *CompileUnitDesc::getAnchorString() const {
+ return "llvm.dbg.compile_units";
}
#ifndef NDEBUG
void CompileUnitDesc::dump() {
- std::cerr << TypeString() << " "
+ std::cerr << getDescString() << " "
<< "Tag(" << getTag() << "), "
+ << "Anchor(" << getAnchor() << "), "
+ << "DebugVersion(" << DebugVersion << "), "
<< "Language(" << Language << "), "
<< "FileName(\"" << FileName << "\"), "
<< "Directory(\"" << Directory << "\"), "
//===----------------------------------------------------------------------===//
-/// ApplyToFields - Target the visitor to the fields of the GlobalVariableDesc.
+GlobalDesc::GlobalDesc(unsigned T)
+: AnchoredDesc(T)
+, Context(0)
+, Name("")
+, TyDesc(NULL)
+, IsStatic(false)
+, IsDefinition(false)
+{}
+
+/// ApplyToFields - Target the visitor to the fields of the global.
///
-void GlobalVariableDesc::ApplyToFields(DIVisitor *Visitor) {
+void GlobalDesc::ApplyToFields(DIVisitor *Visitor) {
+ AnchoredDesc::ApplyToFields(Visitor);
+
Visitor->Apply(Context);
Visitor->Apply(Name);
- Visitor->Apply(TransUnit);
Visitor->Apply(TyDesc);
Visitor->Apply(IsStatic);
Visitor->Apply(IsDefinition);
+}
+
+//===----------------------------------------------------------------------===//
+
+GlobalVariableDesc::GlobalVariableDesc()
+: GlobalDesc(DI_TAG_global_variable)
+, Global(NULL)
+{}
+
+/// ApplyToFields - Target the visitor to the fields of the GlobalVariableDesc.
+///
+void GlobalVariableDesc::ApplyToFields(DIVisitor *Visitor) {
+ GlobalDesc::ApplyToFields(Visitor);
+
Visitor->Apply(Global);
}
-/// TypeString - Return a string used to compose globalnames and labels.
+/// getDescString - Return a string used to compose global names and labels.
///
-const char *GlobalVariableDesc::TypeString() const {
- return "global_variable";
+const char *GlobalVariableDesc::getDescString() const {
+ return "llvm.dbg.global_variable";
+}
+
+/// getTypeString - Return a string used to label this descriptors type.
+///
+const char *GlobalVariableDesc::getTypeString() const {
+ return "llvm.dbg.global_variable.type";
+}
+
+/// getAnchorString - Return a string used to label this descriptor's anchor.
+///
+const char *GlobalVariableDesc::getAnchorString() const {
+ return "llvm.dbg.global_variables";
}
#ifndef NDEBUG
void GlobalVariableDesc::dump() {
- std::cerr << TypeString() << " "
+ std::cerr << getDescString() << " "
<< "Tag(" << getTag() << "), "
- << "Name(\"" << Name << "\"), "
- << "Type(" << TyDesc << "), "
- << "IsStatic(" << (IsStatic ? "true" : "false") << "), "
- << "IsDefinition(" << (IsDefinition ? "true" : "false") << "), "
+ << "Anchor(" << getAnchor() << "), "
+ << "Name(\"" << getName() << "\"), "
+ << "IsStatic(" << (isStatic() ? "true" : "false") << "), "
+ << "IsDefinition(" << (isDefinition() ? "true" : "false") << "), "
<< "Global(" << Global << ")\n";
}
#endif
//===----------------------------------------------------------------------===//
+SubprogramDesc::SubprogramDesc()
+: GlobalDesc(DI_TAG_subprogram)
+{}
+
/// ApplyToFields - Target the visitor to the fields of the
/// SubprogramDesc.
void SubprogramDesc::ApplyToFields(DIVisitor *Visitor) {
- Visitor->Apply(Context);
- Visitor->Apply(Name);
- Visitor->Apply(TransUnit);
- Visitor->Apply(TyDesc);
- Visitor->Apply(IsStatic);
- Visitor->Apply(IsDefinition);
-
- // FIXME - Temp variable until restructured.
- GlobalVariable *Tmp;
- Visitor->Apply(Tmp);
+ GlobalDesc::ApplyToFields(Visitor);
+}
+
+/// getDescString - Return a string used to compose global names and labels.
+///
+const char *SubprogramDesc::getDescString() const {
+ return "llvm.dbg.subprogram";
+}
+
+/// getTypeString - Return a string used to label this descriptors type.
+///
+const char *SubprogramDesc::getTypeString() const {
+ return "llvm.dbg.subprogram.type";
}
-/// TypeString - Return a string used to compose globalnames and labels.
+/// getAnchorString - Return a string used to label this descriptor's anchor.
///
-const char *SubprogramDesc::TypeString() const {
- return "subprogram";
+const char *SubprogramDesc::getAnchorString() const {
+ return "llvm.dbg.subprograms";
}
#ifndef NDEBUG
void SubprogramDesc::dump() {
- std::cerr << TypeString() << " "
+ std::cerr << getDescString() << " "
<< "Tag(" << getTag() << "), "
- << "Name(\"" << Name << "\"), "
- << "Type(" << TyDesc << "), "
- << "IsStatic(" << (IsStatic ? "true" : "false") << "), "
- << "IsDefinition(" << (IsDefinition ? "true" : "false") << ")\n";
+ << "Anchor(" << getAnchor() << "), "
+ << "Name(\"" << getName() << "\"), "
+ << "IsStatic(" << (isStatic() ? "true" : "false") << "), "
+ << "IsDefinition(" << (isDefinition() ? "true" : "false") << ")\n";
}
#endif
//===----------------------------------------------------------------------===//
DebugInfoDesc *DIDeserializer::Deserialize(Value *V) {
- return Deserialize(cast<GlobalVariable>(V));
+ return Deserialize(getGlobalVariable(V));
}
DebugInfoDesc *DIDeserializer::Deserialize(GlobalVariable *GV) {
+ // Handle NULL.
+ if (!GV) return NULL;
+
// Check to see if it has been already deserialized.
DebugInfoDesc *&Slot = GlobalDescs[GV];
if (Slot) return Slot;
// If not already defined.
if (!Ty) {
- // Get descriptor type name.
- const char *TS = DD->TypeString();
-
// Set up fields vector.
std::vector<const Type*> Fields;
- // Add tag field.
- Fields.push_back(Type::UIntTy);
- // Get types of remaining fields.
+ // Get types of fields.
DIGetTypesVisitor GTAM(*this, Fields);
GTAM.ApplyToFields(DD);
// Construct structured type.
Ty = StructType::get(Fields);
- // Construct a name for the type.
- const std::string Name = std::string("lldb.") + DD->TypeString() + ".type";
-
// Register type name with module.
- M->addTypeName(Name, Ty);
+ M->addTypeName(DD->getTypeString(), Ty);
}
return Ty;
/// getString - Construct the string as constant string global.
///
-GlobalVariable *DISerializer::getString(const std::string &String) {
+Constant *DISerializer::getString(const std::string &String) {
// Check string cache for previous edition.
- GlobalVariable *&Slot = StringCache[String];
- // return GlobalVariable if previously defined.
+ Constant *&Slot = StringCache[String];
+ // return Constant if previously defined.
if (Slot) return Slot;
- // Construct strings as an llvm constant.
+ // Construct string as an llvm constant.
Constant *ConstStr = ConstantArray::get(String);
// Otherwise create and return a new string global.
- return Slot = new GlobalVariable(ConstStr->getType(), true,
- GlobalVariable::InternalLinkage,
- ConstStr, "str", M);
+ GlobalVariable *StrGV = new GlobalVariable(ConstStr->getType(), true,
+ GlobalVariable::InternalLinkage,
+ ConstStr, "str", M);
+ // Convert to generic string pointer.
+ Slot = ConstantExpr::getCast(StrGV, getStrPtrType());
+ return Slot;
+
}
/// Serialize - Recursively cast the specified descriptor into a GlobalVariable
// See if DebugInfoDesc exists, if so return prior GlobalVariable.
if (Slot) return Slot;
- // Get DebugInfoDesc type Tag.
- unsigned Tag = DD->getTag();
-
- // Construct name.
- const std::string Name = std::string("lldb.") +
- DD->TypeString();
-
// Get the type associated with the Tag.
const StructType *Ty = getTagType(DD);
// Create the GlobalVariable early to prevent infinite recursion.
- GlobalVariable *GV = new GlobalVariable(Ty, true,
- GlobalValue::InternalLinkage,
- NULL, Name, M);
+ GlobalVariable *GV = new GlobalVariable(Ty, true, DD->getLinkage(),
+ NULL, DD->getDescString(), M);
// Insert new GlobalVariable in DescGlobals map.
Slot = GV;
// Set up elements vector
std::vector<Constant*> Elements;
- // Add Tag value.
- Elements.push_back(ConstantUInt::get(Type::UIntTy, Tag));
- // Add remaining fields.
+ // Add fields.
DISerializeVisitor SRAM(*this, Elements);
SRAM.ApplyToFields(DD);
/// Verify - Return true if the GlobalVariable appears to be a valid
/// serialization of a DebugInfoDesc.
+bool DIVerifier::Verify(Value *V) {
+ return Verify(getGlobalVariable(V));
+}
bool DIVerifier::Verify(GlobalVariable *GV) {
// Check if seen before.
if (markVisited(GV)) return true;
MachineDebugInfo::MachineDebugInfo()
-: SR()
-, DR()
-, VR()
+: DR()
, CompileUnits()
, Directories()
, SourceFiles()
return false;
}
+/// Deserialize - Convert a Value to a debug information descriptor.
+///
+DebugInfoDesc *MachineDebugInfo::Deserialize(Value *V) {
+ return DR.Deserialize(V);
+}
+
+/// Verify - Verify that a Value is debug information descriptor.
+///
+bool MachineDebugInfo::Verify(Value *V) {
+ DIVerifier VR;
+ return VR.Verify(V);
+}
+
/// AnalyzeModule - Scan the module for global debug information.
///
void MachineDebugInfo::AnalyzeModule(Module &M) {
- SR.setModule(&M);
- DR.setModule(&M);
SetupCompileUnits(M);
}
/// SetupCompileUnits - Set up the unique vector of compile units.
///
void MachineDebugInfo::SetupCompileUnits(Module &M) {
- SR.setModule(&M);
- DR.setModule(&M);
// Get vector of all debug compile units.
+ CompileUnitDesc CompileUnit;
std::vector<GlobalVariable*> Globals =
- getGlobalVariablesUsing(M, "llvm.dbg.translation_units");
+ getGlobalVariablesUsing(M, CompileUnit.getAnchorString());
// Scan all compile unit globals.
for (unsigned i = 0, N = Globals.size(); i < N; ++i) {
///
std::vector<GlobalVariableDesc *>
MachineDebugInfo::getGlobalVariables(Module &M) {
- SR.setModule(&M);
- DR.setModule(&M);
// Get vector of all debug global objects.
+ GlobalVariableDesc Global;
std::vector<GlobalVariable*> Globals =
- getGlobalVariablesUsing(M, "llvm.dbg.globals");
+ getGlobalVariablesUsing(M, Global.getAnchorString());
// Accumulation of GlobalVariables.
std::vector<GlobalVariableDesc *> GlobalVariables;
// Scan all globals.
for (unsigned i = 0, N = Globals.size(); i < N; ++i) {
GlobalVariable *GV = Globals[i];
- if (DebugInfoDesc::TagFromGlobal(GV) == DI_TAG_global_variable) {
- GlobalVariableDesc *GVD =
- static_cast<GlobalVariableDesc *>(DR.Deserialize(GV));
- GlobalVariables.push_back(GVD);
- }
+ GlobalVariableDesc *GVD =
+ static_cast<GlobalVariableDesc *>(DR.Deserialize(GV));
+ GlobalVariables.push_back(GVD);
}
return GlobalVariables;