mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-10 02:36:06 +00:00
Non-functionality changes:
- Reformatting. - Use while() instead of do-while(). - Move simple constructors into .h file. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@71782 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling
parent
e66b291240
commit
dc817b6f42
@ -8,7 +8,9 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This file defines a bunch of datatypes that are useful for creating and
|
||||
// walking debug info in LLVM IR form.
|
||||
// walking debug info in LLVM IR form. They essentially provide wrappers around
|
||||
// the information in the global variables that's needed when constructing the
|
||||
// DWARF information.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@ -81,7 +83,8 @@ namespace llvm {
|
||||
/// DIAnchor - A wrapper for various anchor descriptors.
|
||||
class DIAnchor : public DIDescriptor {
|
||||
public:
|
||||
explicit DIAnchor(GlobalVariable *GV = 0);
|
||||
explicit DIAnchor(GlobalVariable *GV = 0)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_anchor) {}
|
||||
|
||||
unsigned getAnchorTag() const { return getUnsignedField(1); }
|
||||
};
|
||||
@ -89,7 +92,8 @@ namespace llvm {
|
||||
/// DISubrange - This is used to represent ranges, for array bounds.
|
||||
class DISubrange : public DIDescriptor {
|
||||
public:
|
||||
explicit DISubrange(GlobalVariable *GV = 0);
|
||||
explicit DISubrange(GlobalVariable *GV = 0)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_subrange_type) {}
|
||||
|
||||
int64_t getLo() const { return (int64_t)getUInt64Field(1); }
|
||||
int64_t getHi() const { return (int64_t)getUInt64Field(2); }
|
||||
@ -109,7 +113,8 @@ namespace llvm {
|
||||
/// DICompileUnit - A wrapper for a compile unit.
|
||||
class DICompileUnit : public DIDescriptor {
|
||||
public:
|
||||
explicit DICompileUnit(GlobalVariable *GV = 0);
|
||||
explicit DICompileUnit(GlobalVariable *GV = 0)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_compile_unit) {}
|
||||
|
||||
unsigned getLanguage() const { return getUnsignedField(2); }
|
||||
const std::string &getFilename(std::string &F) const {
|
||||
@ -150,7 +155,8 @@ namespace llvm {
|
||||
/// type/precision or a file/line pair for location info.
|
||||
class DIEnumerator : public DIDescriptor {
|
||||
public:
|
||||
explicit DIEnumerator(GlobalVariable *GV = 0);
|
||||
explicit DIEnumerator(GlobalVariable *GV = 0)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_enumerator) {}
|
||||
|
||||
const std::string &getName(std::string &F) const {
|
||||
return getStringField(1, F);
|
||||
@ -220,7 +226,9 @@ namespace llvm {
|
||||
/// DIBasicType - A basic type, like 'int' or 'float'.
|
||||
class DIBasicType : public DIType {
|
||||
public:
|
||||
explicit DIBasicType(GlobalVariable *GV);
|
||||
explicit DIBasicType(GlobalVariable *GV)
|
||||
: DIType(GV, dwarf::DW_TAG_base_type) {}
|
||||
|
||||
unsigned getEncoding() const { return getUnsignedField(9); }
|
||||
|
||||
/// dump - print basic type.
|
||||
@ -234,7 +242,12 @@ namespace llvm {
|
||||
explicit DIDerivedType(GlobalVariable *GV, bool, bool)
|
||||
: DIType(GV, true, true) {}
|
||||
public:
|
||||
explicit DIDerivedType(GlobalVariable *GV);
|
||||
explicit DIDerivedType(GlobalVariable *GV)
|
||||
: DIType(GV, true, true) {
|
||||
if (GV && !isDerivedType(getTag()))
|
||||
GV = 0;
|
||||
}
|
||||
|
||||
DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
|
||||
|
||||
/// getOriginalTypeSize - If this type is derived from a base type then
|
||||
@ -249,7 +262,12 @@ namespace llvm {
|
||||
/// FIXME: Why is this a DIDerivedType??
|
||||
class DICompositeType : public DIDerivedType {
|
||||
public:
|
||||
explicit DICompositeType(GlobalVariable *GV);
|
||||
explicit DICompositeType(GlobalVariable *GV)
|
||||
: DIDerivedType(GV, true, true) {
|
||||
if (GV && !isCompositeType(getTag()))
|
||||
GV = 0;
|
||||
}
|
||||
|
||||
DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
|
||||
unsigned getRunTimeLang() const { return getUnsignedField(11); }
|
||||
|
||||
@ -307,7 +325,9 @@ namespace llvm {
|
||||
/// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
|
||||
class DISubprogram : public DIGlobal {
|
||||
public:
|
||||
explicit DISubprogram(GlobalVariable *GV = 0);
|
||||
explicit DISubprogram(GlobalVariable *GV = 0)
|
||||
: DIGlobal(GV, dwarf::DW_TAG_subprogram) {}
|
||||
|
||||
DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
|
||||
|
||||
/// Verify - Verify that a subprogram descriptor is well formed.
|
||||
@ -324,7 +344,9 @@ namespace llvm {
|
||||
/// DIGlobalVariable - This is a wrapper for a global variable.
|
||||
class DIGlobalVariable : public DIGlobal {
|
||||
public:
|
||||
explicit DIGlobalVariable(GlobalVariable *GV = 0);
|
||||
explicit DIGlobalVariable(GlobalVariable *GV = 0)
|
||||
: DIGlobal(GV, dwarf::DW_TAG_variable) {}
|
||||
|
||||
GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
|
||||
|
||||
/// Verify - Verify that a global variable descriptor is well formed.
|
||||
@ -338,7 +360,11 @@ namespace llvm {
|
||||
/// global etc).
|
||||
class DIVariable : public DIDescriptor {
|
||||
public:
|
||||
explicit DIVariable(GlobalVariable *GV = 0);
|
||||
explicit DIVariable(GlobalVariable *gv = 0)
|
||||
: DIDescriptor(gv) {
|
||||
if (gv && !isVariable(getTag()))
|
||||
GV = 0;
|
||||
}
|
||||
|
||||
DIDescriptor getContext() const { return getDescriptorField(1); }
|
||||
const std::string &getName(std::string &F) const {
|
||||
@ -361,8 +387,9 @@ namespace llvm {
|
||||
/// DIBlock - This is a wrapper for a block (e.g. a function, scope, etc).
|
||||
class DIBlock : public DIDescriptor {
|
||||
public:
|
||||
explicit DIBlock(GlobalVariable *GV = 0);
|
||||
|
||||
explicit DIBlock(GlobalVariable *GV = 0)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_lexical_block) {}
|
||||
|
||||
DIDescriptor getContext() const { return getDescriptorField(1); }
|
||||
};
|
||||
|
||||
|
||||
@ -22,6 +22,7 @@
|
||||
#include "llvm/Analysis/ValueTracking.h"
|
||||
#include "llvm/Support/Dwarf.h"
|
||||
#include "llvm/Support/Streams.h"
|
||||
|
||||
using namespace llvm;
|
||||
using namespace llvm::dwarf;
|
||||
|
||||
@ -60,10 +61,11 @@ bool DIDescriptor::ValidDebugInfo(Value *V, CodeGenOpt::Level OptLevel) {
|
||||
assert(DISubprogram(GV).Verify() && "Invalid DebugInfo value");
|
||||
break;
|
||||
case DW_TAG_lexical_block:
|
||||
/// FIXME. This interfers with the quality of generated code when
|
||||
/// during optimization.
|
||||
// FIXME: This interfers with the quality of generated code during
|
||||
// optimization.
|
||||
if (OptLevel != CodeGenOpt::None)
|
||||
return false;
|
||||
// FALLTHROUGH
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -74,7 +76,7 @@ bool DIDescriptor::ValidDebugInfo(Value *V, CodeGenOpt::Level OptLevel) {
|
||||
DIDescriptor::DIDescriptor(GlobalVariable *gv, unsigned RequiredTag) {
|
||||
GV = gv;
|
||||
|
||||
// If this is non-null, check to see if the Tag matches. If not, set to null.
|
||||
// If this is non-null, check to see if the Tag matches. If not, set to null.
|
||||
if (GV && getTag() != RequiredTag)
|
||||
GV = 0;
|
||||
}
|
||||
@ -91,7 +93,7 @@ DIDescriptor::getStringField(unsigned Elt, std::string &Result) const {
|
||||
Result.clear();
|
||||
return Result;
|
||||
}
|
||||
|
||||
|
||||
// Fills in the string if it succeeds
|
||||
if (!GetConstantStringInfo(C->getOperand(Elt), Result))
|
||||
Result.clear();
|
||||
@ -101,9 +103,11 @@ DIDescriptor::getStringField(unsigned Elt, std::string &Result) const {
|
||||
|
||||
uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
|
||||
if (GV == 0) return 0;
|
||||
|
||||
Constant *C = GV->getInitializer();
|
||||
if (C == 0 || Elt >= C->getNumOperands())
|
||||
return 0;
|
||||
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(C->getOperand(Elt)))
|
||||
return CI->getZExtValue();
|
||||
return 0;
|
||||
@ -111,46 +115,31 @@ uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
|
||||
|
||||
DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const {
|
||||
if (GV == 0) return DIDescriptor();
|
||||
|
||||
Constant *C = GV->getInitializer();
|
||||
if (C == 0 || Elt >= C->getNumOperands())
|
||||
return DIDescriptor();
|
||||
|
||||
C = C->getOperand(Elt);
|
||||
return DIDescriptor(dyn_cast<GlobalVariable>(C->stripPointerCasts()));
|
||||
}
|
||||
|
||||
GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const {
|
||||
if (GV == 0) return 0;
|
||||
|
||||
Constant *C = GV->getInitializer();
|
||||
if (C == 0 || Elt >= C->getNumOperands())
|
||||
return 0;
|
||||
|
||||
C = C->getOperand(Elt);
|
||||
|
||||
return dyn_cast<GlobalVariable>(C->stripPointerCasts());
|
||||
}
|
||||
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Simple Descriptor Constructors and other Methods
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
DIAnchor::DIAnchor(GlobalVariable *GV)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_anchor) {}
|
||||
DIEnumerator::DIEnumerator(GlobalVariable *GV)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_enumerator) {}
|
||||
DISubrange::DISubrange(GlobalVariable *GV)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_subrange_type) {}
|
||||
DICompileUnit::DICompileUnit(GlobalVariable *GV)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_compile_unit) {}
|
||||
DIBasicType::DIBasicType(GlobalVariable *GV)
|
||||
: DIType(GV, dwarf::DW_TAG_base_type) {}
|
||||
DISubprogram::DISubprogram(GlobalVariable *GV)
|
||||
: DIGlobal(GV, dwarf::DW_TAG_subprogram) {}
|
||||
DIGlobalVariable::DIGlobalVariable(GlobalVariable *GV)
|
||||
: DIGlobal(GV, dwarf::DW_TAG_variable) {}
|
||||
DIBlock::DIBlock(GlobalVariable *GV)
|
||||
: DIDescriptor(GV, dwarf::DW_TAG_lexical_block) {}
|
||||
// needed by DIVariable::getType()
|
||||
// Needed by DIVariable::getType().
|
||||
DIType::DIType(GlobalVariable *gv) : DIDescriptor(gv) {
|
||||
if (!gv) return;
|
||||
unsigned tag = getTag();
|
||||
@ -179,11 +168,6 @@ bool DIType::isDerivedType(unsigned Tag) {
|
||||
}
|
||||
}
|
||||
|
||||
DIDerivedType::DIDerivedType(GlobalVariable *GV) : DIType(GV, true, true) {
|
||||
if (GV && !isDerivedType(getTag()))
|
||||
GV = 0;
|
||||
}
|
||||
|
||||
/// isCompositeType - Return true if the specified tag is legal for
|
||||
/// DICompositeType.
|
||||
bool DIType::isCompositeType(unsigned TAG) {
|
||||
@ -201,12 +185,6 @@ bool DIType::isCompositeType(unsigned TAG) {
|
||||
}
|
||||
}
|
||||
|
||||
DICompositeType::DICompositeType(GlobalVariable *GV)
|
||||
: DIDerivedType(GV, true, true) {
|
||||
if (GV && !isCompositeType(getTag()))
|
||||
GV = 0;
|
||||
}
|
||||
|
||||
/// isVariable - Return true if the specified tag is legal for DIVariable.
|
||||
bool DIVariable::isVariable(unsigned Tag) {
|
||||
switch (Tag) {
|
||||
@ -219,11 +197,6 @@ bool DIVariable::isVariable(unsigned Tag) {
|
||||
}
|
||||
}
|
||||
|
||||
DIVariable::DIVariable(GlobalVariable *gv) : DIDescriptor(gv) {
|
||||
if (gv && !isVariable(getTag()))
|
||||
GV = 0;
|
||||
}
|
||||
|
||||
unsigned DIArray::getNumElements() const {
|
||||
assert (GV && "Invalid DIArray");
|
||||
Constant *C = GV->getInitializer();
|
||||
@ -351,8 +324,9 @@ bool DISubprogram::describes(const Function *F) {
|
||||
// DIFactory: Basic Helpers
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
DIFactory::DIFactory(Module &m) : M(m) {
|
||||
StopPointFn = FuncStartFn = RegionStartFn = RegionEndFn = DeclareFn = 0;
|
||||
DIFactory::DIFactory(Module &m)
|
||||
: M(m), StopPointFn(0), FuncStartFn(0), RegionStartFn(0), RegionEndFn(0),
|
||||
DeclareFn(0) {
|
||||
EmptyStructPtr = PointerType::getUnqual(StructType::get(NULL, NULL));
|
||||
}
|
||||
|
||||
@ -809,8 +783,7 @@ void DIFactory::InsertStopPoint(DICompileUnit CU, unsigned LineNo,
|
||||
void DIFactory::InsertSubprogramStart(DISubprogram SP, BasicBlock *BB) {
|
||||
// Lazily construct llvm.dbg.func.start.
|
||||
if (!FuncStartFn)
|
||||
FuncStartFn = llvm::Intrinsic::getDeclaration(&M,
|
||||
llvm::Intrinsic::dbg_func_start);
|
||||
FuncStartFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_func_start);
|
||||
|
||||
// Call llvm.dbg.func.start which also implicitly sets a stoppoint.
|
||||
CallInst::Create(FuncStartFn, getCastToEmpty(SP), "", BB);
|
||||
@ -821,100 +794,99 @@ void DIFactory::InsertSubprogramStart(DISubprogram SP, BasicBlock *BB) {
|
||||
void DIFactory::InsertRegionStart(DIDescriptor D, BasicBlock *BB) {
|
||||
// Lazily construct llvm.dbg.region.start function.
|
||||
if (!RegionStartFn)
|
||||
RegionStartFn = llvm::Intrinsic::getDeclaration(&M,
|
||||
llvm::Intrinsic::dbg_region_start);
|
||||
RegionStartFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_region_start);
|
||||
|
||||
// Call llvm.dbg.func.start.
|
||||
CallInst::Create(RegionStartFn, getCastToEmpty(D), "", BB);
|
||||
}
|
||||
|
||||
|
||||
/// InsertRegionEnd - Insert a new llvm.dbg.region.end intrinsic call to
|
||||
/// mark the end of a region for the specified scoping descriptor.
|
||||
void DIFactory::InsertRegionEnd(DIDescriptor D, BasicBlock *BB) {
|
||||
// Lazily construct llvm.dbg.region.end function.
|
||||
if (!RegionEndFn)
|
||||
RegionEndFn = llvm::Intrinsic::getDeclaration(&M,
|
||||
llvm::Intrinsic::dbg_region_end);
|
||||
|
||||
RegionEndFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_region_end);
|
||||
|
||||
// Call llvm.dbg.region.end.
|
||||
CallInst::Create(RegionEndFn, getCastToEmpty(D), "", BB);
|
||||
}
|
||||
|
||||
/// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
|
||||
void DIFactory::InsertDeclare(llvm::Value *Storage, DIVariable D,
|
||||
BasicBlock *BB) {
|
||||
void DIFactory::InsertDeclare(Value *Storage, DIVariable D, BasicBlock *BB) {
|
||||
// Cast the storage to a {}* for the call to llvm.dbg.declare.
|
||||
Storage = new llvm::BitCastInst(Storage, EmptyStructPtr, "", BB);
|
||||
Storage = new BitCastInst(Storage, EmptyStructPtr, "", BB);
|
||||
|
||||
if (!DeclareFn)
|
||||
DeclareFn = llvm::Intrinsic::getDeclaration(&M,
|
||||
llvm::Intrinsic::dbg_declare);
|
||||
DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
|
||||
|
||||
Value *Args[] = { Storage, getCastToEmpty(D) };
|
||||
CallInst::Create(DeclareFn, Args, Args+2, "", BB);
|
||||
}
|
||||
|
||||
namespace llvm {
|
||||
/// Finds the stoppoint coressponding to this instruction, that is the
|
||||
/// stoppoint that dominates this instruction
|
||||
const DbgStopPointInst *findStopPoint(const Instruction *Inst)
|
||||
{
|
||||
/// findStopPoint - Find the stoppoint coressponding to this instruction, that
|
||||
/// is the stoppoint that dominates this instruction.
|
||||
const DbgStopPointInst *findStopPoint(const Instruction *Inst) {
|
||||
if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(Inst))
|
||||
return DSI;
|
||||
|
||||
const BasicBlock *BB = Inst->getParent();
|
||||
BasicBlock::const_iterator I = Inst, B;
|
||||
do {
|
||||
while (BB) {
|
||||
B = BB->begin();
|
||||
|
||||
// A BB consisting only of a terminator can't have a stoppoint.
|
||||
if (I != B) {
|
||||
do {
|
||||
--I;
|
||||
if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
|
||||
return DSI;
|
||||
} while (I != B);
|
||||
while (I != B) {
|
||||
--I;
|
||||
if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
|
||||
return DSI;
|
||||
}
|
||||
// This BB didn't have a stoppoint: if there is only one
|
||||
// predecessor, look for a stoppoint there.
|
||||
// We could use getIDom(), but that would require dominator info.
|
||||
|
||||
// This BB didn't have a stoppoint: if there is only one predecessor, look
|
||||
// for a stoppoint there. We could use getIDom(), but that would require
|
||||
// dominator info.
|
||||
BB = I->getParent()->getUniquePredecessor();
|
||||
if (BB)
|
||||
I = BB->getTerminator();
|
||||
} while (BB != 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// Finds the stoppoint corresponding to first real (non-debug intrinsic)
|
||||
/// instruction in this Basic Block, and returns the stoppoint for it.
|
||||
const DbgStopPointInst *findBBStopPoint(const BasicBlock *BB)
|
||||
{
|
||||
for(BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
|
||||
/// findBBStopPoint - Find the stoppoint corresponding to first real
|
||||
/// (non-debug intrinsic) instruction in this Basic Block, and return the
|
||||
/// stoppoint for it.
|
||||
const DbgStopPointInst *findBBStopPoint(const BasicBlock *BB) {
|
||||
for(BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
|
||||
if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
|
||||
return DSI;
|
||||
}
|
||||
// Fallback to looking for stoppoint of unique predecessor.
|
||||
// Useful if this BB contains no stoppoints, but unique predecessor does.
|
||||
|
||||
// Fallback to looking for stoppoint of unique predecessor. Useful if this
|
||||
// BB contains no stoppoints, but unique predecessor does.
|
||||
BB = BB->getUniquePredecessor();
|
||||
if (BB)
|
||||
return findStopPoint(BB->getTerminator());
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Value *findDbgGlobalDeclare(GlobalVariable *V)
|
||||
{
|
||||
Value *findDbgGlobalDeclare(GlobalVariable *V) {
|
||||
const Module *M = V->getParent();
|
||||
const Type *Ty = M->getTypeByName("llvm.dbg.global_variable.type");
|
||||
if (!Ty)
|
||||
return 0;
|
||||
if (!Ty) return 0;
|
||||
|
||||
Ty = PointerType::get(Ty, 0);
|
||||
|
||||
Value *Val = V->stripPointerCasts();
|
||||
for (Value::use_iterator I = Val->use_begin(), E =Val->use_end();
|
||||
for (Value::use_iterator I = Val->use_begin(), E = Val->use_end();
|
||||
I != E; ++I) {
|
||||
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I)) {
|
||||
if (CE->getOpcode() == Instruction::BitCast) {
|
||||
Value *VV = CE;
|
||||
while (VV->hasOneUse()) {
|
||||
|
||||
while (VV->hasOneUse())
|
||||
VV = *VV->use_begin();
|
||||
}
|
||||
|
||||
if (VV->getType() == Ty)
|
||||
return VV;
|
||||
}
|
||||
@ -923,57 +895,60 @@ namespace llvm {
|
||||
|
||||
if (Val->getType() == Ty)
|
||||
return Val;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// Finds the dbg.declare intrinsic corresponding to this value if any.
|
||||
/// Finds the llvm.dbg.declare intrinsic corresponding to this value if any.
|
||||
/// It looks through pointer casts too.
|
||||
const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts)
|
||||
{
|
||||
const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts) {
|
||||
if (stripCasts) {
|
||||
V = V->stripPointerCasts();
|
||||
|
||||
// Look for the bitcast.
|
||||
for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
|
||||
I != E; ++I) {
|
||||
I != E; ++I)
|
||||
if (isa<BitCastInst>(I))
|
||||
return findDbgDeclare(*I, false);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Find dbg.declare among uses of the instruction.
|
||||
// Find llvm.dbg.declare among uses of the instruction.
|
||||
for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
|
||||
I != E; ++I) {
|
||||
I != E; ++I)
|
||||
if (const DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I))
|
||||
return DDI;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool getLocationInfo(const Value *V, std::string &DisplayName, std::string &Type,
|
||||
unsigned &LineNo, std::string &File, std::string &Dir)
|
||||
{
|
||||
bool getLocationInfo(const Value *V, std::string &DisplayName,
|
||||
std::string &Type, unsigned &LineNo, std::string &File,
|
||||
std::string &Dir) {
|
||||
DICompileUnit Unit;
|
||||
DIType TypeD;
|
||||
|
||||
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(const_cast<Value*>(V))) {
|
||||
Value *DIGV = findDbgGlobalDeclare(GV);
|
||||
if (!DIGV)
|
||||
return false;
|
||||
if (!DIGV) return false;
|
||||
DIGlobalVariable Var(cast<GlobalVariable>(DIGV));
|
||||
|
||||
Var.getDisplayName(DisplayName);
|
||||
LineNo = Var.getLineNumber();
|
||||
Unit = Var.getCompileUnit();
|
||||
TypeD = Var.getType();
|
||||
} else {
|
||||
const DbgDeclareInst *DDI = findDbgDeclare(V);
|
||||
if (!DDI)
|
||||
return false;
|
||||
if (!DDI) return false;
|
||||
DIVariable Var(cast<GlobalVariable>(DDI->getVariable()));
|
||||
|
||||
Var.getName(DisplayName);
|
||||
LineNo = Var.getLineNumber();
|
||||
Unit = Var.getCompileUnit();
|
||||
TypeD = Var.getType();
|
||||
}
|
||||
|
||||
TypeD.getName(Type);
|
||||
Unit.getFilename(File);
|
||||
Unit.getDirectory(Dir);
|
||||
@ -981,13 +956,13 @@ namespace llvm {
|
||||
}
|
||||
}
|
||||
|
||||
/// dump - print descriptor.
|
||||
/// dump - Print descriptor.
|
||||
void DIDescriptor::dump() const {
|
||||
cerr << "[" << dwarf::TagString(getTag()) << "] ";
|
||||
cerr << std::hex << "[GV:" << GV << "]" << std::dec;
|
||||
}
|
||||
|
||||
/// dump - print compile unit.
|
||||
/// dump - Print compile unit.
|
||||
void DICompileUnit::dump() const {
|
||||
if (getLanguage())
|
||||
cerr << " [" << dwarf::LanguageString(getLanguage()) << "] ";
|
||||
@ -996,7 +971,7 @@ void DICompileUnit::dump() const {
|
||||
cerr << " [" << getDirectory(Res1) << "/" << getFilename(Res2) << " ]";
|
||||
}
|
||||
|
||||
/// dump - print type.
|
||||
/// dump - Print type.
|
||||
void DIType::dump() const {
|
||||
if (isNull()) return;
|
||||
|
||||
@ -1038,17 +1013,17 @@ void DIType::dump() const {
|
||||
cerr << "\n";
|
||||
}
|
||||
|
||||
/// dump - print basic type.
|
||||
/// dump - Print basic type.
|
||||
void DIBasicType::dump() const {
|
||||
cerr << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
|
||||
}
|
||||
|
||||
/// dump - print derived type.
|
||||
/// dump - Print derived type.
|
||||
void DIDerivedType::dump() const {
|
||||
cerr << "\n\t Derived From: "; getTypeDerivedFrom().dump();
|
||||
}
|
||||
|
||||
/// dump - print composite type.
|
||||
/// dump - Print composite type.
|
||||
void DICompositeType::dump() const {
|
||||
DIArray A = getTypeArray();
|
||||
if (A.isNull())
|
||||
@ -1056,7 +1031,7 @@ void DICompositeType::dump() const {
|
||||
cerr << " [" << A.getNumElements() << " elements]";
|
||||
}
|
||||
|
||||
/// dump - print global.
|
||||
/// dump - Print global.
|
||||
void DIGlobal::dump() const {
|
||||
std::string Res;
|
||||
if (!getName(Res).empty())
|
||||
@ -1081,17 +1056,17 @@ void DIGlobal::dump() const {
|
||||
cerr << "\n";
|
||||
}
|
||||
|
||||
/// dump - print subprogram.
|
||||
/// dump - Print subprogram.
|
||||
void DISubprogram::dump() const {
|
||||
DIGlobal::dump();
|
||||
}
|
||||
|
||||
/// dump - print global variable.
|
||||
/// dump - Print global variable.
|
||||
void DIGlobalVariable::dump() const {
|
||||
cerr << " ["; getGlobal()->dump(); cerr << "] ";
|
||||
}
|
||||
|
||||
/// dump - print variable.
|
||||
/// dump - Print variable.
|
||||
void DIVariable::dump() const {
|
||||
std::string Res;
|
||||
if (!getName(Res).empty())
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user