lib/IR/DIBuilder.cpp

   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/ADT/STLExtras.h"
  16 #include "llvm/IR/Constants.h"
  17 #include "llvm/IR/DebugInfo.h"
  18 #include "llvm/IR/IntrinsicInst.h"
  19 #include "llvm/IR/Module.h"
  20 #include "llvm/Support/Debug.h"
  21 #include "llvm/Support/Dwarf.h"
  22
  23 using namespace llvm;
  24 using namespace llvm::dwarf;
  25
  26 namespace {
  27 class HeaderBuilder {
  28   /// \brief Whether there are any fields yet.
  29   ///
  30   /// Note that this is not equivalent to \c Chars.empty(), since \a concat()
  31   /// may have been called already with an empty string.
  32   bool IsEmpty;
  33   SmallVector<char, 256> Chars;
  34
  35 public:
  36   HeaderBuilder() : IsEmpty(true) {}
  37   HeaderBuilder(const HeaderBuilder &X) : IsEmpty(X.IsEmpty), Chars(X.Chars) {}
  38   HeaderBuilder(HeaderBuilder &&X)
  39       : IsEmpty(X.IsEmpty), Chars(std::move(X.Chars)) {}
  40
  41   template <class Twineable> HeaderBuilder &concat(Twineable &&X) {
  42     if (IsEmpty)
  43       IsEmpty = false;
  44     else
  45       Chars.push_back(0);
  46     Twine(X).toVector(Chars);
  47     return *this;
  48   }
  49
  50   MDString *get(LLVMContext &Context) const {
  51     return MDString::get(Context, StringRef(Chars.begin(), Chars.size()));
  52   }
  53
  54   static HeaderBuilder get(unsigned Tag) {
  55     return HeaderBuilder().concat("0x" + Twine::utohexstr(Tag));
  56   }
  57 };
  58 }
  59
  60 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
  61     : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
  62       TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
  63       DeclareFn(nullptr), ValueFn(nullptr),
  64       AllowUnresolvedNodes(AllowUnresolvedNodes) {}
  65
  66 void DIBuilder::trackIfUnresolved(MDNode *N) {
  67   if (!N)
  68     return;
  69   if (N->isResolved())
  70     return;
  71
  72   assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
  73   UnresolvedNodes.emplace_back(N);
  74 }
  75
  76 void DIBuilder::finalize() {
  77   DIArray Enums = getOrCreateArray(AllEnumTypes);
  78   TempEnumTypes->replaceAllUsesWith(Enums.get());
  79
  80   SmallVector<Metadata *, 16> RetainValues;
  81   // Declarations and definitions of the same type may be retained. Some
  82   // clients RAUW these pairs, leaving duplicates in the retained types
  83   // list. Use a set to remove the duplicates while we transform the
  84   // TrackingVHs back into Values.
  85   SmallPtrSet<Metadata *, 16> RetainSet;
  86   for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
  87     if (RetainSet.insert(AllRetainTypes[I]).second)
  88       RetainValues.push_back(AllRetainTypes[I]);
  89   DIArray RetainTypes = getOrCreateArray(RetainValues);
  90   TempRetainTypes->replaceAllUsesWith(RetainTypes.get());
  91
  92   DIArray SPs = getOrCreateArray(AllSubprograms);
  93   TempSubprograms->replaceAllUsesWith(SPs.get());
  94   for (unsigned i = 0, e = SPs.size(); i != e; ++i) {
  95     DISubprogram SP = cast<MDSubprogram>(SPs[i]);
  96     if (MDTuple *Temp = SP->getVariables().get()) {
  97       const auto &PV = PreservedVariables.lookup(SP);
  98       SmallVector<Metadata *, 4> Variables(PV.begin(), PV.end());
  99       DIArray AV = getOrCreateArray(Variables);
 100       TempMDTuple(Temp)->replaceAllUsesWith(AV.get());
 101     }
 102   }
 103
 104   DIArray GVs = getOrCreateArray(AllGVs);
 105   TempGVs->replaceAllUsesWith(GVs.get());
 106
 107   SmallVector<Metadata *, 16> RetainValuesI(AllImportedModules.begin(),
 108                                             AllImportedModules.end());
 109   DIArray IMs = getOrCreateArray(RetainValuesI);
 110   TempImportedModules->replaceAllUsesWith(IMs.get());
 111
 112   // Now that all temp nodes have been replaced or deleted, resolve remaining
 113   // cycles.
 114   for (const auto &N : UnresolvedNodes)
 115     if (N && !N->isResolved())
 116       N->resolveCycles();
 117   UnresolvedNodes.clear();
 118
 119   // Can't handle unresolved nodes anymore.
 120   AllowUnresolvedNodes = false;
 121 }
 122
 123 /// If N is compile unit return NULL otherwise return N.
 124 static MDScope *getNonCompileUnitScope(MDNode *N) {
 125   if (!N || isa<MDCompileUnit>(N))
 126     return nullptr;
 127   return cast<MDScope>(N);
 128 }
 129
 130 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
 131                                            StringRef Directory,
 132                                            StringRef Producer, bool isOptimized,
 133                                            StringRef Flags, unsigned RunTimeVer,
 134                                            StringRef SplitName,
 135                                            DebugEmissionKind Kind,
 136                                            bool EmitDebugInfo) {
 137
 138   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
 139           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
 140          "Invalid Language tag");
 141   assert(!Filename.empty() &&
 142          "Unable to create compile unit without filename");
 143
 144   // TODO: Once we make MDCompileUnit distinct, stop using temporaries here
 145   // (just start with operands assigned to nullptr).
 146   TempEnumTypes = MDTuple::getTemporary(VMContext, None);
 147   TempRetainTypes = MDTuple::getTemporary(VMContext, None);
 148   TempSubprograms = MDTuple::getTemporary(VMContext, None);
 149   TempGVs = MDTuple::getTemporary(VMContext, None);
 150   TempImportedModules = MDTuple::getTemporary(VMContext, None);
 151
 152   // TODO: Switch to getDistinct().  We never want to merge compile units based
 153   // on contents.
 154   MDCompileUnit *CUNode = MDCompileUnit::get(
 155       VMContext, Lang, MDFile::get(VMContext, Filename, Directory), Producer,
 156       isOptimized, Flags, RunTimeVer, SplitName, Kind, TempEnumTypes.get(),
 157       TempRetainTypes.get(), TempSubprograms.get(), TempGVs.get(),
 158       TempImportedModules.get());
 159
 160   // Create a named metadata so that it is easier to find cu in a module.
 161   // Note that we only generate this when the caller wants to actually
 162   // emit debug information. When we are only interested in tracking
 163   // source line locations throughout the backend, we prevent codegen from
 164   // emitting debug info in the final output by not generating llvm.dbg.cu.
 165   if (EmitDebugInfo) {
 166     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
 167     NMD->addOperand(CUNode);
 168   }
 169
 170   trackIfUnresolved(CUNode);
 171   return CUNode;
 172 }
 173
 174 static DIImportedEntity
 175 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
 176                      Metadata *NS, unsigned Line, StringRef Name,
 177                      SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
 178   DIImportedEntity M =
 179       MDImportedEntity::get(C, Tag, Context, DebugNodeRef(NS), Line, Name);
 180   AllImportedModules.emplace_back(M);
 181   return M;
 182 }
 183
 184 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
 185                                                  DINameSpace NS,
 186                                                  unsigned Line) {
 187   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
 188                                 Context, NS, Line, StringRef(), AllImportedModules);
 189 }
 190
 191 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
 192                                                  DIImportedEntity NS,
 193                                                  unsigned Line) {
 194   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
 195                                 Context, NS, Line, StringRef(), AllImportedModules);
 196 }
 197
 198 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
 199                                                       DIDescriptor Decl,
 200                                                       unsigned Line,
 201                                                       StringRef Name) {
 202   // Make sure to use the unique identifier based metadata reference for
 203   // types that have one.
 204   return ::createImportedModule(
 205       VMContext, dwarf::DW_TAG_imported_declaration, Context,
 206       DebugNodeRef::get(cast_or_null<DebugNode>(Decl.get())), Line, Name,
 207       AllImportedModules);
 208 }
 209
 210 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
 211                                                       DIImportedEntity Imp,
 212                                                       unsigned Line, StringRef Name) {
 213   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
 214                                 Context, Imp, Line, Name, AllImportedModules);
 215 }
 216
 217 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
 218   return MDFile::get(VMContext, Filename, Directory);
 219 }
 220
 221 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
 222   assert(!Name.empty() && "Unable to create enumerator without name");
 223   return MDEnumerator::get(VMContext, Val, Name);
 224 }
 225
 226 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
 227   assert(!Name.empty() && "Unable to create type without name");
 228   return MDBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
 229 }
 230
 231 DIBasicType DIBuilder::createNullPtrType() {
 232   return createUnspecifiedType("decltype(nullptr)");
 233 }
 234
 235 DIBasicType
 236 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
 237                            uint64_t AlignInBits, unsigned Encoding) {
 238   assert(!Name.empty() && "Unable to create type without name");
 239   return MDBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
 240                           AlignInBits, Encoding);
 241 }
 242
 243 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
 244   return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
 245                             MDTypeRef::get(FromTy), 0, 0, 0, 0);
 246 }
 247
 248 DIDerivedType
 249 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
 250                              uint64_t AlignInBits, StringRef Name) {
 251   // FIXME: Why is there a name here?
 252   return MDDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
 253                             nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
 254                             SizeInBits, AlignInBits, 0, 0);
 255 }
 256
 257 DIDerivedType
 258 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
 259                                    uint64_t SizeInBits, uint64_t AlignInBits) {
 260   return MDDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
 261                             nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
 262                             SizeInBits, AlignInBits, 0, 0, MDTypeRef::get(Base));
 263 }
 264
 265 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
 266   assert(RTy && "Unable to create reference type");
 267   return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
 268                             MDTypeRef::get(RTy), 0, 0, 0, 0);
 269 }
 270
 271 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
 272                                        unsigned LineNo, DIDescriptor Context) {
 273   return MDDerivedType::get(
 274       VMContext, dwarf::DW_TAG_typedef, Name, File, LineNo,
 275       MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
 276       MDTypeRef::get(Ty), 0, 0, 0, 0);
 277 }
 278
 279 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
 280   // typedefs are encoded in DIDerivedType format.
 281   assert(Ty && "Invalid type!");
 282   assert(FriendTy && "Invalid friend type!");
 283   return MDDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0,
 284                             MDTypeRef::get(Ty), MDTypeRef::get(FriendTy), 0, 0,
 285                             0, 0);
 286 }
 287
 288 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
 289                                            uint64_t BaseOffset,
 290                                            unsigned Flags) {
 291   assert(Ty && "Unable to create inheritance");
 292   return MDDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
 293                             0, MDTypeRef::get(Ty), MDTypeRef::get(BaseTy), 0, 0,
 294                             BaseOffset, Flags);
 295 }
 296
 297 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
 298                                           DIFile File, unsigned LineNumber,
 299                                           uint64_t SizeInBits,
 300                                           uint64_t AlignInBits,
 301                                           uint64_t OffsetInBits, unsigned Flags,
 302                                           DIType Ty) {
 303   return MDDerivedType::get(
 304       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
 305       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
 306       MDTypeRef::get(Ty), SizeInBits, AlignInBits, OffsetInBits, Flags);
 307 }
 308
 309 static ConstantAsMetadata *getConstantOrNull(Constant *C) {
 310   if (C)
 311     return ConstantAsMetadata::get(C);
 312   return nullptr;
 313 }
 314
 315 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
 316                                                 StringRef Name, DIFile File,
 317                                                 unsigned LineNumber, DIType Ty,
 318                                                 unsigned Flags,
 319                                                 llvm::Constant *Val) {
 320   // TAG_member is encoded in DIDerivedType format.
 321   Flags |= DIDescriptor::FlagStaticMember;
 322   return MDDerivedType::get(
 323       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
 324       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
 325       MDTypeRef::get(Ty), 0, 0, 0, Flags, getConstantOrNull(Val));
 326 }
 327
 328 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
 329                                         unsigned LineNumber,
 330                                         uint64_t SizeInBits,
 331                                         uint64_t AlignInBits,
 332                                         uint64_t OffsetInBits, unsigned Flags,
 333                                         DIType Ty, MDNode *PropertyNode) {
 334   return MDDerivedType::get(
 335       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
 336       MDScopeRef::get(getNonCompileUnitScope(File)), MDTypeRef::get(Ty),
 337       SizeInBits, AlignInBits, OffsetInBits, Flags, PropertyNode);
 338 }
 339
 340 DIObjCProperty
 341 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
 342                               StringRef GetterName, StringRef SetterName,
 343                               unsigned PropertyAttributes, DIType Ty) {
 344   return MDObjCProperty::get(VMContext, Name, File, LineNumber, GetterName,
 345                              SetterName, PropertyAttributes, Ty);
 346 }
 347
 348 DITemplateTypeParameter
 349 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
 350                                        DIType Ty) {
 351   assert((!Context || isa<MDCompileUnit>(Context)) && "Expected compile unit");
 352   return MDTemplateTypeParameter::get(VMContext, Name, MDTypeRef::get(Ty));
 353 }
 354
 355 static DITemplateValueParameter
 356 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
 357                                    DIDescriptor Context, StringRef Name,
 358                                    DIType Ty, Metadata *MD) {
 359   assert((!Context || isa<MDCompileUnit>(Context)) && "Expected compile unit");
 360   return MDTemplateValueParameter::get(VMContext, Tag, Name, MDTypeRef::get(Ty),
 361                                        MD);
 362 }
 363
 364 DITemplateValueParameter
 365 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
 366                                         DIType Ty, Constant *Val) {
 367   return createTemplateValueParameterHelper(
 368       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
 369       getConstantOrNull(Val));
 370 }
 371
 372 DITemplateValueParameter
 373 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
 374                                            DIType Ty, StringRef Val) {
 375   return createTemplateValueParameterHelper(
 376       VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
 377       MDString::get(VMContext, Val));
 378 }
 379
 380 DITemplateValueParameter
 381 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
 382                                        DIType Ty, DIArray Val) {
 383   return createTemplateValueParameterHelper(
 384       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
 385       Val.get());
 386 }
 387
 388 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
 389                                            DIFile File, unsigned LineNumber,
 390                                            uint64_t SizeInBits,
 391                                            uint64_t AlignInBits,
 392                                            uint64_t OffsetInBits,
 393                                            unsigned Flags, DIType DerivedFrom,
 394                                            DIArray Elements,
 395                                            DIType VTableHolder,
 396                                            MDNode *TemplateParams,
 397                                            StringRef UniqueIdentifier) {
 398   assert((!Context || isa<MDScope>(Context)) &&
 399          "createClassType should be called with a valid Context");
 400   // TAG_class_type is encoded in DICompositeType format.
 401   DICompositeType R = MDCompositeType::get(
 402       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
 403       MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
 404       MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, OffsetInBits, Flags,
 405       Elements, 0, MDTypeRef::get(VTableHolder),
 406       cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
 407   if (!UniqueIdentifier.empty())
 408     retainType(R);
 409   trackIfUnresolved(R);
 410   return R;
 411 }
 412
 413 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
 414                                             StringRef Name, DIFile File,
 415                                             unsigned LineNumber,
 416                                             uint64_t SizeInBits,
 417                                             uint64_t AlignInBits,
 418                                             unsigned Flags, DIType DerivedFrom,
 419                                             DIArray Elements,
 420                                             unsigned RunTimeLang,
 421                                             DIType VTableHolder,
 422                                             StringRef UniqueIdentifier) {
 423   DICompositeType R = MDCompositeType::get(
 424       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
 425       MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
 426       MDTypeRef::get(DerivedFrom), SizeInBits, AlignInBits, 0, Flags, Elements,
 427       RunTimeLang, MDTypeRef::get(VTableHolder), nullptr, UniqueIdentifier);
 428   if (!UniqueIdentifier.empty())
 429     retainType(R);
 430   trackIfUnresolved(R);
 431   return R;
 432 }
 433
 434 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
 435                                            DIFile File, unsigned LineNumber,
 436                                            uint64_t SizeInBits,
 437                                            uint64_t AlignInBits, unsigned Flags,
 438                                            DIArray Elements,
 439                                            unsigned RunTimeLang,
 440                                            StringRef UniqueIdentifier) {
 441   DICompositeType R = MDCompositeType::get(
 442       VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
 443       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
 444       SizeInBits, AlignInBits, 0, Flags, Elements, RunTimeLang, nullptr,
 445       nullptr, UniqueIdentifier);
 446   if (!UniqueIdentifier.empty())
 447     retainType(R);
 448   trackIfUnresolved(R);
 449   return R;
 450 }
 451
 452 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
 453                                                  DITypeArray ParameterTypes,
 454                                                  unsigned Flags) {
 455   return MDSubroutineType::get(VMContext, Flags, ParameterTypes);
 456 }
 457
 458 DICompositeType DIBuilder::createEnumerationType(
 459     DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
 460     uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
 461     DIType UnderlyingType, StringRef UniqueIdentifier) {
 462   DICompositeType CTy = MDCompositeType::get(
 463       VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
 464       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
 465       MDTypeRef::get(UnderlyingType), SizeInBits, AlignInBits, 0, 0, Elements,
 466       0, nullptr, nullptr, UniqueIdentifier);
 467   AllEnumTypes.push_back(CTy);
 468   if (!UniqueIdentifier.empty())
 469     retainType(CTy);
 470   trackIfUnresolved(CTy);
 471   return CTy;
 472 }
 473
 474 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
 475                                            DIType Ty, DIArray Subscripts) {
 476   auto *R = MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
 477                                  nullptr, 0, nullptr, MDTypeRef::get(Ty), Size,
 478                                  AlignInBits, 0, 0, Subscripts, 0, nullptr);
 479   trackIfUnresolved(R);
 480   return R;
 481 }
 482
 483 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
 484                                             DIType Ty, DIArray Subscripts) {
 485   auto *R =
 486       MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0,
 487                            nullptr, MDTypeRef::get(Ty), Size, AlignInBits, 0,
 488                            DebugNode::FlagVector, Subscripts, 0, nullptr);
 489   trackIfUnresolved(R);
 490   return R;
 491 }
 492
 493 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
 494                                   unsigned FlagsToSet) {
 495   TempMDType NewTy = cast<MDType>(static_cast<MDNode *>(Ty))->clone();
 496   NewTy->setFlags(NewTy->getFlags() | FlagsToSet);
 497   return MDNode::replaceWithUniqued(std::move(NewTy));
 498 }
 499
 500 DIType DIBuilder::createArtificialType(DIType Ty) {
 501   // FIXME: Restrict this to the nodes where it's valid.
 502   if (Ty->isArtificial())
 503     return Ty;
 504   return createTypeWithFlags(VMContext, Ty, DebugNode::FlagArtificial);
 505 }
 506
 507 DIType DIBuilder::createObjectPointerType(DIType Ty) {
 508   // FIXME: Restrict this to the nodes where it's valid.
 509   if (Ty->isObjectPointer())
 510     return Ty;
 511   unsigned Flags = DebugNode::FlagObjectPointer | DebugNode::FlagArtificial;
 512   return createTypeWithFlags(VMContext, Ty, Flags);
 513 }
 514
 515 void DIBuilder::retainType(DIType T) {
 516   assert(T && "Expected non-null type");
 517   AllRetainTypes.emplace_back(T);
 518 }
 519
 520 DIBasicType DIBuilder::createUnspecifiedParameter() { return nullptr; }
 521
 522 DICompositeType
 523 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
 524                              DIFile F, unsigned Line, unsigned RuntimeLang,
 525                              uint64_t SizeInBits, uint64_t AlignInBits,
 526                              StringRef UniqueIdentifier) {
 527   // FIXME: Define in terms of createReplaceableForwardDecl() by calling
 528   // replaceWithUniqued().
 529   DICompositeType RetTy = MDCompositeType::get(
 530       VMContext, Tag, Name, F, Line,
 531       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
 532       SizeInBits, AlignInBits, 0, DIDescriptor::FlagFwdDecl, nullptr,
 533       RuntimeLang, nullptr, nullptr, UniqueIdentifier);
 534   if (!UniqueIdentifier.empty())
 535     retainType(RetTy);
 536   trackIfUnresolved(RetTy);
 537   return RetTy;
 538 }
 539
 540 DICompositeType DIBuilder::createReplaceableCompositeType(
 541     unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
 542     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
 543     unsigned Flags, StringRef UniqueIdentifier) {
 544   DICompositeType RetTy =
 545       MDCompositeType::getTemporary(
 546           VMContext, Tag, Name, F, Line,
 547           MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
 548           SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
 549           nullptr, UniqueIdentifier)
 550           .release();
 551   if (!UniqueIdentifier.empty())
 552     retainType(RetTy);
 553   trackIfUnresolved(RetTy);
 554   return RetTy;
 555 }
 556
 557 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
 558   return DIArray(MDNode::get(VMContext, Elements));
 559 }
 560
 561 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
 562   SmallVector<llvm::Metadata *, 16> Elts;
 563   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
 564     if (Elements[i] && isa<MDNode>(Elements[i]))
 565       Elts.push_back(MDTypeRef::get(cast<MDType>(Elements[i])));
 566     else
 567       Elts.push_back(Elements[i]);
 568   }
 569   return DITypeArray(MDNode::get(VMContext, Elts));
 570 }
 571
 572 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
 573   return MDSubrange::get(VMContext, Count, Lo);
 574 }
 575
 576 static void checkGlobalVariableScope(DIDescriptor Context) {
 577 #ifndef NDEBUG
 578   if (auto *CT =
 579           dyn_cast_or_null<MDCompositeType>(getNonCompileUnitScope(Context)))
 580     assert(CT->getIdentifier().empty() &&
 581            "Context of a global variable should not be a type with identifier");
 582 #endif
 583 }
 584
 585 DIGlobalVariable DIBuilder::createGlobalVariable(
 586     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 587     unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
 588     MDNode *Decl) {
 589   checkGlobalVariableScope(Context);
 590
 591   auto *N = MDGlobalVariable::get(VMContext, cast_or_null<MDScope>(Context),
 592                                   Name, LinkageName, F, LineNumber,
 593                                   MDTypeRef::get(Ty), isLocalToUnit, true, Val,
 594                                   cast_or_null<MDDerivedType>(Decl));
 595   AllGVs.push_back(N);
 596   return N;
 597 }
 598
 599 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
 600     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 601     unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
 602     MDNode *Decl) {
 603   checkGlobalVariableScope(Context);
 604
 605   return MDGlobalVariable::getTemporary(
 606              VMContext, cast_or_null<MDScope>(Context), Name, LinkageName, F,
 607              LineNumber, MDTypeRef::get(Ty), isLocalToUnit, false, Val,
 608              cast_or_null<MDDerivedType>(Decl))
 609       .release();
 610 }
 611
 612 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
 613                                           StringRef Name, DIFile File,
 614                                           unsigned LineNo, DIType Ty,
 615                                           bool AlwaysPreserve, unsigned Flags,
 616                                           unsigned ArgNo) {
 617   // FIXME: Why getNonCompileUnitScope()?
 618   // FIXME: Why is "!Context" okay here?
 619   // FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT
 620   // the only valid scopes)?
 621   DIScope Context = getNonCompileUnitScope(Scope);
 622
 623   auto *Node = MDLocalVariable::get(
 624       VMContext, Tag, cast_or_null<MDLocalScope>(Context), Name, File, LineNo,
 625       MDTypeRef::get(Ty), ArgNo, Flags);
 626   if (AlwaysPreserve) {
 627     // The optimizer may remove local variable. If there is an interest
 628     // to preserve variable info in such situation then stash it in a
 629     // named mdnode.
 630     DISubprogram Fn(getDISubprogram(Scope));
 631     assert(Fn && "Missing subprogram for local variable");
 632     PreservedVariables[Fn].emplace_back(Node);
 633   }
 634   return Node;
 635 }
 636
 637 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
 638   return MDExpression::get(VMContext, Addr);
 639 }
 640
 641 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
 642   // TODO: Remove the callers of this signed version and delete.
 643   SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
 644   return createExpression(Addr);
 645 }
 646
 647 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
 648                                                  unsigned SizeInBytes) {
 649   uint64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBytes, SizeInBytes};
 650   return MDExpression::get(VMContext, Addr);
 651 }
 652
 653 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
 654                                        StringRef LinkageName, DIFile File,
 655                                        unsigned LineNo, DICompositeType Ty,
 656                                        bool isLocalToUnit, bool isDefinition,
 657                                        unsigned ScopeLine, unsigned Flags,
 658                                        bool isOptimized, Function *Fn,
 659                                        MDNode *TParams, MDNode *Decl) {
 660   // dragonegg does not generate identifier for types, so using an empty map
 661   // to resolve the context should be fine.
 662   DITypeIdentifierMap EmptyMap;
 663   return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
 664                         LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
 665                         Flags, isOptimized, Fn, TParams, Decl);
 666 }
 667
 668 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
 669                                        StringRef LinkageName, DIFile File,
 670                                        unsigned LineNo, DICompositeType Ty,
 671                                        bool isLocalToUnit, bool isDefinition,
 672                                        unsigned ScopeLine, unsigned Flags,
 673                                        bool isOptimized, Function *Fn,
 674                                        MDNode *TParams, MDNode *Decl) {
 675   assert(Ty->getTag() == dwarf::DW_TAG_subroutine_type &&
 676          "function types should be subroutines");
 677   auto *Node = MDSubprogram::get(
 678       VMContext, MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
 679       Name, LinkageName, File, LineNo, cast_or_null<MDSubroutineType>(Ty),
 680       isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, Flags, isOptimized,
 681       Fn, cast_or_null<MDTuple>(TParams), cast_or_null<MDSubprogram>(Decl),
 682       MDTuple::getTemporary(VMContext, None).release());
 683
 684   if (isDefinition)
 685     AllSubprograms.push_back(Node);
 686   trackIfUnresolved(Node);
 687   return Node;
 688 }
 689
 690 DISubprogram
 691 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
 692                                      StringRef LinkageName, DIFile File,
 693                                      unsigned LineNo, DICompositeType Ty,
 694                                      bool isLocalToUnit, bool isDefinition,
 695                                      unsigned ScopeLine, unsigned Flags,
 696                                      bool isOptimized, Function *Fn,
 697                                      MDNode *TParams, MDNode *Decl) {
 698   return MDSubprogram::getTemporary(
 699              VMContext,
 700              MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))), Name,
 701              LinkageName, File, LineNo, cast_or_null<MDSubroutineType>(Ty),
 702              isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, Flags,
 703              isOptimized, Fn, cast_or_null<MDTuple>(TParams),
 704              cast_or_null<MDSubprogram>(Decl), nullptr)
 705       .release();
 706 }
 707
 708 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
 709                                      StringRef LinkageName, DIFile F,
 710                                      unsigned LineNo, DICompositeType Ty,
 711                                      bool isLocalToUnit, bool isDefinition,
 712                                      unsigned VK, unsigned VIndex,
 713                                      DIType VTableHolder, unsigned Flags,
 714                                      bool isOptimized, Function *Fn,
 715                                      MDNode *TParam) {
 716   assert(Ty->getTag() == dwarf::DW_TAG_subroutine_type &&
 717          "function types should be subroutines");
 718   assert(getNonCompileUnitScope(Context) &&
 719          "Methods should have both a Context and a context that isn't "
 720          "the compile unit.");
 721   // FIXME: Do we want to use different scope/lines?
 722   auto *SP = MDSubprogram::get(
 723       VMContext, MDScopeRef::get(cast<MDScope>(Context)), Name, LinkageName, F,
 724       LineNo, cast_or_null<MDSubroutineType>(Ty), isLocalToUnit, isDefinition,
 725       LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags, isOptimized, Fn,
 726       cast_or_null<MDTuple>(TParam), nullptr, nullptr);
 727
 728   if (isDefinition)
 729     AllSubprograms.push_back(SP);
 730   trackIfUnresolved(SP);
 731   return SP;
 732 }
 733
 734 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
 735                                        DIFile File, unsigned LineNo) {
 736   return MDNamespace::get(VMContext, getNonCompileUnitScope(Scope), File, Name,
 737                           LineNo);
 738 }
 739
 740 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
 741                                                      DIFile File,
 742                                                      unsigned Discriminator) {
 743   return MDLexicalBlockFile::get(VMContext, Scope, File, Discriminator);
 744 }
 745
 746 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
 747                                              unsigned Line, unsigned Col) {
 748   // Make these distinct, to avoid merging two lexical blocks on the same
 749   // file/line/column.
 750   return MDLexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope),
 751                                      File, Line, Col);
 752 }
 753
 754 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
 755   assert(V && "no value passed to dbg intrinsic");
 756   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
 757 }
 758
 759 static Instruction *withDebugLoc(Instruction *I, const MDLocation *DL) {
 760   I->setDebugLoc(const_cast<MDLocation *>(DL));
 761   return I;
 762 }
 763
 764 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
 765                                       DIExpression Expr, const MDLocation *DL,
 766                                       Instruction *InsertBefore) {
 767   assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
 768   assert(DL && "Expected debug loc");
 769   assert(DL->getScope()->getSubprogram() ==
 770              VarInfo->getScope()->getSubprogram() &&
 771          "Expected matching subprograms");
 772   if (!DeclareFn)
 773     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 774
 775   trackIfUnresolved(VarInfo);
 776   trackIfUnresolved(Expr);
 777   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
 778                    MetadataAsValue::get(VMContext, VarInfo),
 779                    MetadataAsValue::get(VMContext, Expr)};
 780   return withDebugLoc(CallInst::Create(DeclareFn, Args, "", InsertBefore), DL);
 781 }
 782
 783 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
 784                                       DIExpression Expr, const MDLocation *DL,
 785                                       BasicBlock *InsertAtEnd) {
 786   assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
 787   assert(DL && "Expected debug loc");
 788   assert(DL->getScope()->getSubprogram() ==
 789              VarInfo->getScope()->getSubprogram() &&
 790          "Expected matching subprograms");
 791   if (!DeclareFn)
 792     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 793
 794   trackIfUnresolved(VarInfo);
 795   trackIfUnresolved(Expr);
 796   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
 797                    MetadataAsValue::get(VMContext, VarInfo),
 798                    MetadataAsValue::get(VMContext, Expr)};
 799
 800   // If this block already has a terminator then insert this intrinsic
 801   // before the terminator.
 802   if (TerminatorInst *T = InsertAtEnd->getTerminator())
 803     return withDebugLoc(CallInst::Create(DeclareFn, Args, "", T), DL);
 804   return withDebugLoc(CallInst::Create(DeclareFn, Args, "", InsertAtEnd), DL);
 805 }
 806
 807 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
 808                                                 DIVariable VarInfo,
 809                                                 DIExpression Expr,
 810                                                 const MDLocation *DL,
 811                                                 Instruction *InsertBefore) {
 812   assert(V && "no value passed to dbg.value");
 813   assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
 814   assert(DL && "Expected debug loc");
 815   assert(DL->getScope()->getSubprogram() ==
 816              VarInfo->getScope()->getSubprogram() &&
 817          "Expected matching subprograms");
 818   if (!ValueFn)
 819     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 820
 821   trackIfUnresolved(VarInfo);
 822   trackIfUnresolved(Expr);
 823   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
 824                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
 825                    MetadataAsValue::get(VMContext, VarInfo),
 826                    MetadataAsValue::get(VMContext, Expr)};
 827   return withDebugLoc(CallInst::Create(ValueFn, Args, "", InsertBefore), DL);
 828 }
 829
 830 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
 831                                                 DIVariable VarInfo,
 832                                                 DIExpression Expr,
 833                                                 const MDLocation *DL,
 834                                                 BasicBlock *InsertAtEnd) {
 835   assert(V && "no value passed to dbg.value");
 836   assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
 837   assert(DL && "Expected debug loc");
 838   assert(DL->getScope()->getSubprogram() ==
 839              VarInfo->getScope()->getSubprogram() &&
 840          "Expected matching subprograms");
 841   if (!ValueFn)
 842     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 843
 844   trackIfUnresolved(VarInfo);
 845   trackIfUnresolved(Expr);
 846   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
 847                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
 848                    MetadataAsValue::get(VMContext, VarInfo),
 849                    MetadataAsValue::get(VMContext, Expr)};
 850
 851   return withDebugLoc(CallInst::Create(ValueFn, Args, "", InsertAtEnd), DL);
 852 }
 853
 854 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
 855   {
 856     TypedTrackingMDRef<MDCompositeTypeBase> N(T);
 857     N->replaceVTableHolder(MDTypeRef::get(VTableHolder));
 858     T = N.get();
 859   }
 860
 861   // If this didn't create a self-reference, just return.
 862   if (T != VTableHolder)
 863     return;
 864
 865   // Look for unresolved operands.  T will drop RAUW support, orphaning any
 866   // cycles underneath it.
 867   if (T->isResolved())
 868     for (const MDOperand &O : T->operands())
 869       if (auto *N = dyn_cast_or_null<MDNode>(O))
 870         trackIfUnresolved(N);
 871 }
 872
 873 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
 874                               DIArray TParams) {
 875   {
 876     TypedTrackingMDRef<MDCompositeTypeBase> N(T);
 877     if (Elements)
 878       N->replaceElements(Elements);
 879     if (TParams)
 880       N->replaceTemplateParams(MDTemplateParameterArray(TParams));
 881     T = N.get();
 882   }
 883
 884   // If T isn't resolved, there's no problem.
 885   if (!T->isResolved())
 886     return;
 887
 888   // If "T" is resolved, it may be due to a self-reference cycle.  Track the
 889   // arrays explicitly if they're unresolved, or else the cycles will be
 890   // orphaned.
 891   if (Elements)
 892     trackIfUnresolved(Elements.get());
 893   if (TParams)
 894     trackIfUnresolved(TParams.get());
 895 }