LCOV - code coverage report
Current view: top level - lib/IR - DIBuilder.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 319 365 87.4 %
Date: 2018-09-23 13:06:45 Functions: 75 86 87.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements the DIBuilder.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/IR/DIBuilder.h"
      15             : #include "llvm/IR/IRBuilder.h"
      16             : #include "LLVMContextImpl.h"
      17             : #include "llvm/ADT/Optional.h"
      18             : #include "llvm/ADT/STLExtras.h"
      19             : #include "llvm/BinaryFormat/Dwarf.h"
      20             : #include "llvm/IR/Constants.h"
      21             : #include "llvm/IR/DebugInfo.h"
      22             : #include "llvm/IR/IntrinsicInst.h"
      23             : #include "llvm/IR/Module.h"
      24             : #include "llvm/Support/Debug.h"
      25             : 
      26             : using namespace llvm;
      27             : using namespace llvm::dwarf;
      28             : 
      29             : cl::opt<bool>
      30             :     UseDbgAddr("use-dbg-addr",
      31             :                llvm::cl::desc("Use llvm.dbg.addr for all local variables"),
      32             :                cl::init(false), cl::Hidden);
      33             : 
      34     2090278 : DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes, DICompileUnit *CU)
      35     2090278 :   : M(m), VMContext(M.getContext()), CUNode(CU),
      36             :       DeclareFn(nullptr), ValueFn(nullptr), LabelFn(nullptr),
      37     2090278 :       AllowUnresolvedNodes(AllowUnresolvedNodes) {}
      38             : 
      39      626214 : void DIBuilder::trackIfUnresolved(MDNode *N) {
      40      626214 :   if (!N)
      41             :     return;
      42             :   if (N->isResolved())
      43             :     return;
      44             : 
      45             :   assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
      46       86744 :   UnresolvedNodes.emplace_back(N);
      47             : }
      48             : 
      49      139211 : void DIBuilder::finalizeSubprogram(DISubprogram *SP) {
      50             :   MDTuple *Temp = SP->getRetainedNodes().get();
      51      139211 :   if (!Temp || !Temp->isTemporary())
      52       69575 :     return;
      53             : 
      54             :   SmallVector<Metadata *, 16> RetainedNodes;
      55             : 
      56       69636 :   auto PV = PreservedVariables.find(SP);
      57       69636 :   if (PV != PreservedVariables.end())
      58       12303 :     RetainedNodes.append(PV->second.begin(), PV->second.end());
      59             : 
      60       69636 :   auto PL = PreservedLabels.find(SP);
      61       69636 :   if (PL != PreservedLabels.end())
      62           0 :     RetainedNodes.append(PL->second.begin(), PL->second.end());
      63             : 
      64       69636 :   DINodeArray Node = getOrCreateArray(RetainedNodes);
      65             : 
      66       69636 :   TempMDTuple(Temp)->replaceAllUsesWith(Node.get());
      67             : }
      68             : 
      69        3104 : void DIBuilder::finalize() {
      70        3104 :   if (!CUNode) {
      71             :     assert(!AllowUnresolvedNodes &&
      72             :            "creating type nodes without a CU is not supported");
      73           0 :     return;
      74             :   }
      75             : 
      76        3104 :   CUNode->replaceEnumTypes(MDTuple::get(VMContext, AllEnumTypes));
      77             : 
      78             :   SmallVector<Metadata *, 16> RetainValues;
      79             :   // Declarations and definitions of the same type may be retained. Some
      80             :   // clients RAUW these pairs, leaving duplicates in the retained types
      81             :   // list. Use a set to remove the duplicates while we transform the
      82             :   // TrackingVHs back into Values.
      83             :   SmallPtrSet<Metadata *, 16> RetainSet;
      84       13790 :   for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
      85       21372 :     if (RetainSet.insert(AllRetainTypes[I]).second)
      86        5092 :       RetainValues.push_back(AllRetainTypes[I]);
      87             : 
      88        3104 :   if (!RetainValues.empty())
      89        1022 :     CUNode->replaceRetainedTypes(MDTuple::get(VMContext, RetainValues));
      90             : 
      91        3104 :   DISubprogramArray SPs = MDTuple::get(VMContext, AllSubprograms);
      92       72705 :   for (auto *SP : SPs)
      93       69601 :     finalizeSubprogram(SP);
      94        8196 :   for (auto *N : RetainValues)
      95             :     if (auto *SP = dyn_cast<DISubprogram>(N))
      96          31 :       finalizeSubprogram(SP);
      97             : 
      98        3104 :   if (!AllGVs.empty())
      99        1626 :     CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));
     100             : 
     101        3104 :   if (!AllImportedModules.empty())
     102         660 :     CUNode->replaceImportedEntities(MDTuple::get(
     103         660 :         VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(),
     104             :                                                AllImportedModules.end())));
     105             : 
     106        3132 :   for (const auto &I : AllMacrosPerParent) {
     107             :     // DIMacroNode's with nullptr parent are DICompileUnit direct children.
     108          28 :     if (!I.first) {
     109          12 :       CUNode->replaceMacros(MDTuple::get(VMContext, I.second.getArrayRef()));
     110           6 :       continue;
     111             :     }
     112             :     // Otherwise, it must be a temporary DIMacroFile that need to be resolved.
     113             :     auto *TMF = cast<DIMacroFile>(I.first);
     114          44 :     auto *MF = DIMacroFile::get(VMContext, dwarf::DW_MACINFO_start_file,
     115             :                                 TMF->getLine(), TMF->getFile(),
     116             :                                 getOrCreateMacroArray(I.second.getArrayRef()));
     117          44 :     replaceTemporary(llvm::TempDIMacroNode(TMF), MF);
     118             :   }
     119             : 
     120             :   // Now that all temp nodes have been replaced or deleted, resolve remaining
     121             :   // cycles.
     122       89848 :   for (const auto &N : UnresolvedNodes)
     123       86744 :     if (N && !N->isResolved())
     124           0 :       N->resolveCycles();
     125        3104 :   UnresolvedNodes.clear();
     126             : 
     127             :   // Can't handle unresolved nodes anymore.
     128        3104 :   AllowUnresolvedNodes = false;
     129             : }
     130             : 
     131             : /// If N is compile unit return NULL otherwise return N.
     132             : static DIScope *getNonCompileUnitScope(DIScope *N) {
     133      459727 :   if (!N || isa<DICompileUnit>(N))
     134             :     return nullptr;
     135             :   return cast<DIScope>(N);
     136             : }
     137             : 
     138        3101 : DICompileUnit *DIBuilder::createCompileUnit(
     139             :     unsigned Lang, DIFile *File, StringRef Producer, bool isOptimized,
     140             :     StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
     141             :     DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
     142             :     bool SplitDebugInlining, bool DebugInfoForProfiling,
     143             :     DICompileUnit::DebugNameTableKind NameTableKind) {
     144             : 
     145             :   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
     146             :           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
     147             :          "Invalid Language tag");
     148             : 
     149             :   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
     150        3101 :   CUNode = DICompileUnit::getDistinct(
     151             :       VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
     152             :       SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId,
     153             :       SplitDebugInlining, DebugInfoForProfiling, NameTableKind);
     154             : 
     155             :   // Create a named metadata so that it is easier to find cu in a module.
     156        6202 :   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
     157        3101 :   NMD->addOperand(CUNode);
     158        3101 :   trackIfUnresolved(CUNode);
     159        3101 :   return CUNode;
     160             : }
     161             : 
     162             : static DIImportedEntity *
     163      104580 : createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context,
     164             :                      Metadata *NS, DIFile *File, unsigned Line, StringRef Name,
     165             :                      SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
     166             :   if (Line)
     167             :     assert(File && "Source location has line number but no file");
     168      104580 :   unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size();
     169             :   auto *M =
     170      104580 :       DIImportedEntity::get(C, Tag, Context, DINodeRef(NS), File, Line, Name);
     171      209160 :   if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
     172             :     // A new Imported Entity was just added to the context.
     173             :     // Add it to the Imported Modules list.
     174      104577 :     AllImportedModules.emplace_back(M);
     175      104580 :   return M;
     176             : }
     177             : 
     178         564 : DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
     179             :                                                   DINamespace *NS, DIFile *File,
     180             :                                                   unsigned Line) {
     181        1692 :   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
     182             :                                 Context, NS, File, Line, StringRef(),
     183         564 :                                 AllImportedModules);
     184             : }
     185             : 
     186           3 : DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
     187             :                                                   DIImportedEntity *NS,
     188             :                                                   DIFile *File, unsigned Line) {
     189           9 :   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
     190             :                                 Context, NS, File, Line, StringRef(),
     191           3 :                                 AllImportedModules);
     192             : }
     193             : 
     194           1 : DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M,
     195             :                                                   DIFile *File, unsigned Line) {
     196           3 :   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
     197             :                                 Context, M, File, Line, StringRef(),
     198           1 :                                 AllImportedModules);
     199             : }
     200             : 
     201      104012 : DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context,
     202             :                                                        DINode *Decl,
     203             :                                                        DIFile *File,
     204             :                                                        unsigned Line,
     205             :                                                        StringRef Name) {
     206             :   // Make sure to use the unique identifier based metadata reference for
     207             :   // types that have one.
     208      104012 :   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
     209             :                                 Context, Decl, File, Line, Name,
     210      104012 :                                 AllImportedModules);
     211             : }
     212             : 
     213       59264 : DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory,
     214             :                               Optional<DIFile::ChecksumInfo<StringRef>> CS,
     215             :                               Optional<StringRef> Source) {
     216       59264 :   return DIFile::get(VMContext, Filename, Directory, CS, Source);
     217             : }
     218             : 
     219        1424 : DIMacro *DIBuilder::createMacro(DIMacroFile *Parent, unsigned LineNumber,
     220             :                                 unsigned MacroType, StringRef Name,
     221             :                                 StringRef Value) {
     222             :   assert(!Name.empty() && "Unable to create macro without name");
     223             :   assert((MacroType == dwarf::DW_MACINFO_undef ||
     224             :           MacroType == dwarf::DW_MACINFO_define) &&
     225             :          "Unexpected macro type");
     226        1424 :   auto *M = DIMacro::get(VMContext, MacroType, LineNumber, Name, Value);
     227        1424 :   AllMacrosPerParent[Parent].insert(M);
     228        1424 :   return M;
     229             : }
     230             : 
     231          22 : DIMacroFile *DIBuilder::createTempMacroFile(DIMacroFile *Parent,
     232             :                                             unsigned LineNumber, DIFile *File) {
     233          22 :   auto *MF = DIMacroFile::getTemporary(VMContext, dwarf::DW_MACINFO_start_file,
     234             :                                        LineNumber, File, DIMacroNodeArray())
     235             :                  .release();
     236          22 :   AllMacrosPerParent[Parent].insert(MF);
     237             :   // Add the new temporary DIMacroFile to the macro per parent map as a parent.
     238             :   // This is needed to assure DIMacroFile with no children to have an entry in
     239             :   // the map. Otherwise, it will not be resolved in DIBuilder::finalize().
     240          66 :   AllMacrosPerParent.insert({MF, {}});
     241          22 :   return MF;
     242             : }
     243             : 
     244       12669 : DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val,
     245             :                                           bool IsUnsigned) {
     246             :   assert(!Name.empty() && "Unable to create enumerator without name");
     247       12669 :   return DIEnumerator::get(VMContext, Val, IsUnsigned, Name);
     248             : }
     249             : 
     250         391 : DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
     251             :   assert(!Name.empty() && "Unable to create type without name");
     252         391 :   return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
     253             : }
     254             : 
     255         391 : DIBasicType *DIBuilder::createNullPtrType() {
     256         391 :   return createUnspecifiedType("decltype(nullptr)");
     257             : }
     258             : 
     259       11278 : DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
     260             :                                         unsigned Encoding,
     261             :                                         DINode::DIFlags Flags) {
     262             :   assert(!Name.empty() && "Unable to create type without name");
     263       11278 :   return DIBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
     264       11278 :                           0, Encoding, Flags);
     265             : }
     266             : 
     267       34384 : DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) {
     268       34384 :   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0,
     269       34384 :                             0, 0, None, DINode::FlagZero);
     270             : }
     271             : 
     272      178021 : DIDerivedType *DIBuilder::createPointerType(
     273             :     DIType *PointeeTy,
     274             :     uint64_t SizeInBits,
     275             :     uint32_t AlignInBits,
     276             :     Optional<unsigned> DWARFAddressSpace,
     277             :     StringRef Name) {
     278             :   // FIXME: Why is there a name here?
     279      178021 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
     280             :                             nullptr, 0, nullptr, PointeeTy, SizeInBits,
     281             :                             AlignInBits, 0, DWARFAddressSpace,
     282      178021 :                             DINode::FlagZero);
     283             : }
     284             : 
     285          55 : DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy,
     286             :                                                   DIType *Base,
     287             :                                                   uint64_t SizeInBits,
     288             :                                                   uint32_t AlignInBits,
     289             :                                                   DINode::DIFlags Flags) {
     290          55 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
     291             :                             nullptr, 0, nullptr, PointeeTy, SizeInBits,
     292          55 :                             AlignInBits, 0, None, Flags, Base);
     293             : }
     294             : 
     295       65225 : DIDerivedType *DIBuilder::createReferenceType(
     296             :     unsigned Tag, DIType *RTy,
     297             :     uint64_t SizeInBits,
     298             :     uint32_t AlignInBits,
     299             :     Optional<unsigned> DWARFAddressSpace) {
     300             :   assert(RTy && "Unable to create reference type");
     301       65225 :   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, RTy,
     302             :                             SizeInBits, AlignInBits, 0, DWARFAddressSpace,
     303       65225 :                             DINode::FlagZero);
     304             : }
     305             : 
     306       61026 : DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name,
     307             :                                         DIFile *File, unsigned LineNo,
     308             :                                         DIScope *Context) {
     309       61026 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_typedef, Name, File,
     310             :                             LineNo, getNonCompileUnitScope(Context), Ty, 0, 0,
     311       61026 :                             0, None, DINode::FlagZero);
     312             : }
     313             : 
     314           0 : DIDerivedType *DIBuilder::createFriend(DIType *Ty, DIType *FriendTy) {
     315             :   assert(Ty && "Invalid type!");
     316             :   assert(FriendTy && "Invalid friend type!");
     317           0 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0, Ty,
     318           0 :                             FriendTy, 0, 0, 0, None, DINode::FlagZero);
     319             : }
     320             : 
     321        7713 : DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy,
     322             :                                             uint64_t BaseOffset,
     323             :                                             uint32_t VBPtrOffset,
     324             :                                             DINode::DIFlags Flags) {
     325             :   assert(Ty && "Unable to create inheritance");
     326             :   Metadata *ExtraData = ConstantAsMetadata::get(
     327        7713 :       ConstantInt::get(IntegerType::get(VMContext, 32), VBPtrOffset));
     328        7713 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
     329             :                             0, Ty, BaseTy, 0, 0, BaseOffset, None,
     330        7713 :                             Flags, ExtraData);
     331             : }
     332             : 
     333       54528 : DIDerivedType *DIBuilder::createMemberType(DIScope *Scope, StringRef Name,
     334             :                                            DIFile *File, unsigned LineNumber,
     335             :                                            uint64_t SizeInBits,
     336             :                                            uint32_t AlignInBits,
     337             :                                            uint64_t OffsetInBits,
     338             :                                            DINode::DIFlags Flags, DIType *Ty) {
     339       54528 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
     340             :                             LineNumber, getNonCompileUnitScope(Scope), Ty,
     341       54528 :                             SizeInBits, AlignInBits, OffsetInBits, None, Flags);
     342             : }
     343             : 
     344             : static ConstantAsMetadata *getConstantOrNull(Constant *C) {
     345        6141 :   if (C)
     346             :     return ConstantAsMetadata::get(C);
     347             :   return nullptr;
     348             : }
     349             : 
     350           0 : DIDerivedType *DIBuilder::createVariantMemberType(
     351             :     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     352             :     uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
     353             :     Constant *Discriminant, DINode::DIFlags Flags, DIType *Ty) {
     354           0 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
     355             :                             LineNumber, getNonCompileUnitScope(Scope), Ty,
     356             :                             SizeInBits, AlignInBits, OffsetInBits, None, Flags,
     357           0 :                             getConstantOrNull(Discriminant));
     358             : }
     359             : 
     360         134 : DIDerivedType *DIBuilder::createBitFieldMemberType(
     361             :     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     362             :     uint64_t SizeInBits, uint64_t OffsetInBits, uint64_t StorageOffsetInBits,
     363             :     DINode::DIFlags Flags, DIType *Ty) {
     364             :   Flags |= DINode::FlagBitField;
     365         134 :   return DIDerivedType::get(
     366             :       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
     367             :       getNonCompileUnitScope(Scope), Ty, SizeInBits, /* AlignInBits */ 0,
     368             :       OffsetInBits, None, Flags,
     369         134 :       ConstantAsMetadata::get(ConstantInt::get(IntegerType::get(VMContext, 64),
     370         134 :                                                StorageOffsetInBits)));
     371             : }
     372             : 
     373             : DIDerivedType *
     374        6141 : DIBuilder::createStaticMemberType(DIScope *Scope, StringRef Name, DIFile *File,
     375             :                                   unsigned LineNumber, DIType *Ty,
     376             :                                   DINode::DIFlags Flags, llvm::Constant *Val,
     377             :                                   uint32_t AlignInBits) {
     378             :   Flags |= DINode::FlagStaticMember;
     379        6141 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
     380             :                             LineNumber, getNonCompileUnitScope(Scope), Ty, 0,
     381             :                             AlignInBits, 0, None, Flags,
     382        6141 :                             getConstantOrNull(Val));
     383             : }
     384             : 
     385             : DIDerivedType *
     386          89 : DIBuilder::createObjCIVar(StringRef Name, DIFile *File, unsigned LineNumber,
     387             :                           uint64_t SizeInBits, uint32_t AlignInBits,
     388             :                           uint64_t OffsetInBits, DINode::DIFlags Flags,
     389             :                           DIType *Ty, MDNode *PropertyNode) {
     390          89 :   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
     391             :                             LineNumber, getNonCompileUnitScope(File), Ty,
     392             :                             SizeInBits, AlignInBits, OffsetInBits, None, Flags,
     393          89 :                             PropertyNode);
     394             : }
     395             : 
     396             : DIObjCProperty *
     397          74 : DIBuilder::createObjCProperty(StringRef Name, DIFile *File, unsigned LineNumber,
     398             :                               StringRef GetterName, StringRef SetterName,
     399             :                               unsigned PropertyAttributes, DIType *Ty) {
     400          74 :   return DIObjCProperty::get(VMContext, Name, File, LineNumber, GetterName,
     401          74 :                              SetterName, PropertyAttributes, Ty);
     402             : }
     403             : 
     404             : DITemplateTypeParameter *
     405       60900 : DIBuilder::createTemplateTypeParameter(DIScope *Context, StringRef Name,
     406             :                                        DIType *Ty) {
     407             :   assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit");
     408       60900 :   return DITemplateTypeParameter::get(VMContext, Name, Ty);
     409             : }
     410             : 
     411             : static DITemplateValueParameter *
     412           0 : createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
     413             :                                    DIScope *Context, StringRef Name, DIType *Ty,
     414             :                                    Metadata *MD) {
     415             :   assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit");
     416       23184 :   return DITemplateValueParameter::get(VMContext, Tag, Name, Ty, MD);
     417             : }
     418             : 
     419             : DITemplateValueParameter *
     420       15459 : DIBuilder::createTemplateValueParameter(DIScope *Context, StringRef Name,
     421             :                                         DIType *Ty, Constant *Val) {
     422       15459 :   return createTemplateValueParameterHelper(
     423             :       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
     424       15459 :       getConstantOrNull(Val));
     425             : }
     426             : 
     427             : DITemplateValueParameter *
     428         156 : DIBuilder::createTemplateTemplateParameter(DIScope *Context, StringRef Name,
     429             :                                            DIType *Ty, StringRef Val) {
     430         156 :   return createTemplateValueParameterHelper(
     431             :       VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
     432         156 :       MDString::get(VMContext, Val));
     433             : }
     434             : 
     435             : DITemplateValueParameter *
     436        7569 : DIBuilder::createTemplateParameterPack(DIScope *Context, StringRef Name,
     437             :                                        DIType *Ty, DINodeArray Val) {
     438        7569 :   return createTemplateValueParameterHelper(
     439             :       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
     440        7569 :       Val.get());
     441             : }
     442             : 
     443           0 : DICompositeType *DIBuilder::createClassType(
     444             :     DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
     445             :     uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
     446             :     DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
     447             :     DIType *VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) {
     448             :   assert((!Context || isa<DIScope>(Context)) &&
     449             :          "createClassType should be called with a valid Context");
     450             : 
     451           0 :   auto *R = DICompositeType::get(
     452             :       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
     453             :       getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits,
     454             :       OffsetInBits, Flags, Elements, 0, VTableHolder,
     455             :       cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
     456           0 :   trackIfUnresolved(R);
     457           0 :   return R;
     458             : }
     459             : 
     460         238 : DICompositeType *DIBuilder::createStructType(
     461             :     DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
     462             :     uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
     463             :     DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,
     464             :     DIType *VTableHolder, StringRef UniqueIdentifier) {
     465         238 :   auto *R = DICompositeType::get(
     466             :       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
     467             :       getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits, 0,
     468             :       Flags, Elements, RunTimeLang, VTableHolder, nullptr, UniqueIdentifier);
     469         238 :   trackIfUnresolved(R);
     470         238 :   return R;
     471             : }
     472             : 
     473           0 : DICompositeType *DIBuilder::createUnionType(
     474             :     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     475             :     uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
     476             :     DINodeArray Elements, unsigned RunTimeLang, StringRef UniqueIdentifier) {
     477           0 :   auto *R = DICompositeType::get(
     478             :       VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
     479             :       getNonCompileUnitScope(Scope), nullptr, SizeInBits, AlignInBits, 0, Flags,
     480             :       Elements, RunTimeLang, nullptr, nullptr, UniqueIdentifier);
     481           0 :   trackIfUnresolved(R);
     482           0 :   return R;
     483             : }
     484             : 
     485           0 : DICompositeType *DIBuilder::createVariantPart(
     486             :     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     487             :     uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
     488             :     DIDerivedType *Discriminator, DINodeArray Elements, StringRef UniqueIdentifier) {
     489           0 :   auto *R = DICompositeType::get(
     490             :       VMContext, dwarf::DW_TAG_variant_part, Name, File, LineNumber,
     491             :       getNonCompileUnitScope(Scope), nullptr, SizeInBits, AlignInBits, 0, Flags,
     492             :       Elements, 0, nullptr, nullptr, UniqueIdentifier, Discriminator);
     493           0 :   trackIfUnresolved(R);
     494           0 :   return R;
     495             : }
     496             : 
     497      412629 : DISubroutineType *DIBuilder::createSubroutineType(DITypeRefArray ParameterTypes,
     498             :                                                   DINode::DIFlags Flags,
     499             :                                                   unsigned CC) {
     500      412629 :   return DISubroutineType::get(VMContext, Flags, CC, ParameterTypes);
     501             : }
     502             : 
     503        1504 : DICompositeType *DIBuilder::createEnumerationType(
     504             :     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     505             :     uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements,
     506             :     DIType *UnderlyingType, StringRef UniqueIdentifier, bool IsFixed) {
     507        3008 :   auto *CTy = DICompositeType::get(
     508             :       VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
     509             :       getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0,
     510             :       IsFixed ? DINode::FlagFixedEnum : DINode::FlagZero, Elements, 0, nullptr,
     511             :       nullptr, UniqueIdentifier);
     512        1504 :   AllEnumTypes.push_back(CTy);
     513        1504 :   trackIfUnresolved(CTy);
     514        1504 :   return CTy;
     515             : }
     516             : 
     517        3667 : DICompositeType *DIBuilder::createArrayType(uint64_t Size,
     518             :                                             uint32_t AlignInBits, DIType *Ty,
     519             :                                             DINodeArray Subscripts) {
     520        3667 :   auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
     521             :                                  nullptr, 0, nullptr, Ty, Size, AlignInBits, 0,
     522             :                                  DINode::FlagZero, Subscripts, 0, nullptr);
     523        3667 :   trackIfUnresolved(R);
     524        3667 :   return R;
     525             : }
     526             : 
     527          46 : DICompositeType *DIBuilder::createVectorType(uint64_t Size,
     528             :                                              uint32_t AlignInBits, DIType *Ty,
     529             :                                              DINodeArray Subscripts) {
     530          46 :   auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
     531             :                                  nullptr, 0, nullptr, Ty, Size, AlignInBits, 0,
     532             :                                  DINode::FlagVector, Subscripts, 0, nullptr);
     533          46 :   trackIfUnresolved(R);
     534          46 :   return R;
     535             : }
     536             : 
     537           1 : DISubprogram *DIBuilder::createArtificialSubprogram(DISubprogram *SP) {
     538           1 :   auto NewSP = SP->cloneWithFlags(SP->getFlags() | DINode::FlagArtificial);
     539           1 :   return MDNode::replaceWithDistinct(std::move(NewSP));
     540             : }
     541             : 
     542      193889 : static DIType *createTypeWithFlags(const DIType *Ty,
     543             :                                    DINode::DIFlags FlagsToSet) {
     544      193889 :   auto NewTy = Ty->cloneWithFlags(Ty->getFlags() | FlagsToSet);
     545      193889 :   return MDNode::replaceWithUniqued(std::move(NewTy));
     546             : }
     547             : 
     548         136 : DIType *DIBuilder::createArtificialType(DIType *Ty) {
     549             :   // FIXME: Restrict this to the nodes where it's valid.
     550         136 :   if (Ty->isArtificial())
     551             :     return Ty;
     552         136 :   return createTypeWithFlags(Ty, DINode::FlagArtificial);
     553             : }
     554             : 
     555      193753 : DIType *DIBuilder::createObjectPointerType(DIType *Ty) {
     556             :   // FIXME: Restrict this to the nodes where it's valid.
     557      193753 :   if (Ty->isObjectPointer())
     558             :     return Ty;
     559             :   DINode::DIFlags Flags = DINode::FlagObjectPointer | DINode::FlagArtificial;
     560      193753 :   return createTypeWithFlags(Ty, Flags);
     561             : }
     562             : 
     563       10686 : void DIBuilder::retainType(DIScope *T) {
     564             :   assert(T && "Expected non-null type");
     565             :   assert((isa<DIType>(T) || (isa<DISubprogram>(T) &&
     566             :                              cast<DISubprogram>(T)->isDefinition() == false)) &&
     567             :          "Expected type or subprogram declaration");
     568       10686 :   AllRetainTypes.emplace_back(T);
     569       10686 : }
     570             : 
     571        6032 : DIBasicType *DIBuilder::createUnspecifiedParameter() { return nullptr; }
     572             : 
     573             : DICompositeType *
     574          74 : DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIScope *Scope,
     575             :                              DIFile *F, unsigned Line, unsigned RuntimeLang,
     576             :                              uint64_t SizeInBits, uint32_t AlignInBits,
     577             :                              StringRef UniqueIdentifier) {
     578             :   // FIXME: Define in terms of createReplaceableForwardDecl() by calling
     579             :   // replaceWithUniqued().
     580          74 :   auto *RetTy = DICompositeType::get(
     581             :       VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr,
     582             :       SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl, nullptr, RuntimeLang,
     583             :       nullptr, nullptr, UniqueIdentifier);
     584          74 :   trackIfUnresolved(RetTy);
     585          74 :   return RetTy;
     586             : }
     587             : 
     588       40786 : DICompositeType *DIBuilder::createReplaceableCompositeType(
     589             :     unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line,
     590             :     unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
     591             :     DINode::DIFlags Flags, StringRef UniqueIdentifier) {
     592             :   auto *RetTy =
     593       40786 :       DICompositeType::getTemporary(
     594             :           VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr,
     595             :           SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
     596             :           nullptr, UniqueIdentifier)
     597             :           .release();
     598       40786 :   trackIfUnresolved(RetTy);
     599       40786 :   return RetTy;
     600             : }
     601             : 
     602      157629 : DINodeArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
     603      157629 :   return MDTuple::get(VMContext, Elements);
     604             : }
     605             : 
     606             : DIMacroNodeArray
     607          24 : DIBuilder::getOrCreateMacroArray(ArrayRef<Metadata *> Elements) {
     608          24 :   return MDTuple::get(VMContext, Elements);
     609             : }
     610             : 
     611      412629 : DITypeRefArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
     612             :   SmallVector<llvm::Metadata *, 16> Elts;
     613     1440077 :   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
     614     2054896 :     if (Elements[i] && isa<MDNode>(Elements[i]))
     615      874526 :       Elts.push_back(cast<DIType>(Elements[i]));
     616             :     else
     617      152922 :       Elts.push_back(Elements[i]);
     618             :   }
     619      412629 :   return DITypeRefArray(MDNode::get(VMContext, Elts));
     620             : }
     621             : 
     622        3724 : DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
     623        3724 :   return DISubrange::get(VMContext, Count, Lo);
     624             : }
     625             : 
     626          32 : DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, Metadata *CountNode) {
     627          32 :   return DISubrange::get(VMContext, CountNode, Lo);
     628             : }
     629             : 
     630           0 : static void checkGlobalVariableScope(DIScope *Context) {
     631             : #ifndef NDEBUG
     632             :   if (auto *CT =
     633             :           dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context)))
     634             :     assert(CT->getIdentifier().empty() &&
     635             :            "Context of a global variable should not be a type with identifier");
     636             : #endif
     637           0 : }
     638             : 
     639        3866 : DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
     640             :     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     641             :     unsigned LineNumber, DIType *Ty, bool isLocalToUnit, DIExpression *Expr,
     642             :     MDNode *Decl, uint32_t AlignInBits) {
     643             :   checkGlobalVariableScope(Context);
     644             : 
     645        3866 :   auto *GV = DIGlobalVariable::getDistinct(
     646             :       VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
     647             :       LineNumber, Ty, isLocalToUnit, true, cast_or_null<DIDerivedType>(Decl),
     648             :       AlignInBits);
     649        3866 :   if (!Expr)
     650        3801 :     Expr = createExpression();
     651        3866 :   auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr);
     652        3866 :   AllGVs.push_back(N);
     653        3866 :   return N;
     654             : }
     655             : 
     656         216 : DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
     657             :     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     658             :     unsigned LineNumber, DIType *Ty, bool isLocalToUnit, MDNode *Decl,
     659             :     uint32_t AlignInBits) {
     660             :   checkGlobalVariableScope(Context);
     661             : 
     662         216 :   return DIGlobalVariable::getTemporary(
     663             :              VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
     664             :              LineNumber, Ty, isLocalToUnit, false,
     665             :              cast_or_null<DIDerivedType>(Decl), AlignInBits)
     666         216 :       .release();
     667             : }
     668             : 
     669       88482 : static DILocalVariable *createLocalVariable(
     670             :     LLVMContext &VMContext,
     671             :     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,
     672             :     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
     673             :     unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags,
     674             :     uint32_t AlignInBits) {
     675             :   // FIXME: Why getNonCompileUnitScope()?
     676             :   // FIXME: Why is "!Context" okay here?
     677             :   // FIXME: Why doesn't this check for a subprogram or lexical block (AFAICT
     678             :   // the only valid scopes)?
     679             :   DIScope *Context = getNonCompileUnitScope(Scope);
     680             : 
     681             :   auto *Node =
     682       88482 :       DILocalVariable::get(VMContext, cast_or_null<DILocalScope>(Context), Name,
     683       88482 :                            File, LineNo, Ty, ArgNo, Flags, AlignInBits);
     684       88482 :   if (AlwaysPreserve) {
     685             :     // The optimizer may remove local variables. If there is an interest
     686             :     // to preserve variable info in such situation then stash it in a
     687             :     // named mdnode.
     688       30881 :     DISubprogram *Fn = getDISubprogram(Scope);
     689             :     assert(Fn && "Missing subprogram for local variable");
     690       30881 :     PreservedVariables[Fn].emplace_back(Node);
     691             :   }
     692       88482 :   return Node;
     693             : }
     694             : 
     695       19115 : DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope, StringRef Name,
     696             :                                                DIFile *File, unsigned LineNo,
     697             :                                                DIType *Ty, bool AlwaysPreserve,
     698             :                                                DINode::DIFlags Flags,
     699             :                                                uint32_t AlignInBits) {
     700       19115 :   return createLocalVariable(VMContext, PreservedVariables, Scope, Name,
     701             :                              /* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve,
     702       19115 :                              Flags, AlignInBits);
     703             : }
     704             : 
     705       69367 : DILocalVariable *DIBuilder::createParameterVariable(
     706             :     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
     707             :     unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags) {
     708             :   assert(ArgNo && "Expected non-zero argument number for parameter");
     709       69367 :   return createLocalVariable(VMContext, PreservedVariables, Scope, Name, ArgNo,
     710             :                              File, LineNo, Ty, AlwaysPreserve, Flags,
     711       69367 :                              /* AlignInBits */0);
     712             : }
     713             : 
     714           0 : DILabel *DIBuilder::createLabel(
     715             :     DIScope *Scope, StringRef Name, DIFile *File,
     716             :     unsigned LineNo, bool AlwaysPreserve) {
     717             :   DIScope *Context = getNonCompileUnitScope(Scope);
     718             : 
     719             :   auto *Node =
     720           0 :       DILabel::get(VMContext, cast_or_null<DILocalScope>(Context), Name,
     721           0 :                    File, LineNo);
     722             : 
     723           0 :   if (AlwaysPreserve) {
     724             :     /// The optimizer may remove labels. If there is an interest
     725             :     /// to preserve label info in such situation then append it to
     726             :     /// the list of retained nodes of the DISubprogram.
     727           0 :     DISubprogram *Fn = getDISubprogram(Scope);
     728             :     assert(Fn && "Missing subprogram for label");
     729           0 :     PreservedLabels[Fn].emplace_back(Node);
     730             :   }
     731           0 :   return Node;
     732             : }
     733             : 
     734       92306 : DIExpression *DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
     735       92306 :   return DIExpression::get(VMContext, Addr);
     736             : }
     737             : 
     738       86975 : DIExpression *DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
     739             :   // TODO: Remove the callers of this signed version and delete.
     740       86975 :   SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
     741       86975 :   return createExpression(Addr);
     742             : }
     743             : 
     744             : template <class... Ts>
     745      259302 : static DISubprogram *getSubprogram(bool IsDistinct, Ts &&... Args) {
     746      259302 :   if (IsDistinct)
     747       69601 :     return DISubprogram::getDistinct(std::forward<Ts>(Args)...);
     748      189701 :   return DISubprogram::get(std::forward<Ts>(Args)...);
     749             : }
     750      189666 : 
     751      189666 : DISubprogram *DIBuilder::createFunction(
     752           0 :     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
     753      189666 :     unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
     754             :     bool isDefinition, unsigned ScopeLine, DINode::DIFlags Flags,
     755       69636 :     bool isOptimized, DITemplateParameterArray TParams, DISubprogram *Decl,
     756       69636 :     DITypeArray ThrownTypes) {
     757       69601 :   auto *Node = getSubprogram(
     758          35 :       /* IsDistinct = */ isDefinition, VMContext,
     759             :       getNonCompileUnitScope(Context), Name, LinkageName, File, LineNo, Ty,
     760             :       isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, 0, Flags,
     761       69636 :       isOptimized, isDefinition ? CUNode : nullptr, TParams, Decl,
     762             :       MDTuple::getTemporary(VMContext, None).release(), ThrownTypes);
     763             : 
     764             :   if (isDefinition)
     765             :     AllSubprograms.push_back(Node);
     766             :   trackIfUnresolved(Node);
     767       69636 :   return Node;
     768             : }
     769       69636 : 
     770      139272 : DISubprogram *DIBuilder::createTempFunctionFwdDecl(
     771       69636 :     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
     772       69636 :     unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
     773             :     bool isDefinition, unsigned ScopeLine, DINode::DIFlags Flags,
     774       69636 :     bool isOptimized, DITemplateParameterArray TParams, DISubprogram *Decl,
     775       69601 :     DITypeArray ThrownTypes) {
     776       69636 :   return DISubprogram::getTemporary(
     777       69636 :              VMContext, getNonCompileUnitScope(Context), Name, LinkageName,
     778             :              File, LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine, nullptr,
     779             :              0, 0, 0, Flags, isOptimized, isDefinition ? CUNode : nullptr,
     780       86551 :              TParams, Decl, nullptr, ThrownTypes)
     781             :       .release();
     782             : }
     783             : 
     784             : DISubprogram *DIBuilder::createMethod(
     785             :     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     786      173102 :     unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
     787             :     bool isDefinition, unsigned VK, unsigned VIndex, int ThisAdjustment,
     788             :     DIType *VTableHolder, DINode::DIFlags Flags, bool isOptimized,
     789             :     DITemplateParameterArray TParams, DITypeArray ThrownTypes) {
     790             :   assert(getNonCompileUnitScope(Context) &&
     791       86551 :          "Methods should have both a Context and a context that isn't "
     792             :          "the compile unit.");
     793             :   // FIXME: Do we want to use different scope/lines?
     794      189666 :   auto *SP = getSubprogram(
     795             :       /* IsDistinct = */ isDefinition, VMContext, cast<DIScope>(Context), Name,
     796             :       LinkageName, F, LineNo, Ty, isLocalToUnit, isDefinition, LineNo,
     797             :       VTableHolder, VK, VIndex, ThisAdjustment, Flags, isOptimized,
     798             :       isDefinition ? CUNode : nullptr, TParams, nullptr, nullptr, ThrownTypes);
     799             : 
     800             :   if (isDefinition)
     801             :     AllSubprograms.push_back(SP);
     802             :   trackIfUnresolved(SP);
     803             :   return SP;
     804      189666 : }
     805      379332 : 
     806             : DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name,
     807             :                                         bool ExportSymbols) {
     808      189666 : 
     809             :   // It is okay to *not* make anonymous top-level namespaces distinct, because
     810      189666 :   // all nodes that have an anonymous namespace as their parent scope are
     811           0 :   // guaranteed to be unique and/or are linked to their containing
     812      189666 :   // DICompileUnit. This decision is an explicit tradeoff of link time versus
     813      189666 :   // memory usage versus code simplicity and may get revisited in the future.
     814             :   return DINamespace::get(VMContext, getNonCompileUnitScope(Scope), Name,
     815             :                           ExportSymbols);
     816       18476 : }
     817             : 
     818             : DIModule *DIBuilder::createModule(DIScope *Scope, StringRef Name,
     819             :                                   StringRef ConfigurationMacros,
     820             :                                   StringRef IncludePath,
     821             :                                   StringRef ISysRoot) {
     822             :  return DIModule::get(VMContext, getNonCompileUnitScope(Scope), Name,
     823             :                       ConfigurationMacros, IncludePath, ISysRoot);
     824       36952 : }
     825       18476 : 
     826             : DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope,
     827             :                                                       DIFile *File,
     828          56 :                                                       unsigned Discriminator) {
     829             :   return DILexicalBlockFile::get(VMContext, Scope, File, Discriminator);
     830             : }
     831             : 
     832          56 : DILexicalBlock *DIBuilder::createLexicalBlock(DIScope *Scope, DIFile *File,
     833          56 :                                               unsigned Line, unsigned Col) {
     834             :   // Make these distinct, to avoid merging two lexical blocks on the same
     835             :   // file/line/column.
     836      246641 :   return DILexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope),
     837             :                                      File, Line, Col);
     838             : }
     839      246641 : 
     840             : Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
     841             :                                       DIExpression *Expr, const DILocation *DL,
     842       32052 :                                       Instruction *InsertBefore) {
     843             :   return insertDeclare(Storage, VarInfo, Expr, DL, InsertBefore->getParent(),
     844             :                        InsertBefore);
     845             : }
     846       32052 : 
     847       32052 : Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
     848             :                                       DIExpression *Expr, const DILocation *DL,
     849             :                                       BasicBlock *InsertAtEnd) {
     850        2170 :   // If this block already has a terminator then insert this intrinsic before
     851             :   // the terminator. Otherwise, put it at the end of the block.
     852             :   Instruction *InsertBefore = InsertAtEnd->getTerminator();
     853        2170 :   return insertDeclare(Storage, VarInfo, Expr, DL, InsertAtEnd, InsertBefore);
     854        2170 : }
     855             : 
     856             : Instruction *DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL,
     857       86967 :                                     Instruction *InsertBefore) {
     858             :   return insertLabel(
     859             :       LabelInfo, DL, InsertBefore ? InsertBefore->getParent() : nullptr,
     860             :       InsertBefore);
     861             : }
     862             : 
     863       86967 : Instruction *DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL,
     864             :                                     BasicBlock *InsertAtEnd) {
     865             :   return insertLabel(LabelInfo, DL, InsertAtEnd, nullptr);
     866           0 : }
     867             : 
     868           0 : Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V,
     869           0 :                                                 DILocalVariable *VarInfo,
     870           0 :                                                 DIExpression *Expr,
     871             :                                                 const DILocation *DL,
     872             :                                                 Instruction *InsertBefore) {
     873           0 :   return insertDbgValueIntrinsic(
     874             :       V, VarInfo, Expr, DL, InsertBefore ? InsertBefore->getParent() : nullptr,
     875           0 :       InsertBefore);
     876             : }
     877             : 
     878       40683 : Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V,
     879             :                                                 DILocalVariable *VarInfo,
     880             :                                                 DIExpression *Expr,
     881             :                                                 const DILocation *DL,
     882             :                                                 BasicBlock *InsertAtEnd) {
     883       80432 :   return insertDbgValueIntrinsic(V, VarInfo, Expr, DL, InsertAtEnd, nullptr);
     884       39749 : }
     885       40683 : 
     886             : /// Return an IRBuilder for inserting dbg.declare and dbg.value intrinsics. This
     887             : /// abstracts over the various ways to specify an insert position.
     888           5 : static IRBuilder<> getIRBForDbgInsertion(const DILocation *DL,
     889             :                                          BasicBlock *InsertBB,
     890             :                                          Instruction *InsertBefore) {
     891             :   IRBuilder<> B(DL->getContext());
     892             :   if (InsertBefore)
     893           5 :     B.SetInsertPoint(InsertBefore);
     894             :   else if (InsertBB)
     895             :     B.SetInsertPoint(InsertBB);
     896             :   B.SetCurrentDebugLocation(DL);
     897             :   return B;
     898      129825 : }
     899             : 
     900             : static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
     901             :   assert(V && "no value passed to dbg intrinsic");
     902      129825 :   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
     903       41919 : }
     904       87906 : 
     905             : static Function *getDeclareIntrin(Module &M) {
     906      129825 :   return Intrinsic::getDeclaration(&M, UseDbgAddr ? Intrinsic::dbg_addr
     907      129825 :                                                   : Intrinsic::dbg_declare);
     908             : }
     909             : 
     910             : Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
     911             :                                       DIExpression *Expr, const DILocation *DL,
     912      129825 :                                       BasicBlock *InsertBB, Instruction *InsertBefore) {
     913             :   assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.declare");
     914             :   assert(DL && "Expected debug loc");
     915             :   assert(DL->getScope()->getSubprogram() ==
     916        5801 :              VarInfo->getScope()->getSubprogram() &&
     917             :          "Expected matching subprograms");
     918             :   if (!DeclareFn)
     919             :     DeclareFn = getDeclareIntrin(M);
     920       89137 : 
     921             :   trackIfUnresolved(VarInfo);
     922             :   trackIfUnresolved(Expr);
     923             :   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
     924             :                    MetadataAsValue::get(VMContext, VarInfo),
     925             :                    MetadataAsValue::get(VMContext, Expr)};
     926             : 
     927             :   IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
     928       89137 :   return B.CreateCall(DeclareFn, Args);
     929        5802 : }
     930             : 
     931       89137 : Instruction *DIBuilder::insertDbgValueIntrinsic(
     932       89137 :     Value *V, DILocalVariable *VarInfo, DIExpression *Expr,
     933       89137 :     const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore) {
     934       89137 :   assert(V && "no value passed to dbg.value");
     935       89137 :   assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.value");
     936             :   assert(DL && "Expected debug loc");
     937       89137 :   assert(DL->getScope()->getSubprogram() ==
     938       89137 :              VarInfo->getScope()->getSubprogram() &&
     939             :          "Expected matching subprograms");
     940             :   if (!ValueFn)
     941       40688 :     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
     942             : 
     943             :   trackIfUnresolved(VarInfo);
     944             :   trackIfUnresolved(Expr);
     945             :   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
     946             :                    MetadataAsValue::get(VMContext, VarInfo),
     947             :                    MetadataAsValue::get(VMContext, Expr)};
     948             : 
     949             :   IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
     950       40688 :   return B.CreateCall(ValueFn, Args);
     951       27472 : }
     952             : 
     953       40688 : Instruction *DIBuilder::insertLabel(
     954       40688 :     DILabel *LabelInfo, const DILocation *DL,
     955       40688 :     BasicBlock *InsertBB, Instruction *InsertBefore) {
     956       40688 :   assert(LabelInfo && "empty or invalid DILabel* passed to dbg.label");
     957       40688 :   assert(DL && "Expected debug loc");
     958             :   assert(DL->getScope()->getSubprogram() ==
     959       40688 :              LabelInfo->getScope()->getSubprogram() &&
     960       40688 :          "Expected matching subprograms");
     961             :   if (!LabelFn)
     962             :     LabelFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_label);
     963           0 : 
     964             :   trackIfUnresolved(LabelInfo);
     965             :   Value *Args[] = {MetadataAsValue::get(VMContext, LabelInfo)};
     966             : 
     967             :   IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
     968             :   return B.CreateCall(LabelFn, Args);
     969             : }
     970             : 
     971           0 : void DIBuilder::replaceVTableHolder(DICompositeType *&T,
     972           0 :                                     DIType *VTableHolder) {
     973             :   {
     974           0 :     TypedTrackingMDRef<DICompositeType> N(T);
     975           0 :     N->replaceVTableHolder(VTableHolder);
     976             :     T = N.get();
     977           0 :   }
     978           0 : 
     979             :   // If this didn't create a self-reference, just return.
     980             :   if (T != VTableHolder)
     981       33890 :     return;
     982             : 
     983             :   // Look for unresolved operands.  T will drop RAUW support, orphaning any
     984       33890 :   // cycles underneath it.
     985             :   if (T->isResolved())
     986       33890 :     for (const MDOperand &O : T->operands())
     987             :       if (auto *N = dyn_cast_or_null<MDNode>(O))
     988             :         trackIfUnresolved(N);
     989             : }
     990       33890 : 
     991             : void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements,
     992             :                               DINodeArray TParams) {
     993             :   {
     994             :     TypedTrackingMDRef<DICompositeType> N(T);
     995             :     if (Elements)
     996        6880 :       N->replaceElements(Elements);
     997             :     if (TParams)
     998        2026 :       N->replaceTemplateParams(DITemplateParameterArray(TParams));
     999             :     T = N.get();
    1000             :   }
    1001       94709 : 
    1002             :   // If T isn't resolved, there's no problem.
    1003             :   if (!T->isResolved())
    1004       94709 :     return;
    1005       94709 : 
    1006             :   // If T is resolved, it may be due to a self-reference cycle.  Track the
    1007       94709 :   // arrays explicitly if they're unresolved, or else the cycles will be
    1008             :   // orphaned.
    1009       94709 :   if (Elements)
    1010             :     trackIfUnresolved(Elements.get());
    1011             :   if (TParams)
    1012             :     trackIfUnresolved(TParams.get());
    1013       94709 : }

Generated by: LCOV version 1.13