LLVM 20.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
58
59//===----------------------------------------------------------------------===//
60// Methods to implement the globals and functions lists.
61//
62
63// Explicit instantiations of SymbolTableListTraits since some of the methods
64// are not in the public header file.
69
70//===----------------------------------------------------------------------===//
71// Primitive Module methods.
72//
73
75 : Context(C), ValSymTab(std::make_unique<ValueSymbolTable>(-1)),
76 ModuleID(std::string(MID)), SourceFileName(std::string(MID)),
77 IsNewDbgInfoFormat(UseNewDbgInfoFormat) {
78 Context.addModule(this);
79}
80
82 Context.removeModule(this);
84 GlobalList.clear();
85 FunctionList.clear();
86 AliasList.clear();
87 IFuncList.clear();
88}
89
91 auto *DeclareIntrinsicFn =
92 Intrinsic::getDeclaration(this, Intrinsic::dbg_declare);
93 assert((!isMaterialized() || DeclareIntrinsicFn->hasZeroLiveUses()) &&
94 "Debug declare intrinsic should have had uses removed.");
95 DeclareIntrinsicFn->eraseFromParent();
96 auto *ValueIntrinsicFn =
97 Intrinsic::getDeclaration(this, Intrinsic::dbg_value);
98 assert((!isMaterialized() || ValueIntrinsicFn->hasZeroLiveUses()) &&
99 "Debug value intrinsic should have had uses removed.");
100 ValueIntrinsicFn->eraseFromParent();
101 auto *AssignIntrinsicFn =
102 Intrinsic::getDeclaration(this, Intrinsic::dbg_assign);
103 assert((!isMaterialized() || AssignIntrinsicFn->hasZeroLiveUses()) &&
104 "Debug assign intrinsic should have had uses removed.");
105 AssignIntrinsicFn->eraseFromParent();
106 auto *LabelntrinsicFn = Intrinsic::getDeclaration(this, Intrinsic::dbg_label);
107 assert((!isMaterialized() || LabelntrinsicFn->hasZeroLiveUses()) &&
108 "Debug label intrinsic should have had uses removed.");
109 LabelntrinsicFn->eraseFromParent();
110}
111
112std::unique_ptr<RandomNumberGenerator>
114 SmallString<32> Salt(Name);
115
116 // This RNG is guaranteed to produce the same random stream only
117 // when the Module ID and thus the input filename is the same. This
118 // might be problematic if the input filename extension changes
119 // (e.g. from .c to .bc or .ll).
120 //
121 // We could store this salt in NamedMetadata, but this would make
122 // the parameter non-const. This would unfortunately make this
123 // interface unusable by any Machine passes, since they only have a
124 // const reference to their IR Module. Alternatively we can always
125 // store salt metadata from the Module constructor.
127
128 return std::unique_ptr<RandomNumberGenerator>(
129 new RandomNumberGenerator(Salt));
130}
131
132/// getNamedValue - Return the first global value in the module with
133/// the specified name, of arbitrary type. This method returns null
134/// if a global with the specified name is not found.
136 return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
137}
138
140 return getValueSymbolTable().size();
141}
142
143/// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
144/// This ID is uniqued across modules in the current LLVMContext.
146 return Context.getMDKindID(Name);
147}
148
149/// getMDKindNames - Populate client supplied SmallVector with the name for
150/// custom metadata IDs registered in this LLVMContext. ID #0 is not used,
151/// so it is filled in as an empty string.
153 return Context.getMDKindNames(Result);
154}
155
157 return Context.getOperandBundleTags(Result);
158}
159
160//===----------------------------------------------------------------------===//
161// Methods for easy access to the functions in the module.
162//
163
164// getOrInsertFunction - Look up the specified function in the module symbol
165// table. If it does not exist, add a prototype for the function and return
166// it. This is nice because it allows most passes to get away with not handling
167// the symbol table directly for this common task.
168//
171 // See if we have a definition for the specified function already.
173 if (!F) {
174 // Nope, add it
176 DL.getProgramAddressSpace(), Name, this);
177 if (!New->isIntrinsic()) // Intrinsics get attrs set on construction
178 New->setAttributes(AttributeList);
179 return {Ty, New}; // Return the new prototype.
180 }
181
182 // Otherwise, we just found the existing function or a prototype.
183 return {Ty, F};
184}
185
188}
189
190// getFunction - Look up the specified function in the module symbol table.
191// If it does not exist, return null.
192//
194 return dyn_cast_or_null<Function>(getNamedValue(Name));
195}
196
197//===----------------------------------------------------------------------===//
198// Methods for easy access to the global variables in the module.
199//
200
201/// getGlobalVariable - Look up the specified global variable in the module
202/// symbol table. If it does not exist, return null. The type argument
203/// should be the underlying type of the global, i.e., it should not have
204/// the top-level PointerType, which represents the address of the global.
205/// If AllowLocal is set to true, this function will return types that
206/// have an local. By default, these types are not returned.
207///
209 bool AllowLocal) const {
210 if (GlobalVariable *Result =
211 dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
212 if (AllowLocal || !Result->hasLocalLinkage())
213 return Result;
214 return nullptr;
215}
216
217/// getOrInsertGlobal - Look up the specified global in the module symbol table.
218/// 1. If it does not exist, add a declaration of the global and return it.
219/// 2. Else, the global exists but has the wrong type: return the function
220/// with a constantexpr cast to the right type.
221/// 3. Finally, if the existing global is the correct declaration, return the
222/// existing global.
224 StringRef Name, Type *Ty,
225 function_ref<GlobalVariable *()> CreateGlobalCallback) {
226 // See if we have a definition for the specified global already.
227 GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
228 if (!GV)
229 GV = CreateGlobalCallback();
230 assert(GV && "The CreateGlobalCallback is expected to create a global");
231
232 // Otherwise, we just found the existing function or a prototype.
233 return GV;
234}
235
236// Overload to construct a global variable using its constructor's defaults.
238 return getOrInsertGlobal(Name, Ty, [&] {
239 return new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
240 nullptr, Name);
241 });
242}
243
244//===----------------------------------------------------------------------===//
245// Methods for easy access to the global variables in the module.
246//
247
248// getNamedAlias - Look up the specified global in the module symbol table.
249// If it does not exist, return null.
250//
252 return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
253}
254
256 return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name));
257}
258
259/// getNamedMetadata - Return the first NamedMDNode in the module with the
260/// specified name. This method returns null if a NamedMDNode with the
261/// specified name is not found.
263 return NamedMDSymTab.lookup(Name);
264}
265
266/// getOrInsertNamedMetadata - Return the first named MDNode in the module
267/// with the specified name. This method returns a new NamedMDNode if a
268/// NamedMDNode with the specified name is not found.
270 NamedMDNode *&NMD = NamedMDSymTab[Name];
271 if (!NMD) {
272 NMD = new NamedMDNode(Name);
273 NMD->setParent(this);
275 if (Name == "llvm.module.flags")
276 ModuleFlags = NMD;
277 }
278 return NMD;
279}
280
281/// eraseNamedMetadata - Remove the given NamedMDNode from this module and
282/// delete it.
284 NamedMDSymTab.erase(NMD->getName());
285 if (NMD == ModuleFlags)
286 ModuleFlags = nullptr;
287 eraseNamedMDNode(NMD);
288}
289
291 if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
292 uint64_t Val = Behavior->getLimitedValue();
293 if (Val >= ModFlagBehaviorFirstVal && Val <= ModFlagBehaviorLastVal) {
294 MFB = static_cast<ModFlagBehavior>(Val);
295 return true;
296 }
297 }
298 return false;
299}
300
301/// getModuleFlagsMetadata - Returns the module flags in the provided vector.
304 const NamedMDNode *ModFlags = getModuleFlagsMetadata();
305 if (!ModFlags) return;
306
307 for (const MDNode *Flag : ModFlags->operands()) {
308 // The verifier will catch errors, so no need to check them here.
309 auto *MFBConstant = mdconst::extract<ConstantInt>(Flag->getOperand(0));
310 auto MFB = static_cast<ModFlagBehavior>(MFBConstant->getLimitedValue());
311 MDString *Key = cast<MDString>(Flag->getOperand(1));
312 Metadata *Val = Flag->getOperand(2);
313 Flags.push_back(ModuleFlagEntry(MFB, Key, Val));
314 }
315}
316
317/// Return the corresponding value if Key appears in module flags, otherwise
318/// return null.
320 const NamedMDNode *ModFlags = getModuleFlagsMetadata();
321 if (!ModFlags)
322 return nullptr;
323 for (const MDNode *Flag : ModFlags->operands()) {
324 if (Key == cast<MDString>(Flag->getOperand(1))->getString())
325 return Flag->getOperand(2);
326 }
327 return nullptr;
328}
329
330/// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
331/// represents module-level flags. If module-level flags aren't found, it
332/// creates the named metadata that contains them.
334 if (ModuleFlags)
335 return ModuleFlags;
336 return getOrInsertNamedMetadata("llvm.module.flags");
337}
338
339/// addModuleFlag - Add a module-level flag to the module-level flags
340/// metadata. It will create the module-level flags named metadata if it doesn't
341/// already exist.
343 Metadata *Val) {
344 Type *Int32Ty = Type::getInt32Ty(Context);
345 Metadata *Ops[3] = {
346 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
347 MDString::get(Context, Key), Val};
349}
351 Constant *Val) {
352 addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
353}
355 uint32_t Val) {
356 Type *Int32Ty = Type::getInt32Ty(Context);
357 addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
358}
360 assert(Node->getNumOperands() == 3 &&
361 "Invalid number of operands for module flag!");
362 assert(mdconst::hasa<ConstantInt>(Node->getOperand(0)) &&
363 isa<MDString>(Node->getOperand(1)) &&
364 "Invalid operand types for module flag!");
366}
367
369 Metadata *Val) {
371 // Replace the flag if it already exists.
372 for (MDNode *Flag : ModFlags->operands()) {
373 if (cast<MDString>(Flag->getOperand(1))->getString() == Key) {
374 Flag->replaceOperandWith(2, Val);
375 return;
376 }
377 }
378 addModuleFlag(Behavior, Key, Val);
379}
381 Constant *Val) {
382 setModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
383}
385 uint32_t Val) {
386 Type *Int32Ty = Type::getInt32Ty(Context);
387 setModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
388}
389
391
393
395 return cast<DICompileUnit>(CUs->getOperand(Idx));
396}
398 return cast<DICompileUnit>(CUs->getOperand(Idx));
399}
400
401void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
402 while (CUs && (Idx < CUs->getNumOperands()) &&
403 ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
404 ++Idx;
405}
406
408 return concat<GlobalObject>(functions(), globals());
409}
412 return concat<const GlobalObject>(functions(), globals());
413}
414
416 return concat<GlobalValue>(functions(), globals(), aliases(), ifuncs());
417}
420 return concat<const GlobalValue>(functions(), globals(), aliases(), ifuncs());
421}
422
423//===----------------------------------------------------------------------===//
424// Methods to control the materialization of GlobalValues in the Module.
425//
427 assert(!Materializer &&
428 "Module already has a GVMaterializer. Call materializeAll"
429 " to clear it out before setting another one.");
430 Materializer.reset(GVM);
431}
432
434 if (!Materializer)
435 return Error::success();
436
437 return Materializer->materialize(GV);
438}
439
441 if (!Materializer)
442 return Error::success();
443 std::unique_ptr<GVMaterializer> M = std::move(Materializer);
444 return M->materializeModule();
445}
446
448 if (!Materializer)
449 return Error::success();
450 return Materializer->materializeMetadata();
451}
452
453//===----------------------------------------------------------------------===//
454// Other module related stuff.
455//
456
457std::vector<StructType *> Module::getIdentifiedStructTypes() const {
458 // If we have a materializer, it is possible that some unread function
459 // uses a type that is currently not visible to a TypeFinder, so ask
460 // the materializer which types it created.
461 if (Materializer)
462 return Materializer->getIdentifiedStructTypes();
463
464 std::vector<StructType *> Ret;
465 TypeFinder SrcStructTypes;
466 SrcStructTypes.run(*this, true);
467 Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
468 return Ret;
469}
470
472 const FunctionType *Proto) {
473 auto Encode = [&BaseName](unsigned Suffix) {
474 return (Twine(BaseName) + "." + Twine(Suffix)).str();
475 };
476
477 {
478 // fast path - the prototype is already known
479 auto UinItInserted = UniquedIntrinsicNames.insert({{Id, Proto}, 0});
480 if (!UinItInserted.second)
481 return Encode(UinItInserted.first->second);
482 }
483
484 // Not known yet. A new entry was created with index 0. Check if there already
485 // exists a matching declaration, or select a new entry.
486
487 // Start looking for names with the current known maximum count (or 0).
488 auto NiidItInserted = CurrentIntrinsicIds.insert({BaseName, 0});
489 unsigned Count = NiidItInserted.first->second;
490
491 // This might be slow if a whole population of intrinsics already existed, but
492 // we cache the values for later usage.
493 std::string NewName;
494 while (true) {
495 NewName = Encode(Count);
496 GlobalValue *F = getNamedValue(NewName);
497 if (!F) {
498 // Reserve this entry for the new proto
499 UniquedIntrinsicNames[{Id, Proto}] = Count;
500 break;
501 }
502
503 // A declaration with this name already exists. Remember it.
504 FunctionType *FT = dyn_cast<FunctionType>(F->getValueType());
505 auto UinItInserted = UniquedIntrinsicNames.insert({{Id, FT}, Count});
506 if (FT == Proto) {
507 // It was a declaration for our prototype. This entry was allocated in the
508 // beginning. Update the count to match the existing declaration.
509 UinItInserted.first->second = Count;
510 break;
511 }
512
513 ++Count;
514 }
515
516 NiidItInserted.first->second = Count + 1;
517
518 return NewName;
519}
520
521// dropAllReferences() - This function causes all the subelements to "let go"
522// of all references that they are maintaining. This allows one to 'delete' a
523// whole module at a time, even though there may be circular references... first
524// all references are dropped, and all use counts go to zero. Then everything
525// is deleted for real. Note that no operations are valid on an object that
526// has "dropped all references", except operator delete.
527//
529 for (Function &F : *this)
530 F.dropAllReferences();
531
532 for (GlobalVariable &GV : globals())
533 GV.dropAllReferences();
534
535 for (GlobalAlias &GA : aliases())
536 GA.dropAllReferences();
537
538 for (GlobalIFunc &GIF : ifuncs())
539 GIF.dropAllReferences();
540}
541
543 auto *Val =
544 cast_or_null<ConstantAsMetadata>(getModuleFlag("NumRegisterParameters"));
545 if (!Val)
546 return 0;
547 return cast<ConstantInt>(Val->getValue())->getZExtValue();
548}
549
550unsigned Module::getDwarfVersion() const {
551 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
552 if (!Val)
553 return 0;
554 return cast<ConstantInt>(Val->getValue())->getZExtValue();
555}
556
557bool Module::isDwarf64() const {
558 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("DWARF64"));
559 return Val && cast<ConstantInt>(Val->getValue())->isOne();
560}
561
562unsigned Module::getCodeViewFlag() const {
563 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
564 if (!Val)
565 return 0;
566 return cast<ConstantInt>(Val->getValue())->getZExtValue();
567}
568
570 unsigned NumInstrs = 0;
571 for (const Function &F : FunctionList)
572 NumInstrs += F.getInstructionCount();
573 return NumInstrs;
574}
575
577 auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
578 Entry.second.Name = &Entry;
579 return &Entry.second;
580}
581
583 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
584
585 if (!Val)
586 return PICLevel::NotPIC;
587
588 return static_cast<PICLevel::Level>(
589 cast<ConstantInt>(Val->getValue())->getZExtValue());
590}
591
593 // The merge result of a non-PIC object and a PIC object can only be reliably
594 // used as a non-PIC object, so use the Min merge behavior.
595 addModuleFlag(ModFlagBehavior::Min, "PIC Level", PL);
596}
597
599 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
600
601 if (!Val)
602 return PIELevel::Default;
603
604 return static_cast<PIELevel::Level>(
605 cast<ConstantInt>(Val->getValue())->getZExtValue());
606}
607
609 addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
610}
611
612std::optional<CodeModel::Model> Module::getCodeModel() const {
613 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Code Model"));
614
615 if (!Val)
616 return std::nullopt;
617
618 return static_cast<CodeModel::Model>(
619 cast<ConstantInt>(Val->getValue())->getZExtValue());
620}
621
623 // Linking object files with different code models is undefined behavior
624 // because the compiler would have to generate additional code (to span
625 // longer jumps) if a larger code model is used with a smaller one.
626 // Therefore we will treat attempts to mix code models as an error.
627 addModuleFlag(ModFlagBehavior::Error, "Code Model", CL);
628}
629
630std::optional<uint64_t> Module::getLargeDataThreshold() const {
631 auto *Val =
632 cast_or_null<ConstantAsMetadata>(getModuleFlag("Large Data Threshold"));
633
634 if (!Val)
635 return std::nullopt;
636
637 return cast<ConstantInt>(Val->getValue())->getZExtValue();
638}
639
641 // Since the large data threshold goes along with the code model, the merge
642 // behavior is the same.
643 addModuleFlag(ModFlagBehavior::Error, "Large Data Threshold",
644 ConstantInt::get(Type::getInt64Ty(Context), Threshold));
645}
646
648 if (Kind == ProfileSummary::PSK_CSInstr)
649 setModuleFlag(ModFlagBehavior::Error, "CSProfileSummary", M);
650 else
651 setModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
652}
653
655 return (IsCS ? getModuleFlag("CSProfileSummary")
656 : getModuleFlag("ProfileSummary"));
657}
658
660 Metadata *MF = getModuleFlag("SemanticInterposition");
661
662 auto *Val = cast_or_null<ConstantAsMetadata>(MF);
663 if (!Val)
664 return false;
665
666 return cast<ConstantInt>(Val->getValue())->getZExtValue();
667}
668
670 addModuleFlag(ModFlagBehavior::Error, "SemanticInterposition", SI);
671}
672
673void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
674 OwnedMemoryBuffer = std::move(MB);
675}
676
678 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
679 return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
680}
681
683 addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
684}
685
687 auto *Val = cast_or_null<ConstantAsMetadata>(
688 getModuleFlag("direct-access-external-data"));
689 if (Val)
690 return cast<ConstantInt>(Val->getValue())->getZExtValue() > 0;
691 return getPICLevel() == PICLevel::NotPIC;
692}
693
695 addModuleFlag(ModFlagBehavior::Max, "direct-access-external-data", Value);
696}
697
699 if (auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("uwtable")))
700 return UWTableKind(cast<ConstantInt>(Val->getValue())->getZExtValue());
701 return UWTableKind::None;
702}
703
706}
707
709 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("frame-pointer"));
710 return static_cast<FramePointerKind>(
711 Val ? cast<ConstantInt>(Val->getValue())->getZExtValue() : 0);
712}
713
715 addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind));
716}
717
719 Metadata *MD = getModuleFlag("stack-protector-guard");
720 if (auto *MDS = dyn_cast_or_null<MDString>(MD))
721 return MDS->getString();
722 return {};
723}
724
727 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard", ID);
728}
729
731 Metadata *MD = getModuleFlag("stack-protector-guard-reg");
732 if (auto *MDS = dyn_cast_or_null<MDString>(MD))
733 return MDS->getString();
734 return {};
735}
736
739 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-reg", ID);
740}
741
743 Metadata *MD = getModuleFlag("stack-protector-guard-symbol");
744 if (auto *MDS = dyn_cast_or_null<MDString>(MD))
745 return MDS->getString();
746 return {};
747}
748
750 MDString *ID = MDString::get(getContext(), Symbol);
751 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-symbol", ID);
752}
753
755 Metadata *MD = getModuleFlag("stack-protector-guard-offset");
756 if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
757 return CI->getSExtValue();
758 return INT_MAX;
759}
760
762 addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-offset", Offset);
763}
764
766 Metadata *MD = getModuleFlag("override-stack-alignment");
767 if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
768 return CI->getZExtValue();
769 return 0;
770}
771
773 Metadata *MD = getModuleFlag("MaxTLSAlign");
774 if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
775 return CI->getZExtValue();
776 return 0;
777}
778
780 addModuleFlag(ModFlagBehavior::Error, "override-stack-alignment", Align);
781}
782
785 Entries.push_back(V.getMajor());
786 if (auto Minor = V.getMinor()) {
787 Entries.push_back(*Minor);
788 if (auto Subminor = V.getSubminor())
789 Entries.push_back(*Subminor);
790 // Ignore the 'build' component as it can't be represented in the object
791 // file.
792 }
793 M.addModuleFlag(Module::ModFlagBehavior::Warning, Name,
794 ConstantDataArray::get(M.getContext(), Entries));
795}
796
798 addSDKVersionMD(V, *this, "SDK Version");
799}
800
802 auto *CM = dyn_cast_or_null<ConstantAsMetadata>(MD);
803 if (!CM)
804 return {};
805 auto *Arr = dyn_cast_or_null<ConstantDataArray>(CM->getValue());
806 if (!Arr)
807 return {};
808 auto getVersionComponent = [&](unsigned Index) -> std::optional<unsigned> {
809 if (Index >= Arr->getNumElements())
810 return std::nullopt;
811 return (unsigned)Arr->getElementAsInteger(Index);
812 };
813 auto Major = getVersionComponent(0);
814 if (!Major)
815 return {};
816 VersionTuple Result = VersionTuple(*Major);
817 if (auto Minor = getVersionComponent(1)) {
818 Result = VersionTuple(*Major, *Minor);
819 if (auto Subminor = getVersionComponent(2)) {
820 Result = VersionTuple(*Major, *Minor, *Subminor);
821 }
822 }
823 return Result;
824}
825
827 return getSDKVersionMD(getModuleFlag("SDK Version"));
828}
829
831 const Module &M, SmallVectorImpl<GlobalValue *> &Vec, bool CompilerUsed) {
832 const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
833 GlobalVariable *GV = M.getGlobalVariable(Name);
834 if (!GV || !GV->hasInitializer())
835 return GV;
836
837 const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
838 for (Value *Op : Init->operands()) {
839 GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
840 Vec.push_back(G);
841 }
842 return GV;
843}
844
846 if (auto *SummaryMD = getProfileSummary(/*IsCS*/ false)) {
847 std::unique_ptr<ProfileSummary> ProfileSummary(
848 ProfileSummary::getFromMD(SummaryMD));
849 if (ProfileSummary) {
852 return;
853 uint64_t BlockCount = Index.getBlockCount();
854 uint32_t NumCounts = ProfileSummary->getNumCounts();
855 if (!NumCounts)
856 return;
857 double Ratio = (double)BlockCount / NumCounts;
861 }
862 }
863}
864
866 if (const auto *MD = getModuleFlag("darwin.target_variant.triple"))
867 return cast<MDString>(MD)->getString();
868 return "";
869}
870
872 addModuleFlag(ModFlagBehavior::Warning, "darwin.target_variant.triple",
874}
875
877 return getSDKVersionMD(getModuleFlag("darwin.target_variant.SDK Version"));
878}
879
881 addSDKVersionMD(Version, *this, "darwin.target_variant.SDK Version");
882}
This file defines the StringMap class.
This file contains the simple types necessary to represent the attributes associated with functions a...
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 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:801
static void addSDKVersionMD(const VersionTuple &V, Module &M, StringRef Name)
Definition: Module.cpp:783
cl::opt< bool > UseNewDbgInfoFormat
Module.h This file contains the declarations for the Module class.
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:424
static ConstantAsMetadata * get(Constant *C)
Definition: Metadata.h:528
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:706
This is the shared class of boolean and integer constants.
Definition: Constants.h:81
This is an important base class in LLVM.
Definition: Constant.h:42
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:103
unsigned getProgramAddressSpace() const
Definition: DataLayout.h:260
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:168
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:172
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:52
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:1069
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1542
A single uniqued string.
Definition: Metadata.h:720
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:606
Root of the metadata hierarchy.
Definition: Metadata.h:62
Class to hold module path string table and global value map, and encapsulate methods for operating on...
DICompileUnit * operator*() const
Definition: Module.cpp:394
DICompileUnit * operator->() const
Definition: Module.cpp:397
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
void setStackProtectorGuardSymbol(StringRef Symbol)
Definition: Module.cpp:749
void setSemanticInterposition(bool)
Set whether semantic interposition is to be respected.
Definition: Module.cpp:669
NamedMDNode * getNamedMetadata(StringRef Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:262
void eraseNamedMDNode(NamedMDNode *MDNode)
Remove MDNode from the list and delete it.
Definition: Module.h:639
ModFlagBehavior
This enumeration defines the supported behaviors of module flags.
Definition: Module.h:115
@ 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:440
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:299
void setOverrideStackAlignment(unsigned Align)
Definition: Module.cpp:779
void setDirectAccessExternalData(bool Value)
Definition: Module.cpp:694
unsigned getMaxTLSAlignment() const
Definition: Module.cpp:772
void setOwnedMemoryBuffer(std::unique_ptr< MemoryBuffer > MB)
Take ownership of the given memory buffer.
Definition: Module.cpp:673
void setMaterializer(GVMaterializer *GVM)
Sets the GVMaterializer to GVM.
Definition: Module.cpp:426
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:433
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:193
void setCodeModel(CodeModel::Model CL)
Set the code model (tiny, small, kernel, medium or large)
Definition: Module.cpp:622
StringRef getStackProtectorGuardSymbol() const
Get/set a symbol to use as the stack protector guard.
Definition: Module.cpp:742
iterator_range< ifunc_iterator > ifuncs()
Definition: Module.h:757
bool getSemanticInterposition() const
Returns whether semantic interposition is to be respected.
Definition: Module.cpp:659
void getMDKindNames(SmallVectorImpl< StringRef > &Result) const
Populate client supplied SmallVector with the name for custom metadata IDs registered in this LLVMCon...
Definition: Module.cpp:152
Module(StringRef ModuleID, LLVMContext &C)
The Module constructor.
Definition: Module.cpp:74
void removeDebugIntrinsicDeclarations()
Used when printing this module in the new debug info format; removes all declarations of debug intrin...
Definition: Module.cpp:90
void setRtLibUseGOT()
Set that PLT should be avoid for RTLib calls.
Definition: Module.cpp:682
llvm::Error materializeMetadata()
Definition: Module.cpp:447
NamedMDNode * getOrInsertModuleFlagsMetadata()
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.cpp:333
iterator_range< iterator > functions()
Definition: Module.h:721
void eraseNamedMetadata(NamedMDNode *NMD)
Remove the given NamedMDNode from this module and delete it.
Definition: Module.cpp:283
unsigned getNumNamedValues() const
Return the number of global values in the module.
Definition: Module.cpp:139
unsigned getMDKindID(StringRef Name) const
Return a unique non-zero ID for the specified metadata kind.
Definition: Module.cpp:145
void setFramePointer(FramePointerKind Kind)
Definition: Module.cpp:714
std::optional< uint64_t > getLargeDataThreshold() const
Returns the code model (tiny, small, kernel, medium or large model)
Definition: Module.cpp:630
StringRef getStackProtectorGuard() const
Get/set what kind of stack protector guard to use.
Definition: Module.cpp:718
bool getRtLibUseGOT() const
Returns true if PLT should be avoided for RTLib calls.
Definition: Module.cpp:677
void setModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Like addModuleFlag but replaces the old module flag if it already exists.
Definition: Module.cpp:368
UWTableKind getUwtable() const
Get/set whether synthesized functions should get the uwtable attribute.
Definition: Module.cpp:698
void dropAllReferences()
This function causes all the subinstructions to "let go" of all references that they are maintaining.
Definition: Module.cpp:528
void setStackProtectorGuard(StringRef Kind)
Definition: Module.cpp:725
iterator_range< alias_iterator > aliases()
Definition: Module.h:739
void setProfileSummary(Metadata *M, ProfileSummary::Kind Kind)
Attach profile summary metadata to this module.
Definition: Module.cpp:647
void setUwtable(UWTableKind Kind)
Definition: Module.cpp:704
unsigned getCodeViewFlag() const
Returns the CodeView Version by checking module flags.
Definition: Module.cpp:562
void setPartialSampleProfileRatio(const ModuleSummaryIndex &Index)
Set the partial sample profile ratio in the profile summary module flag, if applicable.
Definition: Module.cpp:845
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:471
~Module()
The module destructor. This will dropAllReferences.
Definition: Module.cpp:81
FramePointerKind getFramePointer() const
Get/set whether synthesized functions should get the "frame-pointer" attribute.
Definition: Module.cpp:708
unsigned getOverrideStackAlignment() const
Get/set the stack alignment overridden from the default.
Definition: Module.cpp:765
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Add a module-level flag to the module-level flags metadata.
Definition: Module.cpp:342
void setStackProtectorGuardReg(StringRef Reg)
Definition: Module.cpp:737
PICLevel::Level getPICLevel() const
Returns the PIC level (small or large model)
Definition: Module.cpp:582
std::unique_ptr< RandomNumberGenerator > createRNG(const StringRef Name) const
Get a RandomNumberGenerator salted for use with this module.
Definition: Module.cpp:113
iterator_range< global_iterator > globals()
Definition: Module.h:699
std::vector< StructType * > getIdentifiedStructTypes() const
Definition: Module.cpp:457
void setDarwinTargetVariantTriple(StringRef T)
Set the target variant triple which is a string describing a variant of the target host platform.
Definition: Module.cpp:871
void setPICLevel(PICLevel::Level PL)
Set the PIC level (small or large model)
Definition: Module.cpp:592
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:265
unsigned getNumberRegisterParameters() const
Returns the Number of Register ParametersDwarf Version by checking module flags.
Definition: Module.cpp:542
void insertNamedMDNode(NamedMDNode *MDNode)
Insert MDNode at the end of the alias list and take ownership.
Definition: Module.h:641
GlobalIFunc * getNamedIFunc(StringRef Name) const
Return the global ifunc in the module with the specified name, of arbitrary type.
Definition: Module.cpp:255
StringRef getStackProtectorGuardReg() const
Get/set which register to use as the stack protector guard register.
Definition: Module.cpp:730
unsigned getDwarfVersion() const
Returns the Dwarf Version by checking module flags.
Definition: Module.cpp:550
void setDataLayout(StringRef Desc)
Set the data layout.
Definition: Module.cpp:390
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:444
void setLargeDataThreshold(uint64_t Threshold)
Set the code model (tiny, small, kernel, medium or large)
Definition: Module.cpp:640
bool isDwarf64() const
Returns the DWARF format by checking module flags.
Definition: Module.cpp:557
static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB)
Checks if Metadata represents a valid ModFlagBehavior, and stores the converted result in MFB.
Definition: Module.cpp:290
const ValueSymbolTable & getValueSymbolTable() const
Get the symbol table of global variable and function identifiers.
Definition: Module.h:679
void setStackProtectorGuardOffset(int Offset)
Definition: Module.cpp:761
iterator_range< global_object_iterator > global_objects()
Definition: Module.cpp:407
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type.
Definition: Module.cpp:135
unsigned getInstructionCount() const
Returns the number of non-debug IR instructions in the module.
Definition: Module.cpp:569
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Definition: Module.cpp:269
void getOperandBundleTags(SmallVectorImpl< StringRef > &Result) const
Populate client supplied SmallVector with the bundle tags registered in this LLVMContext.
Definition: Module.cpp:156
bool isMaterialized() const
Definition: Module.h:566
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:576
FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:169
Constant * getOrInsertGlobal(StringRef Name, Type *Ty, function_ref< GlobalVariable *()> CreateGlobalCallback)
Look up the specified global in the module symbol table.
Definition: Module.cpp:223
std::optional< CodeModel::Model > getCodeModel() const
Returns the code model (tiny, small, kernel, medium or large model)
Definition: Module.cpp:612
NamedMDNode * getModuleFlagsMetadata() const
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.h:534
VersionTuple getDarwinTargetVariantSDKVersion() const
Get the target variant version build SDK version metadata.
Definition: Module.cpp:876
void setPIELevel(PIELevel::Level PL)
Set the PIE level (small or large model)
Definition: Module.cpp:608
VersionTuple getSDKVersion() const
Get the build SDK version metadata.
Definition: Module.cpp:826
GlobalAlias * getNamedAlias(StringRef Name) const
Return the global alias in the module with the specified name, of arbitrary type.
Definition: Module.cpp:251
void setDarwinTargetVariantSDKVersion(VersionTuple Version)
Set the target variant version build SDK version metadata.
Definition: Module.cpp:880
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition: Module.cpp:598
StringRef getDarwinTargetVariantTriple() const
Get the target variant triple which is a string describing a variant of the target host platform.
Definition: Module.cpp:865
void setSDKVersion(const VersionTuple &V)
Attach a build SDK version metadata to this module.
Definition: Module.cpp:797
iterator_range< global_value_iterator > global_values()
Definition: Module.cpp:415
int getStackProtectorGuardOffset() const
Get/set what offset from the stack protector to use.
Definition: Module.cpp:754
bool getDirectAccessExternalData() const
Get/set whether referencing global variables can use direct access relocations on ELF targets.
Definition: Module.cpp:686
Metadata * getProfileSummary(bool IsCS) const
Returns profile summary metadata.
Definition: Module.cpp:654
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:319
A tuple of MDNodes.
Definition: Metadata.h:1730
StringRef getName() const
Definition: Metadata.cpp:1405
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1388
iterator_range< op_iterator > operands()
Definition: Metadata.h:1826
void addOperand(MDNode *M)
Definition: Metadata.cpp:1394
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:587
void push_back(const T &Elt)
Definition: SmallVector.h:427
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1210
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:253
void erase(iterator I)
Definition: StringMap.h:416
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:308
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
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(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:29
An efficient, type-erasing, non-owning reference to a callable.
void clear()
Definition: ilist.h:246
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
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1539
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:578
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
FramePointerKind
Definition: CodeGen.h:90
UWTableKind
Definition: CodeGen.h:120
@ None
No unwind table requested.
@ Other
Any other memory.
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:830
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Description of the encoding of one expression Op.