xref: /freebsd/contrib/llvm-project/llvm/lib/IR/Module.cpp (revision f126890ac5386406dadf7c4cfa9566cbb56537c5)
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/SmallString.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringMap.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/Twine.h"
20 #include "llvm/IR/Attributes.h"
21 #include "llvm/IR/Comdat.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/DataLayout.h"
24 #include "llvm/IR/DebugInfoMetadata.h"
25 #include "llvm/IR/DerivedTypes.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/IR/GVMaterializer.h"
28 #include "llvm/IR/GlobalAlias.h"
29 #include "llvm/IR/GlobalIFunc.h"
30 #include "llvm/IR/GlobalValue.h"
31 #include "llvm/IR/GlobalVariable.h"
32 #include "llvm/IR/LLVMContext.h"
33 #include "llvm/IR/Metadata.h"
34 #include "llvm/IR/ModuleSummaryIndex.h"
35 #include "llvm/IR/SymbolTableListTraits.h"
36 #include "llvm/IR/Type.h"
37 #include "llvm/IR/TypeFinder.h"
38 #include "llvm/IR/Value.h"
39 #include "llvm/IR/ValueSymbolTable.h"
40 #include "llvm/Support/Casting.h"
41 #include "llvm/Support/CodeGen.h"
42 #include "llvm/Support/Error.h"
43 #include "llvm/Support/MemoryBuffer.h"
44 #include "llvm/Support/Path.h"
45 #include "llvm/Support/RandomNumberGenerator.h"
46 #include "llvm/Support/VersionTuple.h"
47 #include <algorithm>
48 #include <cassert>
49 #include <cstdint>
50 #include <memory>
51 #include <optional>
52 #include <utility>
53 #include <vector>
54 
55 using namespace llvm;
56 
57 //===----------------------------------------------------------------------===//
58 // Methods to implement the globals and functions lists.
59 //
60 
61 // Explicit instantiations of SymbolTableListTraits since some of the methods
62 // are not in the public header file.
63 template class llvm::SymbolTableListTraits<Function>;
64 template class llvm::SymbolTableListTraits<GlobalVariable>;
65 template class llvm::SymbolTableListTraits<GlobalAlias>;
66 template class llvm::SymbolTableListTraits<GlobalIFunc>;
67 
68 //===----------------------------------------------------------------------===//
69 // Primitive Module methods.
70 //
71 
72 Module::Module(StringRef MID, LLVMContext &C)
73     : Context(C), ValSymTab(std::make_unique<ValueSymbolTable>(-1)),
74       ModuleID(std::string(MID)), SourceFileName(std::string(MID)), DL("") {
75   Context.addModule(this);
76 }
77 
78 Module::~Module() {
79   Context.removeModule(this);
80   dropAllReferences();
81   GlobalList.clear();
82   FunctionList.clear();
83   AliasList.clear();
84   IFuncList.clear();
85 }
86 
87 std::unique_ptr<RandomNumberGenerator>
88 Module::createRNG(const StringRef Name) const {
89   SmallString<32> Salt(Name);
90 
91   // This RNG is guaranteed to produce the same random stream only
92   // when the Module ID and thus the input filename is the same. This
93   // might be problematic if the input filename extension changes
94   // (e.g. from .c to .bc or .ll).
95   //
96   // We could store this salt in NamedMetadata, but this would make
97   // the parameter non-const. This would unfortunately make this
98   // interface unusable by any Machine passes, since they only have a
99   // const reference to their IR Module. Alternatively we can always
100   // store salt metadata from the Module constructor.
101   Salt += sys::path::filename(getModuleIdentifier());
102 
103   return std::unique_ptr<RandomNumberGenerator>(
104       new RandomNumberGenerator(Salt));
105 }
106 
107 /// getNamedValue - Return the first global value in the module with
108 /// the specified name, of arbitrary type.  This method returns null
109 /// if a global with the specified name is not found.
110 GlobalValue *Module::getNamedValue(StringRef Name) const {
111   return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
112 }
113 
114 unsigned Module::getNumNamedValues() const {
115   return getValueSymbolTable().size();
116 }
117 
118 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
119 /// This ID is uniqued across modules in the current LLVMContext.
120 unsigned Module::getMDKindID(StringRef Name) const {
121   return Context.getMDKindID(Name);
122 }
123 
124 /// getMDKindNames - Populate client supplied SmallVector with the name for
125 /// custom metadata IDs registered in this LLVMContext.   ID #0 is not used,
126 /// so it is filled in as an empty string.
127 void Module::getMDKindNames(SmallVectorImpl<StringRef> &Result) const {
128   return Context.getMDKindNames(Result);
129 }
130 
131 void Module::getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const {
132   return Context.getOperandBundleTags(Result);
133 }
134 
135 //===----------------------------------------------------------------------===//
136 // Methods for easy access to the functions in the module.
137 //
138 
139 // getOrInsertFunction - Look up the specified function in the module symbol
140 // table.  If it does not exist, add a prototype for the function and return
141 // it.  This is nice because it allows most passes to get away with not handling
142 // the symbol table directly for this common task.
143 //
144 FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty,
145                                            AttributeList AttributeList) {
146   // See if we have a definition for the specified function already.
147   GlobalValue *F = getNamedValue(Name);
148   if (!F) {
149     // Nope, add it
150     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage,
151                                      DL.getProgramAddressSpace(), Name);
152     if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
153       New->setAttributes(AttributeList);
154     FunctionList.push_back(New);
155     return {Ty, New}; // Return the new prototype.
156   }
157 
158   // If the function exists but has the wrong type, return a bitcast to the
159   // right type.
160   auto *PTy = PointerType::get(Ty, F->getAddressSpace());
161   if (F->getType() != PTy)
162     return {Ty, ConstantExpr::getBitCast(F, PTy)};
163 
164   // Otherwise, we just found the existing function or a prototype.
165   return {Ty, F};
166 }
167 
168 FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty) {
169   return getOrInsertFunction(Name, Ty, AttributeList());
170 }
171 
172 // getFunction - Look up the specified function in the module symbol table.
173 // If it does not exist, return null.
174 //
175 Function *Module::getFunction(StringRef Name) const {
176   return dyn_cast_or_null<Function>(getNamedValue(Name));
177 }
178 
179 //===----------------------------------------------------------------------===//
180 // Methods for easy access to the global variables in the module.
181 //
182 
183 /// getGlobalVariable - Look up the specified global variable in the module
184 /// symbol table.  If it does not exist, return null.  The type argument
185 /// should be the underlying type of the global, i.e., it should not have
186 /// the top-level PointerType, which represents the address of the global.
187 /// If AllowLocal is set to true, this function will return types that
188 /// have an local. By default, these types are not returned.
189 ///
190 GlobalVariable *Module::getGlobalVariable(StringRef Name,
191                                           bool AllowLocal) const {
192   if (GlobalVariable *Result =
193       dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
194     if (AllowLocal || !Result->hasLocalLinkage())
195       return Result;
196   return nullptr;
197 }
198 
199 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
200 ///   1. If it does not exist, add a declaration of the global and return it.
201 ///   2. Else, the global exists but has the wrong type: return the function
202 ///      with a constantexpr cast to the right type.
203 ///   3. Finally, if the existing global is the correct declaration, return the
204 ///      existing global.
205 Constant *Module::getOrInsertGlobal(
206     StringRef Name, Type *Ty,
207     function_ref<GlobalVariable *()> CreateGlobalCallback) {
208   // See if we have a definition for the specified global already.
209   GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
210   if (!GV)
211     GV = CreateGlobalCallback();
212   assert(GV && "The CreateGlobalCallback is expected to create a global");
213 
214   // If the variable exists but has the wrong type, return a bitcast to the
215   // right type.
216   Type *GVTy = GV->getType();
217   PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace());
218   if (GVTy != PTy)
219     return ConstantExpr::getBitCast(GV, PTy);
220 
221   // Otherwise, we just found the existing function or a prototype.
222   return GV;
223 }
224 
225 // Overload to construct a global variable using its constructor's defaults.
226 Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) {
227   return getOrInsertGlobal(Name, Ty, [&] {
228     return new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
229                               nullptr, Name);
230   });
231 }
232 
233 //===----------------------------------------------------------------------===//
234 // Methods for easy access to the global variables in the module.
235 //
236 
237 // getNamedAlias - Look up the specified global in the module symbol table.
238 // If it does not exist, return null.
239 //
240 GlobalAlias *Module::getNamedAlias(StringRef Name) const {
241   return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
242 }
243 
244 GlobalIFunc *Module::getNamedIFunc(StringRef Name) const {
245   return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name));
246 }
247 
248 /// getNamedMetadata - Return the first NamedMDNode in the module with the
249 /// specified name. This method returns null if a NamedMDNode with the
250 /// specified name is not found.
251 NamedMDNode *Module::getNamedMetadata(const Twine &Name) const {
252   SmallString<256> NameData;
253   StringRef NameRef = Name.toStringRef(NameData);
254   return NamedMDSymTab.lookup(NameRef);
255 }
256 
257 /// getOrInsertNamedMetadata - Return the first named MDNode in the module
258 /// with the specified name. This method returns a new NamedMDNode if a
259 /// NamedMDNode with the specified name is not found.
260 NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) {
261   NamedMDNode *&NMD = NamedMDSymTab[Name];
262   if (!NMD) {
263     NMD = new NamedMDNode(Name);
264     NMD->setParent(this);
265     insertNamedMDNode(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   NamedMDSymTab.erase(NMD->getName());
274   eraseNamedMDNode(NMD);
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 bool Module::isValidModuleFlag(const MDNode &ModFlag, ModFlagBehavior &MFB,
289                                MDString *&Key, Metadata *&Val) {
290   if (ModFlag.getNumOperands() < 3)
291     return false;
292   if (!isValidModFlagBehavior(ModFlag.getOperand(0), MFB))
293     return false;
294   MDString *K = dyn_cast_or_null<MDString>(ModFlag.getOperand(1));
295   if (!K)
296     return false;
297   Key = K;
298   Val = ModFlag.getOperand(2);
299   return true;
300 }
301 
302 /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
303 void Module::
304 getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const {
305   const NamedMDNode *ModFlags = getModuleFlagsMetadata();
306   if (!ModFlags) return;
307 
308   for (const MDNode *Flag : ModFlags->operands()) {
309     ModFlagBehavior MFB;
310     MDString *Key = nullptr;
311     Metadata *Val = nullptr;
312     if (isValidModuleFlag(*Flag, MFB, Key, Val)) {
313       // Check the operands of the MDNode before accessing the operands.
314       // The verifier will actually catch these failures.
315       Flags.push_back(ModuleFlagEntry(MFB, Key, Val));
316     }
317   }
318 }
319 
320 /// Return the corresponding value if Key appears in module flags, otherwise
321 /// return null.
322 Metadata *Module::getModuleFlag(StringRef Key) const {
323   SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
324   getModuleFlagsMetadata(ModuleFlags);
325   for (const ModuleFlagEntry &MFE : ModuleFlags) {
326     if (Key == MFE.Key->getString())
327       return MFE.Val;
328   }
329   return nullptr;
330 }
331 
332 /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
333 /// represents module-level flags. This method returns null if there are no
334 /// module-level flags.
335 NamedMDNode *Module::getModuleFlagsMetadata() const {
336   return getNamedMetadata("llvm.module.flags");
337 }
338 
339 /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
340 /// represents module-level flags. If module-level flags aren't found, it
341 /// creates the named metadata that contains them.
342 NamedMDNode *Module::getOrInsertModuleFlagsMetadata() {
343   return getOrInsertNamedMetadata("llvm.module.flags");
344 }
345 
346 /// addModuleFlag - Add a module-level flag to the module-level flags
347 /// metadata. It will create the module-level flags named metadata if it doesn't
348 /// already exist.
349 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
350                            Metadata *Val) {
351   Type *Int32Ty = Type::getInt32Ty(Context);
352   Metadata *Ops[3] = {
353       ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
354       MDString::get(Context, Key), Val};
355   getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops));
356 }
357 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
358                            Constant *Val) {
359   addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
360 }
361 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
362                            uint32_t Val) {
363   Type *Int32Ty = Type::getInt32Ty(Context);
364   addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
365 }
366 void Module::addModuleFlag(MDNode *Node) {
367   assert(Node->getNumOperands() == 3 &&
368          "Invalid number of operands for module flag!");
369   assert(mdconst::hasa<ConstantInt>(Node->getOperand(0)) &&
370          isa<MDString>(Node->getOperand(1)) &&
371          "Invalid operand types for module flag!");
372   getOrInsertModuleFlagsMetadata()->addOperand(Node);
373 }
374 
375 void Module::setModuleFlag(ModFlagBehavior Behavior, StringRef Key,
376                            Metadata *Val) {
377   NamedMDNode *ModFlags = getOrInsertModuleFlagsMetadata();
378   // Replace the flag if it already exists.
379   for (unsigned I = 0, E = ModFlags->getNumOperands(); I != E; ++I) {
380     MDNode *Flag = ModFlags->getOperand(I);
381     ModFlagBehavior MFB;
382     MDString *K = nullptr;
383     Metadata *V = nullptr;
384     if (isValidModuleFlag(*Flag, MFB, K, V) && K->getString() == Key) {
385       Flag->replaceOperandWith(2, Val);
386       return;
387     }
388   }
389   addModuleFlag(Behavior, Key, Val);
390 }
391 
392 void Module::setDataLayout(StringRef Desc) {
393   DL.reset(Desc);
394 }
395 
396 void Module::setDataLayout(const DataLayout &Other) { DL = Other; }
397 
398 const DataLayout &Module::getDataLayout() const { return DL; }
399 
400 DICompileUnit *Module::debug_compile_units_iterator::operator*() const {
401   return cast<DICompileUnit>(CUs->getOperand(Idx));
402 }
403 DICompileUnit *Module::debug_compile_units_iterator::operator->() const {
404   return cast<DICompileUnit>(CUs->getOperand(Idx));
405 }
406 
407 void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
408   while (CUs && (Idx < CUs->getNumOperands()) &&
409          ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
410     ++Idx;
411 }
412 
413 iterator_range<Module::global_object_iterator> Module::global_objects() {
414   return concat<GlobalObject>(functions(), globals());
415 }
416 iterator_range<Module::const_global_object_iterator>
417 Module::global_objects() const {
418   return concat<const GlobalObject>(functions(), globals());
419 }
420 
421 iterator_range<Module::global_value_iterator> Module::global_values() {
422   return concat<GlobalValue>(functions(), globals(), aliases(), ifuncs());
423 }
424 iterator_range<Module::const_global_value_iterator>
425 Module::global_values() const {
426   return concat<const GlobalValue>(functions(), globals(), aliases(), ifuncs());
427 }
428 
429 //===----------------------------------------------------------------------===//
430 // Methods to control the materialization of GlobalValues in the Module.
431 //
432 void Module::setMaterializer(GVMaterializer *GVM) {
433   assert(!Materializer &&
434          "Module already has a GVMaterializer.  Call materializeAll"
435          " to clear it out before setting another one.");
436   Materializer.reset(GVM);
437 }
438 
439 Error Module::materialize(GlobalValue *GV) {
440   if (!Materializer)
441     return Error::success();
442 
443   return Materializer->materialize(GV);
444 }
445 
446 Error Module::materializeAll() {
447   if (!Materializer)
448     return Error::success();
449   std::unique_ptr<GVMaterializer> M = std::move(Materializer);
450   return M->materializeModule();
451 }
452 
453 Error Module::materializeMetadata() {
454   if (!Materializer)
455     return Error::success();
456   return Materializer->materializeMetadata();
457 }
458 
459 //===----------------------------------------------------------------------===//
460 // Other module related stuff.
461 //
462 
463 std::vector<StructType *> Module::getIdentifiedStructTypes() const {
464   // If we have a materializer, it is possible that some unread function
465   // uses a type that is currently not visible to a TypeFinder, so ask
466   // the materializer which types it created.
467   if (Materializer)
468     return Materializer->getIdentifiedStructTypes();
469 
470   std::vector<StructType *> Ret;
471   TypeFinder SrcStructTypes;
472   SrcStructTypes.run(*this, true);
473   Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
474   return Ret;
475 }
476 
477 std::string Module::getUniqueIntrinsicName(StringRef BaseName, Intrinsic::ID Id,
478                                            const FunctionType *Proto) {
479   auto Encode = [&BaseName](unsigned Suffix) {
480     return (Twine(BaseName) + "." + Twine(Suffix)).str();
481   };
482 
483   {
484     // fast path - the prototype is already known
485     auto UinItInserted = UniquedIntrinsicNames.insert({{Id, Proto}, 0});
486     if (!UinItInserted.second)
487       return Encode(UinItInserted.first->second);
488   }
489 
490   // Not known yet. A new entry was created with index 0. Check if there already
491   // exists a matching declaration, or select a new entry.
492 
493   // Start looking for names with the current known maximum count (or 0).
494   auto NiidItInserted = CurrentIntrinsicIds.insert({BaseName, 0});
495   unsigned Count = NiidItInserted.first->second;
496 
497   // This might be slow if a whole population of intrinsics already existed, but
498   // we cache the values for later usage.
499   std::string NewName;
500   while (true) {
501     NewName = Encode(Count);
502     GlobalValue *F = getNamedValue(NewName);
503     if (!F) {
504       // Reserve this entry for the new proto
505       UniquedIntrinsicNames[{Id, Proto}] = Count;
506       break;
507     }
508 
509     // A declaration with this name already exists. Remember it.
510     FunctionType *FT = dyn_cast<FunctionType>(F->getValueType());
511     auto UinItInserted = UniquedIntrinsicNames.insert({{Id, FT}, Count});
512     if (FT == Proto) {
513       // It was a declaration for our prototype. This entry was allocated in the
514       // beginning. Update the count to match the existing declaration.
515       UinItInserted.first->second = Count;
516       break;
517     }
518 
519     ++Count;
520   }
521 
522   NiidItInserted.first->second = Count + 1;
523 
524   return NewName;
525 }
526 
527 // dropAllReferences() - This function causes all the subelements to "let go"
528 // of all references that they are maintaining.  This allows one to 'delete' a
529 // whole module at a time, even though there may be circular references... first
530 // all references are dropped, and all use counts go to zero.  Then everything
531 // is deleted for real.  Note that no operations are valid on an object that
532 // has "dropped all references", except operator delete.
533 //
534 void Module::dropAllReferences() {
535   for (Function &F : *this)
536     F.dropAllReferences();
537 
538   for (GlobalVariable &GV : globals())
539     GV.dropAllReferences();
540 
541   for (GlobalAlias &GA : aliases())
542     GA.dropAllReferences();
543 
544   for (GlobalIFunc &GIF : ifuncs())
545     GIF.dropAllReferences();
546 }
547 
548 unsigned Module::getNumberRegisterParameters() const {
549   auto *Val =
550       cast_or_null<ConstantAsMetadata>(getModuleFlag("NumRegisterParameters"));
551   if (!Val)
552     return 0;
553   return cast<ConstantInt>(Val->getValue())->getZExtValue();
554 }
555 
556 unsigned Module::getDwarfVersion() const {
557   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
558   if (!Val)
559     return 0;
560   return cast<ConstantInt>(Val->getValue())->getZExtValue();
561 }
562 
563 bool Module::isDwarf64() const {
564   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("DWARF64"));
565   return Val && cast<ConstantInt>(Val->getValue())->isOne();
566 }
567 
568 unsigned Module::getCodeViewFlag() const {
569   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
570   if (!Val)
571     return 0;
572   return cast<ConstantInt>(Val->getValue())->getZExtValue();
573 }
574 
575 unsigned Module::getInstructionCount() const {
576   unsigned NumInstrs = 0;
577   for (const Function &F : FunctionList)
578     NumInstrs += F.getInstructionCount();
579   return NumInstrs;
580 }
581 
582 Comdat *Module::getOrInsertComdat(StringRef Name) {
583   auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
584   Entry.second.Name = &Entry;
585   return &Entry.second;
586 }
587 
588 PICLevel::Level Module::getPICLevel() const {
589   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
590 
591   if (!Val)
592     return PICLevel::NotPIC;
593 
594   return static_cast<PICLevel::Level>(
595       cast<ConstantInt>(Val->getValue())->getZExtValue());
596 }
597 
598 void Module::setPICLevel(PICLevel::Level PL) {
599   // The merge result of a non-PIC object and a PIC object can only be reliably
600   // used as a non-PIC object, so use the Min merge behavior.
601   addModuleFlag(ModFlagBehavior::Min, "PIC Level", PL);
602 }
603 
604 PIELevel::Level Module::getPIELevel() const {
605   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
606 
607   if (!Val)
608     return PIELevel::Default;
609 
610   return static_cast<PIELevel::Level>(
611       cast<ConstantInt>(Val->getValue())->getZExtValue());
612 }
613 
614 void Module::setPIELevel(PIELevel::Level PL) {
615   addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
616 }
617 
618 std::optional<CodeModel::Model> Module::getCodeModel() const {
619   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Code Model"));
620 
621   if (!Val)
622     return std::nullopt;
623 
624   return static_cast<CodeModel::Model>(
625       cast<ConstantInt>(Val->getValue())->getZExtValue());
626 }
627 
628 void Module::setCodeModel(CodeModel::Model CL) {
629   // Linking object files with different code models is undefined behavior
630   // because the compiler would have to generate additional code (to span
631   // longer jumps) if a larger code model is used with a smaller one.
632   // Therefore we will treat attempts to mix code models as an error.
633   addModuleFlag(ModFlagBehavior::Error, "Code Model", CL);
634 }
635 
636 void Module::setProfileSummary(Metadata *M, ProfileSummary::Kind Kind) {
637   if (Kind == ProfileSummary::PSK_CSInstr)
638     setModuleFlag(ModFlagBehavior::Error, "CSProfileSummary", M);
639   else
640     setModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
641 }
642 
643 Metadata *Module::getProfileSummary(bool IsCS) const {
644   return (IsCS ? getModuleFlag("CSProfileSummary")
645                : getModuleFlag("ProfileSummary"));
646 }
647 
648 bool Module::getSemanticInterposition() const {
649   Metadata *MF = getModuleFlag("SemanticInterposition");
650 
651   auto *Val = cast_or_null<ConstantAsMetadata>(MF);
652   if (!Val)
653     return false;
654 
655   return cast<ConstantInt>(Val->getValue())->getZExtValue();
656 }
657 
658 void Module::setSemanticInterposition(bool SI) {
659   addModuleFlag(ModFlagBehavior::Error, "SemanticInterposition", SI);
660 }
661 
662 void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
663   OwnedMemoryBuffer = std::move(MB);
664 }
665 
666 bool Module::getRtLibUseGOT() const {
667   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
668   return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
669 }
670 
671 void Module::setRtLibUseGOT() {
672   addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
673 }
674 
675 bool Module::getDirectAccessExternalData() const {
676   auto *Val = cast_or_null<ConstantAsMetadata>(
677       getModuleFlag("direct-access-external-data"));
678   if (Val)
679     return cast<ConstantInt>(Val->getValue())->getZExtValue() > 0;
680   return getPICLevel() == PICLevel::NotPIC;
681 }
682 
683 void Module::setDirectAccessExternalData(bool Value) {
684   addModuleFlag(ModFlagBehavior::Max, "direct-access-external-data", Value);
685 }
686 
687 UWTableKind Module::getUwtable() const {
688   if (auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("uwtable")))
689     return UWTableKind(cast<ConstantInt>(Val->getValue())->getZExtValue());
690   return UWTableKind::None;
691 }
692 
693 void Module::setUwtable(UWTableKind Kind) {
694   addModuleFlag(ModFlagBehavior::Max, "uwtable", uint32_t(Kind));
695 }
696 
697 FramePointerKind Module::getFramePointer() const {
698   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("frame-pointer"));
699   return static_cast<FramePointerKind>(
700       Val ? cast<ConstantInt>(Val->getValue())->getZExtValue() : 0);
701 }
702 
703 void Module::setFramePointer(FramePointerKind Kind) {
704   addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind));
705 }
706 
707 StringRef Module::getStackProtectorGuard() const {
708   Metadata *MD = getModuleFlag("stack-protector-guard");
709   if (auto *MDS = dyn_cast_or_null<MDString>(MD))
710     return MDS->getString();
711   return {};
712 }
713 
714 void Module::setStackProtectorGuard(StringRef Kind) {
715   MDString *ID = MDString::get(getContext(), Kind);
716   addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard", ID);
717 }
718 
719 StringRef Module::getStackProtectorGuardReg() const {
720   Metadata *MD = getModuleFlag("stack-protector-guard-reg");
721   if (auto *MDS = dyn_cast_or_null<MDString>(MD))
722     return MDS->getString();
723   return {};
724 }
725 
726 void Module::setStackProtectorGuardReg(StringRef Reg) {
727   MDString *ID = MDString::get(getContext(), Reg);
728   addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-reg", ID);
729 }
730 
731 StringRef Module::getStackProtectorGuardSymbol() const {
732   Metadata *MD = getModuleFlag("stack-protector-guard-symbol");
733   if (auto *MDS = dyn_cast_or_null<MDString>(MD))
734     return MDS->getString();
735   return {};
736 }
737 
738 void Module::setStackProtectorGuardSymbol(StringRef Symbol) {
739   MDString *ID = MDString::get(getContext(), Symbol);
740   addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-symbol", ID);
741 }
742 
743 int Module::getStackProtectorGuardOffset() const {
744   Metadata *MD = getModuleFlag("stack-protector-guard-offset");
745   if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
746     return CI->getSExtValue();
747   return INT_MAX;
748 }
749 
750 void Module::setStackProtectorGuardOffset(int Offset) {
751   addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-offset", Offset);
752 }
753 
754 unsigned Module::getOverrideStackAlignment() const {
755   Metadata *MD = getModuleFlag("override-stack-alignment");
756   if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
757     return CI->getZExtValue();
758   return 0;
759 }
760 
761 unsigned Module::getMaxTLSAlignment() const {
762   Metadata *MD = getModuleFlag("MaxTLSAlign");
763   if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
764     return CI->getZExtValue();
765   return 0;
766 }
767 
768 void Module::setOverrideStackAlignment(unsigned Align) {
769   addModuleFlag(ModFlagBehavior::Error, "override-stack-alignment", Align);
770 }
771 
772 static void addSDKVersionMD(const VersionTuple &V, Module &M, StringRef Name) {
773   SmallVector<unsigned, 3> Entries;
774   Entries.push_back(V.getMajor());
775   if (auto Minor = V.getMinor()) {
776     Entries.push_back(*Minor);
777     if (auto Subminor = V.getSubminor())
778       Entries.push_back(*Subminor);
779     // Ignore the 'build' component as it can't be represented in the object
780     // file.
781   }
782   M.addModuleFlag(Module::ModFlagBehavior::Warning, Name,
783                   ConstantDataArray::get(M.getContext(), Entries));
784 }
785 
786 void Module::setSDKVersion(const VersionTuple &V) {
787   addSDKVersionMD(V, *this, "SDK Version");
788 }
789 
790 static VersionTuple getSDKVersionMD(Metadata *MD) {
791   auto *CM = dyn_cast_or_null<ConstantAsMetadata>(MD);
792   if (!CM)
793     return {};
794   auto *Arr = dyn_cast_or_null<ConstantDataArray>(CM->getValue());
795   if (!Arr)
796     return {};
797   auto getVersionComponent = [&](unsigned Index) -> std::optional<unsigned> {
798     if (Index >= Arr->getNumElements())
799       return std::nullopt;
800     return (unsigned)Arr->getElementAsInteger(Index);
801   };
802   auto Major = getVersionComponent(0);
803   if (!Major)
804     return {};
805   VersionTuple Result = VersionTuple(*Major);
806   if (auto Minor = getVersionComponent(1)) {
807     Result = VersionTuple(*Major, *Minor);
808     if (auto Subminor = getVersionComponent(2)) {
809       Result = VersionTuple(*Major, *Minor, *Subminor);
810     }
811   }
812   return Result;
813 }
814 
815 VersionTuple Module::getSDKVersion() const {
816   return getSDKVersionMD(getModuleFlag("SDK Version"));
817 }
818 
819 GlobalVariable *llvm::collectUsedGlobalVariables(
820     const Module &M, SmallVectorImpl<GlobalValue *> &Vec, bool CompilerUsed) {
821   const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
822   GlobalVariable *GV = M.getGlobalVariable(Name);
823   if (!GV || !GV->hasInitializer())
824     return GV;
825 
826   const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
827   for (Value *Op : Init->operands()) {
828     GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
829     Vec.push_back(G);
830   }
831   return GV;
832 }
833 
834 void Module::setPartialSampleProfileRatio(const ModuleSummaryIndex &Index) {
835   if (auto *SummaryMD = getProfileSummary(/*IsCS*/ false)) {
836     std::unique_ptr<ProfileSummary> ProfileSummary(
837         ProfileSummary::getFromMD(SummaryMD));
838     if (ProfileSummary) {
839       if (ProfileSummary->getKind() != ProfileSummary::PSK_Sample ||
840           !ProfileSummary->isPartialProfile())
841         return;
842       uint64_t BlockCount = Index.getBlockCount();
843       uint32_t NumCounts = ProfileSummary->getNumCounts();
844       if (!NumCounts)
845         return;
846       double Ratio = (double)BlockCount / NumCounts;
847       ProfileSummary->setPartialProfileRatio(Ratio);
848       setProfileSummary(ProfileSummary->getMD(getContext()),
849                         ProfileSummary::PSK_Sample);
850     }
851   }
852 }
853 
854 StringRef Module::getDarwinTargetVariantTriple() const {
855   if (const auto *MD = getModuleFlag("darwin.target_variant.triple"))
856     return cast<MDString>(MD)->getString();
857   return "";
858 }
859 
860 void Module::setDarwinTargetVariantTriple(StringRef T) {
861   addModuleFlag(ModFlagBehavior::Override, "darwin.target_variant.triple",
862                 MDString::get(getContext(), T));
863 }
864 
865 VersionTuple Module::getDarwinTargetVariantSDKVersion() const {
866   return getSDKVersionMD(getModuleFlag("darwin.target_variant.SDK Version"));
867 }
868 
869 void Module::setDarwinTargetVariantSDKVersion(VersionTuple Version) {
870   addSDKVersionMD(Version, *this, "darwin.target_variant.SDK Version");
871 }
872