lib/IR/Module.cpp

   1 //===- Module.cpp - Implement the Module class ----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the Module class for the IR library.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/IR/Module.h"
  14 #include "SymbolTableListTraitsImpl.h"
  15 #include "llvm/ADT/Optional.h"
  16 #include "llvm/ADT/SmallPtrSet.h"
  17 #include "llvm/ADT/SmallString.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/StringMap.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/ADT/Twine.h"
  22 #include "llvm/IR/Attributes.h"
  23 #include "llvm/IR/Comdat.h"
  24 #include "llvm/IR/Constants.h"
  25 #include "llvm/IR/DataLayout.h"
  26 #include "llvm/IR/DebugInfoMetadata.h"
  27 #include "llvm/IR/DerivedTypes.h"
  28 #include "llvm/IR/Function.h"
  29 #include "llvm/IR/GVMaterializer.h"
  30 #include "llvm/IR/GlobalAlias.h"
  31 #include "llvm/IR/GlobalIFunc.h"
  32 #include "llvm/IR/GlobalValue.h"
  33 #include "llvm/IR/GlobalVariable.h"
  34 #include "llvm/IR/LLVMContext.h"
  35 #include "llvm/IR/Metadata.h"
  36 #include "llvm/IR/SymbolTableListTraits.h"
  37 #include "llvm/IR/Type.h"
  38 #include "llvm/IR/TypeFinder.h"
  39 #include "llvm/IR/Value.h"
  40 #include "llvm/IR/ValueSymbolTable.h"
  41 #include "llvm/Pass.h"
  42 #include "llvm/Support/Casting.h"
  43 #include "llvm/Support/CodeGen.h"
  44 #include "llvm/Support/Error.h"
  45 #include "llvm/Support/MemoryBuffer.h"
  46 #include "llvm/Support/Path.h"
  47 #include "llvm/Support/RandomNumberGenerator.h"
  48 #include "llvm/Support/VersionTuple.h"
  49 #include <algorithm>
  50 #include <cassert>
  51 #include <cstdint>
  52 #include <memory>
  53 #include <utility>
  54 #include <vector>
  55
  56 using namespace llvm;
  57
  58 //===----------------------------------------------------------------------===//
  59 // Methods to implement the globals and functions lists.
  60 //
  61
  62 // Explicit instantiations of SymbolTableListTraits since some of the methods
  63 // are not in the public header file.
  64 template class llvm::SymbolTableListTraits<Function>;
  65 template class llvm::SymbolTableListTraits<GlobalVariable>;
  66 template class llvm::SymbolTableListTraits<GlobalAlias>;
  67 template class llvm::SymbolTableListTraits<GlobalIFunc>;
  68
  69 //===----------------------------------------------------------------------===//
  70 // Primitive Module methods.
  71 //
  72
  73 Module::Module(StringRef MID, LLVMContext &C)
  74     : Context(C), Materializer(), ModuleID(MID), SourceFileName(MID), DL("") {
  75   ValSymTab = new ValueSymbolTable();
  76   NamedMDSymTab = new StringMap<NamedMDNode *>();
  77   Context.addModule(this);
  78 }
  79
  80 Module::~Module() {
  81   Context.removeModule(this);
  82   dropAllReferences();
  83   GlobalList.clear();
  84   FunctionList.clear();
  85   AliasList.clear();
  86   IFuncList.clear();
  87   NamedMDList.clear();
  88   delete ValSymTab;
  89   delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
  90 }
  91
  92 std::unique_ptr<RandomNumberGenerator> Module::createRNG(const Pass* P) const {
  93   SmallString<32> Salt(P->getPassName());
  94
  95   // This RNG is guaranteed to produce the same random stream only
  96   // when the Module ID and thus the input filename is the same. This
  97   // might be problematic if the input filename extension changes
  98   // (e.g. from .c to .bc or .ll).
  99   //
 100   // We could store this salt in NamedMetadata, but this would make
 101   // the parameter non-const. This would unfortunately make this
 102   // interface unusable by any Machine passes, since they only have a
 103   // const reference to their IR Module. Alternatively we can always
 104   // store salt metadata from the Module constructor.
 105   Salt += sys::path::filename(getModuleIdentifier());
 106
 107   return std::unique_ptr<RandomNumberGenerator>(new RandomNumberGenerator(Salt));
 108 }
 109
 110 /// getNamedValue - Return the first global value in the module with
 111 /// the specified name, of arbitrary type.  This method returns null
 112 /// if a global with the specified name is not found.
 113 GlobalValue *Module::getNamedValue(StringRef Name) const {
 114   return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
 115 }
 116
 117 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
 118 /// This ID is uniqued across modules in the current LLVMContext.
 119 unsigned Module::getMDKindID(StringRef Name) const {
 120   return Context.getMDKindID(Name);
 121 }
 122
 123 /// getMDKindNames - Populate client supplied SmallVector with the name for
 124 /// custom metadata IDs registered in this LLVMContext.   ID #0 is not used,
 125 /// so it is filled in as an empty string.
 126 void Module::getMDKindNames(SmallVectorImpl<StringRef> &Result) const {
 127   return Context.getMDKindNames(Result);
 128 }
 129
 130 void Module::getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const {
 131   return Context.getOperandBundleTags(Result);
 132 }
 133
 134 //===----------------------------------------------------------------------===//
 135 // Methods for easy access to the functions in the module.
 136 //
 137
 138 // getOrInsertFunction - Look up the specified function in the module symbol
 139 // table.  If it does not exist, add a prototype for the function and return
 140 // it.  This is nice because it allows most passes to get away with not handling
 141 // the symbol table directly for this common task.
 142 //
 143 FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty,
 144                                            AttributeList AttributeList) {
 145   // See if we have a definition for the specified function already.
 146   GlobalValue *F = getNamedValue(Name);
 147   if (!F) {
 148     // Nope, add it
 149     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage,
 150                                      DL.getProgramAddressSpace(), Name);
 151     if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
 152       New->setAttributes(AttributeList);
 153     FunctionList.push_back(New);
 154     return {Ty, New}; // Return the new prototype.
 155   }
 156
 157   // If the function exists but has the wrong type, return a bitcast to the
 158   // right type.
 159   auto *PTy = PointerType::get(Ty, F->getAddressSpace());
 160   if (F->getType() != PTy)
 161     return {Ty, ConstantExpr::getBitCast(F, PTy)};
 162
 163   // Otherwise, we just found the existing function or a prototype.
 164   return {Ty, F};
 165 }
 166
 167 FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty) {
 168   return getOrInsertFunction(Name, Ty, AttributeList());
 169 }
 170
 171 // getFunction - Look up the specified function in the module symbol table.
 172 // If it does not exist, return null.
 173 //
 174 Function *Module::getFunction(StringRef Name) const {
 175   return dyn_cast_or_null<Function>(getNamedValue(Name));
 176 }
 177
 178 //===----------------------------------------------------------------------===//
 179 // Methods for easy access to the global variables in the module.
 180 //
 181
 182 /// getGlobalVariable - Look up the specified global variable in the module
 183 /// symbol table.  If it does not exist, return null.  The type argument
 184 /// should be the underlying type of the global, i.e., it should not have
 185 /// the top-level PointerType, which represents the address of the global.
 186 /// If AllowLocal is set to true, this function will return types that
 187 /// have an local. By default, these types are not returned.
 188 ///
 189 GlobalVariable *Module::getGlobalVariable(StringRef Name,
 190                                           bool AllowLocal) const {
 191   if (GlobalVariable *Result =
 192       dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
 193     if (AllowLocal || !Result->hasLocalLinkage())
 194       return Result;
 195   return nullptr;
 196 }
 197
 198 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
 199 ///   1. If it does not exist, add a declaration of the global and return it.
 200 ///   2. Else, the global exists but has the wrong type: return the function
 201 ///      with a constantexpr cast to the right type.
 202 ///   3. Finally, if the existing global is the correct declaration, return the
 203 ///      existing global.
 204 Constant *Module::getOrInsertGlobal(
 205     StringRef Name, Type *Ty,
 206     function_ref<GlobalVariable *()> CreateGlobalCallback) {
 207   // See if we have a definition for the specified global already.
 208   GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
 209   if (!GV)
 210     GV = CreateGlobalCallback();
 211   assert(GV && "The CreateGlobalCallback is expected to create a global");
 212
 213   // If the variable exists but has the wrong type, return a bitcast to the
 214   // right type.
 215   Type *GVTy = GV->getType();
 216   PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace());
 217   if (GVTy != PTy)
 218     return ConstantExpr::getBitCast(GV, PTy);
 219
 220   // Otherwise, we just found the existing function or a prototype.
 221   return GV;
 222 }
 223
 224 // Overload to construct a global variable using its constructor's defaults.
 225 Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) {
 226   return getOrInsertGlobal(Name, Ty, [&] {
 227     return new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
 228                               nullptr, Name);
 229   });
 230 }
 231
 232 //===----------------------------------------------------------------------===//
 233 // Methods for easy access to the global variables in the module.
 234 //
 235
 236 // getNamedAlias - Look up the specified global in the module symbol table.
 237 // If it does not exist, return null.
 238 //
 239 GlobalAlias *Module::getNamedAlias(StringRef Name) const {
 240   return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
 241 }
 242
 243 GlobalIFunc *Module::getNamedIFunc(StringRef Name) const {
 244   return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name));
 245 }
 246
 247 /// getNamedMetadata - Return the first NamedMDNode in the module with the
 248 /// specified name. This method returns null if a NamedMDNode with the
 249 /// specified name is not found.
 250 NamedMDNode *Module::getNamedMetadata(const Twine &Name) const {
 251   SmallString<256> NameData;
 252   StringRef NameRef = Name.toStringRef(NameData);
 253   return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef);
 254 }
 255
 256 /// getOrInsertNamedMetadata - Return the first named MDNode in the module
 257 /// with the specified name. This method returns a new NamedMDNode if a
 258 /// NamedMDNode with the specified name is not found.
 259 NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) {
 260   NamedMDNode *&NMD =
 261     (*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name];
 262   if (!NMD) {
 263     NMD = new NamedMDNode(Name);
 264     NMD->setParent(this);
 265     NamedMDList.push_back(NMD);
 266   }
 267   return NMD;
 268 }
 269
 270 /// eraseNamedMetadata - Remove the given NamedMDNode from this module and
 271 /// delete it.
 272 void Module::eraseNamedMetadata(NamedMDNode *NMD) {
 273   static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName());
 274   NamedMDList.erase(NMD->getIterator());
 275 }
 276
 277 bool Module::isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB) {
 278   if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
 279     uint64_t Val = Behavior->getLimitedValue();
 280     if (Val >= ModFlagBehaviorFirstVal && Val <= ModFlagBehaviorLastVal) {
 281       MFB = static_cast<ModFlagBehavior>(Val);
 282       return true;
 283     }
 284   }
 285   return false;
 286 }
 287
 288 /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
 289 void Module::
 290 getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const {
 291   const NamedMDNode *ModFlags = getModuleFlagsMetadata();
 292   if (!ModFlags) return;
 293
 294   for (const MDNode *Flag : ModFlags->operands()) {
 295     ModFlagBehavior MFB;
 296     if (Flag->getNumOperands() >= 3 &&
 297         isValidModFlagBehavior(Flag->getOperand(0), MFB) &&
 298         dyn_cast_or_null<MDString>(Flag->getOperand(1))) {
 299       // Check the operands of the MDNode before accessing the operands.
 300       // The verifier will actually catch these failures.
 301       MDString *Key = cast<MDString>(Flag->getOperand(1));
 302       Metadata *Val = Flag->getOperand(2);
 303       Flags.push_back(ModuleFlagEntry(MFB, Key, Val));
 304     }
 305   }
 306 }
 307
 308 /// Return the corresponding value if Key appears in module flags, otherwise
 309 /// return null.
 310 Metadata *Module::getModuleFlag(StringRef Key) const {
 311   SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
 312   getModuleFlagsMetadata(ModuleFlags);
 313   for (const ModuleFlagEntry &MFE : ModuleFlags) {
 314     if (Key == MFE.Key->getString())
 315       return MFE.Val;
 316   }
 317   return nullptr;
 318 }
 319
 320 /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
 321 /// represents module-level flags. This method returns null if there are no
 322 /// module-level flags.
 323 NamedMDNode *Module::getModuleFlagsMetadata() const {
 324   return getNamedMetadata("llvm.module.flags");
 325 }
 326
 327 /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
 328 /// represents module-level flags. If module-level flags aren't found, it
 329 /// creates the named metadata that contains them.
 330 NamedMDNode *Module::getOrInsertModuleFlagsMetadata() {
 331   return getOrInsertNamedMetadata("llvm.module.flags");
 332 }
 333
 334 /// addModuleFlag - Add a module-level flag to the module-level flags
 335 /// metadata. It will create the module-level flags named metadata if it doesn't
 336 /// already exist.
 337 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
 338                            Metadata *Val) {
 339   Type *Int32Ty = Type::getInt32Ty(Context);
 340   Metadata *Ops[3] = {
 341       ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
 342       MDString::get(Context, Key), Val};
 343   getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops));
 344 }
 345 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
 346                            Constant *Val) {
 347   addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
 348 }
 349 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
 350                            uint32_t Val) {
 351   Type *Int32Ty = Type::getInt32Ty(Context);
 352   addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
 353 }
 354 void Module::addModuleFlag(MDNode *Node) {
 355   assert(Node->getNumOperands() == 3 &&
 356          "Invalid number of operands for module flag!");
 357   assert(mdconst::hasa<ConstantInt>(Node->getOperand(0)) &&
 358          isa<MDString>(Node->getOperand(1)) &&
 359          "Invalid operand types for module flag!");
 360   getOrInsertModuleFlagsMetadata()->addOperand(Node);
 361 }
 362
 363 void Module::setDataLayout(StringRef Desc) {
 364   DL.reset(Desc);
 365 }
 366
 367 void Module::setDataLayout(const DataLayout &Other) { DL = Other; }
 368
 369 const DataLayout &Module::getDataLayout() const { return DL; }
 370
 371 DICompileUnit *Module::debug_compile_units_iterator::operator*() const {
 372   return cast<DICompileUnit>(CUs->getOperand(Idx));
 373 }
 374 DICompileUnit *Module::debug_compile_units_iterator::operator->() const {
 375   return cast<DICompileUnit>(CUs->getOperand(Idx));
 376 }
 377
 378 void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
 379   while (CUs && (Idx < CUs->getNumOperands()) &&
 380          ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
 381     ++Idx;
 382 }
 383
 384 //===----------------------------------------------------------------------===//
 385 // Methods to control the materialization of GlobalValues in the Module.
 386 //
 387 void Module::setMaterializer(GVMaterializer *GVM) {
 388   assert(!Materializer &&
 389          "Module already has a GVMaterializer.  Call materializeAll"
 390          " to clear it out before setting another one.");
 391   Materializer.reset(GVM);
 392 }
 393
 394 Error Module::materialize(GlobalValue *GV) {
 395   if (!Materializer)
 396     return Error::success();
 397
 398   return Materializer->materialize(GV);
 399 }
 400
 401 Error Module::materializeAll() {
 402   if (!Materializer)
 403     return Error::success();
 404   std::unique_ptr<GVMaterializer> M = std::move(Materializer);
 405   return M->materializeModule();
 406 }
 407
 408 Error Module::materializeMetadata() {
 409   if (!Materializer)
 410     return Error::success();
 411   return Materializer->materializeMetadata();
 412 }
 413
 414 //===----------------------------------------------------------------------===//
 415 // Other module related stuff.
 416 //
 417
 418 std::vector<StructType *> Module::getIdentifiedStructTypes() const {
 419   // If we have a materializer, it is possible that some unread function
 420   // uses a type that is currently not visible to a TypeFinder, so ask
 421   // the materializer which types it created.
 422   if (Materializer)
 423     return Materializer->getIdentifiedStructTypes();
 424
 425   std::vector<StructType *> Ret;
 426   TypeFinder SrcStructTypes;
 427   SrcStructTypes.run(*this, true);
 428   Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
 429   return Ret;
 430 }
 431
 432 // dropAllReferences() - This function causes all the subelements to "let go"
 433 // of all references that they are maintaining.  This allows one to 'delete' a
 434 // whole module at a time, even though there may be circular references... first
 435 // all references are dropped, and all use counts go to zero.  Then everything
 436 // is deleted for real.  Note that no operations are valid on an object that
 437 // has "dropped all references", except operator delete.
 438 //
 439 void Module::dropAllReferences() {
 440   for (Function &F : *this)
 441     F.dropAllReferences();
 442
 443   for (GlobalVariable &GV : globals())
 444     GV.dropAllReferences();
 445
 446   for (GlobalAlias &GA : aliases())
 447     GA.dropAllReferences();
 448
 449   for (GlobalIFunc &GIF : ifuncs())
 450     GIF.dropAllReferences();
 451 }
 452
 453 unsigned Module::getNumberRegisterParameters() const {
 454   auto *Val =
 455       cast_or_null<ConstantAsMetadata>(getModuleFlag("NumRegisterParameters"));
 456   if (!Val)
 457     return 0;
 458   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 459 }
 460
 461 unsigned Module::getDwarfVersion() const {
 462   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
 463   if (!Val)
 464     return 0;
 465   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 466 }
 467
 468 unsigned Module::getCodeViewFlag() const {
 469   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
 470   if (!Val)
 471     return 0;
 472   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 473 }
 474
 475 unsigned Module::getInstructionCount() {
 476   unsigned NumInstrs = 0;
 477   for (Function &F : FunctionList)
 478     NumInstrs += F.getInstructionCount();
 479   return NumInstrs;
 480 }
 481
 482 Comdat *Module::getOrInsertComdat(StringRef Name) {
 483   auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
 484   Entry.second.Name = &Entry;
 485   return &Entry.second;
 486 }
 487
 488 PICLevel::Level Module::getPICLevel() const {
 489   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
 490
 491   if (!Val)
 492     return PICLevel::NotPIC;
 493
 494   return static_cast<PICLevel::Level>(
 495       cast<ConstantInt>(Val->getValue())->getZExtValue());
 496 }
 497
 498 void Module::setPICLevel(PICLevel::Level PL) {
 499   addModuleFlag(ModFlagBehavior::Max, "PIC Level", PL);
 500 }
 501
 502 PIELevel::Level Module::getPIELevel() const {
 503   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
 504
 505   if (!Val)
 506     return PIELevel::Default;
 507
 508   return static_cast<PIELevel::Level>(
 509       cast<ConstantInt>(Val->getValue())->getZExtValue());
 510 }
 511
 512 void Module::setPIELevel(PIELevel::Level PL) {
 513   addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
 514 }
 515
 516 Optional<CodeModel::Model> Module::getCodeModel() const {
 517   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Code Model"));
 518
 519   if (!Val)
 520     return None;
 521
 522   return static_cast<CodeModel::Model>(
 523       cast<ConstantInt>(Val->getValue())->getZExtValue());
 524 }
 525
 526 void Module::setCodeModel(CodeModel::Model CL) {
 527   // Linking object files with different code models is undefined behavior
 528   // because the compiler would have to generate additional code (to span
 529   // longer jumps) if a larger code model is used with a smaller one.
 530   // Therefore we will treat attempts to mix code models as an error.
 531   addModuleFlag(ModFlagBehavior::Error, "Code Model", CL);
 532 }
 533
 534 void Module::setProfileSummary(Metadata *M, ProfileSummary::Kind Kind) {
 535   if (Kind == ProfileSummary::PSK_CSInstr)
 536     addModuleFlag(ModFlagBehavior::Error, "CSProfileSummary", M);
 537   else
 538     addModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
 539 }
 540
 541 Metadata *Module::getProfileSummary(bool IsCS) {
 542   return (IsCS ? getModuleFlag("CSProfileSummary")
 543                : getModuleFlag("ProfileSummary"));
 544 }
 545
 546 void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
 547   OwnedMemoryBuffer = std::move(MB);
 548 }
 549
 550 bool Module::getRtLibUseGOT() const {
 551   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
 552   return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
 553 }
 554
 555 void Module::setRtLibUseGOT() {
 556   addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
 557 }
 558
 559 void Module::setSDKVersion(const VersionTuple &V) {
 560   SmallVector<unsigned, 3> Entries;
 561   Entries.push_back(V.getMajor());
 562   if (auto Minor = V.getMinor()) {
 563     Entries.push_back(*Minor);
 564     if (auto Subminor = V.getSubminor())
 565       Entries.push_back(*Subminor);
 566     // Ignore the 'build' component as it can't be represented in the object
 567     // file.
 568   }
 569   addModuleFlag(ModFlagBehavior::Warning, "SDK Version",
 570                 ConstantDataArray::get(Context, Entries));
 571 }
 572
 573 VersionTuple Module::getSDKVersion() const {
 574   auto *CM = dyn_cast_or_null<ConstantAsMetadata>(getModuleFlag("SDK Version"));
 575   if (!CM)
 576     return {};
 577   auto *Arr = dyn_cast_or_null<ConstantDataArray>(CM->getValue());
 578   if (!Arr)
 579     return {};
 580   auto getVersionComponent = [&](unsigned Index) -> Optional<unsigned> {
 581     if (Index >= Arr->getNumElements())
 582       return None;
 583     return (unsigned)Arr->getElementAsInteger(Index);
 584   };
 585   auto Major = getVersionComponent(0);
 586   if (!Major)
 587     return {};
 588   VersionTuple Result = VersionTuple(*Major);
 589   if (auto Minor = getVersionComponent(1)) {
 590     Result = VersionTuple(*Major, *Minor);
 591     if (auto Subminor = getVersionComponent(2)) {
 592       Result = VersionTuple(*Major, *Minor, *Subminor);
 593     }
 594   }
 595   return Result;
 596 }
 597
 598 GlobalVariable *llvm::collectUsedGlobalVariables(
 599     const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
 600   const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
 601   GlobalVariable *GV = M.getGlobalVariable(Name);
 602   if (!GV || !GV->hasInitializer())
 603     return GV;
 604
 605   const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
 606   for (Value *Op : Init->operands()) {
 607     GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
 608     Set.insert(G);
 609   }
 610   return GV;
 611 }