1 //===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the helper classes used to build and interpret debug
11 // information in LLVM IR form.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/Analysis/DebugInfo.h"
16 #include "llvm/Constants.h"
17 #include "llvm/DerivedTypes.h"
18 #include "llvm/Intrinsics.h"
19 #include "llvm/IntrinsicInst.h"
20 #include "llvm/Instructions.h"
21 #include "llvm/LLVMContext.h"
22 #include "llvm/Module.h"
23 #include "llvm/Analysis/ValueTracking.h"
24 #include "llvm/ADT/SmallPtrSet.h"
25 #include "llvm/Support/Dwarf.h"
26 #include "llvm/Support/DebugLoc.h"
27 #include "llvm/Support/raw_ostream.h"
29 using namespace llvm::dwarf;
31 //===----------------------------------------------------------------------===//
33 //===----------------------------------------------------------------------===//
35 /// ValidDebugInfo - Return true if V represents valid debug info value.
36 /// FIXME : Add DIDescriptor.isValid()
37 bool DIDescriptor::ValidDebugInfo(MDNode *N, CodeGenOpt::Level OptLevel) {
43 // Check current version. Allow Version6 for now.
44 unsigned Version = DI.getVersion();
45 if (Version != LLVMDebugVersion && Version != LLVMDebugVersion6)
48 unsigned Tag = DI.getTag();
51 assert(DIVariable(N).Verify() && "Invalid DebugInfo value");
53 case DW_TAG_compile_unit:
54 assert(DICompileUnit(N).Verify() && "Invalid DebugInfo value");
56 case DW_TAG_subprogram:
57 assert(DISubprogram(N).Verify() && "Invalid DebugInfo value");
59 case DW_TAG_lexical_block:
60 // FIXME: This interfers with the quality of generated code during
62 if (OptLevel != CodeGenOpt::None)
72 DIDescriptor::DIDescriptor(MDNode *N, unsigned RequiredTag) {
75 // If this is non-null, check to see if the Tag matches. If not, set to null.
76 if (N && getTag() != RequiredTag) {
82 DIDescriptor::getStringField(unsigned Elt, std::string &Result) const {
87 if (Elt < DbgNode->getNumElements())
88 if (MDString *MDS = dyn_cast_or_null<MDString>(DbgNode->getElement(Elt))) {
89 Result.assign(MDS->begin(), MDS->begin() + MDS->length());
96 uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
100 if (Elt < DbgNode->getNumElements())
101 if (ConstantInt *CI = dyn_cast<ConstantInt>(DbgNode->getElement(Elt)))
102 return CI->getZExtValue();
107 DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const {
109 return DIDescriptor();
111 if (Elt < DbgNode->getNumElements() && DbgNode->getElement(Elt))
112 return DIDescriptor(dyn_cast<MDNode>(DbgNode->getElement(Elt)));
114 return DIDescriptor();
117 GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const {
121 if (Elt < DbgNode->getNumElements())
122 return dyn_cast<GlobalVariable>(DbgNode->getElement(Elt));
126 //===----------------------------------------------------------------------===//
128 //===----------------------------------------------------------------------===//
130 /// isBasicType - Return true if the specified tag is legal for
132 bool DIDescriptor::isBasicType() const {
133 assert (!isNull() && "Invalid descriptor!");
134 unsigned Tag = getTag();
136 return Tag == dwarf::DW_TAG_base_type;
139 /// isDerivedType - Return true if the specified tag is legal for DIDerivedType.
140 bool DIDescriptor::isDerivedType() const {
141 assert (!isNull() && "Invalid descriptor!");
142 unsigned Tag = getTag();
145 case dwarf::DW_TAG_typedef:
146 case dwarf::DW_TAG_pointer_type:
147 case dwarf::DW_TAG_reference_type:
148 case dwarf::DW_TAG_const_type:
149 case dwarf::DW_TAG_volatile_type:
150 case dwarf::DW_TAG_restrict_type:
151 case dwarf::DW_TAG_member:
152 case dwarf::DW_TAG_inheritance:
155 // CompositeTypes are currently modelled as DerivedTypes.
156 return isCompositeType();
160 /// isCompositeType - Return true if the specified tag is legal for
162 bool DIDescriptor::isCompositeType() const {
163 assert (!isNull() && "Invalid descriptor!");
164 unsigned Tag = getTag();
167 case dwarf::DW_TAG_array_type:
168 case dwarf::DW_TAG_structure_type:
169 case dwarf::DW_TAG_union_type:
170 case dwarf::DW_TAG_enumeration_type:
171 case dwarf::DW_TAG_vector_type:
172 case dwarf::DW_TAG_subroutine_type:
173 case dwarf::DW_TAG_class_type:
180 /// isVariable - Return true if the specified tag is legal for DIVariable.
181 bool DIDescriptor::isVariable() const {
182 assert (!isNull() && "Invalid descriptor!");
183 unsigned Tag = getTag();
186 case dwarf::DW_TAG_auto_variable:
187 case dwarf::DW_TAG_arg_variable:
188 case dwarf::DW_TAG_return_variable:
195 /// isSubprogram - Return true if the specified tag is legal for
197 bool DIDescriptor::isSubprogram() const {
198 assert (!isNull() && "Invalid descriptor!");
199 unsigned Tag = getTag();
201 return Tag == dwarf::DW_TAG_subprogram;
204 /// isGlobalVariable - Return true if the specified tag is legal for
205 /// DIGlobalVariable.
206 bool DIDescriptor::isGlobalVariable() const {
207 assert (!isNull() && "Invalid descriptor!");
208 unsigned Tag = getTag();
210 return Tag == dwarf::DW_TAG_variable;
213 /// isScope - Return true if the specified tag is one of the scope
215 bool DIDescriptor::isScope() const {
216 assert (!isNull() && "Invalid descriptor!");
217 unsigned Tag = getTag();
220 case dwarf::DW_TAG_compile_unit:
221 case dwarf::DW_TAG_lexical_block:
222 case dwarf::DW_TAG_subprogram:
230 /// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit.
231 bool DIDescriptor::isCompileUnit() const {
232 assert (!isNull() && "Invalid descriptor!");
233 unsigned Tag = getTag();
235 return Tag == dwarf::DW_TAG_compile_unit;
238 /// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block.
239 bool DIDescriptor::isLexicalBlock() const {
240 assert (!isNull() && "Invalid descriptor!");
241 unsigned Tag = getTag();
243 return Tag == dwarf::DW_TAG_lexical_block;
246 //===----------------------------------------------------------------------===//
247 // Simple Descriptor Constructors and other Methods
248 //===----------------------------------------------------------------------===//
250 DIType::DIType(MDNode *N) : DIDescriptor(N) {
252 if (!isBasicType() && !isDerivedType() && !isCompositeType()) {
257 unsigned DIArray::getNumElements() const {
258 assert (DbgNode && "Invalid DIArray");
259 return DbgNode->getNumElements();
262 /// replaceAllUsesWith - Replace all uses of debug info referenced by
263 /// this descriptor. After this completes, the current debug info value
265 void DIDerivedType::replaceAllUsesWith(DIDescriptor &D) {
269 assert (!D.isNull() && "Can not replace with null");
270 DbgNode->replaceAllUsesWith(D.getNode());
274 /// Verify - Verify that a compile unit is well formed.
275 bool DICompileUnit::Verify() const {
279 if (getFilename(Res).empty())
281 // It is possible that directory and produce string is empty.
285 /// Verify - Verify that a type descriptor is well formed.
286 bool DIType::Verify() const {
289 if (getContext().isNull())
292 DICompileUnit CU = getCompileUnit();
293 if (!CU.isNull() && !CU.Verify())
298 /// Verify - Verify that a composite type descriptor is well formed.
299 bool DICompositeType::Verify() const {
302 if (getContext().isNull())
305 DICompileUnit CU = getCompileUnit();
306 if (!CU.isNull() && !CU.Verify())
311 /// Verify - Verify that a subprogram descriptor is well formed.
312 bool DISubprogram::Verify() const {
316 if (getContext().isNull())
319 DICompileUnit CU = getCompileUnit();
323 DICompositeType Ty = getType();
324 if (!Ty.isNull() && !Ty.Verify())
329 /// Verify - Verify that a global variable descriptor is well formed.
330 bool DIGlobalVariable::Verify() const {
334 if (getContext().isNull())
337 DICompileUnit CU = getCompileUnit();
338 if (!CU.isNull() && !CU.Verify())
341 DIType Ty = getType();
351 /// Verify - Verify that a variable descriptor is well formed.
352 bool DIVariable::Verify() const {
356 if (getContext().isNull())
359 DIType Ty = getType();
366 /// getOriginalTypeSize - If this type is derived from a base type then
367 /// return base type size.
368 uint64_t DIDerivedType::getOriginalTypeSize() const {
369 if (getTag() != dwarf::DW_TAG_member)
370 return getSizeInBits();
371 DIType BT = getTypeDerivedFrom();
372 if (BT.getTag() != dwarf::DW_TAG_base_type)
373 return getSizeInBits();
374 return BT.getSizeInBits();
377 /// describes - Return true if this subprogram provides debugging
378 /// information for the function F.
379 bool DISubprogram::describes(const Function *F) {
380 assert (F && "Invalid function");
382 getLinkageName(Name);
385 if (F->getName() == Name)
390 //===----------------------------------------------------------------------===//
391 // DIDescriptor: dump routines for all descriptors.
392 //===----------------------------------------------------------------------===//
395 /// dump - Print descriptor.
396 void DIDescriptor::dump() const {
397 errs() << "[" << dwarf::TagString(getTag()) << "] ";
398 errs().write_hex((intptr_t)DbgNode) << ']';
401 /// dump - Print compile unit.
402 void DICompileUnit::dump() const {
404 errs() << " [" << dwarf::LanguageString(getLanguage()) << "] ";
406 std::string Res1, Res2;
407 errs() << " [" << getDirectory(Res1) << "/" << getFilename(Res2) << " ]";
410 /// dump - Print type.
411 void DIType::dump() const {
412 if (isNull()) return;
415 if (!getName(Res).empty())
416 errs() << " [" << Res << "] ";
418 unsigned Tag = getTag();
419 errs() << " [" << dwarf::TagString(Tag) << "] ";
421 // TODO : Print context
422 getCompileUnit().dump();
424 << getLineNumber() << ", "
425 << getSizeInBits() << ", "
426 << getAlignInBits() << ", "
431 errs() << " [private] ";
432 else if (isProtected())
433 errs() << " [protected] ";
439 DIBasicType(DbgNode).dump();
440 else if (isDerivedType())
441 DIDerivedType(DbgNode).dump();
442 else if (isCompositeType())
443 DICompositeType(DbgNode).dump();
445 errs() << "Invalid DIType\n";
452 /// dump - Print basic type.
453 void DIBasicType::dump() const {
454 errs() << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
457 /// dump - Print derived type.
458 void DIDerivedType::dump() const {
459 errs() << "\n\t Derived From: "; getTypeDerivedFrom().dump();
462 /// dump - Print composite type.
463 void DICompositeType::dump() const {
464 DIArray A = getTypeArray();
467 errs() << " [" << A.getNumElements() << " elements]";
470 /// dump - Print global.
471 void DIGlobal::dump() const {
473 if (!getName(Res).empty())
474 errs() << " [" << Res << "] ";
476 unsigned Tag = getTag();
477 errs() << " [" << dwarf::TagString(Tag) << "] ";
479 // TODO : Print context
480 getCompileUnit().dump();
481 errs() << " [" << getLineNumber() << "] ";
484 errs() << " [local] ";
489 if (isGlobalVariable())
490 DIGlobalVariable(DbgNode).dump();
495 /// dump - Print subprogram.
496 void DISubprogram::dump() const {
498 if (!getName(Res).empty())
499 errs() << " [" << Res << "] ";
501 unsigned Tag = getTag();
502 errs() << " [" << dwarf::TagString(Tag) << "] ";
504 // TODO : Print context
505 getCompileUnit().dump();
506 errs() << " [" << getLineNumber() << "] ";
509 errs() << " [local] ";
517 /// dump - Print global variable.
518 void DIGlobalVariable::dump() const {
524 /// dump - Print variable.
525 void DIVariable::dump() const {
527 if (!getName(Res).empty())
528 errs() << " [" << Res << "] ";
530 getCompileUnit().dump();
531 errs() << " [" << getLineNumber() << "] ";
536 //===----------------------------------------------------------------------===//
537 // DIFactory: Basic Helpers
538 //===----------------------------------------------------------------------===//
540 DIFactory::DIFactory(Module &m)
541 : M(m), VMContext(M.getContext()), StopPointFn(0), FuncStartFn(0),
542 RegionStartFn(0), RegionEndFn(0),
544 EmptyStructPtr = PointerType::getUnqual(StructType::get(VMContext));
547 Constant *DIFactory::GetTagConstant(unsigned TAG) {
548 assert((TAG & LLVMDebugVersionMask) == 0 &&
549 "Tag too large for debug encoding!");
550 return ConstantInt::get(Type::getInt32Ty(VMContext), TAG | LLVMDebugVersion);
553 //===----------------------------------------------------------------------===//
554 // DIFactory: Primary Constructors
555 //===----------------------------------------------------------------------===//
557 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
558 /// This implicitly uniques the arrays created.
559 DIArray DIFactory::GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys) {
560 SmallVector<Value*, 16> Elts;
563 Elts.push_back(llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)));
565 for (unsigned i = 0; i != NumTys; ++i)
566 Elts.push_back(Tys[i].getNode());
568 return DIArray(MDNode::get(VMContext,Elts.data(), Elts.size()));
571 /// GetOrCreateSubrange - Create a descriptor for a value range. This
572 /// implicitly uniques the values returned.
573 DISubrange DIFactory::GetOrCreateSubrange(int64_t Lo, int64_t Hi) {
575 GetTagConstant(dwarf::DW_TAG_subrange_type),
576 ConstantInt::get(Type::getInt64Ty(VMContext), Lo),
577 ConstantInt::get(Type::getInt64Ty(VMContext), Hi)
580 return DISubrange(MDNode::get(VMContext, &Elts[0], 3));
585 /// CreateCompileUnit - Create a new descriptor for the specified compile
586 /// unit. Note that this does not unique compile units within the module.
587 DICompileUnit DIFactory::CreateCompileUnit(unsigned LangID,
588 const std::string &Filename,
589 const std::string &Directory,
590 const std::string &Producer,
594 unsigned RunTimeVer) {
596 GetTagConstant(dwarf::DW_TAG_compile_unit),
597 llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
598 ConstantInt::get(Type::getInt32Ty(VMContext), LangID),
599 MDString::get(VMContext, Filename),
600 MDString::get(VMContext, Directory),
601 MDString::get(VMContext, Producer),
602 ConstantInt::get(Type::getInt1Ty(VMContext), isMain),
603 ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
604 MDString::get(VMContext, Flags),
605 ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeVer)
608 return DICompileUnit(MDNode::get(VMContext, &Elts[0], 10));
611 /// CreateEnumerator - Create a single enumerator value.
612 DIEnumerator DIFactory::CreateEnumerator(const std::string &Name, uint64_t Val){
614 GetTagConstant(dwarf::DW_TAG_enumerator),
615 MDString::get(VMContext, Name),
616 ConstantInt::get(Type::getInt64Ty(VMContext), Val)
618 return DIEnumerator(MDNode::get(VMContext, &Elts[0], 3));
622 /// CreateBasicType - Create a basic type like int, float, etc.
623 DIBasicType DIFactory::CreateBasicType(DIDescriptor Context,
624 const std::string &Name,
625 DICompileUnit CompileUnit,
628 uint64_t AlignInBits,
629 uint64_t OffsetInBits, unsigned Flags,
632 GetTagConstant(dwarf::DW_TAG_base_type),
634 MDString::get(VMContext, Name),
635 CompileUnit.getNode(),
636 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
637 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
638 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
639 ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
640 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
641 ConstantInt::get(Type::getInt32Ty(VMContext), Encoding)
643 return DIBasicType(MDNode::get(VMContext, &Elts[0], 10));
646 /// CreateDerivedType - Create a derived type like const qualified type,
647 /// pointer, typedef, etc.
648 DIDerivedType DIFactory::CreateDerivedType(unsigned Tag,
649 DIDescriptor Context,
650 const std::string &Name,
651 DICompileUnit CompileUnit,
654 uint64_t AlignInBits,
655 uint64_t OffsetInBits,
657 DIType DerivedFrom) {
661 MDString::get(VMContext, Name),
662 CompileUnit.getNode(),
663 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
664 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
665 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
666 ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
667 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
668 DerivedFrom.getNode(),
670 return DIDerivedType(MDNode::get(VMContext, &Elts[0], 10));
673 /// CreateCompositeType - Create a composite type like array, struct, etc.
674 DICompositeType DIFactory::CreateCompositeType(unsigned Tag,
675 DIDescriptor Context,
676 const std::string &Name,
677 DICompileUnit CompileUnit,
680 uint64_t AlignInBits,
681 uint64_t OffsetInBits,
685 unsigned RuntimeLang) {
690 MDString::get(VMContext, Name),
691 CompileUnit.getNode(),
692 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
693 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
694 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
695 ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
696 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
697 DerivedFrom.getNode(),
699 ConstantInt::get(Type::getInt32Ty(VMContext), RuntimeLang)
701 return DICompositeType(MDNode::get(VMContext, &Elts[0], 12));
705 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
706 /// See comments in DISubprogram for descriptions of these fields. This
707 /// method does not unique the generated descriptors.
708 DISubprogram DIFactory::CreateSubprogram(DIDescriptor Context,
709 const std::string &Name,
710 const std::string &DisplayName,
711 const std::string &LinkageName,
712 DICompileUnit CompileUnit,
713 unsigned LineNo, DIType Type,
718 GetTagConstant(dwarf::DW_TAG_subprogram),
719 llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
721 MDString::get(VMContext, Name),
722 MDString::get(VMContext, DisplayName),
723 MDString::get(VMContext, LinkageName),
724 CompileUnit.getNode(),
725 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
727 ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
728 ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition)
730 return DISubprogram(MDNode::get(VMContext, &Elts[0], 11));
733 /// CreateGlobalVariable - Create a new descriptor for the specified global.
735 DIFactory::CreateGlobalVariable(DIDescriptor Context, const std::string &Name,
736 const std::string &DisplayName,
737 const std::string &LinkageName,
738 DICompileUnit CompileUnit,
739 unsigned LineNo, DIType Type,bool isLocalToUnit,
740 bool isDefinition, llvm::GlobalVariable *Val) {
742 GetTagConstant(dwarf::DW_TAG_variable),
743 llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
745 MDString::get(VMContext, Name),
746 MDString::get(VMContext, DisplayName),
747 MDString::get(VMContext, LinkageName),
748 CompileUnit.getNode(),
749 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
751 ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
752 ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
756 Value *const *Vs = &Elts[0];
757 MDNode *Node = MDNode::get(VMContext,Vs, 12);
759 // Create a named metadata so that we do not lose this mdnode.
760 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.gv");
761 NMD->addElement(Node);
763 return DIGlobalVariable(Node);
767 /// CreateVariable - Create a new descriptor for the specified variable.
768 DIVariable DIFactory::CreateVariable(unsigned Tag, DIDescriptor Context,
769 const std::string &Name,
770 DICompileUnit CompileUnit, unsigned LineNo,
775 MDString::get(VMContext, Name),
776 CompileUnit.getNode(),
777 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
780 return DIVariable(MDNode::get(VMContext, &Elts[0], 6));
784 /// CreateBlock - This creates a descriptor for a lexical block with the
785 /// specified parent VMContext.
786 DILexicalBlock DIFactory::CreateLexicalBlock(DIDescriptor Context) {
788 GetTagConstant(dwarf::DW_TAG_lexical_block),
791 return DILexicalBlock(MDNode::get(VMContext, &Elts[0], 2));
794 /// CreateLocation - Creates a debug info location.
795 DILocation DIFactory::CreateLocation(unsigned LineNo, unsigned ColumnNo,
796 DIScope S, DILocation OrigLoc) {
798 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
799 ConstantInt::get(Type::getInt32Ty(VMContext), ColumnNo),
803 return DILocation(MDNode::get(VMContext, &Elts[0], 4));
807 //===----------------------------------------------------------------------===//
808 // DIFactory: Routines for inserting code into a function
809 //===----------------------------------------------------------------------===//
811 /// InsertStopPoint - Create a new llvm.dbg.stoppoint intrinsic invocation,
812 /// inserting it at the end of the specified basic block.
813 void DIFactory::InsertStopPoint(DICompileUnit CU, unsigned LineNo,
814 unsigned ColNo, BasicBlock *BB) {
816 // Lazily construct llvm.dbg.stoppoint function.
818 StopPointFn = llvm::Intrinsic::getDeclaration(&M,
819 llvm::Intrinsic::dbg_stoppoint);
821 // Invoke llvm.dbg.stoppoint
823 ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo),
824 ConstantInt::get(llvm::Type::getInt32Ty(VMContext), ColNo),
827 CallInst::Create(StopPointFn, Args, Args+3, "", BB);
830 /// InsertSubprogramStart - Create a new llvm.dbg.func.start intrinsic to
831 /// mark the start of the specified subprogram.
832 void DIFactory::InsertSubprogramStart(DISubprogram SP, BasicBlock *BB) {
833 // Lazily construct llvm.dbg.func.start.
835 FuncStartFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_func_start);
837 // Call llvm.dbg.func.start which also implicitly sets a stoppoint.
838 CallInst::Create(FuncStartFn, SP.getNode(), "", BB);
841 /// InsertRegionStart - Insert a new llvm.dbg.region.start intrinsic call to
842 /// mark the start of a region for the specified scoping descriptor.
843 void DIFactory::InsertRegionStart(DIDescriptor D, BasicBlock *BB) {
844 // Lazily construct llvm.dbg.region.start function.
846 RegionStartFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_region_start);
848 // Call llvm.dbg.func.start.
849 CallInst::Create(RegionStartFn, D.getNode(), "", BB);
852 /// InsertRegionEnd - Insert a new llvm.dbg.region.end intrinsic call to
853 /// mark the end of a region for the specified scoping descriptor.
854 void DIFactory::InsertRegionEnd(DIDescriptor D, BasicBlock *BB) {
855 // Lazily construct llvm.dbg.region.end function.
857 RegionEndFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_region_end);
859 // Call llvm.dbg.region.end.
860 CallInst::Create(RegionEndFn, D.getNode(), "", BB);
863 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
864 void DIFactory::InsertDeclare(Value *Storage, DIVariable D, BasicBlock *BB) {
865 // Cast the storage to a {}* for the call to llvm.dbg.declare.
866 Storage = new BitCastInst(Storage, EmptyStructPtr, "", BB);
869 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
871 Value *Args[] = { Storage, D.getNode() };
872 CallInst::Create(DeclareFn, Args, Args+2, "", BB);
876 //===----------------------------------------------------------------------===//
877 // DebugInfoFinder implementations.
878 //===----------------------------------------------------------------------===//
880 /// processModule - Process entire module and collect debug info.
881 void DebugInfoFinder::processModule(Module &M) {
884 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
885 for (Function::iterator FI = (*I).begin(), FE = (*I).end(); FI != FE; ++FI)
886 for (BasicBlock::iterator BI = (*FI).begin(), BE = (*FI).end(); BI != BE;
888 if (DbgStopPointInst *SPI = dyn_cast<DbgStopPointInst>(BI))
889 processStopPoint(SPI);
890 else if (DbgFuncStartInst *FSI = dyn_cast<DbgFuncStartInst>(BI))
891 processFuncStart(FSI);
892 else if (DbgRegionStartInst *DRS = dyn_cast<DbgRegionStartInst>(BI))
893 processRegionStart(DRS);
894 else if (DbgRegionEndInst *DRE = dyn_cast<DbgRegionEndInst>(BI))
895 processRegionEnd(DRE);
896 else if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(BI))
900 NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.gv");
904 for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
905 DIGlobalVariable DIG(cast<MDNode>(NMD->getElement(i)));
906 if (addGlobalVariable(DIG)) {
907 addCompileUnit(DIG.getCompileUnit());
908 processType(DIG.getType());
913 /// processType - Process DIType.
914 void DebugInfoFinder::processType(DIType DT) {
918 addCompileUnit(DT.getCompileUnit());
919 if (DT.isCompositeType()) {
920 DICompositeType DCT(DT.getNode());
921 processType(DCT.getTypeDerivedFrom());
922 DIArray DA = DCT.getTypeArray();
924 for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
925 DIDescriptor D = DA.getElement(i);
926 DIType TypeE = DIType(D.getNode());
930 processSubprogram(DISubprogram(D.getNode()));
932 } else if (DT.isDerivedType()) {
933 DIDerivedType DDT(DT.getNode());
935 processType(DDT.getTypeDerivedFrom());
939 /// processSubprogram - Process DISubprogram.
940 void DebugInfoFinder::processSubprogram(DISubprogram SP) {
943 if (!addSubprogram(SP))
945 addCompileUnit(SP.getCompileUnit());
946 processType(SP.getType());
949 /// processStopPoint - Process DbgStopPointInst.
950 void DebugInfoFinder::processStopPoint(DbgStopPointInst *SPI) {
951 MDNode *Context = dyn_cast<MDNode>(SPI->getContext());
952 addCompileUnit(DICompileUnit(Context));
955 /// processFuncStart - Process DbgFuncStartInst.
956 void DebugInfoFinder::processFuncStart(DbgFuncStartInst *FSI) {
957 MDNode *SP = dyn_cast<MDNode>(FSI->getSubprogram());
958 processSubprogram(DISubprogram(SP));
961 /// processRegionStart - Process DbgRegionStart.
962 void DebugInfoFinder::processRegionStart(DbgRegionStartInst *DRS) {
963 MDNode *SP = dyn_cast<MDNode>(DRS->getContext());
964 processSubprogram(DISubprogram(SP));
967 /// processRegionEnd - Process DbgRegionEnd.
968 void DebugInfoFinder::processRegionEnd(DbgRegionEndInst *DRE) {
969 MDNode *SP = dyn_cast<MDNode>(DRE->getContext());
970 processSubprogram(DISubprogram(SP));
973 /// processDeclare - Process DbgDeclareInst.
974 void DebugInfoFinder::processDeclare(DbgDeclareInst *DDI) {
975 DIVariable DV(cast<MDNode>(DDI->getVariable()));
979 if (!NodesSeen.insert(DV.getNode()))
982 addCompileUnit(DV.getCompileUnit());
983 processType(DV.getType());
986 /// addType - Add type into Tys.
987 bool DebugInfoFinder::addType(DIType DT) {
991 if (!NodesSeen.insert(DT.getNode()))
994 TYs.push_back(DT.getNode());
998 /// addCompileUnit - Add compile unit into CUs.
999 bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) {
1003 if (!NodesSeen.insert(CU.getNode()))
1006 CUs.push_back(CU.getNode());
1010 /// addGlobalVariable - Add global variable into GVs.
1011 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) {
1015 if (!NodesSeen.insert(DIG.getNode()))
1018 GVs.push_back(DIG.getNode());
1022 // addSubprogram - Add subprgoram into SPs.
1023 bool DebugInfoFinder::addSubprogram(DISubprogram SP) {
1027 if (!NodesSeen.insert(SP.getNode()))
1030 SPs.push_back(SP.getNode());
1035 /// findStopPoint - Find the stoppoint coressponding to this instruction, that
1036 /// is the stoppoint that dominates this instruction.
1037 const DbgStopPointInst *findStopPoint(const Instruction *Inst) {
1038 if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(Inst))
1041 const BasicBlock *BB = Inst->getParent();
1042 BasicBlock::const_iterator I = Inst, B;
1046 // A BB consisting only of a terminator can't have a stoppoint.
1049 if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
1053 // This BB didn't have a stoppoint: if there is only one predecessor, look
1054 // for a stoppoint there. We could use getIDom(), but that would require
1056 BB = I->getParent()->getUniquePredecessor();
1058 I = BB->getTerminator();
1064 /// findBBStopPoint - Find the stoppoint corresponding to first real
1065 /// (non-debug intrinsic) instruction in this Basic Block, and return the
1066 /// stoppoint for it.
1067 const DbgStopPointInst *findBBStopPoint(const BasicBlock *BB) {
1068 for(BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
1069 if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
1072 // Fallback to looking for stoppoint of unique predecessor. Useful if this
1073 // BB contains no stoppoints, but unique predecessor does.
1074 BB = BB->getUniquePredecessor();
1076 return findStopPoint(BB->getTerminator());
1081 Value *findDbgGlobalDeclare(GlobalVariable *V) {
1082 const Module *M = V->getParent();
1083 NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv");
1087 for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
1088 DIGlobalVariable DIG(cast_or_null<MDNode>(NMD->getElement(i)));
1091 if (DIG.getGlobal() == V)
1092 return DIG.getNode();
1097 /// Finds the llvm.dbg.declare intrinsic corresponding to this value if any.
1098 /// It looks through pointer casts too.
1099 const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts) {
1101 V = V->stripPointerCasts();
1103 // Look for the bitcast.
1104 for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
1106 if (isa<BitCastInst>(I))
1107 return findDbgDeclare(*I, false);
1112 // Find llvm.dbg.declare among uses of the instruction.
1113 for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
1115 if (const DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I))
1121 bool getLocationInfo(const Value *V, std::string &DisplayName,
1122 std::string &Type, unsigned &LineNo, std::string &File,
1127 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(const_cast<Value*>(V))) {
1128 Value *DIGV = findDbgGlobalDeclare(GV);
1129 if (!DIGV) return false;
1130 DIGlobalVariable Var(cast<MDNode>(DIGV));
1132 Var.getDisplayName(DisplayName);
1133 LineNo = Var.getLineNumber();
1134 Unit = Var.getCompileUnit();
1135 TypeD = Var.getType();
1137 const DbgDeclareInst *DDI = findDbgDeclare(V);
1138 if (!DDI) return false;
1139 DIVariable Var(cast<MDNode>(DDI->getVariable()));
1141 Var.getName(DisplayName);
1142 LineNo = Var.getLineNumber();
1143 Unit = Var.getCompileUnit();
1144 TypeD = Var.getType();
1147 TypeD.getName(Type);
1148 Unit.getFilename(File);
1149 Unit.getDirectory(Dir);
1153 /// isValidDebugInfoIntrinsic - Return true if SPI is a valid debug
1155 bool isValidDebugInfoIntrinsic(DbgStopPointInst &SPI,
1156 CodeGenOpt::Level OptLev) {
1157 return DIDescriptor::ValidDebugInfo(SPI.getContext(), OptLev);
1160 /// isValidDebugInfoIntrinsic - Return true if FSI is a valid debug
1162 bool isValidDebugInfoIntrinsic(DbgFuncStartInst &FSI,
1163 CodeGenOpt::Level OptLev) {
1164 return DIDescriptor::ValidDebugInfo(FSI.getSubprogram(), OptLev);
1167 /// isValidDebugInfoIntrinsic - Return true if RSI is a valid debug
1169 bool isValidDebugInfoIntrinsic(DbgRegionStartInst &RSI,
1170 CodeGenOpt::Level OptLev) {
1171 return DIDescriptor::ValidDebugInfo(RSI.getContext(), OptLev);
1174 /// isValidDebugInfoIntrinsic - Return true if REI is a valid debug
1176 bool isValidDebugInfoIntrinsic(DbgRegionEndInst &REI,
1177 CodeGenOpt::Level OptLev) {
1178 return DIDescriptor::ValidDebugInfo(REI.getContext(), OptLev);
1182 /// isValidDebugInfoIntrinsic - Return true if DI is a valid debug
1184 bool isValidDebugInfoIntrinsic(DbgDeclareInst &DI,
1185 CodeGenOpt::Level OptLev) {
1186 return DIDescriptor::ValidDebugInfo(DI.getVariable(), OptLev);
1189 /// ExtractDebugLocation - Extract debug location information
1190 /// from llvm.dbg.stoppoint intrinsic.
1191 DebugLoc ExtractDebugLocation(DbgStopPointInst &SPI,
1192 DebugLocTracker &DebugLocInfo) {
1194 Value *Context = SPI.getContext();
1196 // If this location is already tracked then use it.
1197 DebugLocTuple Tuple(cast<MDNode>(Context), SPI.getLine(),
1199 DenseMap<DebugLocTuple, unsigned>::iterator II
1200 = DebugLocInfo.DebugIdMap.find(Tuple);
1201 if (II != DebugLocInfo.DebugIdMap.end())
1202 return DebugLoc::get(II->second);
1204 // Add a new location entry.
1205 unsigned Id = DebugLocInfo.DebugLocations.size();
1206 DebugLocInfo.DebugLocations.push_back(Tuple);
1207 DebugLocInfo.DebugIdMap[Tuple] = Id;
1209 return DebugLoc::get(Id);
1212 /// ExtractDebugLocation - Extract debug location information
1213 /// from llvm.dbg.func_start intrinsic.
1214 DebugLoc ExtractDebugLocation(DbgFuncStartInst &FSI,
1215 DebugLocTracker &DebugLocInfo) {
1217 Value *SP = FSI.getSubprogram();
1219 DISubprogram Subprogram(cast<MDNode>(SP));
1220 unsigned Line = Subprogram.getLineNumber();
1221 DICompileUnit CU(Subprogram.getCompileUnit());
1223 // If this location is already tracked then use it.
1224 DebugLocTuple Tuple(CU.getNode(), Line, /* Column */ 0);
1225 DenseMap<DebugLocTuple, unsigned>::iterator II
1226 = DebugLocInfo.DebugIdMap.find(Tuple);
1227 if (II != DebugLocInfo.DebugIdMap.end())
1228 return DebugLoc::get(II->second);
1230 // Add a new location entry.
1231 unsigned Id = DebugLocInfo.DebugLocations.size();
1232 DebugLocInfo.DebugLocations.push_back(Tuple);
1233 DebugLocInfo.DebugIdMap[Tuple] = Id;
1235 return DebugLoc::get(Id);
1238 /// isInlinedFnStart - Return true if FSI is starting an inlined function.
1239 bool isInlinedFnStart(DbgFuncStartInst &FSI, const Function *CurrentFn) {
1240 DISubprogram Subprogram(cast<MDNode>(FSI.getSubprogram()));
1241 if (Subprogram.describes(CurrentFn))
1247 /// isInlinedFnEnd - Return true if REI is ending an inlined function.
1248 bool isInlinedFnEnd(DbgRegionEndInst &REI, const Function *CurrentFn) {
1249 DISubprogram Subprogram(cast<MDNode>(REI.getContext()));
1250 if (Subprogram.isNull() || Subprogram.describes(CurrentFn))