LLVM 17.0.0git
Module.cpp
Go to the documentation of this file.
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"
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"
26#include "llvm/IR/Function.h"
28#include "llvm/IR/GlobalAlias.h"
29#include "llvm/IR/GlobalIFunc.h"
30#include "llvm/IR/GlobalValue.h"
32#include "llvm/IR/LLVMContext.h"
33#include "llvm/IR/Metadata.h"
36#include "llvm/IR/Type.h"
37#include "llvm/IR/TypeFinder.h"
38#include "llvm/IR/Value.h"
42#include "llvm/Support/Error.h"
44#include "llvm/Support/Path.h"
47#include <algorithm>
48#include <cassert>
49#include <cstdint>
50#include <memory>
51#include <optional>
52#include <utility>
53#include <vector>
54
55using 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.
67
68//===----------------------------------------------------------------------===//
69// Primitive Module methods.
70//
71
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
79 Context.removeModule(this);
81 GlobalList.clear();
82 FunctionList.clear();
83 AliasList.clear();
84 IFuncList.clear();
85}
86
87std::unique_ptr<RandomNumberGenerator>
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.
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.
111 return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
112}
113
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.
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.
128 return Context.getMDKindNames(Result);
129}
130
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//
146 // See if we have a definition for the specified function already.
148 if (!F) {
149 // Nope, add it
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
170}
171
172// getFunction - Look up the specified function in the module symbol table.
173// If it does not exist, return null.
174//
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///
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.
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();
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.
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//
241 return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
242}
243
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.
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.
261 NamedMDNode *&NMD = 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.
273 NamedMDSymTab.erase(NMD->getName());
274 NamedMDList.erase(NMD->getIterator());
275}
276
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
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.
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.
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.
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.
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.
350 Metadata *Val) {
351 Type *Int32Ty = Type::getInt32Ty(Context);
352 Metadata *Ops[3] = {
354 MDString::get(Context, Key), Val};
356}
358 Constant *Val) {
359 addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
360}
362 uint32_t Val) {
363 Type *Int32Ty = Type::getInt32Ty(Context);
364 addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
365}
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!");
373}
374
376 Metadata *Val) {
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
393 DL.reset(Desc);
394}
395
397
398const DataLayout &Module::getDataLayout() const { return DL; }
399
401 return cast<DICompileUnit>(CUs->getOperand(Idx));
402}
404 return cast<DICompileUnit>(CUs->getOperand(Idx));
405}
406
407void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
408 while (CUs && (Idx < CUs->getNumOperands()) &&
409 ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
410 ++Idx;
411}
412
414 return concat<GlobalObject>(functions(), globals());
415}
418 return concat<const GlobalObject>(functions(), globals());
419}
420
422 return concat<GlobalValue>(functions(), globals(), aliases(), ifuncs());
423}
426 return concat<const GlobalValue>(functions(), globals(), aliases(), ifuncs());
427}
428
429//===----------------------------------------------------------------------===//
430// Methods to control the materialization of GlobalValues in the Module.
431//
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
440 if (!Materializer)
441 return Error::success();
442
443 return Materializer->materialize(GV);
444}
445
447 if (!Materializer)
448 return Error::success();
449 std::unique_ptr<GVMaterializer> M = std::move(Materializer);
450 return M->materializeModule();
451}
452
454 if (!Materializer)
455 return Error::success();
456 return Materializer->materializeMetadata();
457}
458
459//===----------------------------------------------------------------------===//
460// Other module related stuff.
461//
462
463std::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
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//
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
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
556unsigned 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
563bool Module::isDwarf64() const {
564 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("DWARF64"));
565 return Val && cast<ConstantInt>(Val->getValue())->isOne();
566}
567
568unsigned 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
576 unsigned NumInstrs = 0;
577 for (const Function &F : FunctionList)
578 NumInstrs += F.getInstructionCount();
579 return NumInstrs;
580}
581
583 auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
584 Entry.second.Name = &Entry;
585 return &Entry.second;
586}
587
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
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
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
615 addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
616}
617
618std::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
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
637 if (Kind == ProfileSummary::PSK_CSInstr)
638 setModuleFlag(ModFlagBehavior::Error, "CSProfileSummary", M);
639 else
640 setModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
641}
642
644 return (IsCS ? getModuleFlag("CSProfileSummary")
645 : getModuleFlag("ProfileSummary"));
646}
647
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
659 addModuleFlag(ModFlagBehavior::Error, "SemanticInterposition", SI);
660}
661
662void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
663 OwnedMemoryBuffer = std::move(MB);
664}
665
667 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
668 return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
669}
670
672 addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
673}
674
676 if (auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("uwtable")))
677 return UWTableKind(cast<ConstantInt>(Val->getValue())->getZExtValue());
678 return UWTableKind::None;
679}
680
683}
684
686 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("frame-pointer"));
687 return static_cast<FramePointerKind>(
688 Val ? cast<ConstantInt>(Val->getValue())->getZExtValue() : 0);
689}
690
692 addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind));
693}
694
696 Metadata *MD = getModuleFlag("stack-protector-guard");
697 if (auto *MDS = dyn_cast_or_null<MDString>(MD))
698 return MDS->getString();
699 return {};
700}
701
704 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard", ID);
705}
706
708 Metadata *MD = getModuleFlag("stack-protector-guard-reg");
709 if (auto *MDS = dyn_cast_or_null<MDString>(MD))
710 return MDS->getString();
711 return {};
712}
713
716 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-reg", ID);
717}
718
720 Metadata *MD = getModuleFlag("stack-protector-guard-symbol");
721 if (auto *MDS = dyn_cast_or_null<MDString>(MD))
722 return MDS->getString();
723 return {};
724}
725
727 MDString *ID = MDString::get(getContext(), Symbol);
728 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-symbol", ID);
729}
730
732 Metadata *MD = getModuleFlag("stack-protector-guard-offset");
733 if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
734 return CI->getSExtValue();
735 return INT_MAX;
736}
737
739 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-offset", Offset);
740}
741
743 Metadata *MD = getModuleFlag("override-stack-alignment");
744 if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
745 return CI->getZExtValue();
746 return 0;
747}
748
750 addModuleFlag(ModFlagBehavior::Error, "override-stack-alignment", Align);
751}
752
755 Entries.push_back(V.getMajor());
756 if (auto Minor = V.getMinor()) {
757 Entries.push_back(*Minor);
758 if (auto Subminor = V.getSubminor())
759 Entries.push_back(*Subminor);
760 // Ignore the 'build' component as it can't be represented in the object
761 // file.
762 }
763 M.addModuleFlag(Module::ModFlagBehavior::Warning, Name,
764 ConstantDataArray::get(M.getContext(), Entries));
765}
766
768 addSDKVersionMD(V, *this, "SDK Version");
769}
770
772 auto *CM = dyn_cast_or_null<ConstantAsMetadata>(MD);
773 if (!CM)
774 return {};
775 auto *Arr = dyn_cast_or_null<ConstantDataArray>(CM->getValue());
776 if (!Arr)
777 return {};
778 auto getVersionComponent = [&](unsigned Index) -> std::optional<unsigned> {
779 if (Index >= Arr->getNumElements())
780 return std::nullopt;
781 return (unsigned)Arr->getElementAsInteger(Index);
782 };
783 auto Major = getVersionComponent(0);
784 if (!Major)
785 return {};
786 VersionTuple Result = VersionTuple(*Major);
787 if (auto Minor = getVersionComponent(1)) {
788 Result = VersionTuple(*Major, *Minor);
789 if (auto Subminor = getVersionComponent(2)) {
790 Result = VersionTuple(*Major, *Minor, *Subminor);
791 }
792 }
793 return Result;
794}
795
797 return getSDKVersionMD(getModuleFlag("SDK Version"));
798}
799
801 const Module &M, SmallVectorImpl<GlobalValue *> &Vec, bool CompilerUsed) {
802 const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
803 GlobalVariable *GV = M.getGlobalVariable(Name);
804 if (!GV || !GV->hasInitializer())
805 return GV;
806
807 const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
808 for (Value *Op : Init->operands()) {
809 GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
810 Vec.push_back(G);
811 }
812 return GV;
813}
814
816 if (auto *SummaryMD = getProfileSummary(/*IsCS*/ false)) {
817 std::unique_ptr<ProfileSummary> ProfileSummary(
818 ProfileSummary::getFromMD(SummaryMD));
819 if (ProfileSummary) {
822 return;
823 uint64_t BlockCount = Index.getBlockCount();
824 uint32_t NumCounts = ProfileSummary->getNumCounts();
825 if (!NumCounts)
826 return;
827 double Ratio = (double)BlockCount / NumCounts;
831 }
832 }
833}
834
836 if (const auto *MD = getModuleFlag("darwin.target_variant.triple"))
837 return cast<MDString>(MD)->getString();
838 return "";
839}
840
842 addModuleFlag(ModFlagBehavior::Override, "darwin.target_variant.triple",
844}
845
847 return getSDKVersionMD(getModuleFlag("darwin.target_variant.SDK Version"));
848}
849
851 addSDKVersionMD(Version, *this, "darwin.target_variant.SDK Version");
852}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file defines the StringMap class.
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
std::string Name
This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...
static bool lookup(const GsymReader &GR, DataExtractor &Data, uint64_t &Offset, uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs, llvm::Error &Err)
A Lookup helper functions.
Definition: InlineInfo.cpp:109
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
This file contains the declarations for metadata subclasses.
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
static VersionTuple getSDKVersionMD(Metadata *MD)
Definition: Module.cpp:771
static void addSDKVersionMD(const VersionTuple &V, Module &M, StringRef Name)
Definition: Module.cpp:753
Module.h This file contains the declarations for the Module class.
IntegerType * Int32Ty
LLVMContext & Context
@ SI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
Defines the llvm::VersionTuple class, which represents a version in the form major[....
ConstantArray - Constant Array Declarations.
Definition: Constants.h:409
static ConstantAsMetadata * get(Constant *C)
Definition: Metadata.h:419
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
Definition: Constants.h:691
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2229
This is the shared class of boolean and integer constants.
Definition: Constants.h:78
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:887
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:114
unsigned getProgramAddressSpace() const
Definition: DataLayout.h:296
void reset(StringRef LayoutDescription)
Parse a data layout string (with fallback to default values).
Definition: DataLayout.cpp:180
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:165
Class to represent function types.
Definition: DerivedTypes.h:103
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:290
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
unsigned getMDKindID(StringRef Name) const
getMDKindID - Return a unique non-zero ID for the specified metadata kind.
void getOperandBundleTags(SmallVectorImpl< StringRef > &Result) const
getOperandBundleTags - Populate client supplied SmallVector with the bundle tags registered in this L...
void getMDKindNames(SmallVectorImpl< StringRef > &Result) const
getMDKindNames - Populate client supplied SmallVector with the name for custom metadata IDs registere...
Metadata node.
Definition: Metadata.h:943
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1291
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1399
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1297
A single uniqued string.
Definition: Metadata.h:611
StringRef getString() const
Definition: Metadata.cpp:507
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:497
Root of the metadata hierarchy.
Definition: Metadata.h:61
Class to hold module path string table and global value map, and encapsulate methods for operating on...
DICompileUnit * operator*() const
Definition: Module.cpp:400
DICompileUnit * operator->() const
Definition: Module.cpp:403
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static bool isValidModuleFlag(const MDNode &ModFlag, ModFlagBehavior &MFB, MDString *&Key, Metadata *&Val)
Check if the given module flag metadata represents a valid module flag, and store the flag behavior,...
Definition: Module.cpp:288
void setStackProtectorGuardSymbol(StringRef Symbol)
Definition: Module.cpp:726
void setSemanticInterposition(bool)
Set whether semantic interposition is to be respected.
Definition: Module.cpp:658
ModFlagBehavior
This enumeration defines the supported behaviors of module flags.
Definition: Module.h:115
@ Override
Uses the specified value, regardless of the behavior or value of the other module.
Definition: Module.h:136
@ Warning
Emits a warning if two values disagree.
Definition: Module.h:122
@ Error
Emits an error if two values disagree, otherwise the resulting value is that of the operands.
Definition: Module.h:118
@ ModFlagBehaviorFirstVal
Definition: Module.h:153
@ Min
Takes the min of the two values, which are required to be integers.
Definition: Module.h:150
@ Max
Takes the max of the two values, which are required to be integers.
Definition: Module.h:147
@ ModFlagBehaviorLastVal
Definition: Module.h:154
llvm::Error materializeAll()
Make sure all GlobalValues in this Module are fully read and clear the Materializer.
Definition: Module.cpp:446
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:262
void setOverrideStackAlignment(unsigned Align)
Definition: Module.cpp:749
void setOwnedMemoryBuffer(std::unique_ptr< MemoryBuffer > MB)
Take ownership of the given memory buffer.
Definition: Module.cpp:662
void setMaterializer(GVMaterializer *GVM)
Sets the GVMaterializer to GVM.
Definition: Module.cpp:432
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:439
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:175
void setCodeModel(CodeModel::Model CL)
Set the code model (tiny, small, kernel, medium or large)
Definition: Module.cpp:628
StringRef getStackProtectorGuardSymbol() const
Get/set a symbol to use as the stack protector guard.
Definition: Module.cpp:719
iterator_range< ifunc_iterator > ifuncs()
Definition: Module.h:672
bool getSemanticInterposition() const
Returns whether semantic interposition is to be respected.
Definition: Module.cpp:648
void getMDKindNames(SmallVectorImpl< StringRef > &Result) const
Populate client supplied SmallVector with the name for custom metadata IDs registered in this LLVMCon...
Definition: Module.cpp:127
Module(StringRef ModuleID, LLVMContext &C)
The Module constructor.
Definition: Module.cpp:72
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:251
void setRtLibUseGOT()
Set that PLT should be avoid for RTLib calls.
Definition: Module.cpp:671
llvm::Error materializeMetadata()
Definition: Module.cpp:453
NamedMDNode * getOrInsertModuleFlagsMetadata()
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.cpp:342
iterator_range< iterator > functions()
Definition: Module.h:636
void eraseNamedMetadata(NamedMDNode *NMD)
Remove the given NamedMDNode from this module and delete it.
Definition: Module.cpp:272
unsigned getNumNamedValues() const
Return the number of global values in the module.
Definition: Module.cpp:114
unsigned getMDKindID(StringRef Name) const
Return a unique non-zero ID for the specified metadata kind.
Definition: Module.cpp:120
void setFramePointer(FramePointerKind Kind)
Definition: Module.cpp:691
StringRef getStackProtectorGuard() const
Get/set what kind of stack protector guard to use.
Definition: Module.cpp:695
bool getRtLibUseGOT() const
Returns true if PLT should be avoided for RTLib calls.
Definition: Module.cpp:666
void setModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Like addModuleFlag but replaces the old module flag if it already exists.
Definition: Module.cpp:375
UWTableKind getUwtable() const
Get/set whether synthesized functions should get the uwtable attribute.
Definition: Module.cpp:675
void dropAllReferences()
This function causes all the subinstructions to "let go" of all references that they are maintaining.
Definition: Module.cpp:534
void setStackProtectorGuard(StringRef Kind)
Definition: Module.cpp:702
iterator_range< alias_iterator > aliases()
Definition: Module.h:654
void setProfileSummary(Metadata *M, ProfileSummary::Kind Kind)
Attach profile summary metadata to this module.
Definition: Module.cpp:636
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:398
void setUwtable(UWTableKind Kind)
Definition: Module.cpp:681
unsigned getCodeViewFlag() const
Returns the CodeView Version by checking module flags.
Definition: Module.cpp:568
void setPartialSampleProfileRatio(const ModuleSummaryIndex &Index)
Set the partial sample profile ratio in the profile summary module flag, if applicable.
Definition: Module.cpp:815
std::string getUniqueIntrinsicName(StringRef BaseName, Intrinsic::ID Id, const FunctionType *Proto)
Return a unique name for an intrinsic whose mangling is based on an unnamed type.
Definition: Module.cpp:477
~Module()
The module destructor. This will dropAllReferences.
Definition: Module.cpp:78
FramePointerKind getFramePointer() const
Get/set whether synthesized functions should get the "frame-pointer" attribute.
Definition: Module.cpp:685
unsigned getOverrideStackAlignment() const
Get/set the stack alignment overridden from the default.
Definition: Module.cpp:742
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Add a module-level flag to the module-level flags metadata.
Definition: Module.cpp:349
void setStackProtectorGuardReg(StringRef Reg)
Definition: Module.cpp:714
PICLevel::Level getPICLevel() const
Returns the PIC level (small or large model)
Definition: Module.cpp:588
std::unique_ptr< RandomNumberGenerator > createRNG(const StringRef Name) const
Get a RandomNumberGenerator salted for use with this module.
Definition: Module.cpp:88
iterator_range< global_iterator > globals()
Definition: Module.h:614
std::vector< StructType * > getIdentifiedStructTypes() const
Definition: Module.cpp:463
void setDarwinTargetVariantTriple(StringRef T)
Set the target variant triple which is a string describing a variant of the target host platform.
Definition: Module.cpp:841
void setPICLevel(PICLevel::Level PL)
Set the PIC level (small or large model)
Definition: Module.cpp:598
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:228
unsigned getNumberRegisterParameters() const
Returns the Number of Register ParametersDwarf Version by checking module flags.
Definition: Module.cpp:548
GlobalIFunc * getNamedIFunc(StringRef Name) const
Return the global ifunc in the module with the specified name, of arbitrary type.
Definition: Module.cpp:244
StringRef getStackProtectorGuardReg() const
Get/set which register to use as the stack protector guard register.
Definition: Module.cpp:707
unsigned getDwarfVersion() const
Returns the Dwarf Version by checking module flags.
Definition: Module.cpp:556
void setDataLayout(StringRef Desc)
Set the data layout.
Definition: Module.cpp:392
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:414
bool isDwarf64() const
Returns the DWARF format by checking module flags.
Definition: Module.cpp:563
static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB)
Checks if Metadata represents a valid ModFlagBehavior, and stores the converted result in MFB.
Definition: Module.cpp:277
const ValueSymbolTable & getValueSymbolTable() const
Get the symbol table of global variable and function identifiers.
Definition: Module.h:594
void setStackProtectorGuardOffset(int Offset)
Definition: Module.cpp:738
iterator_range< global_object_iterator > global_objects()
Definition: Module.cpp:413
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type.
Definition: Module.cpp:110
unsigned getInstructionCount() const
Returns the number of non-debug IR instructions in the module.
Definition: Module.cpp:575
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Definition: Module.cpp:260
void getOperandBundleTags(SmallVectorImpl< StringRef > &Result) const
Populate client supplied SmallVector with the bundle tags registered in this LLVMContext.
Definition: Module.cpp:131
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:582
FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:144
Constant * getOrInsertGlobal(StringRef Name, Type *Ty, function_ref< GlobalVariable *()> CreateGlobalCallback)
Look up the specified global in the module symbol table.
Definition: Module.cpp:205
std::optional< CodeModel::Model > getCodeModel() const
Returns the code model (tiny, small, kernel, medium or large model)
Definition: Module.cpp:618
VersionTuple getDarwinTargetVariantSDKVersion() const
Get the target variant version build SDK version metadata.
Definition: Module.cpp:846
void setPIELevel(PIELevel::Level PL)
Set the PIE level (small or large model)
Definition: Module.cpp:614
VersionTuple getSDKVersion() const
Get the build SDK version metadata.
Definition: Module.cpp:796
NamedMDNode * getModuleFlagsMetadata() const
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.cpp:335
GlobalAlias * getNamedAlias(StringRef Name) const
Return the global alias in the module with the specified name, of arbitrary type.
Definition: Module.cpp:240
void setDarwinTargetVariantSDKVersion(VersionTuple Version)
Set the target variant version build SDK version metadata.
Definition: Module.cpp:850
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition: Module.cpp:604
StringRef getDarwinTargetVariantTriple() const
Get the target variant triple which is a string describing a variant of the target host platform.
Definition: Module.cpp:835
void setSDKVersion(const VersionTuple &V)
Attach a build SDK version metadata to this module.
Definition: Module.cpp:767
iterator_range< global_value_iterator > global_values()
Definition: Module.cpp:421
int getStackProtectorGuardOffset() const
Get/set what offset from the stack protector to use.
Definition: Module.cpp:731
Metadata * getProfileSummary(bool IsCS) const
Returns profile summary metadata.
Definition: Module.cpp:643
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:322
A tuple of MDNodes.
Definition: Metadata.h:1587
StringRef getName() const
Definition: Metadata.cpp:1232
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1215
unsigned getNumOperands() const
Definition: Metadata.cpp:1211
iterator_range< op_iterator > operands()
Definition: Metadata.h:1683
void addOperand(MDNode *M)
Definition: Metadata.cpp:1221
Class to represent pointers.
Definition: DerivedTypes.h:632
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
void setPartialProfileRatio(double R)
Metadata * getMD(LLVMContext &Context, bool AddPartialField=true, bool AddPartialProfileRatioField=true)
Return summary information as metadata.
uint32_t getNumCounts() const
bool isPartialProfile() const
Kind getKind() const
static ProfileSummary * getFromMD(Metadata *MD)
Construct profile summary from metdata.
A random number generator.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
ValueTy lookup(StringRef Key) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: StringMap.h:233
void erase(iterator I)
Definition: StringMap.h:370
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:275
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
TypeFinder - Walk over a module, identifying all of the types that are used by the module.
Definition: TypeFinder.h:31
iterator end()
Definition: TypeFinder.h:52
void run(const Module &M, bool onlyNamed)
Definition: TypeFinder.cpp:34
iterator begin()
Definition: TypeFinder.h:51
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
static IntegerType * getInt32Ty(LLVMContext &C)
This class provides a symbol table of name/value pairs.
unsigned size() const
The number of name/type pairs is returned.
LLVM Value Representation.
Definition: Value.h:74
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:31
unsigned getMajor() const
Retrieve the major version number.
Definition: VersionTuple.h:73
std::optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.
Definition: VersionTuple.h:83
std::optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
Definition: VersionTuple.h:76
An efficient, type-erasing, non-owning reference to a callable.
self_iterator getIterator()
Definition: ilist_node.h:82
void push_back(pointer val)
Definition: ilist.h:314
iterator erase(iterator where)
Definition: ilist.h:268
void clear()
Definition: ilist.h:310
A range adaptor for a pair of iterators.
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:577
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:406
FramePointerKind
Definition: CodeGen.h:91
UWTableKind
Definition: CodeGen.h:121
@ None
No unwind table requested.
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Definition: Module.cpp:800
Definition: BitVector.h:851
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39