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);
  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);
  91
  92   DIArray SPs = getOrCreateArray(AllSubprograms);
  93   TempSubprograms->replaceAllUsesWith(SPs);
  94   for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
  95     DISubprogram SP = cast<MDSubprogram>(SPs.getElement(i));
  96     if (MDNode *Temp = SP.getVariablesNodes()) {
  97       const auto &PV = PreservedVariables.lookup(SP);
  98       SmallVector<Metadata *, 4> Variables(PV.begin(), PV.end());
  99       DIArray AV = getOrCreateArray(Variables);
 100       Temp->replaceAllUsesWith(AV);
 101     }
 102   }
 103
 104   DIArray GVs = getOrCreateArray(AllGVs);
 105   TempGVs->replaceAllUsesWith(GVs);
 106
 107   SmallVector<Metadata *, 16> RetainValuesI(AllImportedModules.begin(),
 108                                             AllImportedModules.end());
 109   DIArray IMs = getOrCreateArray(RetainValuesI);
 110   TempImportedModules->replaceAllUsesWith(IMs);
 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).release();
 147   TempRetainTypes = MDTuple::getTemporary(VMContext, None).release();
 148   TempSubprograms = MDTuple::getTemporary(VMContext, None).release();
 149   TempGVs = MDTuple::getTemporary(VMContext, None).release();
 150   TempImportedModules = MDTuple::getTemporary(VMContext, None).release();
 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,
 157       TempRetainTypes, TempSubprograms, TempGVs, TempImportedModules);
 158
 159   // Create a named metadata so that it is easier to find cu in a module.
 160   // Note that we only generate this when the caller wants to actually
 161   // emit debug information. When we are only interested in tracking
 162   // source line locations throughout the backend, we prevent codegen from
 163   // emitting debug info in the final output by not generating llvm.dbg.cu.
 164   if (EmitDebugInfo) {
 165     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
 166     NMD->addOperand(CUNode);
 167   }
 168
 169   trackIfUnresolved(CUNode);
 170   return CUNode;
 171 }
 172
 173 static DIImportedEntity
 174 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
 175                      Metadata *NS, unsigned Line, StringRef Name,
 176                      SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
 177   DIImportedEntity M = MDImportedEntity::get(C, Tag, Context, NS, Line, Name);
 178   AllImportedModules.emplace_back(M.get());
 179   return M;
 180 }
 181
 182 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
 183                                                  DINameSpace NS,
 184                                                  unsigned Line) {
 185   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
 186                                 Context, NS, Line, StringRef(), AllImportedModules);
 187 }
 188
 189 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
 190                                                  DIImportedEntity NS,
 191                                                  unsigned Line) {
 192   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
 193                                 Context, NS, Line, StringRef(), AllImportedModules);
 194 }
 195
 196 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
 197                                                       DIDescriptor Decl,
 198                                                       unsigned Line,
 199                                                       StringRef Name) {
 200   // Make sure to use the unique identifier based metadata reference for
 201   // types that have one.
 202   return ::createImportedModule(
 203       VMContext, dwarf::DW_TAG_imported_declaration, Context,
 204       DebugNodeRef::get(cast_or_null<DebugNode>(Decl.get())), Line, Name,
 205       AllImportedModules);
 206 }
 207
 208 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
 209                                                       DIImportedEntity Imp,
 210                                                       unsigned Line, StringRef Name) {
 211   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
 212                                 Context, Imp, Line, Name, AllImportedModules);
 213 }
 214
 215 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
 216   return MDFile::get(VMContext, Filename, Directory);
 217 }
 218
 219 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
 220   assert(!Name.empty() && "Unable to create enumerator without name");
 221   return MDEnumerator::get(VMContext, Val, Name);
 222 }
 223
 224 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
 225   assert(!Name.empty() && "Unable to create type without name");
 226   return MDBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
 227 }
 228
 229 DIBasicType DIBuilder::createNullPtrType() {
 230   return createUnspecifiedType("decltype(nullptr)");
 231 }
 232
 233 DIBasicType
 234 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
 235                            uint64_t AlignInBits, unsigned Encoding) {
 236   assert(!Name.empty() && "Unable to create type without name");
 237   return MDBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
 238                           AlignInBits, Encoding);
 239 }
 240
 241 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
 242   return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
 243                             MDTypeRef::get(FromTy), 0, 0, 0, 0);
 244 }
 245
 246 DIDerivedType
 247 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
 248                              uint64_t AlignInBits, StringRef Name) {
 249   // FIXME: Why is there a name here?
 250   return MDDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
 251                             nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
 252                             SizeInBits, AlignInBits, 0, 0);
 253 }
 254
 255 DIDerivedType
 256 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
 257                                    uint64_t SizeInBits, uint64_t AlignInBits) {
 258   return MDDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
 259                             nullptr, 0, nullptr, MDTypeRef::get(PointeeTy),
 260                             SizeInBits, AlignInBits, 0, 0, MDTypeRef::get(Base));
 261 }
 262
 263 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
 264   assert(RTy && "Unable to create reference type");
 265   return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
 266                             MDTypeRef::get(RTy), 0, 0, 0, 0);
 267 }
 268
 269 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
 270                                        unsigned LineNo, DIDescriptor Context) {
 271   return MDDerivedType::get(
 272       VMContext, dwarf::DW_TAG_typedef, Name, File, LineNo,
 273       MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
 274       MDTypeRef::get(Ty), 0, 0, 0, 0);
 275 }
 276
 277 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
 278   // typedefs are encoded in DIDerivedType format.
 279   assert(Ty && "Invalid type!");
 280   assert(FriendTy && "Invalid friend type!");
 281   return MDDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0,
 282                             MDTypeRef::get(Ty), MDTypeRef::get(FriendTy), 0, 0,
 283                             0, 0);
 284 }
 285
 286 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
 287                                            uint64_t BaseOffset,
 288                                            unsigned Flags) {
 289   assert(Ty && "Unable to create inheritance");
 290   return MDDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
 291                             0, MDTypeRef::get(Ty), MDTypeRef::get(BaseTy), 0, 0,
 292                             BaseOffset, Flags);
 293 }
 294
 295 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
 296                                           DIFile File, unsigned LineNumber,
 297                                           uint64_t SizeInBits,
 298                                           uint64_t AlignInBits,
 299                                           uint64_t OffsetInBits, unsigned Flags,
 300                                           DIType Ty) {
 301   return MDDerivedType::get(
 302       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
 303       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
 304       MDTypeRef::get(Ty), SizeInBits, AlignInBits, OffsetInBits, Flags);
 305 }
 306
 307 static ConstantAsMetadata *getConstantOrNull(Constant *C) {
 308   if (C)
 309     return ConstantAsMetadata::get(C);
 310   return nullptr;
 311 }
 312
 313 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
 314                                                 StringRef Name, DIFile File,
 315                                                 unsigned LineNumber, DIType Ty,
 316                                                 unsigned Flags,
 317                                                 llvm::Constant *Val) {
 318   // TAG_member is encoded in DIDerivedType format.
 319   Flags |= DIDescriptor::FlagStaticMember;
 320   return MDDerivedType::get(
 321       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
 322       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))),
 323       MDTypeRef::get(Ty), 0, 0, 0, Flags, getConstantOrNull(Val));
 324 }
 325
 326 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
 327                                         unsigned LineNumber,
 328                                         uint64_t SizeInBits,
 329                                         uint64_t AlignInBits,
 330                                         uint64_t OffsetInBits, unsigned Flags,
 331                                         DIType Ty, MDNode *PropertyNode) {
 332   return MDDerivedType::get(
 333       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
 334       MDScopeRef::get(getNonCompileUnitScope(File)), MDTypeRef::get(Ty),
 335       SizeInBits, AlignInBits, OffsetInBits, Flags, PropertyNode);
 336 }
 337
 338 DIObjCProperty
 339 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
 340                               StringRef GetterName, StringRef SetterName,
 341                               unsigned PropertyAttributes, DIType Ty) {
 342   return MDObjCProperty::get(VMContext, Name, File, LineNumber, GetterName,
 343                              SetterName, PropertyAttributes, Ty);
 344 }
 345
 346 DITemplateTypeParameter
 347 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
 348                                        DIType Ty) {
 349   assert((!Context || isa<MDCompileUnit>(Context.get())) &&
 350          "Expected compile unit");
 351   return MDTemplateTypeParameter::get(VMContext, Name, MDTypeRef::get(Ty));
 352 }
 353
 354 static DITemplateValueParameter
 355 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
 356                                    DIDescriptor Context, StringRef Name,
 357                                    DIType Ty, Metadata *MD) {
 358   assert((!Context || isa<MDCompileUnit>(Context.get())) &&
 359          "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);
 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                            DIType::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, DIType::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 = DIType::FlagObjectPointer | DIType::FlagArtificial;
 512   return createTypeWithFlags(VMContext, Ty, Flags);
 513 }
 514
 515 void DIBuilder::retainType(DIType T) {
 516   assert(T.get() && "Expected non-null type");
 517   AllRetainTypes.emplace_back(T);
 518 }
 519
 520 DIBasicType DIBuilder::createUnspecifiedParameter() {
 521   return DIBasicType();
 522 }
 523
 524 DICompositeType
 525 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
 526                              DIFile F, unsigned Line, unsigned RuntimeLang,
 527                              uint64_t SizeInBits, uint64_t AlignInBits,
 528                              StringRef UniqueIdentifier) {
 529   // FIXME: Define in terms of createReplaceableForwardDecl() by calling
 530   // replaceWithUniqued().
 531   DICompositeType RetTy = MDCompositeType::get(
 532       VMContext, Tag, Name, F, Line,
 533       MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
 534       SizeInBits, AlignInBits, 0, DIDescriptor::FlagFwdDecl, nullptr,
 535       RuntimeLang, nullptr, nullptr, UniqueIdentifier);
 536   if (!UniqueIdentifier.empty())
 537     retainType(RetTy);
 538   trackIfUnresolved(RetTy);
 539   return RetTy;
 540 }
 541
 542 DICompositeType DIBuilder::createReplaceableCompositeType(
 543     unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
 544     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
 545     unsigned Flags, StringRef UniqueIdentifier) {
 546   DICompositeType RetTy =
 547       MDCompositeType::getTemporary(
 548           VMContext, Tag, Name, F, Line,
 549           MDScopeRef::get(DIScope(getNonCompileUnitScope(Scope))), nullptr,
 550           SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
 551           nullptr, UniqueIdentifier)
 552           .release();
 553   if (!UniqueIdentifier.empty())
 554     retainType(RetTy);
 555   trackIfUnresolved(RetTy);
 556   return RetTy;
 557 }
 558
 559 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
 560   return DIArray(MDNode::get(VMContext, Elements));
 561 }
 562
 563 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
 564   SmallVector<llvm::Metadata *, 16> Elts;
 565   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
 566     if (Elements[i] && isa<MDNode>(Elements[i]))
 567       Elts.push_back(MDTypeRef::get(cast<MDType>(Elements[i])));
 568     else
 569       Elts.push_back(Elements[i]);
 570   }
 571   return DITypeArray(MDNode::get(VMContext, Elts));
 572 }
 573
 574 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
 575   return MDSubrange::get(VMContext, Count, Lo);
 576 }
 577
 578 static void checkGlobalVariableScope(DIDescriptor Context) {
 579 #ifndef NDEBUG
 580   if (DICompositeType CT =
 581           dyn_cast_or_null<MDCompositeType>(getNonCompileUnitScope(Context)))
 582     assert(!CT.getIdentifier() &&
 583            "Context of a global variable should not be a type with identifier");
 584 #endif
 585 }
 586
 587 DIGlobalVariable DIBuilder::createGlobalVariable(
 588     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 589     unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
 590     MDNode *Decl) {
 591   checkGlobalVariableScope(Context);
 592
 593   auto *N = MDGlobalVariable::get(
 594       VMContext, cast_or_null<MDScope>(Context.get()), Name, LinkageName, F,
 595       LineNumber, MDTypeRef::get(Ty), isLocalToUnit, true,
 596       getConstantOrNull(Val), cast_or_null<MDDerivedType>(Decl));
 597   AllGVs.push_back(N);
 598   return N;
 599 }
 600
 601 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
 602     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 603     unsigned LineNumber, DIType Ty, bool isLocalToUnit, Constant *Val,
 604     MDNode *Decl) {
 605   checkGlobalVariableScope(Context);
 606
 607   return MDGlobalVariable::getTemporary(
 608              VMContext, cast_or_null<MDScope>(Context.get()), Name, LinkageName,
 609              F, LineNumber, MDTypeRef::get(Ty), isLocalToUnit, false, getConstantOrNull(Val),
 610              cast_or_null<MDDerivedType>(Decl)).release();
 611 }
 612
 613 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
 614                                           StringRef Name, DIFile File,
 615                                           unsigned LineNo, DIType Ty,
 616                                           bool AlwaysPreserve, unsigned Flags,
 617                                           unsigned ArgNo) {
 618   // FIXME: Why getNonCompileUnitScope()?
 619   // FIXME: Why is "!Context" okay here?
 620   // FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT
 621   // the only valid scopes)?
 622   DIScope Context = getNonCompileUnitScope(Scope);
 623
 624   auto *Node = MDLocalVariable::get(
 625       VMContext, Tag, cast_or_null<MDLocalScope>(Context.get()), Name, File,
 626       LineNo, MDTypeRef::get(Ty), ArgNo, Flags);
 627   if (AlwaysPreserve) {
 628     // The optimizer may remove local variable. If there is an interest
 629     // to preserve variable info in such situation then stash it in a
 630     // named mdnode.
 631     DISubprogram Fn(getDISubprogram(Scope));
 632     assert(Fn && "Missing subprogram for local variable");
 633     PreservedVariables[Fn].emplace_back(Node);
 634   }
 635   return Node;
 636 }
 637
 638 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
 639   return MDExpression::get(VMContext, Addr);
 640 }
 641
 642 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
 643   // TODO: Remove the callers of this signed version and delete.
 644   SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
 645   return createExpression(Addr);
 646 }
 647
 648 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
 649                                                  unsigned SizeInBytes) {
 650   uint64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBytes, SizeInBytes};
 651   return MDExpression::get(VMContext, Addr);
 652 }
 653
 654 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
 655                                        StringRef LinkageName, DIFile File,
 656                                        unsigned LineNo, DICompositeType Ty,
 657                                        bool isLocalToUnit, bool isDefinition,
 658                                        unsigned ScopeLine, unsigned Flags,
 659                                        bool isOptimized, Function *Fn,
 660                                        MDNode *TParams, MDNode *Decl) {
 661   // dragonegg does not generate identifier for types, so using an empty map
 662   // to resolve the context should be fine.
 663   DITypeIdentifierMap EmptyMap;
 664   return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
 665                         LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
 666                         Flags, isOptimized, Fn, TParams, Decl);
 667 }
 668
 669 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
 670                                        StringRef LinkageName, DIFile File,
 671                                        unsigned LineNo, DICompositeType Ty,
 672                                        bool isLocalToUnit, bool isDefinition,
 673                                        unsigned ScopeLine, unsigned Flags,
 674                                        bool isOptimized, Function *Fn,
 675                                        MDNode *TParams, MDNode *Decl) {
 676   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
 677          "function types should be subroutines");
 678   auto *Node = MDSubprogram::get(
 679       VMContext, MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))),
 680       Name, LinkageName, File.get(), LineNo,
 681       cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit, isDefinition,
 682       ScopeLine, nullptr, 0, 0, Flags, isOptimized, getConstantOrNull(Fn),
 683       cast_or_null<MDTuple>(TParams), cast_or_null<MDSubprogram>(Decl),
 684       MDTuple::getTemporary(VMContext, None).release());
 685
 686   if (isDefinition)
 687     AllSubprograms.push_back(Node);
 688   trackIfUnresolved(Node);
 689   return Node;
 690 }
 691
 692 DISubprogram
 693 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
 694                                      StringRef LinkageName, DIFile File,
 695                                      unsigned LineNo, DICompositeType Ty,
 696                                      bool isLocalToUnit, bool isDefinition,
 697                                      unsigned ScopeLine, unsigned Flags,
 698                                      bool isOptimized, Function *Fn,
 699                                      MDNode *TParams, MDNode *Decl) {
 700   return MDSubprogram::getTemporary(
 701              VMContext,
 702              MDScopeRef::get(DIScope(getNonCompileUnitScope(Context))), Name,
 703              LinkageName, File.get(), LineNo,
 704              cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit,
 705              isDefinition, ScopeLine, nullptr, 0, 0, Flags, isOptimized,
 706              getConstantOrNull(Fn), cast_or_null<MDTuple>(TParams),
 707              cast_or_null<MDSubprogram>(Decl), nullptr)
 708       .release();
 709 }
 710
 711 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
 712                                      StringRef LinkageName, DIFile F,
 713                                      unsigned LineNo, DICompositeType Ty,
 714                                      bool isLocalToUnit, bool isDefinition,
 715                                      unsigned VK, unsigned VIndex,
 716                                      DIType VTableHolder, unsigned Flags,
 717                                      bool isOptimized, Function *Fn,
 718                                      MDNode *TParam) {
 719   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
 720          "function types should be subroutines");
 721   assert(getNonCompileUnitScope(Context) &&
 722          "Methods should have both a Context and a context that isn't "
 723          "the compile unit.");
 724   // FIXME: Do we want to use different scope/lines?
 725   auto *SP = MDSubprogram::get(
 726       VMContext, MDScopeRef::get(cast<MDScope>(Context)), Name, LinkageName,
 727       F.get(), LineNo, cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit,
 728       isDefinition, LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags,
 729       isOptimized, getConstantOrNull(Fn), cast_or_null<MDTuple>(TParam),
 730       nullptr, nullptr);
 731
 732   if (isDefinition)
 733     AllSubprograms.push_back(SP);
 734   trackIfUnresolved(SP);
 735   return SP;
 736 }
 737
 738 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
 739                                        DIFile File, unsigned LineNo) {
 740   return MDNamespace::get(VMContext, getNonCompileUnitScope(Scope), File, Name,
 741                           LineNo);
 742 }
 743
 744 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
 745                                                      DIFile File,
 746                                                      unsigned Discriminator) {
 747   return MDLexicalBlockFile::get(VMContext, Scope, File.getFileNode(),
 748                                  Discriminator);
 749 }
 750
 751 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
 752                                              unsigned Line, unsigned Col) {
 753   // Make these distinct, to avoid merging two lexical blocks on the same
 754   // file/line/column.
 755   return MDLexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope),
 756                                      File.getFileNode(), Line, Col);
 757 }
 758
 759 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
 760   assert(V && "no value passed to dbg intrinsic");
 761   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
 762 }
 763
 764 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
 765                                       DIExpression Expr,
 766                                       Instruction *InsertBefore) {
 767   assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
 768   if (!DeclareFn)
 769     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 770
 771   trackIfUnresolved(VarInfo);
 772   trackIfUnresolved(Expr);
 773   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
 774                    MetadataAsValue::get(VMContext, VarInfo),
 775                    MetadataAsValue::get(VMContext, Expr)};
 776   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
 777 }
 778
 779 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
 780                                       DIExpression Expr,
 781                                       BasicBlock *InsertAtEnd) {
 782   assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
 783   if (!DeclareFn)
 784     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 785
 786   trackIfUnresolved(VarInfo);
 787   trackIfUnresolved(Expr);
 788   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
 789                    MetadataAsValue::get(VMContext, VarInfo),
 790                    MetadataAsValue::get(VMContext, Expr)};
 791
 792   // If this block already has a terminator then insert this intrinsic
 793   // before the terminator.
 794   if (TerminatorInst *T = InsertAtEnd->getTerminator())
 795     return CallInst::Create(DeclareFn, Args, "", T);
 796   else
 797     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
 798 }
 799
 800 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
 801                                                 DIVariable VarInfo,
 802                                                 DIExpression Expr,
 803                                                 Instruction *InsertBefore) {
 804   assert(V && "no value passed to dbg.value");
 805   assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
 806   if (!ValueFn)
 807     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 808
 809   trackIfUnresolved(VarInfo);
 810   trackIfUnresolved(Expr);
 811   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
 812                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
 813                    MetadataAsValue::get(VMContext, VarInfo),
 814                    MetadataAsValue::get(VMContext, Expr)};
 815   return CallInst::Create(ValueFn, Args, "", InsertBefore);
 816 }
 817
 818 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
 819                                                 DIVariable VarInfo,
 820                                                 DIExpression Expr,
 821                                                 BasicBlock *InsertAtEnd) {
 822   assert(V && "no value passed to dbg.value");
 823   assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
 824   if (!ValueFn)
 825     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 826
 827   trackIfUnresolved(VarInfo);
 828   trackIfUnresolved(Expr);
 829   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
 830                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
 831                    MetadataAsValue::get(VMContext, VarInfo),
 832                    MetadataAsValue::get(VMContext, Expr)};
 833   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
 834 }
 835
 836 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
 837   T.setContainingType(VTableHolder);
 838
 839   // If this didn't create a self-reference, just return.
 840   if (T != VTableHolder)
 841     return;
 842
 843   // Look for unresolved operands.  T will drop RAUW support, orphaning any
 844   // cycles underneath it.
 845   if (T->isResolved())
 846     for (const MDOperand &O : T->operands())
 847       if (auto *N = dyn_cast_or_null<MDNode>(O))
 848         trackIfUnresolved(N);
 849 }
 850
 851 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
 852                               DIArray TParams) {
 853   T.setArrays(Elements, TParams);
 854
 855   // If T isn't resolved, there's no problem.
 856   if (!T->isResolved())
 857     return;
 858
 859   // If "T" is resolved, it may be due to a self-reference cycle.  Track the
 860   // arrays explicitly if they're unresolved, or else the cycles will be
 861   // orphaned.
 862   if (Elements)
 863     trackIfUnresolved(Elements);
 864   if (TParams)
 865     trackIfUnresolved(TParams);
 866 }