10b57cec5SDimitry Andric //===- Module.cpp - Implement the Module class ----------------------------===//
20b57cec5SDimitry Andric //
30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information.
50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
60b57cec5SDimitry Andric //
70b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
80b57cec5SDimitry Andric //
90b57cec5SDimitry Andric // This file implements the Module class for the IR library.
100b57cec5SDimitry Andric //
110b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
120b57cec5SDimitry Andric
130b57cec5SDimitry Andric #include "llvm/IR/Module.h"
140b57cec5SDimitry Andric #include "SymbolTableListTraitsImpl.h"
150b57cec5SDimitry Andric #include "llvm/ADT/SmallString.h"
160b57cec5SDimitry Andric #include "llvm/ADT/SmallVector.h"
170b57cec5SDimitry Andric #include "llvm/ADT/StringMap.h"
180b57cec5SDimitry Andric #include "llvm/ADT/StringRef.h"
190b57cec5SDimitry Andric #include "llvm/ADT/Twine.h"
200b57cec5SDimitry Andric #include "llvm/IR/Attributes.h"
210b57cec5SDimitry Andric #include "llvm/IR/Comdat.h"
220b57cec5SDimitry Andric #include "llvm/IR/Constants.h"
230b57cec5SDimitry Andric #include "llvm/IR/DataLayout.h"
240b57cec5SDimitry Andric #include "llvm/IR/DebugInfoMetadata.h"
250b57cec5SDimitry Andric #include "llvm/IR/DerivedTypes.h"
260b57cec5SDimitry Andric #include "llvm/IR/Function.h"
270b57cec5SDimitry Andric #include "llvm/IR/GVMaterializer.h"
280b57cec5SDimitry Andric #include "llvm/IR/GlobalAlias.h"
290b57cec5SDimitry Andric #include "llvm/IR/GlobalIFunc.h"
300b57cec5SDimitry Andric #include "llvm/IR/GlobalValue.h"
310b57cec5SDimitry Andric #include "llvm/IR/GlobalVariable.h"
320b57cec5SDimitry Andric #include "llvm/IR/LLVMContext.h"
330b57cec5SDimitry Andric #include "llvm/IR/Metadata.h"
345ffd83dbSDimitry Andric #include "llvm/IR/ModuleSummaryIndex.h"
350b57cec5SDimitry Andric #include "llvm/IR/SymbolTableListTraits.h"
360b57cec5SDimitry Andric #include "llvm/IR/Type.h"
370b57cec5SDimitry Andric #include "llvm/IR/TypeFinder.h"
380b57cec5SDimitry Andric #include "llvm/IR/Value.h"
390b57cec5SDimitry Andric #include "llvm/IR/ValueSymbolTable.h"
400b57cec5SDimitry Andric #include "llvm/Support/Casting.h"
410b57cec5SDimitry Andric #include "llvm/Support/CodeGen.h"
420b57cec5SDimitry Andric #include "llvm/Support/Error.h"
430b57cec5SDimitry Andric #include "llvm/Support/MemoryBuffer.h"
440b57cec5SDimitry Andric #include "llvm/Support/Path.h"
450b57cec5SDimitry Andric #include "llvm/Support/RandomNumberGenerator.h"
460b57cec5SDimitry Andric #include "llvm/Support/VersionTuple.h"
470b57cec5SDimitry Andric #include <algorithm>
480b57cec5SDimitry Andric #include <cassert>
490b57cec5SDimitry Andric #include <cstdint>
500b57cec5SDimitry Andric #include <memory>
51bdd1243dSDimitry Andric #include <optional>
520b57cec5SDimitry Andric #include <utility>
530b57cec5SDimitry Andric #include <vector>
540b57cec5SDimitry Andric
550b57cec5SDimitry Andric using namespace llvm;
560b57cec5SDimitry Andric
570b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
580b57cec5SDimitry Andric // Methods to implement the globals and functions lists.
590b57cec5SDimitry Andric //
600b57cec5SDimitry Andric
610b57cec5SDimitry Andric // Explicit instantiations of SymbolTableListTraits since some of the methods
620b57cec5SDimitry Andric // are not in the public header file.
630b57cec5SDimitry Andric template class llvm::SymbolTableListTraits<Function>;
640b57cec5SDimitry Andric template class llvm::SymbolTableListTraits<GlobalVariable>;
650b57cec5SDimitry Andric template class llvm::SymbolTableListTraits<GlobalAlias>;
660b57cec5SDimitry Andric template class llvm::SymbolTableListTraits<GlobalIFunc>;
670b57cec5SDimitry Andric
680b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
690b57cec5SDimitry Andric // Primitive Module methods.
700b57cec5SDimitry Andric //
710b57cec5SDimitry Andric
Module(StringRef MID,LLVMContext & C)720b57cec5SDimitry Andric Module::Module(StringRef MID, LLVMContext &C)
73fe6060f1SDimitry Andric : Context(C), ValSymTab(std::make_unique<ValueSymbolTable>(-1)),
745f757f3fSDimitry Andric ModuleID(std::string(MID)), SourceFileName(std::string(MID)), DL(""),
755f757f3fSDimitry Andric IsNewDbgInfoFormat(false) {
760b57cec5SDimitry Andric Context.addModule(this);
770b57cec5SDimitry Andric }
780b57cec5SDimitry Andric
~Module()790b57cec5SDimitry Andric Module::~Module() {
800b57cec5SDimitry Andric Context.removeModule(this);
810b57cec5SDimitry Andric dropAllReferences();
820b57cec5SDimitry Andric GlobalList.clear();
830b57cec5SDimitry Andric FunctionList.clear();
840b57cec5SDimitry Andric AliasList.clear();
850b57cec5SDimitry Andric IFuncList.clear();
860b57cec5SDimitry Andric }
870b57cec5SDimitry Andric
885ffd83dbSDimitry Andric std::unique_ptr<RandomNumberGenerator>
createRNG(const StringRef Name) const895ffd83dbSDimitry Andric Module::createRNG(const StringRef Name) const {
905ffd83dbSDimitry Andric SmallString<32> Salt(Name);
910b57cec5SDimitry Andric
920b57cec5SDimitry Andric // This RNG is guaranteed to produce the same random stream only
930b57cec5SDimitry Andric // when the Module ID and thus the input filename is the same. This
940b57cec5SDimitry Andric // might be problematic if the input filename extension changes
950b57cec5SDimitry Andric // (e.g. from .c to .bc or .ll).
960b57cec5SDimitry Andric //
970b57cec5SDimitry Andric // We could store this salt in NamedMetadata, but this would make
980b57cec5SDimitry Andric // the parameter non-const. This would unfortunately make this
990b57cec5SDimitry Andric // interface unusable by any Machine passes, since they only have a
1000b57cec5SDimitry Andric // const reference to their IR Module. Alternatively we can always
1010b57cec5SDimitry Andric // store salt metadata from the Module constructor.
1020b57cec5SDimitry Andric Salt += sys::path::filename(getModuleIdentifier());
1030b57cec5SDimitry Andric
1045ffd83dbSDimitry Andric return std::unique_ptr<RandomNumberGenerator>(
1055ffd83dbSDimitry Andric new RandomNumberGenerator(Salt));
1060b57cec5SDimitry Andric }
1070b57cec5SDimitry Andric
1080b57cec5SDimitry Andric /// getNamedValue - Return the first global value in the module with
1090b57cec5SDimitry Andric /// the specified name, of arbitrary type. This method returns null
1100b57cec5SDimitry Andric /// if a global with the specified name is not found.
getNamedValue(StringRef Name) const1110b57cec5SDimitry Andric GlobalValue *Module::getNamedValue(StringRef Name) const {
1120b57cec5SDimitry Andric return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
1130b57cec5SDimitry Andric }
1140b57cec5SDimitry Andric
getNumNamedValues() const1156e75b2fbSDimitry Andric unsigned Module::getNumNamedValues() const {
1166e75b2fbSDimitry Andric return getValueSymbolTable().size();
1176e75b2fbSDimitry Andric }
1186e75b2fbSDimitry Andric
1190b57cec5SDimitry Andric /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
1200b57cec5SDimitry Andric /// This ID is uniqued across modules in the current LLVMContext.
getMDKindID(StringRef Name) const1210b57cec5SDimitry Andric unsigned Module::getMDKindID(StringRef Name) const {
1220b57cec5SDimitry Andric return Context.getMDKindID(Name);
1230b57cec5SDimitry Andric }
1240b57cec5SDimitry Andric
1250b57cec5SDimitry Andric /// getMDKindNames - Populate client supplied SmallVector with the name for
1260b57cec5SDimitry Andric /// custom metadata IDs registered in this LLVMContext. ID #0 is not used,
1270b57cec5SDimitry Andric /// so it is filled in as an empty string.
getMDKindNames(SmallVectorImpl<StringRef> & Result) const1280b57cec5SDimitry Andric void Module::getMDKindNames(SmallVectorImpl<StringRef> &Result) const {
1290b57cec5SDimitry Andric return Context.getMDKindNames(Result);
1300b57cec5SDimitry Andric }
1310b57cec5SDimitry Andric
getOperandBundleTags(SmallVectorImpl<StringRef> & Result) const1320b57cec5SDimitry Andric void Module::getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const {
1330b57cec5SDimitry Andric return Context.getOperandBundleTags(Result);
1340b57cec5SDimitry Andric }
1350b57cec5SDimitry Andric
1360b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
1370b57cec5SDimitry Andric // Methods for easy access to the functions in the module.
1380b57cec5SDimitry Andric //
1390b57cec5SDimitry Andric
1400b57cec5SDimitry Andric // getOrInsertFunction - Look up the specified function in the module symbol
1410b57cec5SDimitry Andric // table. If it does not exist, add a prototype for the function and return
1420b57cec5SDimitry Andric // it. This is nice because it allows most passes to get away with not handling
1430b57cec5SDimitry Andric // the symbol table directly for this common task.
1440b57cec5SDimitry Andric //
getOrInsertFunction(StringRef Name,FunctionType * Ty,AttributeList AttributeList)1450b57cec5SDimitry Andric FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty,
1460b57cec5SDimitry Andric AttributeList AttributeList) {
1470b57cec5SDimitry Andric // See if we have a definition for the specified function already.
1480b57cec5SDimitry Andric GlobalValue *F = getNamedValue(Name);
1490b57cec5SDimitry Andric if (!F) {
1500b57cec5SDimitry Andric // Nope, add it
1510b57cec5SDimitry Andric Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage,
1520b57cec5SDimitry Andric DL.getProgramAddressSpace(), Name);
1530b57cec5SDimitry Andric if (!New->isIntrinsic()) // Intrinsics get attrs set on construction
1540b57cec5SDimitry Andric New->setAttributes(AttributeList);
1550b57cec5SDimitry Andric FunctionList.push_back(New);
1560b57cec5SDimitry Andric return {Ty, New}; // Return the new prototype.
1570b57cec5SDimitry Andric }
1580b57cec5SDimitry Andric
1590b57cec5SDimitry Andric // Otherwise, we just found the existing function or a prototype.
1600b57cec5SDimitry Andric return {Ty, F};
1610b57cec5SDimitry Andric }
1620b57cec5SDimitry Andric
getOrInsertFunction(StringRef Name,FunctionType * Ty)1630b57cec5SDimitry Andric FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty) {
1640b57cec5SDimitry Andric return getOrInsertFunction(Name, Ty, AttributeList());
1650b57cec5SDimitry Andric }
1660b57cec5SDimitry Andric
1670b57cec5SDimitry Andric // getFunction - Look up the specified function in the module symbol table.
1680b57cec5SDimitry Andric // If it does not exist, return null.
1690b57cec5SDimitry Andric //
getFunction(StringRef Name) const1700b57cec5SDimitry Andric Function *Module::getFunction(StringRef Name) const {
1710b57cec5SDimitry Andric return dyn_cast_or_null<Function>(getNamedValue(Name));
1720b57cec5SDimitry Andric }
1730b57cec5SDimitry Andric
1740b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
1750b57cec5SDimitry Andric // Methods for easy access to the global variables in the module.
1760b57cec5SDimitry Andric //
1770b57cec5SDimitry Andric
1780b57cec5SDimitry Andric /// getGlobalVariable - Look up the specified global variable in the module
1790b57cec5SDimitry Andric /// symbol table. If it does not exist, return null. The type argument
1800b57cec5SDimitry Andric /// should be the underlying type of the global, i.e., it should not have
1810b57cec5SDimitry Andric /// the top-level PointerType, which represents the address of the global.
1820b57cec5SDimitry Andric /// If AllowLocal is set to true, this function will return types that
1830b57cec5SDimitry Andric /// have an local. By default, these types are not returned.
1840b57cec5SDimitry Andric ///
getGlobalVariable(StringRef Name,bool AllowLocal) const1850b57cec5SDimitry Andric GlobalVariable *Module::getGlobalVariable(StringRef Name,
1860b57cec5SDimitry Andric bool AllowLocal) const {
1870b57cec5SDimitry Andric if (GlobalVariable *Result =
1880b57cec5SDimitry Andric dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
1890b57cec5SDimitry Andric if (AllowLocal || !Result->hasLocalLinkage())
1900b57cec5SDimitry Andric return Result;
1910b57cec5SDimitry Andric return nullptr;
1920b57cec5SDimitry Andric }
1930b57cec5SDimitry Andric
1940b57cec5SDimitry Andric /// getOrInsertGlobal - Look up the specified global in the module symbol table.
1950b57cec5SDimitry Andric /// 1. If it does not exist, add a declaration of the global and return it.
1960b57cec5SDimitry Andric /// 2. Else, the global exists but has the wrong type: return the function
1970b57cec5SDimitry Andric /// with a constantexpr cast to the right type.
1980b57cec5SDimitry Andric /// 3. Finally, if the existing global is the correct declaration, return the
1990b57cec5SDimitry Andric /// existing global.
getOrInsertGlobal(StringRef Name,Type * Ty,function_ref<GlobalVariable * ()> CreateGlobalCallback)2000b57cec5SDimitry Andric Constant *Module::getOrInsertGlobal(
2010b57cec5SDimitry Andric StringRef Name, Type *Ty,
2020b57cec5SDimitry Andric function_ref<GlobalVariable *()> CreateGlobalCallback) {
2030b57cec5SDimitry Andric // See if we have a definition for the specified global already.
2040b57cec5SDimitry Andric GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
2050b57cec5SDimitry Andric if (!GV)
2060b57cec5SDimitry Andric GV = CreateGlobalCallback();
2070b57cec5SDimitry Andric assert(GV && "The CreateGlobalCallback is expected to create a global");
2080b57cec5SDimitry Andric
2090b57cec5SDimitry Andric // Otherwise, we just found the existing function or a prototype.
2100b57cec5SDimitry Andric return GV;
2110b57cec5SDimitry Andric }
2120b57cec5SDimitry Andric
2130b57cec5SDimitry Andric // Overload to construct a global variable using its constructor's defaults.
getOrInsertGlobal(StringRef Name,Type * Ty)2140b57cec5SDimitry Andric Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) {
2150b57cec5SDimitry Andric return getOrInsertGlobal(Name, Ty, [&] {
2160b57cec5SDimitry Andric return new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
2170b57cec5SDimitry Andric nullptr, Name);
2180b57cec5SDimitry Andric });
2190b57cec5SDimitry Andric }
2200b57cec5SDimitry Andric
2210b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
2220b57cec5SDimitry Andric // Methods for easy access to the global variables in the module.
2230b57cec5SDimitry Andric //
2240b57cec5SDimitry Andric
2250b57cec5SDimitry Andric // getNamedAlias - Look up the specified global in the module symbol table.
2260b57cec5SDimitry Andric // If it does not exist, return null.
2270b57cec5SDimitry Andric //
getNamedAlias(StringRef Name) const2280b57cec5SDimitry Andric GlobalAlias *Module::getNamedAlias(StringRef Name) const {
2290b57cec5SDimitry Andric return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
2300b57cec5SDimitry Andric }
2310b57cec5SDimitry Andric
getNamedIFunc(StringRef Name) const2320b57cec5SDimitry Andric GlobalIFunc *Module::getNamedIFunc(StringRef Name) const {
2330b57cec5SDimitry Andric return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name));
2340b57cec5SDimitry Andric }
2350b57cec5SDimitry Andric
2360b57cec5SDimitry Andric /// getNamedMetadata - Return the first NamedMDNode in the module with the
2370b57cec5SDimitry Andric /// specified name. This method returns null if a NamedMDNode with the
2380b57cec5SDimitry Andric /// specified name is not found.
getNamedMetadata(const Twine & Name) const2390b57cec5SDimitry Andric NamedMDNode *Module::getNamedMetadata(const Twine &Name) const {
2400b57cec5SDimitry Andric SmallString<256> NameData;
2410b57cec5SDimitry Andric StringRef NameRef = Name.toStringRef(NameData);
2425ffd83dbSDimitry Andric return NamedMDSymTab.lookup(NameRef);
2430b57cec5SDimitry Andric }
2440b57cec5SDimitry Andric
2450b57cec5SDimitry Andric /// getOrInsertNamedMetadata - Return the first named MDNode in the module
2460b57cec5SDimitry Andric /// with the specified name. This method returns a new NamedMDNode if a
2470b57cec5SDimitry Andric /// NamedMDNode with the specified name is not found.
getOrInsertNamedMetadata(StringRef Name)2480b57cec5SDimitry Andric NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) {
2495ffd83dbSDimitry Andric NamedMDNode *&NMD = NamedMDSymTab[Name];
2500b57cec5SDimitry Andric if (!NMD) {
2510b57cec5SDimitry Andric NMD = new NamedMDNode(Name);
2520b57cec5SDimitry Andric NMD->setParent(this);
25306c3fb27SDimitry Andric insertNamedMDNode(NMD);
2540b57cec5SDimitry Andric }
2550b57cec5SDimitry Andric return NMD;
2560b57cec5SDimitry Andric }
2570b57cec5SDimitry Andric
2580b57cec5SDimitry Andric /// eraseNamedMetadata - Remove the given NamedMDNode from this module and
2590b57cec5SDimitry Andric /// delete it.
eraseNamedMetadata(NamedMDNode * NMD)2600b57cec5SDimitry Andric void Module::eraseNamedMetadata(NamedMDNode *NMD) {
2615ffd83dbSDimitry Andric NamedMDSymTab.erase(NMD->getName());
26206c3fb27SDimitry Andric eraseNamedMDNode(NMD);
2630b57cec5SDimitry Andric }
2640b57cec5SDimitry Andric
isValidModFlagBehavior(Metadata * MD,ModFlagBehavior & MFB)2650b57cec5SDimitry Andric bool Module::isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB) {
2660b57cec5SDimitry Andric if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
2670b57cec5SDimitry Andric uint64_t Val = Behavior->getLimitedValue();
2680b57cec5SDimitry Andric if (Val >= ModFlagBehaviorFirstVal && Val <= ModFlagBehaviorLastVal) {
2690b57cec5SDimitry Andric MFB = static_cast<ModFlagBehavior>(Val);
2700b57cec5SDimitry Andric return true;
2710b57cec5SDimitry Andric }
2720b57cec5SDimitry Andric }
2730b57cec5SDimitry Andric return false;
2740b57cec5SDimitry Andric }
2750b57cec5SDimitry Andric
isValidModuleFlag(const MDNode & ModFlag,ModFlagBehavior & MFB,MDString * & Key,Metadata * & Val)2765ffd83dbSDimitry Andric bool Module::isValidModuleFlag(const MDNode &ModFlag, ModFlagBehavior &MFB,
2775ffd83dbSDimitry Andric MDString *&Key, Metadata *&Val) {
2785ffd83dbSDimitry Andric if (ModFlag.getNumOperands() < 3)
2795ffd83dbSDimitry Andric return false;
2805ffd83dbSDimitry Andric if (!isValidModFlagBehavior(ModFlag.getOperand(0), MFB))
2815ffd83dbSDimitry Andric return false;
2825ffd83dbSDimitry Andric MDString *K = dyn_cast_or_null<MDString>(ModFlag.getOperand(1));
2835ffd83dbSDimitry Andric if (!K)
2845ffd83dbSDimitry Andric return false;
2855ffd83dbSDimitry Andric Key = K;
2865ffd83dbSDimitry Andric Val = ModFlag.getOperand(2);
2875ffd83dbSDimitry Andric return true;
2885ffd83dbSDimitry Andric }
2895ffd83dbSDimitry Andric
2900b57cec5SDimitry Andric /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
2910b57cec5SDimitry Andric void Module::
getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> & Flags) const2920b57cec5SDimitry Andric getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const {
2930b57cec5SDimitry Andric const NamedMDNode *ModFlags = getModuleFlagsMetadata();
2940b57cec5SDimitry Andric if (!ModFlags) return;
2950b57cec5SDimitry Andric
2960b57cec5SDimitry Andric for (const MDNode *Flag : ModFlags->operands()) {
2970b57cec5SDimitry Andric ModFlagBehavior MFB;
2985ffd83dbSDimitry Andric MDString *Key = nullptr;
2995ffd83dbSDimitry Andric Metadata *Val = nullptr;
3005ffd83dbSDimitry Andric if (isValidModuleFlag(*Flag, MFB, Key, Val)) {
3010b57cec5SDimitry Andric // Check the operands of the MDNode before accessing the operands.
3020b57cec5SDimitry Andric // The verifier will actually catch these failures.
3030b57cec5SDimitry Andric Flags.push_back(ModuleFlagEntry(MFB, Key, Val));
3040b57cec5SDimitry Andric }
3050b57cec5SDimitry Andric }
3060b57cec5SDimitry Andric }
3070b57cec5SDimitry Andric
3080b57cec5SDimitry Andric /// Return the corresponding value if Key appears in module flags, otherwise
3090b57cec5SDimitry Andric /// return null.
getModuleFlag(StringRef Key) const3100b57cec5SDimitry Andric Metadata *Module::getModuleFlag(StringRef Key) const {
3110b57cec5SDimitry Andric SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
3120b57cec5SDimitry Andric getModuleFlagsMetadata(ModuleFlags);
3130b57cec5SDimitry Andric for (const ModuleFlagEntry &MFE : ModuleFlags) {
3140b57cec5SDimitry Andric if (Key == MFE.Key->getString())
3150b57cec5SDimitry Andric return MFE.Val;
3160b57cec5SDimitry Andric }
3170b57cec5SDimitry Andric return nullptr;
3180b57cec5SDimitry Andric }
3190b57cec5SDimitry Andric
3200b57cec5SDimitry Andric /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
3210b57cec5SDimitry Andric /// represents module-level flags. This method returns null if there are no
3220b57cec5SDimitry Andric /// module-level flags.
getModuleFlagsMetadata() const3230b57cec5SDimitry Andric NamedMDNode *Module::getModuleFlagsMetadata() const {
3240b57cec5SDimitry Andric return getNamedMetadata("llvm.module.flags");
3250b57cec5SDimitry Andric }
3260b57cec5SDimitry Andric
3270b57cec5SDimitry Andric /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
3280b57cec5SDimitry Andric /// represents module-level flags. If module-level flags aren't found, it
3290b57cec5SDimitry Andric /// creates the named metadata that contains them.
getOrInsertModuleFlagsMetadata()3300b57cec5SDimitry Andric NamedMDNode *Module::getOrInsertModuleFlagsMetadata() {
3310b57cec5SDimitry Andric return getOrInsertNamedMetadata("llvm.module.flags");
3320b57cec5SDimitry Andric }
3330b57cec5SDimitry Andric
3340b57cec5SDimitry Andric /// addModuleFlag - Add a module-level flag to the module-level flags
3350b57cec5SDimitry Andric /// metadata. It will create the module-level flags named metadata if it doesn't
3360b57cec5SDimitry Andric /// already exist.
addModuleFlag(ModFlagBehavior Behavior,StringRef Key,Metadata * Val)3370b57cec5SDimitry Andric void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
3380b57cec5SDimitry Andric Metadata *Val) {
3390b57cec5SDimitry Andric Type *Int32Ty = Type::getInt32Ty(Context);
3400b57cec5SDimitry Andric Metadata *Ops[3] = {
3410b57cec5SDimitry Andric ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
3420b57cec5SDimitry Andric MDString::get(Context, Key), Val};
3430b57cec5SDimitry Andric getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops));
3440b57cec5SDimitry Andric }
addModuleFlag(ModFlagBehavior Behavior,StringRef Key,Constant * Val)3450b57cec5SDimitry Andric void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
3460b57cec5SDimitry Andric Constant *Val) {
3470b57cec5SDimitry Andric addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
3480b57cec5SDimitry Andric }
addModuleFlag(ModFlagBehavior Behavior,StringRef Key,uint32_t Val)3490b57cec5SDimitry Andric void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
3500b57cec5SDimitry Andric uint32_t Val) {
3510b57cec5SDimitry Andric Type *Int32Ty = Type::getInt32Ty(Context);
3520b57cec5SDimitry Andric addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
3530b57cec5SDimitry Andric }
addModuleFlag(MDNode * Node)3540b57cec5SDimitry Andric void Module::addModuleFlag(MDNode *Node) {
3550b57cec5SDimitry Andric assert(Node->getNumOperands() == 3 &&
3560b57cec5SDimitry Andric "Invalid number of operands for module flag!");
3570b57cec5SDimitry Andric assert(mdconst::hasa<ConstantInt>(Node->getOperand(0)) &&
3580b57cec5SDimitry Andric isa<MDString>(Node->getOperand(1)) &&
3590b57cec5SDimitry Andric "Invalid operand types for module flag!");
3600b57cec5SDimitry Andric getOrInsertModuleFlagsMetadata()->addOperand(Node);
3610b57cec5SDimitry Andric }
3620b57cec5SDimitry Andric
setModuleFlag(ModFlagBehavior Behavior,StringRef Key,Metadata * Val)3635ffd83dbSDimitry Andric void Module::setModuleFlag(ModFlagBehavior Behavior, StringRef Key,
3645ffd83dbSDimitry Andric Metadata *Val) {
3655ffd83dbSDimitry Andric NamedMDNode *ModFlags = getOrInsertModuleFlagsMetadata();
3665ffd83dbSDimitry Andric // Replace the flag if it already exists.
3675ffd83dbSDimitry Andric for (unsigned I = 0, E = ModFlags->getNumOperands(); I != E; ++I) {
3685ffd83dbSDimitry Andric MDNode *Flag = ModFlags->getOperand(I);
3695ffd83dbSDimitry Andric ModFlagBehavior MFB;
3705ffd83dbSDimitry Andric MDString *K = nullptr;
3715ffd83dbSDimitry Andric Metadata *V = nullptr;
3725ffd83dbSDimitry Andric if (isValidModuleFlag(*Flag, MFB, K, V) && K->getString() == Key) {
3735ffd83dbSDimitry Andric Flag->replaceOperandWith(2, Val);
3745ffd83dbSDimitry Andric return;
3755ffd83dbSDimitry Andric }
3765ffd83dbSDimitry Andric }
3775ffd83dbSDimitry Andric addModuleFlag(Behavior, Key, Val);
3785ffd83dbSDimitry Andric }
3795ffd83dbSDimitry Andric
setDataLayout(StringRef Desc)3800b57cec5SDimitry Andric void Module::setDataLayout(StringRef Desc) {
3810b57cec5SDimitry Andric DL.reset(Desc);
3820b57cec5SDimitry Andric }
3830b57cec5SDimitry Andric
setDataLayout(const DataLayout & Other)3840b57cec5SDimitry Andric void Module::setDataLayout(const DataLayout &Other) { DL = Other; }
3850b57cec5SDimitry Andric
operator *() const3860b57cec5SDimitry Andric DICompileUnit *Module::debug_compile_units_iterator::operator*() const {
3870b57cec5SDimitry Andric return cast<DICompileUnit>(CUs->getOperand(Idx));
3880b57cec5SDimitry Andric }
operator ->() const3890b57cec5SDimitry Andric DICompileUnit *Module::debug_compile_units_iterator::operator->() const {
3900b57cec5SDimitry Andric return cast<DICompileUnit>(CUs->getOperand(Idx));
3910b57cec5SDimitry Andric }
3920b57cec5SDimitry Andric
SkipNoDebugCUs()3930b57cec5SDimitry Andric void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
3940b57cec5SDimitry Andric while (CUs && (Idx < CUs->getNumOperands()) &&
3950b57cec5SDimitry Andric ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
3960b57cec5SDimitry Andric ++Idx;
3970b57cec5SDimitry Andric }
3980b57cec5SDimitry Andric
global_objects()399480093f4SDimitry Andric iterator_range<Module::global_object_iterator> Module::global_objects() {
400480093f4SDimitry Andric return concat<GlobalObject>(functions(), globals());
401480093f4SDimitry Andric }
402480093f4SDimitry Andric iterator_range<Module::const_global_object_iterator>
global_objects() const403480093f4SDimitry Andric Module::global_objects() const {
404480093f4SDimitry Andric return concat<const GlobalObject>(functions(), globals());
405480093f4SDimitry Andric }
406480093f4SDimitry Andric
global_values()407480093f4SDimitry Andric iterator_range<Module::global_value_iterator> Module::global_values() {
408480093f4SDimitry Andric return concat<GlobalValue>(functions(), globals(), aliases(), ifuncs());
409480093f4SDimitry Andric }
410480093f4SDimitry Andric iterator_range<Module::const_global_value_iterator>
global_values() const411480093f4SDimitry Andric Module::global_values() const {
412480093f4SDimitry Andric return concat<const GlobalValue>(functions(), globals(), aliases(), ifuncs());
413480093f4SDimitry Andric }
414480093f4SDimitry Andric
4150b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
4160b57cec5SDimitry Andric // Methods to control the materialization of GlobalValues in the Module.
4170b57cec5SDimitry Andric //
setMaterializer(GVMaterializer * GVM)4180b57cec5SDimitry Andric void Module::setMaterializer(GVMaterializer *GVM) {
4190b57cec5SDimitry Andric assert(!Materializer &&
4200b57cec5SDimitry Andric "Module already has a GVMaterializer. Call materializeAll"
4210b57cec5SDimitry Andric " to clear it out before setting another one.");
4220b57cec5SDimitry Andric Materializer.reset(GVM);
4230b57cec5SDimitry Andric }
4240b57cec5SDimitry Andric
materialize(GlobalValue * GV)4250b57cec5SDimitry Andric Error Module::materialize(GlobalValue *GV) {
4260b57cec5SDimitry Andric if (!Materializer)
4270b57cec5SDimitry Andric return Error::success();
4280b57cec5SDimitry Andric
4290b57cec5SDimitry Andric return Materializer->materialize(GV);
4300b57cec5SDimitry Andric }
4310b57cec5SDimitry Andric
materializeAll()4320b57cec5SDimitry Andric Error Module::materializeAll() {
4330b57cec5SDimitry Andric if (!Materializer)
4340b57cec5SDimitry Andric return Error::success();
4350b57cec5SDimitry Andric std::unique_ptr<GVMaterializer> M = std::move(Materializer);
4360b57cec5SDimitry Andric return M->materializeModule();
4370b57cec5SDimitry Andric }
4380b57cec5SDimitry Andric
materializeMetadata()4390b57cec5SDimitry Andric Error Module::materializeMetadata() {
4400b57cec5SDimitry Andric if (!Materializer)
4410b57cec5SDimitry Andric return Error::success();
4420b57cec5SDimitry Andric return Materializer->materializeMetadata();
4430b57cec5SDimitry Andric }
4440b57cec5SDimitry Andric
4450b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
4460b57cec5SDimitry Andric // Other module related stuff.
4470b57cec5SDimitry Andric //
4480b57cec5SDimitry Andric
getIdentifiedStructTypes() const4490b57cec5SDimitry Andric std::vector<StructType *> Module::getIdentifiedStructTypes() const {
4500b57cec5SDimitry Andric // If we have a materializer, it is possible that some unread function
4510b57cec5SDimitry Andric // uses a type that is currently not visible to a TypeFinder, so ask
4520b57cec5SDimitry Andric // the materializer which types it created.
4530b57cec5SDimitry Andric if (Materializer)
4540b57cec5SDimitry Andric return Materializer->getIdentifiedStructTypes();
4550b57cec5SDimitry Andric
4560b57cec5SDimitry Andric std::vector<StructType *> Ret;
4570b57cec5SDimitry Andric TypeFinder SrcStructTypes;
4580b57cec5SDimitry Andric SrcStructTypes.run(*this, true);
4590b57cec5SDimitry Andric Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
4600b57cec5SDimitry Andric return Ret;
4610b57cec5SDimitry Andric }
4620b57cec5SDimitry Andric
getUniqueIntrinsicName(StringRef BaseName,Intrinsic::ID Id,const FunctionType * Proto)463fe6060f1SDimitry Andric std::string Module::getUniqueIntrinsicName(StringRef BaseName, Intrinsic::ID Id,
464fe6060f1SDimitry Andric const FunctionType *Proto) {
465fe6060f1SDimitry Andric auto Encode = [&BaseName](unsigned Suffix) {
466fe6060f1SDimitry Andric return (Twine(BaseName) + "." + Twine(Suffix)).str();
467fe6060f1SDimitry Andric };
468fe6060f1SDimitry Andric
469fe6060f1SDimitry Andric {
470fe6060f1SDimitry Andric // fast path - the prototype is already known
471fe6060f1SDimitry Andric auto UinItInserted = UniquedIntrinsicNames.insert({{Id, Proto}, 0});
472fe6060f1SDimitry Andric if (!UinItInserted.second)
473fe6060f1SDimitry Andric return Encode(UinItInserted.first->second);
474fe6060f1SDimitry Andric }
475fe6060f1SDimitry Andric
476fe6060f1SDimitry Andric // Not known yet. A new entry was created with index 0. Check if there already
477fe6060f1SDimitry Andric // exists a matching declaration, or select a new entry.
478fe6060f1SDimitry Andric
479fe6060f1SDimitry Andric // Start looking for names with the current known maximum count (or 0).
480fe6060f1SDimitry Andric auto NiidItInserted = CurrentIntrinsicIds.insert({BaseName, 0});
481fe6060f1SDimitry Andric unsigned Count = NiidItInserted.first->second;
482fe6060f1SDimitry Andric
483fe6060f1SDimitry Andric // This might be slow if a whole population of intrinsics already existed, but
484fe6060f1SDimitry Andric // we cache the values for later usage.
485fe6060f1SDimitry Andric std::string NewName;
486fe6060f1SDimitry Andric while (true) {
487fe6060f1SDimitry Andric NewName = Encode(Count);
488fe6060f1SDimitry Andric GlobalValue *F = getNamedValue(NewName);
489fe6060f1SDimitry Andric if (!F) {
490fe6060f1SDimitry Andric // Reserve this entry for the new proto
491fe6060f1SDimitry Andric UniquedIntrinsicNames[{Id, Proto}] = Count;
492fe6060f1SDimitry Andric break;
493fe6060f1SDimitry Andric }
494fe6060f1SDimitry Andric
495fe6060f1SDimitry Andric // A declaration with this name already exists. Remember it.
496fe6060f1SDimitry Andric FunctionType *FT = dyn_cast<FunctionType>(F->getValueType());
497fe6060f1SDimitry Andric auto UinItInserted = UniquedIntrinsicNames.insert({{Id, FT}, Count});
498fe6060f1SDimitry Andric if (FT == Proto) {
499fe6060f1SDimitry Andric // It was a declaration for our prototype. This entry was allocated in the
500fe6060f1SDimitry Andric // beginning. Update the count to match the existing declaration.
501fe6060f1SDimitry Andric UinItInserted.first->second = Count;
502fe6060f1SDimitry Andric break;
503fe6060f1SDimitry Andric }
504fe6060f1SDimitry Andric
505fe6060f1SDimitry Andric ++Count;
506fe6060f1SDimitry Andric }
507fe6060f1SDimitry Andric
508fe6060f1SDimitry Andric NiidItInserted.first->second = Count + 1;
509fe6060f1SDimitry Andric
510fe6060f1SDimitry Andric return NewName;
511fe6060f1SDimitry Andric }
512fe6060f1SDimitry Andric
5130b57cec5SDimitry Andric // dropAllReferences() - This function causes all the subelements to "let go"
5140b57cec5SDimitry Andric // of all references that they are maintaining. This allows one to 'delete' a
5150b57cec5SDimitry Andric // whole module at a time, even though there may be circular references... first
5160b57cec5SDimitry Andric // all references are dropped, and all use counts go to zero. Then everything
5170b57cec5SDimitry Andric // is deleted for real. Note that no operations are valid on an object that
5180b57cec5SDimitry Andric // has "dropped all references", except operator delete.
5190b57cec5SDimitry Andric //
dropAllReferences()5200b57cec5SDimitry Andric void Module::dropAllReferences() {
5210b57cec5SDimitry Andric for (Function &F : *this)
5220b57cec5SDimitry Andric F.dropAllReferences();
5230b57cec5SDimitry Andric
5240b57cec5SDimitry Andric for (GlobalVariable &GV : globals())
5250b57cec5SDimitry Andric GV.dropAllReferences();
5260b57cec5SDimitry Andric
5270b57cec5SDimitry Andric for (GlobalAlias &GA : aliases())
5280b57cec5SDimitry Andric GA.dropAllReferences();
5290b57cec5SDimitry Andric
5300b57cec5SDimitry Andric for (GlobalIFunc &GIF : ifuncs())
5310b57cec5SDimitry Andric GIF.dropAllReferences();
5320b57cec5SDimitry Andric }
5330b57cec5SDimitry Andric
getNumberRegisterParameters() const5340b57cec5SDimitry Andric unsigned Module::getNumberRegisterParameters() const {
5350b57cec5SDimitry Andric auto *Val =
5360b57cec5SDimitry Andric cast_or_null<ConstantAsMetadata>(getModuleFlag("NumRegisterParameters"));
5370b57cec5SDimitry Andric if (!Val)
5380b57cec5SDimitry Andric return 0;
5390b57cec5SDimitry Andric return cast<ConstantInt>(Val->getValue())->getZExtValue();
5400b57cec5SDimitry Andric }
5410b57cec5SDimitry Andric
getDwarfVersion() const5420b57cec5SDimitry Andric unsigned Module::getDwarfVersion() const {
5430b57cec5SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
5440b57cec5SDimitry Andric if (!Val)
5450b57cec5SDimitry Andric return 0;
5460b57cec5SDimitry Andric return cast<ConstantInt>(Val->getValue())->getZExtValue();
5470b57cec5SDimitry Andric }
5480b57cec5SDimitry Andric
isDwarf64() const549fe6060f1SDimitry Andric bool Module::isDwarf64() const {
550fe6060f1SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("DWARF64"));
551fe6060f1SDimitry Andric return Val && cast<ConstantInt>(Val->getValue())->isOne();
552fe6060f1SDimitry Andric }
553fe6060f1SDimitry Andric
getCodeViewFlag() const5540b57cec5SDimitry Andric unsigned Module::getCodeViewFlag() const {
5550b57cec5SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
5560b57cec5SDimitry Andric if (!Val)
5570b57cec5SDimitry Andric return 0;
5580b57cec5SDimitry Andric return cast<ConstantInt>(Val->getValue())->getZExtValue();
5590b57cec5SDimitry Andric }
5600b57cec5SDimitry Andric
getInstructionCount() const561fe6060f1SDimitry Andric unsigned Module::getInstructionCount() const {
5620b57cec5SDimitry Andric unsigned NumInstrs = 0;
563fe6060f1SDimitry Andric for (const Function &F : FunctionList)
5640b57cec5SDimitry Andric NumInstrs += F.getInstructionCount();
5650b57cec5SDimitry Andric return NumInstrs;
5660b57cec5SDimitry Andric }
5670b57cec5SDimitry Andric
getOrInsertComdat(StringRef Name)5680b57cec5SDimitry Andric Comdat *Module::getOrInsertComdat(StringRef Name) {
5690b57cec5SDimitry Andric auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
5700b57cec5SDimitry Andric Entry.second.Name = &Entry;
5710b57cec5SDimitry Andric return &Entry.second;
5720b57cec5SDimitry Andric }
5730b57cec5SDimitry Andric
getPICLevel() const5740b57cec5SDimitry Andric PICLevel::Level Module::getPICLevel() const {
5750b57cec5SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
5760b57cec5SDimitry Andric
5770b57cec5SDimitry Andric if (!Val)
5780b57cec5SDimitry Andric return PICLevel::NotPIC;
5790b57cec5SDimitry Andric
5800b57cec5SDimitry Andric return static_cast<PICLevel::Level>(
5810b57cec5SDimitry Andric cast<ConstantInt>(Val->getValue())->getZExtValue());
5820b57cec5SDimitry Andric }
5830b57cec5SDimitry Andric
setPICLevel(PICLevel::Level PL)5840b57cec5SDimitry Andric void Module::setPICLevel(PICLevel::Level PL) {
585bdd1243dSDimitry Andric // The merge result of a non-PIC object and a PIC object can only be reliably
586bdd1243dSDimitry Andric // used as a non-PIC object, so use the Min merge behavior.
587bdd1243dSDimitry Andric addModuleFlag(ModFlagBehavior::Min, "PIC Level", PL);
5880b57cec5SDimitry Andric }
5890b57cec5SDimitry Andric
getPIELevel() const5900b57cec5SDimitry Andric PIELevel::Level Module::getPIELevel() const {
5910b57cec5SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
5920b57cec5SDimitry Andric
5930b57cec5SDimitry Andric if (!Val)
5940b57cec5SDimitry Andric return PIELevel::Default;
5950b57cec5SDimitry Andric
5960b57cec5SDimitry Andric return static_cast<PIELevel::Level>(
5970b57cec5SDimitry Andric cast<ConstantInt>(Val->getValue())->getZExtValue());
5980b57cec5SDimitry Andric }
5990b57cec5SDimitry Andric
setPIELevel(PIELevel::Level PL)6000b57cec5SDimitry Andric void Module::setPIELevel(PIELevel::Level PL) {
6010b57cec5SDimitry Andric addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
6020b57cec5SDimitry Andric }
6030b57cec5SDimitry Andric
getCodeModel() const604bdd1243dSDimitry Andric std::optional<CodeModel::Model> Module::getCodeModel() const {
6050b57cec5SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Code Model"));
6060b57cec5SDimitry Andric
6070b57cec5SDimitry Andric if (!Val)
608bdd1243dSDimitry Andric return std::nullopt;
6090b57cec5SDimitry Andric
6100b57cec5SDimitry Andric return static_cast<CodeModel::Model>(
6110b57cec5SDimitry Andric cast<ConstantInt>(Val->getValue())->getZExtValue());
6120b57cec5SDimitry Andric }
6130b57cec5SDimitry Andric
setCodeModel(CodeModel::Model CL)6140b57cec5SDimitry Andric void Module::setCodeModel(CodeModel::Model CL) {
6150b57cec5SDimitry Andric // Linking object files with different code models is undefined behavior
6160b57cec5SDimitry Andric // because the compiler would have to generate additional code (to span
6170b57cec5SDimitry Andric // longer jumps) if a larger code model is used with a smaller one.
6180b57cec5SDimitry Andric // Therefore we will treat attempts to mix code models as an error.
6190b57cec5SDimitry Andric addModuleFlag(ModFlagBehavior::Error, "Code Model", CL);
6200b57cec5SDimitry Andric }
6210b57cec5SDimitry Andric
getLargeDataThreshold() const6225f757f3fSDimitry Andric std::optional<uint64_t> Module::getLargeDataThreshold() const {
6235f757f3fSDimitry Andric auto *Val =
6245f757f3fSDimitry Andric cast_or_null<ConstantAsMetadata>(getModuleFlag("Large Data Threshold"));
6255f757f3fSDimitry Andric
6265f757f3fSDimitry Andric if (!Val)
6275f757f3fSDimitry Andric return std::nullopt;
6285f757f3fSDimitry Andric
6295f757f3fSDimitry Andric return cast<ConstantInt>(Val->getValue())->getZExtValue();
6305f757f3fSDimitry Andric }
6315f757f3fSDimitry Andric
setLargeDataThreshold(uint64_t Threshold)6325f757f3fSDimitry Andric void Module::setLargeDataThreshold(uint64_t Threshold) {
6335f757f3fSDimitry Andric // Since the large data threshold goes along with the code model, the merge
6345f757f3fSDimitry Andric // behavior is the same.
6355f757f3fSDimitry Andric addModuleFlag(ModFlagBehavior::Error, "Large Data Threshold",
6365f757f3fSDimitry Andric ConstantInt::get(Type::getInt64Ty(Context), Threshold));
6375f757f3fSDimitry Andric }
6385f757f3fSDimitry Andric
setProfileSummary(Metadata * M,ProfileSummary::Kind Kind)6390b57cec5SDimitry Andric void Module::setProfileSummary(Metadata *M, ProfileSummary::Kind Kind) {
6400b57cec5SDimitry Andric if (Kind == ProfileSummary::PSK_CSInstr)
6415ffd83dbSDimitry Andric setModuleFlag(ModFlagBehavior::Error, "CSProfileSummary", M);
6420b57cec5SDimitry Andric else
6435ffd83dbSDimitry Andric setModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
6440b57cec5SDimitry Andric }
6450b57cec5SDimitry Andric
getProfileSummary(bool IsCS) const646e8d8bef9SDimitry Andric Metadata *Module::getProfileSummary(bool IsCS) const {
6470b57cec5SDimitry Andric return (IsCS ? getModuleFlag("CSProfileSummary")
6480b57cec5SDimitry Andric : getModuleFlag("ProfileSummary"));
6490b57cec5SDimitry Andric }
6500b57cec5SDimitry Andric
getSemanticInterposition() const6515ffd83dbSDimitry Andric bool Module::getSemanticInterposition() const {
6525ffd83dbSDimitry Andric Metadata *MF = getModuleFlag("SemanticInterposition");
6535ffd83dbSDimitry Andric
6545ffd83dbSDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(MF);
6555ffd83dbSDimitry Andric if (!Val)
6565ffd83dbSDimitry Andric return false;
6575ffd83dbSDimitry Andric
6585ffd83dbSDimitry Andric return cast<ConstantInt>(Val->getValue())->getZExtValue();
6595ffd83dbSDimitry Andric }
6605ffd83dbSDimitry Andric
setSemanticInterposition(bool SI)6615ffd83dbSDimitry Andric void Module::setSemanticInterposition(bool SI) {
6625ffd83dbSDimitry Andric addModuleFlag(ModFlagBehavior::Error, "SemanticInterposition", SI);
6635ffd83dbSDimitry Andric }
6645ffd83dbSDimitry Andric
setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB)6650b57cec5SDimitry Andric void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
6660b57cec5SDimitry Andric OwnedMemoryBuffer = std::move(MB);
6670b57cec5SDimitry Andric }
6680b57cec5SDimitry Andric
getRtLibUseGOT() const6690b57cec5SDimitry Andric bool Module::getRtLibUseGOT() const {
6700b57cec5SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
6710b57cec5SDimitry Andric return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
6720b57cec5SDimitry Andric }
6730b57cec5SDimitry Andric
setRtLibUseGOT()6740b57cec5SDimitry Andric void Module::setRtLibUseGOT() {
6750b57cec5SDimitry Andric addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
6760b57cec5SDimitry Andric }
6770b57cec5SDimitry Andric
getDirectAccessExternalData() const67806c3fb27SDimitry Andric bool Module::getDirectAccessExternalData() const {
67906c3fb27SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(
68006c3fb27SDimitry Andric getModuleFlag("direct-access-external-data"));
68106c3fb27SDimitry Andric if (Val)
68206c3fb27SDimitry Andric return cast<ConstantInt>(Val->getValue())->getZExtValue() > 0;
68306c3fb27SDimitry Andric return getPICLevel() == PICLevel::NotPIC;
68406c3fb27SDimitry Andric }
68506c3fb27SDimitry Andric
setDirectAccessExternalData(bool Value)68606c3fb27SDimitry Andric void Module::setDirectAccessExternalData(bool Value) {
68706c3fb27SDimitry Andric addModuleFlag(ModFlagBehavior::Max, "direct-access-external-data", Value);
68806c3fb27SDimitry Andric }
68906c3fb27SDimitry Andric
getUwtable() const69081ad6265SDimitry Andric UWTableKind Module::getUwtable() const {
69181ad6265SDimitry Andric if (auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("uwtable")))
69281ad6265SDimitry Andric return UWTableKind(cast<ConstantInt>(Val->getValue())->getZExtValue());
69381ad6265SDimitry Andric return UWTableKind::None;
694fe6060f1SDimitry Andric }
695fe6060f1SDimitry Andric
setUwtable(UWTableKind Kind)69681ad6265SDimitry Andric void Module::setUwtable(UWTableKind Kind) {
69781ad6265SDimitry Andric addModuleFlag(ModFlagBehavior::Max, "uwtable", uint32_t(Kind));
69881ad6265SDimitry Andric }
699fe6060f1SDimitry Andric
getFramePointer() const700fe6060f1SDimitry Andric FramePointerKind Module::getFramePointer() const {
701fe6060f1SDimitry Andric auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("frame-pointer"));
702fe6060f1SDimitry Andric return static_cast<FramePointerKind>(
703fe6060f1SDimitry Andric Val ? cast<ConstantInt>(Val->getValue())->getZExtValue() : 0);
704fe6060f1SDimitry Andric }
705fe6060f1SDimitry Andric
setFramePointer(FramePointerKind Kind)706fe6060f1SDimitry Andric void Module::setFramePointer(FramePointerKind Kind) {
707fe6060f1SDimitry Andric addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind));
708fe6060f1SDimitry Andric }
709fe6060f1SDimitry Andric
getStackProtectorGuard() const710fe6060f1SDimitry Andric StringRef Module::getStackProtectorGuard() const {
711fe6060f1SDimitry Andric Metadata *MD = getModuleFlag("stack-protector-guard");
712fe6060f1SDimitry Andric if (auto *MDS = dyn_cast_or_null<MDString>(MD))
713fe6060f1SDimitry Andric return MDS->getString();
714fe6060f1SDimitry Andric return {};
715fe6060f1SDimitry Andric }
716fe6060f1SDimitry Andric
setStackProtectorGuard(StringRef Kind)717fe6060f1SDimitry Andric void Module::setStackProtectorGuard(StringRef Kind) {
718fe6060f1SDimitry Andric MDString *ID = MDString::get(getContext(), Kind);
719fe6060f1SDimitry Andric addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard", ID);
720fe6060f1SDimitry Andric }
721fe6060f1SDimitry Andric
getStackProtectorGuardReg() const722fe6060f1SDimitry Andric StringRef Module::getStackProtectorGuardReg() const {
723fe6060f1SDimitry Andric Metadata *MD = getModuleFlag("stack-protector-guard-reg");
724fe6060f1SDimitry Andric if (auto *MDS = dyn_cast_or_null<MDString>(MD))
725fe6060f1SDimitry Andric return MDS->getString();
726fe6060f1SDimitry Andric return {};
727fe6060f1SDimitry Andric }
728fe6060f1SDimitry Andric
setStackProtectorGuardReg(StringRef Reg)729fe6060f1SDimitry Andric void Module::setStackProtectorGuardReg(StringRef Reg) {
730fe6060f1SDimitry Andric MDString *ID = MDString::get(getContext(), Reg);
731fe6060f1SDimitry Andric addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-reg", ID);
732fe6060f1SDimitry Andric }
733fe6060f1SDimitry Andric
getStackProtectorGuardSymbol() const734753f127fSDimitry Andric StringRef Module::getStackProtectorGuardSymbol() const {
735753f127fSDimitry Andric Metadata *MD = getModuleFlag("stack-protector-guard-symbol");
736753f127fSDimitry Andric if (auto *MDS = dyn_cast_or_null<MDString>(MD))
737753f127fSDimitry Andric return MDS->getString();
738753f127fSDimitry Andric return {};
739753f127fSDimitry Andric }
740753f127fSDimitry Andric
setStackProtectorGuardSymbol(StringRef Symbol)741753f127fSDimitry Andric void Module::setStackProtectorGuardSymbol(StringRef Symbol) {
742753f127fSDimitry Andric MDString *ID = MDString::get(getContext(), Symbol);
743753f127fSDimitry Andric addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-symbol", ID);
744753f127fSDimitry Andric }
745753f127fSDimitry Andric
getStackProtectorGuardOffset() const746fe6060f1SDimitry Andric int Module::getStackProtectorGuardOffset() const {
747fe6060f1SDimitry Andric Metadata *MD = getModuleFlag("stack-protector-guard-offset");
748fe6060f1SDimitry Andric if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
749fe6060f1SDimitry Andric return CI->getSExtValue();
750fe6060f1SDimitry Andric return INT_MAX;
751fe6060f1SDimitry Andric }
752fe6060f1SDimitry Andric
setStackProtectorGuardOffset(int Offset)753fe6060f1SDimitry Andric void Module::setStackProtectorGuardOffset(int Offset) {
754fe6060f1SDimitry Andric addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-offset", Offset);
755fe6060f1SDimitry Andric }
756fe6060f1SDimitry Andric
getOverrideStackAlignment() const757fe6060f1SDimitry Andric unsigned Module::getOverrideStackAlignment() const {
758fe6060f1SDimitry Andric Metadata *MD = getModuleFlag("override-stack-alignment");
759fe6060f1SDimitry Andric if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
760fe6060f1SDimitry Andric return CI->getZExtValue();
761fe6060f1SDimitry Andric return 0;
762fe6060f1SDimitry Andric }
763fe6060f1SDimitry Andric
getMaxTLSAlignment() const76406c3fb27SDimitry Andric unsigned Module::getMaxTLSAlignment() const {
76506c3fb27SDimitry Andric Metadata *MD = getModuleFlag("MaxTLSAlign");
76606c3fb27SDimitry Andric if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
76706c3fb27SDimitry Andric return CI->getZExtValue();
76806c3fb27SDimitry Andric return 0;
76906c3fb27SDimitry Andric }
77006c3fb27SDimitry Andric
setOverrideStackAlignment(unsigned Align)771fe6060f1SDimitry Andric void Module::setOverrideStackAlignment(unsigned Align) {
772fe6060f1SDimitry Andric addModuleFlag(ModFlagBehavior::Error, "override-stack-alignment", Align);
773fe6060f1SDimitry Andric }
774fe6060f1SDimitry Andric
addSDKVersionMD(const VersionTuple & V,Module & M,StringRef Name)77581ad6265SDimitry Andric static void addSDKVersionMD(const VersionTuple &V, Module &M, StringRef Name) {
7760b57cec5SDimitry Andric SmallVector<unsigned, 3> Entries;
7770b57cec5SDimitry Andric Entries.push_back(V.getMajor());
7780b57cec5SDimitry Andric if (auto Minor = V.getMinor()) {
7790b57cec5SDimitry Andric Entries.push_back(*Minor);
7800b57cec5SDimitry Andric if (auto Subminor = V.getSubminor())
7810b57cec5SDimitry Andric Entries.push_back(*Subminor);
7820b57cec5SDimitry Andric // Ignore the 'build' component as it can't be represented in the object
7830b57cec5SDimitry Andric // file.
7840b57cec5SDimitry Andric }
78581ad6265SDimitry Andric M.addModuleFlag(Module::ModFlagBehavior::Warning, Name,
78681ad6265SDimitry Andric ConstantDataArray::get(M.getContext(), Entries));
78781ad6265SDimitry Andric }
78881ad6265SDimitry Andric
setSDKVersion(const VersionTuple & V)78981ad6265SDimitry Andric void Module::setSDKVersion(const VersionTuple &V) {
79081ad6265SDimitry Andric addSDKVersionMD(V, *this, "SDK Version");
7910b57cec5SDimitry Andric }
7920b57cec5SDimitry Andric
getSDKVersionMD(Metadata * MD)7930eae32dcSDimitry Andric static VersionTuple getSDKVersionMD(Metadata *MD) {
7940eae32dcSDimitry Andric auto *CM = dyn_cast_or_null<ConstantAsMetadata>(MD);
7950b57cec5SDimitry Andric if (!CM)
7960b57cec5SDimitry Andric return {};
7970b57cec5SDimitry Andric auto *Arr = dyn_cast_or_null<ConstantDataArray>(CM->getValue());
7980b57cec5SDimitry Andric if (!Arr)
7990b57cec5SDimitry Andric return {};
800bdd1243dSDimitry Andric auto getVersionComponent = [&](unsigned Index) -> std::optional<unsigned> {
8010b57cec5SDimitry Andric if (Index >= Arr->getNumElements())
802bdd1243dSDimitry Andric return std::nullopt;
8030b57cec5SDimitry Andric return (unsigned)Arr->getElementAsInteger(Index);
8040b57cec5SDimitry Andric };
8050b57cec5SDimitry Andric auto Major = getVersionComponent(0);
8060b57cec5SDimitry Andric if (!Major)
8070b57cec5SDimitry Andric return {};
8080b57cec5SDimitry Andric VersionTuple Result = VersionTuple(*Major);
8090b57cec5SDimitry Andric if (auto Minor = getVersionComponent(1)) {
8100b57cec5SDimitry Andric Result = VersionTuple(*Major, *Minor);
8110b57cec5SDimitry Andric if (auto Subminor = getVersionComponent(2)) {
8120b57cec5SDimitry Andric Result = VersionTuple(*Major, *Minor, *Subminor);
8130b57cec5SDimitry Andric }
8140b57cec5SDimitry Andric }
8150b57cec5SDimitry Andric return Result;
8160b57cec5SDimitry Andric }
8170b57cec5SDimitry Andric
getSDKVersion() const8180eae32dcSDimitry Andric VersionTuple Module::getSDKVersion() const {
8190eae32dcSDimitry Andric return getSDKVersionMD(getModuleFlag("SDK Version"));
8200eae32dcSDimitry Andric }
8210eae32dcSDimitry Andric
collectUsedGlobalVariables(const Module & M,SmallVectorImpl<GlobalValue * > & Vec,bool CompilerUsed)8220b57cec5SDimitry Andric GlobalVariable *llvm::collectUsedGlobalVariables(
823fe6060f1SDimitry Andric const Module &M, SmallVectorImpl<GlobalValue *> &Vec, bool CompilerUsed) {
8240b57cec5SDimitry Andric const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
8250b57cec5SDimitry Andric GlobalVariable *GV = M.getGlobalVariable(Name);
8260b57cec5SDimitry Andric if (!GV || !GV->hasInitializer())
8270b57cec5SDimitry Andric return GV;
8280b57cec5SDimitry Andric
8290b57cec5SDimitry Andric const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
8300b57cec5SDimitry Andric for (Value *Op : Init->operands()) {
8318bcb0991SDimitry Andric GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
832fe6060f1SDimitry Andric Vec.push_back(G);
8330b57cec5SDimitry Andric }
8340b57cec5SDimitry Andric return GV;
8350b57cec5SDimitry Andric }
8365ffd83dbSDimitry Andric
setPartialSampleProfileRatio(const ModuleSummaryIndex & Index)8375ffd83dbSDimitry Andric void Module::setPartialSampleProfileRatio(const ModuleSummaryIndex &Index) {
8385ffd83dbSDimitry Andric if (auto *SummaryMD = getProfileSummary(/*IsCS*/ false)) {
8395ffd83dbSDimitry Andric std::unique_ptr<ProfileSummary> ProfileSummary(
8405ffd83dbSDimitry Andric ProfileSummary::getFromMD(SummaryMD));
8415ffd83dbSDimitry Andric if (ProfileSummary) {
8425ffd83dbSDimitry Andric if (ProfileSummary->getKind() != ProfileSummary::PSK_Sample ||
8435ffd83dbSDimitry Andric !ProfileSummary->isPartialProfile())
8445ffd83dbSDimitry Andric return;
8455ffd83dbSDimitry Andric uint64_t BlockCount = Index.getBlockCount();
8465ffd83dbSDimitry Andric uint32_t NumCounts = ProfileSummary->getNumCounts();
8475ffd83dbSDimitry Andric if (!NumCounts)
8485ffd83dbSDimitry Andric return;
8495ffd83dbSDimitry Andric double Ratio = (double)BlockCount / NumCounts;
8505ffd83dbSDimitry Andric ProfileSummary->setPartialProfileRatio(Ratio);
8515ffd83dbSDimitry Andric setProfileSummary(ProfileSummary->getMD(getContext()),
8525ffd83dbSDimitry Andric ProfileSummary::PSK_Sample);
8535ffd83dbSDimitry Andric }
8545ffd83dbSDimitry Andric }
8555ffd83dbSDimitry Andric }
8560eae32dcSDimitry Andric
getDarwinTargetVariantTriple() const8570eae32dcSDimitry Andric StringRef Module::getDarwinTargetVariantTriple() const {
8580eae32dcSDimitry Andric if (const auto *MD = getModuleFlag("darwin.target_variant.triple"))
8590eae32dcSDimitry Andric return cast<MDString>(MD)->getString();
8600eae32dcSDimitry Andric return "";
8610eae32dcSDimitry Andric }
8620eae32dcSDimitry Andric
setDarwinTargetVariantTriple(StringRef T)86381ad6265SDimitry Andric void Module::setDarwinTargetVariantTriple(StringRef T) {
86481ad6265SDimitry Andric addModuleFlag(ModFlagBehavior::Override, "darwin.target_variant.triple",
86581ad6265SDimitry Andric MDString::get(getContext(), T));
86681ad6265SDimitry Andric }
86781ad6265SDimitry Andric
getDarwinTargetVariantSDKVersion() const8680eae32dcSDimitry Andric VersionTuple Module::getDarwinTargetVariantSDKVersion() const {
8690eae32dcSDimitry Andric return getSDKVersionMD(getModuleFlag("darwin.target_variant.SDK Version"));
8700eae32dcSDimitry Andric }
87181ad6265SDimitry Andric
setDarwinTargetVariantSDKVersion(VersionTuple Version)87281ad6265SDimitry Andric void Module::setDarwinTargetVariantSDKVersion(VersionTuple Version) {
87381ad6265SDimitry Andric addSDKVersionMD(Version, *this, "darwin.target_variant.SDK Version");
87481ad6265SDimitry Andric }
875