X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAnalysis%2FDebugInfo.cpp;h=11a56bdf7d48aaf5e7f05515ca19cdb72152eea8;hb=55e7c827301da0e5e03b26835bff259c320b3bf7;hp=a063aa53ba48bb549f895e527e92a9d666f68e5b;hpb=667d4b8de6dea70195ff12ef39a4deebffa2f5c7;p=oota-llvm.git diff --git a/lib/Analysis/DebugInfo.cpp b/lib/Analysis/DebugInfo.cpp index a063aa53ba4..11a56bdf7d4 100644 --- a/lib/Analysis/DebugInfo.cpp +++ b/lib/Analysis/DebugInfo.cpp @@ -20,94 +20,132 @@ #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; +using namespace llvm::dwarf; //===----------------------------------------------------------------------===// // DIDescriptor //===----------------------------------------------------------------------===// -DIDescriptor::DIDescriptor(GlobalVariable *gv, unsigned RequiredTag) { - GV = gv; +/// ValidDebugInfo - Return true if V represents valid debug info value. +bool DIDescriptor::ValidDebugInfo(Value *V, CodeGenOpt::Level OptLevel) { + if (!V) + return false; + + GlobalVariable *GV = dyn_cast(V->stripPointerCasts()); + if (!GV) + return false; + + if (!GV->hasInternalLinkage () && !GV->hasLinkOnceLinkage()) + return false; + + DIDescriptor DI(GV); + + // Check current version. Allow Version6 for now. + unsigned Version = DI.getVersion(); + if (Version != LLVMDebugVersion && Version != LLVMDebugVersion6) + return false; + + unsigned Tag = DI.getTag(); + switch (Tag) { + case DW_TAG_variable: + assert(DIVariable(GV).Verify() && "Invalid DebugInfo value"); + break; + case DW_TAG_compile_unit: + assert(DICompileUnit(GV).Verify() && "Invalid DebugInfo value"); + break; + case DW_TAG_subprogram: + assert(DISubprogram(GV).Verify() && "Invalid DebugInfo value"); + break; + case DW_TAG_lexical_block: + // FIXME: This interfers with the quality of generated code during + // optimization. + if (OptLevel != CodeGenOpt::None) + return false; + // FALLTHROUGH + default: + break; + } + + return true; +} + +DIDescriptor::DIDescriptor(GlobalVariable *GV, unsigned RequiredTag) { + DbgGV = 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; + DbgGV = 0; } +const std::string & +DIDescriptor::getStringField(unsigned Elt, std::string &Result) const { + if (DbgGV == 0) { + Result.clear(); + return Result; + } + + Constant *C = DbgGV->getInitializer(); + if (C == 0 || Elt >= C->getNumOperands()) { + Result.clear(); + return Result; + } -std::string DIDescriptor::getStringField(unsigned Elt) const { - if (GV == 0) return ""; - Constant *C = GV->getInitializer(); - if (C == 0 || Elt >= C->getNumOperands()) - return ""; - - std::string Result; // Fills in the string if it succeeds if (!GetConstantStringInfo(C->getOperand(Elt), Result)) Result.clear(); + return Result; } uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const { - if (GV == 0) return 0; - Constant *C = GV->getInitializer(); + if (DbgGV == 0) return 0; + + Constant *C = DbgGV->getInitializer(); if (C == 0 || Elt >= C->getNumOperands()) return 0; + if (ConstantInt *CI = dyn_cast(C->getOperand(Elt))) return CI->getZExtValue(); return 0; } - DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const { - if (GV == 0) return DIDescriptor(); - Constant *C = GV->getInitializer(); + if (DbgGV == 0) return DIDescriptor(); + + Constant *C = DbgGV->getInitializer(); if (C == 0 || Elt >= C->getNumOperands()) return DIDescriptor(); + C = C->getOperand(Elt); return DIDescriptor(dyn_cast(C->stripPointerCasts())); } GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const { - if (GV == 0) return 0; - Constant *C = GV->getInitializer(); + if (DbgGV == 0) return 0; + + Constant *C = DbgGV->getInitializer(); if (C == 0 || Elt >= C->getNumOperands()) return 0; + C = C->getOperand(Elt); - return dyn_cast(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() -DIType::DIType(GlobalVariable *gv) : DIDescriptor(gv) { - if (!gv) return; +// Needed by DIVariable::getType(). +DIType::DIType(GlobalVariable *GV) : DIDescriptor(GV) { + if (!GV) return; unsigned tag = getTag(); if (tag != dwarf::DW_TAG_base_type && !DIDerivedType::isDerivedType(tag) && !DICompositeType::isCompositeType(tag)) - GV = 0; + DbgGV = 0; } /// isDerivedType - Return true if the specified tag is legal for @@ -130,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) { @@ -145,18 +178,13 @@ bool DIType::isCompositeType(unsigned TAG) { case dwarf::DW_TAG_enumeration_type: case dwarf::DW_TAG_vector_type: case dwarf::DW_TAG_subroutine_type: + case dwarf::DW_TAG_class_type: return true; default: return false; } } -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) { @@ -169,14 +197,9 @@ 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(); + assert (DbgGV && "Invalid DIArray"); + Constant *C = DbgGV->getInitializer(); assert (C && "Invalid DIArray initializer"); return C->getNumOperands(); } @@ -185,7 +208,8 @@ unsigned DIArray::getNumElements() const { bool DICompileUnit::Verify() const { if (isNull()) return false; - if (getFilename().empty()) + std::string Res; + if (getFilename(Res).empty()) return false; // It is possible that directory and produce string is empty. return true; @@ -244,7 +268,7 @@ bool DIGlobalVariable::Verify() const { return false; DICompileUnit CU = getCompileUnit(); - if (!CU.Verify()) + if (!CU.isNull() && !CU.Verify()) return false; DIType Ty = getType(); @@ -269,7 +293,6 @@ bool DIVariable::Verify() const { if (!Ty.Verify()) return false; - return true; } @@ -284,12 +307,26 @@ uint64_t DIDerivedType::getOriginalTypeSize() const { return BT.getSizeInBits(); } +/// describes - Return true if this subprogram provides debugging +/// information for the function F. +bool DISubprogram::describes(const Function *F) { + assert (F && "Invalid function"); + std::string Name; + getLinkageName(Name); + if (Name.empty()) + getName(Name); + if (!Name.empty() && (strcmp(Name.c_str(), F->getNameStart()) == false)) + return true; + return false; +} + //===----------------------------------------------------------------------===// // 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)); } @@ -315,7 +352,7 @@ Constant *DIFactory::GetStringConstant(const std::string &String) { const PointerType *DestTy = PointerType::getUnqual(Type::Int8Ty); - // If empty string then use a sbyte* null instead. + // If empty string then use a i8* null instead. if (String.empty()) return Slot = ConstantPointerNull::get(DestTy); @@ -405,7 +442,7 @@ DIArray DIFactory::GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys) { Constant *Init = ConstantArray::get(ArrayType::get(EmptyStructPtr, Elts.size()), - &Elts[0], Elts.size()); + Elts.data(), Elts.size()); // If we already have this array, just return the uniqued version. DIDescriptor &Entry = SimpleConstantCache[Init]; if (!Entry.isNull()) return DIArray(Entry.getGV()); @@ -746,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); @@ -758,122 +794,194 @@ 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(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(I)) - return DSI; - } while (I != B); + while (I != B) { + --I; + if (const DbgStopPointInst *DSI = dyn_cast(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(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; } - /// Finds the dbg.declare intrinsic corresponding to this value if any. + Value *findDbgGlobalDeclare(GlobalVariable *V) { + const Module *M = V->getParent(); + const Type *Ty = M->getTypeByName("llvm.dbg.global_variable.type"); + 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(); + I != E; ++I) { + if (ConstantExpr *CE = dyn_cast(I)) { + if (CE->getOpcode() == Instruction::BitCast) { + Value *VV = CE; + + while (VV->hasOneUse()) + VV = *VV->use_begin(); + + if (VV->getType() == Ty) + return VV; + } + } + } + + if (Val->getType() == Ty) + return Val; + + return 0; + } + + /// 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(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(I)) return DDI; - } + return 0; } + + 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(const_cast(V))) { + Value *DIGV = findDbgGlobalDeclare(GV); + if (!DIGV) return false; + DIGlobalVariable Var(cast(DIGV)); + + Var.getDisplayName(DisplayName); + LineNo = Var.getLineNumber(); + Unit = Var.getCompileUnit(); + TypeD = Var.getType(); + } else { + const DbgDeclareInst *DDI = findDbgDeclare(V); + if (!DDI) return false; + DIVariable Var(cast(DDI->getVariable())); + + Var.getName(DisplayName); + LineNo = Var.getLineNumber(); + Unit = Var.getCompileUnit(); + TypeD = Var.getType(); + } + + TypeD.getName(Type); + Unit.getFilename(File); + Unit.getDirectory(Dir); + return true; + } } -/// dump - print compile unit. +/// dump - Print descriptor. +void DIDescriptor::dump() const { + cerr << "[" << dwarf::TagString(getTag()) << "] "; + cerr << std::hex << "[GV:" << DbgGV << "]" << std::dec; +} + +/// dump - Print compile unit. void DICompileUnit::dump() const { if (getLanguage()) cerr << " [" << dwarf::LanguageString(getLanguage()) << "] "; - cerr << " [" << getDirectory() << "/" << getFilename() << " ]"; + + std::string Res1, Res2; + cerr << " [" << getDirectory(Res1) << "/" << getFilename(Res2) << " ]"; } -/// dump - print type. +/// dump - Print type. void DIType::dump() const { if (isNull()) return; - if (!getName().empty()) - cerr << " [" << getName() << "] "; + + std::string Res; + if (!getName(Res).empty()) + cerr << " [" << Res << "] "; + unsigned Tag = getTag(); cerr << " [" << dwarf::TagString(Tag) << "] "; + // TODO : Print context getCompileUnit().dump(); cerr << " [" @@ -882,38 +990,40 @@ void DIType::dump() const { << getAlignInBits() << ", " << getOffsetInBits() << "] "; + if (isPrivate()) cerr << " [private] "; else if (isProtected()) cerr << " [protected] "; + if (isForwardDecl()) cerr << " [fwd] "; if (isBasicType(Tag)) - DIBasicType(GV).dump(); + DIBasicType(DbgGV).dump(); else if (isDerivedType(Tag)) - DIDerivedType(GV).dump(); + DIDerivedType(DbgGV).dump(); else if (isCompositeType(Tag)) - DICompositeType(GV).dump(); + DICompositeType(DbgGV).dump(); else { cerr << "Invalid DIType\n"; return; } + 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()) @@ -921,41 +1031,47 @@ 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()) + cerr << " [" << Res << "] "; - 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(); + DIGlobalVariable(DbgGV).dump(); 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 { - if (!getName().empty()) - cerr << " [" << getName() << "] "; + std::string Res; + if (!getName(Res).empty()) + cerr << " [" << Res << "] "; + getCompileUnit().dump(); cerr << " [" << getLineNumber() << "] "; getType().dump();