#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/Analysis/ValueTracking.h"
-#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/Streams.h"
using namespace llvm;
//===----------------------------------------------------------------------===//
/// isDerivedType - Return true if the specified tag is legal for
/// DIDerivedType.
-bool DIDerivedType::isDerivedType(unsigned Tag) {
+bool DIType::isDerivedType(unsigned Tag) {
switch (Tag) {
case dwarf::DW_TAG_typedef:
case dwarf::DW_TAG_pointer_type:
/// isCompositeType - Return true if the specified tag is legal for
/// DICompositeType.
-bool DICompositeType::isCompositeType(unsigned TAG) {
+bool DIType::isCompositeType(unsigned TAG) {
switch (TAG) {
case dwarf::DW_TAG_array_type:
case dwarf::DW_TAG_structure_type:
}
}
-DIVariable::DIVariable(GlobalVariable *GV) : DIDescriptor(GV) {
- if (GV && !isVariable(getTag()))
+DIVariable::DIVariable(GlobalVariable *gv) : DIDescriptor(gv) {
+ if (gv && !isVariable(getTag()))
GV = 0;
}
+unsigned DIArray::getNumElements() const {
+ assert (GV && "Invalid DIArray");
+ Constant *C = GV->getInitializer();
+ assert (C && "Invalid DIArray initializer");
+ return C->getNumOperands();
+}
+
+/// Verify - Verify that a compile unit is well formed.
+bool DICompileUnit::Verify() const {
+ if (isNull())
+ return false;
+ if (getFilename().empty())
+ return false;
+ // It is possible that directory and produce string is empty.
+ return true;
+}
+
+/// Verify - Verify that a type descriptor is well formed.
+bool DIType::Verify() const {
+ if (isNull())
+ return false;
+ if (getContext().isNull())
+ return false;
+
+ DICompileUnit CU = getCompileUnit();
+ if (!CU.isNull() && !CU.Verify())
+ return false;
+ return true;
+}
+
+/// Verify - Verify that a composite type descriptor is well formed.
+bool DICompositeType::Verify() const {
+ if (isNull())
+ return false;
+ if (getContext().isNull())
+ return false;
+
+ DICompileUnit CU = getCompileUnit();
+ if (!CU.isNull() && !CU.Verify())
+ return false;
+ return true;
+}
+
+/// Verify - Verify that a subprogram descriptor is well formed.
+bool DISubprogram::Verify() const {
+ if (isNull())
+ return false;
+
+ if (getContext().isNull())
+ return false;
+
+ DICompileUnit CU = getCompileUnit();
+ if (!CU.Verify())
+ return false;
+
+ DICompositeType Ty = getType();
+ if (!Ty.isNull() && !Ty.Verify())
+ return false;
+ return true;
+}
+
+/// Verify - Verify that a global variable descriptor is well formed.
+bool DIGlobalVariable::Verify() const {
+ if (isNull())
+ return false;
+
+ if (getContext().isNull())
+ return false;
+
+ DICompileUnit CU = getCompileUnit();
+ if (!CU.Verify())
+ return false;
+
+ DIType Ty = getType();
+ if (!Ty.Verify())
+ return false;
+
+ if (!getGlobal())
+ return false;
+ return true;
+}
+
+/// Verify - Verify that a variable descriptor is well formed.
+bool DIVariable::Verify() const {
+ if (isNull())
+ return false;
+
+ if (getContext().isNull())
+ return false;
+
+ DIType Ty = getType();
+ if (!Ty.Verify())
+ return false;
+
+
+ return true;
+}
+
+/// getOriginalTypeSize - If this type is derived from a base type then
+/// return base type size.
+uint64_t DIDerivedType::getOriginalTypeSize() const {
+ if (getTag() != dwarf::DW_TAG_member)
+ return getSizeInBits();
+ DIType BT = getTypeDerivedFrom();
+ if (BT.getTag() != dwarf::DW_TAG_base_type)
+ return getSizeInBits();
+ return BT.getSizeInBits();
+}
//===----------------------------------------------------------------------===//
// DIFactory: Basic Helpers
}
Constant *DIFactory::GetTagConstant(unsigned TAG) {
- assert((TAG & DIDescriptor::VersionMask) == 0 &&
+ assert((TAG & LLVMDebugVersionMask) == 0 &&
"Tag too large for debug encoding!");
- return ConstantInt::get(Type::Int32Ty, TAG | DIDescriptor::Version7);
+ return ConstantInt::get(Type::Int32Ty, TAG | LLVMDebugVersion);
}
Constant *DIFactory::GetStringConstant(const std::string &String) {
DICompileUnit DIFactory::CreateCompileUnit(unsigned LangID,
const std::string &Filename,
const std::string &Directory,
- const std::string &Producer) {
+ const std::string &Producer,
+ bool isMain,
+ bool isOptimized,
+ const char *Flags,
+ unsigned RunTimeVer) {
Constant *Elts[] = {
GetTagConstant(dwarf::DW_TAG_compile_unit),
getCastToEmpty(GetOrCreateCompileUnitAnchor()),
ConstantInt::get(Type::Int32Ty, LangID),
GetStringConstant(Filename),
GetStringConstant(Directory),
- GetStringConstant(Producer)
+ GetStringConstant(Producer),
+ ConstantInt::get(Type::Int1Ty, isMain),
+ ConstantInt::get(Type::Int1Ty, isOptimized),
+ GetStringConstant(Flags),
+ ConstantInt::get(Type::Int32Ty, RunTimeVer)
};
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
uint64_t SizeInBits,
uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
- unsigned Encoding,
- const std::string *FileName,
- const std::string *Directory) {
+ unsigned Encoding) {
Constant *Elts[] = {
GetTagConstant(dwarf::DW_TAG_base_type),
getCastToEmpty(Context),
ConstantInt::get(Type::Int64Ty, AlignInBits),
ConstantInt::get(Type::Int64Ty, OffsetInBits),
ConstantInt::get(Type::Int32Ty, Flags),
- ConstantInt::get(Type::Int32Ty, Encoding),
- GetStringConstant(FileName ? FileName->c_str() : ""),
- GetStringConstant(Directory ? Directory->c_str() : "")
+ ConstantInt::get(Type::Int32Ty, Encoding)
};
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
uint64_t AlignInBits,
uint64_t OffsetInBits,
unsigned Flags,
- DIType DerivedFrom,
- const std::string *FileName,
- const std::string *Directory) {
+ DIType DerivedFrom) {
Constant *Elts[] = {
GetTagConstant(Tag),
getCastToEmpty(Context),
ConstantInt::get(Type::Int64Ty, AlignInBits),
ConstantInt::get(Type::Int64Ty, OffsetInBits),
ConstantInt::get(Type::Int32Ty, Flags),
- getCastToEmpty(DerivedFrom),
- GetStringConstant(FileName ? FileName->c_str() : ""),
- GetStringConstant(Directory ? Directory->c_str() : "")
+ getCastToEmpty(DerivedFrom)
};
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
unsigned Flags,
DIType DerivedFrom,
DIArray Elements,
- const std::string *FileName,
- const std::string *Directory) {
+ unsigned RuntimeLang) {
Constant *Elts[] = {
GetTagConstant(Tag),
ConstantInt::get(Type::Int32Ty, Flags),
getCastToEmpty(DerivedFrom),
getCastToEmpty(Elements),
- GetStringConstant(FileName ? FileName->c_str() : ""),
- GetStringConstant(Directory ? Directory->c_str() : "")
+ ConstantInt::get(Type::Int32Ty, RuntimeLang)
};
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
DICompileUnit CompileUnit,
unsigned LineNo, DIType Type,
bool isLocalToUnit,
- bool isDefinition,
- const std::string *FileName,
- const std::string *Directory) {
+ bool isDefinition) {
Constant *Elts[] = {
GetTagConstant(dwarf::DW_TAG_subprogram),
ConstantInt::get(Type::Int32Ty, LineNo),
getCastToEmpty(Type),
ConstantInt::get(Type::Int1Ty, isLocalToUnit),
- ConstantInt::get(Type::Int1Ty, isDefinition),
- GetStringConstant(FileName ? FileName->c_str() : ""),
- GetStringConstant(Directory ? Directory->c_str() : "")
+ ConstantInt::get(Type::Int1Ty, isDefinition)
};
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
const std::string &LinkageName,
DICompileUnit CompileUnit,
unsigned LineNo, DIType Type,bool isLocalToUnit,
- bool isDefinition, llvm::GlobalVariable *Val,
- const std::string *FileName,
- const std::string *Directory) {
+ bool isDefinition, llvm::GlobalVariable *Val) {
Constant *Elts[] = {
GetTagConstant(dwarf::DW_TAG_variable),
getCastToEmpty(GetOrCreateGlobalVariableAnchor()),
getCastToEmpty(Type),
ConstantInt::get(Type::Int1Ty, isLocalToUnit),
ConstantInt::get(Type::Int1Ty, isDefinition),
- ConstantExpr::getBitCast(Val, EmptyStructPtr),
- GetStringConstant(FileName ? FileName->c_str() : ""),
- GetStringConstant(Directory ? Directory->c_str() : "")
+ ConstantExpr::getBitCast(Val, EmptyStructPtr)
};
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
DIVariable DIFactory::CreateVariable(unsigned Tag, DIDescriptor Context,
const std::string &Name,
DICompileUnit CompileUnit, unsigned LineNo,
- DIType Type,
- const std::string *FileName,
- const std::string *Directory) {
-
-
+ DIType Type) {
Constant *Elts[] = {
GetTagConstant(Tag),
getCastToEmpty(Context),
GetStringConstant(Name),
getCastToEmpty(CompileUnit),
ConstantInt::get(Type::Int32Ty, LineNo),
- getCastToEmpty(Type),
- GetStringConstant(FileName ? FileName->c_str() : ""),
- GetStringConstant(Directory ? Directory->c_str() : "")
+ getCastToEmpty(Type)
};
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
}
}
+/// dump - print compile unit.
+void DICompileUnit::dump() const {
+ cerr << " [" << dwarf::LanguageString(getLanguage()) << "] ";
+ cerr << " [" << getDirectory() << "/" << getFilename() << " ]";
+}
+
+/// dump - print type.
+void DIType::dump() const {
+ if (isNull()) return;
+ if (!getName().empty())
+ cerr << " [" << getName() << "] ";
+ unsigned Tag = getTag();
+ cerr << " [" << dwarf::TagString(Tag) << "] ";
+ // TODO : Print context
+ getCompileUnit().dump();
+ cerr << " ["
+ << getLineNumber() << ", "
+ << getSizeInBits() << ", "
+ << getAlignInBits() << ", "
+ << getOffsetInBits()
+ << "] ";
+ if (isPrivate())
+ cerr << " [private] ";
+ else if (isProtected())
+ cerr << " [protected] ";
+ if (isForwardDecl())
+ cerr << " [fwd] ";
+
+ if (isBasicType(Tag))
+ DIBasicType(GV).dump();
+ else if (isDerivedType(Tag))
+ DIDerivedType(GV).dump();
+ else if (isCompositeType(Tag))
+ DICompositeType(GV).dump();
+ else {
+ cerr << "Invalid DIType\n";
+ return;
+ }
+ cerr << "\n";
+}
+
+/// dump - print basic type.
+void DIBasicType::dump() const {
+ cerr << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
+
+}
+
+/// dump - print derived type.
+void DIDerivedType::dump() const {
+ cerr << "\n\t Derived From: "; getTypeDerivedFrom().dump();
+}
+
+/// dump - print composite type.
+void DICompositeType::dump() const {
+ DIArray A = getTypeArray();
+ if (A.isNull())
+ return;
+ cerr << " [" << A.getNumElements() << " elements]";
+}
+
+/// dump - print global.
+void DIGlobal::dump() const {
+
+ if (!getName().empty())
+ cerr << " [" << getName() << "] ";
+ unsigned Tag = getTag();
+ cerr << " [" << dwarf::TagString(Tag) << "] ";
+ // TODO : Print context
+ getCompileUnit().dump();
+ cerr << " [" << getLineNumber() << "] ";
+ if (isLocalToUnit())
+ cerr << " [local] ";
+ if (isDefinition())
+ cerr << " [def] ";
+
+ if (isGlobalVariable(Tag))
+ DIGlobalVariable(GV).dump();
+
+ cerr << "\n";
+}
+
+/// dump - print subprogram.
+void DISubprogram::dump() const {
+ DIGlobal::dump();
+}
+
+/// dump - print global variable.
+void DIGlobalVariable::dump() const {
+ cerr << " ["; getGlobal()->dump(); cerr << "] ";
+}
+
+/// dump - print variable.
+void DIVariable::dump() const {
+ if (!getName().empty())
+ cerr << " [" << getName() << "] ";
+ getCompileUnit().dump();
+ cerr << " [" << getLineNumber() << "] ";
+ getType().dump();
+ cerr << "\n";
+}
projects / oota-llvm.git / blobdiff