|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/BlockFrequencyInfo.h 29 class Module;
include/llvm/Analysis/CGSCCPassManager.h 112 class Module;
include/llvm/Analysis/CallGraph.h 65 class Module;
include/llvm/Analysis/DivergenceAnalysis.h 25 class Module;
include/llvm/Analysis/LazyCallGraph.h 63 class Module;
include/llvm/Analysis/Lint.h 25 class Module;
include/llvm/Analysis/ModuleSummaryAnalysis.h 26 class Module;
include/llvm/AsmParser/Parser.h 22 class Module;
include/llvm/Bitcode/BitcodeReader.h 32 class Module;
include/llvm/Bitcode/BitcodeWriter.h 28 class Module;
include/llvm/Bitcode/BitcodeWriterPass.h 21 class Module;
include/llvm/CodeGen/AsmPrinter.h 71 class Module;
include/llvm/CodeGen/GCMetadataPrinter.h 30 class Module;
include/llvm/CodeGen/IntrinsicLowering.h 22 class Module;
include/llvm/CodeGen/MIRPrinter.h 21 class Module;
include/llvm/CodeGen/MachineModuleInfo.h 52 class Module;
include/llvm/CodeGen/ParallelCG.h 24 class Module;
include/llvm/CodeGen/PreISelIntrinsicLowering.h 20 class Module;
include/llvm/CodeGen/StackProtector.h 32 class Module;
include/llvm/CodeGen/TargetInstrInfo.h 52 class Module;
include/llvm/CodeGen/TargetLowering.h 88 class Module;
include/llvm/ExecutionEngine/ObjectCache.h 17 class Module;
include/llvm/ExecutionEngine/Orc/CompileUtils.h 23 class Module;
include/llvm/ExecutionEngine/Orc/ExecutionUtils.h 35 class Module;
include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h 24 class Module;
include/llvm/ExecutionEngine/Orc/IRCompileLayer.h 26 class Module;
include/llvm/ExecutionEngine/Orc/IRTransformLayer.h 22 class Module;
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h 42 class Module;
include/llvm/FuzzMutate/IRMutator.h 26 class Module;
include/llvm/IR/AutoUpgrade.h 24 class Module;
include/llvm/IR/BasicBlock.h 38 class Module;
include/llvm/IR/DIBuilder.h 38 class Module;
include/llvm/IR/DataLayout.h 45 class Module;
include/llvm/IR/DebugInfo.h 28 class Module;
include/llvm/IR/DiagnosticInfo.h 38 class Module;
include/llvm/IR/DiagnosticPrinter.h 23 class Module;
include/llvm/IR/Dominators.h 32 class Module;
include/llvm/IR/Function.h 53 class Module;
include/llvm/IR/GlobalAlias.h 24 class Module;
include/llvm/IR/GlobalIFunc.h 27 class Module;
include/llvm/IR/GlobalValue.h 38 class Module;
include/llvm/IR/GlobalVariable.h 35 class Module;
include/llvm/IR/IRPrintingPasses.h 29 class Module;
include/llvm/IR/Instruction.h 36 class Module;
include/llvm/IR/Intrinsics.h 29 class Module;
include/llvm/IR/LLVMContext.h 32 class Module;
include/llvm/IR/LegacyPassManager.h 25 class Module;
include/llvm/IR/LegacyPassManagers.h 94 class Module;
include/llvm/IR/Metadata.h 45 class Module;
include/llvm/IR/ModuleSlotTracker.h 16 class Module;
include/llvm/IR/SymbolTableListTraits.h 40 class Module;
include/llvm/IR/TypeFinder.h 23 class Module;
include/llvm/IR/Value.h 46 class Module;
include/llvm/IR/Verifier.h 34 class Module;
include/llvm/IRReader/IRReader.h 25 class Module;
include/llvm/LTO/Config.h 27 class Module;
include/llvm/LTO/LTO.h 39 class Module;
include/llvm/LTO/LTOBackend.h 31 class Module;
include/llvm/LTO/legacy/UpdateCompilerUsed.h 20 class Module;
include/llvm/Linker/IRMover.h 20 class Module;
include/llvm/Linker/Linker.h 16 class Module;
include/llvm/Object/IRObjectFile.h 24 class Module;
include/llvm/Pass.h 41 class Module;
include/llvm/Passes/StandardInstrumentations.h 27 class Module;
include/llvm/ProfileData/InstrProf.h 54 class Module;
include/llvm/Target/TargetIntrinsicInfo.h 23 class Module;
include/llvm/Target/TargetOptions.h 21 class Module;
include/llvm/Transforms/IPO/ConstantMerge.h 26 class Module;
include/llvm/Transforms/IPO/DeadArgumentElimination.h 33 class Module;
include/llvm/Transforms/IPO/ElimAvailExtern.h 21 class Module;
include/llvm/Transforms/IPO/FunctionAttrs.h 26 class Module;
include/llvm/Transforms/IPO/FunctionImport.h 29 class Module;
include/llvm/Transforms/IPO/GlobalOpt.h 22 class Module;
include/llvm/Transforms/IPO/GlobalSplit.h 23 class Module;
include/llvm/Transforms/IPO/HotColdSplitting.h 19 class Module;
include/llvm/Transforms/IPO/Internalize.h 31 class Module;
include/llvm/Transforms/IPO/LowerTypeTests.h 27 class Module;
include/llvm/Transforms/IPO/PartialInlining.h 21 class Module;
include/llvm/Transforms/IPO/SCCP.h 27 class Module;
include/llvm/Transforms/IPO/SampleProfile.h 22 class Module;
include/llvm/Transforms/IPO/SyntheticCountsPropagation.h 11 class Module;
include/llvm/Transforms/Instrumentation/InstrOrderFile.h 18 class Module;
include/llvm/Transforms/Instrumentation/PGOInstrumentation.h 27 class Module;
include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h 25 class Module;
include/llvm/Transforms/Utils/Cloning.h 46 class Module;
include/llvm/Transforms/Utils/CodeExtractor.h 36 class Module;
include/llvm/Transforms/Utils/CtorUtils.h 22 class Module;
include/llvm/Transforms/Utils/FunctionImportUtils.h 21 class Module;
include/llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h 22 class Module;
include/llvm/Transforms/Utils/ModuleUtils.h 22 class Module;
include/llvm/Transforms/Utils/SplitModule.h 23 class Module;
include/llvm/Transforms/Utils/SymbolRewriter.h 43 class Module;
lib/AsmParser/LLParser.h 29 class Module;
lib/Bitcode/Reader/MetadataLoader.h 31 class Module;
lib/Bitcode/Writer/ValueEnumerator.h 37 class Module;
lib/CodeGen/AsmPrinter/DwarfDebug.h 63 class Module;
lib/Object/RecordStreamer.h 23 class Module;
lib/Target/AMDGPU/AMDGPU.h 26 class Module;
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h 31 class Module;
lib/Target/AMDGPU/AMDGPULibFunc.h 18 class Module;
lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h 28 class Module;
lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h 26 class Module;
lib/Target/Hexagon/HexagonTargetMachine.h 23 class Module;
lib/Target/Mips/MipsAsmPrinter.h 38 class Module;
lib/Target/SystemZ/SystemZAsmPrinter.h 22 class Module;
lib/Transforms/ObjCARC/ObjCARCExpand.cpp 42 class Module;
tools/bugpoint/BugDriver.h 30 class Module;
tools/clang/include/clang/CodeGen/BackendUtil.h 19 class Module;
tools/clang/include/clang/CodeGen/CodeGenABITypes.h 32 class Module;
tools/clang/include/clang/CodeGen/CodeGenAction.h 17 class Module;
tools/clang/include/clang/CodeGen/ModuleBuilder.h 21 class Module;
tools/clang/lib/CodeGen/CGObjCRuntime.h 27 class Module;
tools/clang/lib/CodeGen/CodeGenFunction.h 47 class Module;
tools/clang/lib/CodeGen/CodeGenModule.h 40 class Module;
tools/lldb/include/lldb/Expression/IRExecutionUnit.h 29 class Module;
tools/lldb/include/lldb/Expression/IRInterpreter.h 20 class Module;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.h 18 class Module;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h 35 class Module;
tools/llvm-diff/DiffConsumer.h 25 class Module;
tools/llvm-diff/DifferenceEngine.h 27 class Module;
tools/opt/NewPMDriver.h 26 class Module;
tools/opt/PassPrinters.h 29 class Module;
unittests/IR/CFGBuilder.h 31 class Module;
References
examples/BrainF/BrainF.cpp 52 Module *BrainF::parse(std::istream *in1, int mem, CompileFlags cf,
65 module = new Module("BrainF", C);
examples/BrainF/BrainF.h 42 Module *parse(std::istream *in1, int mem, CompileFlags cf,
80 Module *module;
examples/BrainF/BrainFDriver.cpp 73 void addMainFunction(Module *mod) {
145 std::unique_ptr<Module> Mod(bf.parse(in, 65536, cf, Context)); // 64 KiB
162 Module &M = *Mod;
examples/Fibonacci/fibonacci.cpp 51 static Function *CreateFibFunction(Module *M, LLVMContext &Context) {
110 std::unique_ptr<Module> Owner(new Module("test", Context));
110 std::unique_ptr<Module> Owner(new Module("test", Context));
111 Module *M = Owner.get();
examples/HowToUseJIT/HowToUseJIT.cpp 66 std::unique_ptr<Module> Owner = std::make_unique<Module>("test", Context);
66 std::unique_ptr<Module> Owner = std::make_unique<Module>("test", Context);
67 Module *M = Owner.get();
examples/HowToUseLLJIT/HowToUseLLJIT.cpp 24 auto M = std::make_unique<Module>("test", *Context);
examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h 71 Error addModule(std::unique_ptr<Module> M) {
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp 702 static std::unique_ptr<Module> TheModule;
1106 TheModule = std::make_unique<Module>("my cool jit", *TheContext);
examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h 78 Error addModule(std::unique_ptr<Module> M) {
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp 702 static std::unique_ptr<Module> TheModule;
1106 TheModule = std::make_unique<Module>("my cool jit", *TheContext);
examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h 57 std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
57 std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
96 VModuleKey addModule(std::unique_ptr<Module> M) {
132 std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
132 std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp 701 static std::unique_ptr<Module> TheModule;
1105 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h 67 std::unique_ptr<llvm::Module>
83 std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
83 std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
129 VModuleKey addModule(std::unique_ptr<Module> M) {
208 std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
208 std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp 686 static std::unique_ptr<Module> TheModule;
1098 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1102 std::unique_ptr<llvm::Module>
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h 69 std::unique_ptr<llvm::Module>
88 std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
88 std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
142 VModuleKey addModule(std::unique_ptr<Module> M) {
225 std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
225 std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp 710 static std::unique_ptr<Module> TheModule;
1122 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1126 std::unique_ptr<llvm::Module>
examples/Kaleidoscope/Chapter3/toy.cpp 404 static std::unique_ptr<Module> TheModule;
601 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter4/toy.cpp 414 static std::unique_ptr<Module> TheModule;
553 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter5/toy.cpp 541 static std::unique_ptr<Module> TheModule;
827 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter6/toy.cpp 633 static std::unique_ptr<Module> TheModule;
946 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter7/toy.cpp 706 static std::unique_ptr<Module> TheModule;
1114 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter8/toy.cpp 707 static std::unique_ptr<Module> TheModule;
1110 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter9/toy.cpp 859 static std::unique_ptr<Module> TheModule;
1317 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1424 TheModule->addModuleFlag(Module::Warning, "Debug Info Version",
1429 TheModule->addModuleFlag(llvm::Module::Warning, "Dwarf Version", 2);
examples/Kaleidoscope/include/KaleidoscopeJIT.h 63 VModuleKey addModule(std::unique_ptr<Module> M) {
examples/LLJITExamples/LLJITWithObjectCache/LLJITWithObjectCache.cpp 28 void notifyObjectCompiled(const Module *M,
34 std::unique_ptr<MemoryBuffer> getObject(const Module *M) override {
examples/ModuleMaker/ModuleMaker.cpp 35 Module *M = new Module("test", Context);
35 Module *M = new Module("test", Context);
examples/ParallelJIT/ParallelJIT.cpp 49 static Function* createAdd1(Module *M) {
80 static Function *CreateFibFunction(Module *M) {
262 std::unique_ptr<Module> Owner = std::make_unique<Module>("test", Context);
262 std::unique_ptr<Module> Owner = std::make_unique<Module>("test", Context);
263 Module *M = Owner.get();
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
127 ArrayRef(const std::vector<U *, A> &Vec,
129 std::is_convertible<U *const *, T const *>::value>::type* = 0)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/Optional.h 187 template <class... Args> void emplace(Args &&... args) {
237 template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
include/llvm/ADT/STLExtras.h 1172 bool any_of(R &&Range, UnaryPredicate P) {
include/llvm/Analysis/AssumptionCache.h 229 bool doFinalization(Module &) override {
include/llvm/Analysis/BlockFrequencyInfo.h 151 void print(raw_ostream &OS, const Module *M) const override;
include/llvm/Analysis/BranchProbabilityInfo.h 247 void print(raw_ostream &OS, const Module *M = nullptr) const override;
include/llvm/Analysis/CGSCCPassManager.h 168 InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
191 bool invalidate(Module &M, const PreservedAnalyses &PA,
203 CGSCCAnalysisManagerModuleProxy::run(Module &M, ModuleAnalysisManager &AM);
357 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
504 if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Module>>()) {
735 ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>::run(Module &M,
include/llvm/Analysis/CallGraph.h 74 Module &M;
102 explicit CallGraph(Module &M);
113 Module &getModule() const { return M; }
304 CallGraph run(Module &M, ModuleAnalysisManager &) { return CallGraph(M); }
314 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
342 Module &getModule() const { return G->getModule(); }
393 bool runOnModule(Module &M) override;
396 void print(raw_ostream &o, const Module *) const override;
include/llvm/Analysis/DOTGraphTraitsPass.h 132 bool runOnModule(Module &M) override {
158 bool runOnModule(Module &M) override {
include/llvm/Analysis/DemandedBits.h 102 void print(raw_ostream &OS, const Module *M) const override;
include/llvm/Analysis/DependenceAnalysis.h 965 void print(raw_ostream &, const Module * = nullptr) const override;
include/llvm/Analysis/DivergenceAnalysis.h 82 void print(raw_ostream &OS, const Module *) const;
209 void print(raw_ostream &OS, const Module *) const;
include/llvm/Analysis/DominanceFrontier.h 173 void print(raw_ostream &OS, const Module * = nullptr) const override;
include/llvm/Analysis/GlobalsModRef.h 84 analyzeModule(Module &M,
111 void AnalyzeGlobals(Module &M);
112 void AnalyzeCallGraph(CallGraph &CG, Module &M);
133 GlobalsAAResult run(Module &M, ModuleAnalysisManager &AM);
148 bool runOnModule(Module &M) override;
149 bool doFinalization(Module &M) override;
include/llvm/Analysis/IVUsers.h 156 void print(raw_ostream &OS, const Module * = nullptr) const;
184 void print(raw_ostream &OS, const Module * = nullptr) const override;
include/llvm/Analysis/IntervalPartition.h 66 void print(raw_ostream &O, const Module* = nullptr) const override;
include/llvm/Analysis/LazyBlockFrequencyInfo.h 125 void print(raw_ostream &OS, const Module *M) const override;
include/llvm/Analysis/LazyBranchProbabilityInfo.h 105 void print(raw_ostream &OS, const Module *M) const override;
include/llvm/Analysis/LazyCallGraph.h 934 LazyCallGraph(Module &M,
1270 LazyCallGraph run(Module &M, ModuleAnalysisManager &AM) {
1290 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
1303 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Analysis/LegacyDivergenceAnalysis.h 39 void print(raw_ostream &OS, const Module *) const override;
include/llvm/Analysis/Lint.h 38 const Module &M ///< The module to be checked
include/llvm/Analysis/LoopAccessAnalysis.h 746 void print(raw_ostream &OS, const Module *M = nullptr) const override;
include/llvm/Analysis/LoopInfo.h 1228 void print(raw_ostream &O, const Module *M = nullptr) const override;
include/llvm/Analysis/MemorySSA.h 979 void print(raw_ostream &OS, const Module *M = nullptr) const override;
include/llvm/Analysis/ModuleSummaryAnalysis.h 36 const Module &M,
50 Result run(Module &M, ModuleAnalysisManager &AM);
66 bool runOnModule(Module &M) override;
67 bool doFinalization(Module &M) override;
include/llvm/Analysis/ObjCARCAliasAnalysis.h 91 bool doInitialization(Module &M) override;
92 bool doFinalization(Module &M) override;
include/llvm/Analysis/ObjCARCAnalysisUtils.h 51 inline bool ModuleHasARC(const Module &M) {
256 Module *M;
268 void init(Module *Mod) {
include/llvm/Analysis/PostDominators.h 90 void print(raw_ostream &OS, const Module*) const override;
include/llvm/Analysis/ProfileSummaryInfo.h 45 Module &M;
66 ProfileSummaryInfo(Module &M) : M(M) {}
97 bool invalidate(Module &, const PreservedAnalyses &,
169 bool doInitialization(Module &M) override;
170 bool doFinalization(Module &M) override;
182 Result run(Module &M, ModuleAnalysisManager &);
196 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Analysis/RegionInfo.h 965 void print(raw_ostream &OS, const Module *) const override;
include/llvm/Analysis/ScalarEvolution.h 1950 void print(raw_ostream &OS, const Module * = nullptr) const override;
include/llvm/Analysis/ScopedNoAliasAA.h 77 bool doInitialization(Module &M) override;
78 bool doFinalization(Module &M) override;
include/llvm/Analysis/StackSafetyAnalysis.h 69 void print(raw_ostream &O, const Module *M) const override;
86 Result run(Module &M, ModuleAnalysisManager &AM);
96 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
111 void print(raw_ostream &O, const Module *M) const override;
114 bool runOnModule(Module &M) override;
include/llvm/Analysis/TargetLibraryInfo.h 199 unsigned getWCharSize(const Module &M) const;
324 unsigned getWCharSize(const Module &M) const {
332 bool invalidate(Module &, const PreservedAnalyses &,
include/llvm/Analysis/TypeBasedAliasAnalysis.h 83 bool doInitialization(Module &M) override;
84 bool doFinalization(Module &M) override;
include/llvm/Analysis/TypeMetadataUtils.h 54 Constant *getPointerAtOffset(Constant *I, uint64_t Offset, Module &M);
include/llvm/AsmParser/Parser.h 43 std::unique_ptr<Module>
63 std::unique_ptr<Module> parseAssemblyString(StringRef AsmString,
73 std::unique_ptr<Module> Mod;
120 std::unique_ptr<Module> parseAssembly(MemoryBufferRef F, SMDiagnostic &Err,
170 bool parseAssemblyInto(MemoryBufferRef F, Module *M, ModuleSummaryIndex *Index,
183 Constant *parseConstantValue(StringRef Asm, SMDiagnostic &Err, const Module &M,
191 Type *parseType(StringRef Asm, SMDiagnostic &Err, const Module &M,
202 const Module &M, const SlotMapping *Slots = nullptr);
include/llvm/Bitcode/BitcodeReader.h 80 Expected<std::unique_ptr<Module>> getModuleImpl(LLVMContext &Context,
98 Expected<std::unique_ptr<Module>> getLazyModule(LLVMContext &Context,
103 Expected<std::unique_ptr<Module>> parseModule(LLVMContext &Context);
138 Expected<std::unique_ptr<Module>>
147 Expected<std::unique_ptr<Module>> getOwningLazyBitcodeModule(
166 Expected<std::unique_ptr<Module>> parseBitcodeFile(MemoryBufferRef Buffer,
include/llvm/Bitcode/BitcodeWriter.h 45 std::vector<Module *> Mods;
88 void writeModule(const Module &M, bool ShouldPreserveUseListOrder = false,
99 void writeThinLinkBitcode(const Module &M, const ModuleSummaryIndex &Index,
128 void WriteBitcodeToFile(const Module &M, raw_ostream &Out,
141 void WriteThinLinkBitcodeToFile(const Module &M, raw_ostream &Out,
include/llvm/Bitcode/BitcodeWriterPass.h 73 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/CodeGen/AsmPrinter.h 293 bool doInitialization(Module &M) override;
297 bool doFinalization(Module &M) override;
370 void computeGlobalGOTEquivs(Module &M);
389 virtual void EmitStartOfAsmFile(Module &) {}
393 virtual void EmitEndOfAsmFile(Module &) {}
684 void EmitModuleIdents(Module &M);
686 void EmitModuleCommandLines(Module &M);
692 void emitGlobalIndirectSymbol(Module &M, const GlobalIndirectSymbol &GIS);
include/llvm/CodeGen/CommandFlags.inc 372 setFunctionAttributes(StringRef CPU, StringRef Features, Module &M) {
include/llvm/CodeGen/GCMetadataPrinter.h 58 virtual void beginAssembly(Module &M, GCModuleInfo &Info, AsmPrinter &AP) {}
62 virtual void finishAssembly(Module &M, GCModuleInfo &Info, AsmPrinter &AP) {}
include/llvm/CodeGen/LazyMachineBlockFrequencyInfo.h 72 void print(raw_ostream &OS, const Module *M) const override;
include/llvm/CodeGen/LiveIntervals.h 293 void print(raw_ostream &O, const Module* = nullptr) const override;
include/llvm/CodeGen/LiveStacks.h 97 void print(raw_ostream &O, const Module * = nullptr) const override;
include/llvm/CodeGen/MIRParser/MIRParser.h 45 std::unique_ptr<Module> parseIRModule();
51 bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI);
include/llvm/CodeGen/MIRPrinter.h 26 void printMIR(raw_ostream &OS, const Module &M);
include/llvm/CodeGen/MachineDominators.h 228 void print(raw_ostream &OS, const Module*) const override;
include/llvm/CodeGen/MachineFunctionPass.h 32 bool doInitialization(Module&) override {
include/llvm/CodeGen/MachineModuleInfo.h 88 const Module *TheModule;
164 const Module *getModule() const { return TheModule; }
271 bool doInitialization(Module &) override;
272 bool doFinalization(Module &) override;
292 MachineModuleInfo run(Module &M, ModuleAnalysisManager &);
include/llvm/CodeGen/MachinePostDominators.h 89 void print(llvm::raw_ostream &OS, const Module *M = nullptr) const override;
include/llvm/CodeGen/MachineRegionInfo.h 104 void print(raw_ostream &OS, const Module *) const override;
include/llvm/CodeGen/ParallelCG.h 38 std::unique_ptr<Module>
39 splitCodeGen(std::unique_ptr<Module> M, ArrayRef<raw_pwrite_stream *> OSs,
include/llvm/CodeGen/PreISelIntrinsicLowering.h 24 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/CodeGen/RegisterUsageInfo.h 45 bool doInitialization(Module &M) override;
47 bool doFinalization(Module &M) override;
57 void print(raw_ostream &OS, const Module *M = nullptr) const override;
include/llvm/CodeGen/StackProtector.h 51 Module *M;
include/llvm/CodeGen/TargetLowering.h 1634 virtual void insertSSPDeclarations(Module &M) const;
1639 virtual Value *getSDagStackGuard(const Module &M) const;
1651 virtual Function *getSSPStackGuardCheck(const Module &M) const;
include/llvm/CodeGen/TargetLoweringObjectFileImpl.h 48 void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override;
105 void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override;
160 void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override;
include/llvm/CodeGen/VirtRegMap.h 179 void print(raw_ostream &OS, const Module* M = nullptr) const override;
include/llvm/ExecutionEngine/ExecutionEngine.h 134 SmallVector<std::unique_ptr<Module>, 1> Modules;
140 std::unique_ptr<Module> M, std::string *ErrorStr,
150 static ExecutionEngine *(*InterpCtor)(std::unique_ptr<Module> M,
173 virtual void addModule(std::unique_ptr<Module> M) {
208 virtual bool removeModule(Module *M);
269 virtual void generateCodeForModule(Module *M) {}
290 void runStaticConstructorsDestructors(Module &module, bool isDtors);
316 void clearGlobalMappingsFromModule(Module *M);
497 explicit ExecutionEngine(DataLayout DL, std::unique_ptr<Module> M);
498 explicit ExecutionEngine(std::unique_ptr<Module> M);
509 void Init(std::unique_ptr<Module> M);
528 std::unique_ptr<Module> M;
549 EngineBuilder(std::unique_ptr<Module> M);
include/llvm/ExecutionEngine/ObjectCache.h 31 virtual void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) = 0;
36 virtual std::unique_ptr<MemoryBuffer> getObject(const Module* M) = 0;
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h 119 void cleanUpModule(Module &M);
199 std::unique_ptr<Module> SourceMod;
213 SourceModuleHandle addSourceModule(std::unique_ptr<Module> M) {
220 Module& getSourceModule(SourceModuleHandle H) {
305 Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
317 Error addExtraModule(VModuleKey K, std::unique_ptr<Module> M) {
371 Module &SrcM = LMResources->SourceModule->getResource();
383 Error addLogicalModule(LogicalDylib &LD, std::unique_ptr<Module> SrcMPtr) {
390 Module &SrcM = *SrcMPtr;
447 auto GVsM = std::make_unique<Module>((SrcM.getName() + ".globals").str(),
583 Module &SrcM = LD.getSourceModule(LMId);
631 Module &SrcM = LD.getSourceModule(LMId);
640 auto M = std::make_unique<Module>(NewName, SrcM.getContext());
include/llvm/ExecutionEngine/Orc/CompileUtils.h 46 CompileResult operator()(Module &M);
49 CompileResult tryToLoadFromObjectCache(const Module &M);
50 void notifyObjectCompiled(const Module &M, const MemoryBuffer &ObjBuffer);
83 std::unique_ptr<MemoryBuffer> operator()(Module &M);
include/llvm/ExecutionEngine/Orc/ExecutionUtils.h 90 iterator_range<CtorDtorIterator> getConstructors(const Module &M);
94 iterator_range<CtorDtorIterator> getDestructors(const Module &M);
include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h 49 addModule(std::shared_ptr<Module> M,
include/llvm/ExecutionEngine/Orc/IRCompileLayer.h 33 std::function<Expected<std::unique_ptr<MemoryBuffer>>(Module &)>;
62 std::function<void(VModuleKey K, std::unique_ptr<Module>)>;
92 Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
include/llvm/ExecutionEngine/Orc/IRTransformLayer.h 78 Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h 417 GlobalVariable *createImplPointer(PointerType &PT, Module &M, const Twine &Name,
431 std::vector<GlobalValue *> operator()(Module &M);
449 Function *cloneFunctionDecl(Module &Dst, const Function &F,
465 GlobalVariable *cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
482 GlobalAlias *cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
486 void cloneModuleFlagsMetadata(Module &Dst, const Module &Src,
486 void cloneModuleFlagsMetadata(Module &Dst, const Module &Src,
include/llvm/ExecutionEngine/Orc/LLJIT.h 132 Error applyDataLayout(Module &M);
134 void recordCtorDtors(Module &M);
include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h 45 EmissionDeferredModule(VModuleKey K, std::unique_ptr<Module> M)
185 std::unique_ptr<Module> M;
205 Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h 104 ThreadSafeModule(std::unique_ptr<Module> M, std::unique_ptr<LLVMContext> Ctx)
109 ThreadSafeModule(std::unique_ptr<Module> M, ThreadSafeContext TSCtx)
134 auto withModuleDo(Func &&F) -> decltype(F(std::declval<Module &>())) {
144 -> decltype(F(std::declval<const Module &>())) {
150 Module *getModuleUnlocked() { return M.get(); }
153 const Module *getModuleUnlocked() const { return M.get(); }
159 std::unique_ptr<Module> M;
include/llvm/FuzzMutate/FuzzerCLI.h 58 std::unique_ptr<Module> parseModule(const uint8_t *Data, size_t Size,
68 size_t writeModule(const Module &M, uint8_t *Dest, size_t MaxSize);
73 std::unique_ptr<Module> parseAndVerify(const uint8_t *Data, size_t Size,
include/llvm/FuzzMutate/IRMutator.h 48 virtual void mutate(Module &M, RandomIRBuilder &IB);
70 void mutateModule(Module &M, int Seed, size_t CurSize, size_t MaxSize);
include/llvm/IR/AutoUpgrade.h 55 bool UpgradeModuleFlags(Module &M);
59 void UpgradeARCRuntime(Module &M);
61 void UpgradeSectionAttributes(Module &M);
80 bool UpgradeDebugInfo(Module &M);
include/llvm/IR/BasicBlock.h 113 const Module *getModule() const;
114 Module *getModule() {
include/llvm/IR/DIBuilder.h 42 Module &M;
102 explicit DIBuilder(Module &M, bool AllowUnresolved = true,
include/llvm/IR/DataLayout.h 200 explicit DataLayout(const Module *M);
226 void init(const Module *M);
include/llvm/IR/DebugInfo.h 38 bool StripDebugInfo(Module &M);
51 bool stripNonLineTableDebugInfo(Module &M);
54 unsigned getDebugMetadataVersionFromModule(const Module &M);
67 void processModule(const Module &M);
69 void processInstruction(const Module &M, const Instruction &I);
72 void processDeclare(const Module &M, const DbgDeclareInst *DDI);
74 void processValue(const Module &M, const DbgValueInst *DVI);
76 void processLocation(const Module &M, const DILocation *Loc);
82 void InitializeTypeMap(const Module &M);
include/llvm/IR/DiagnosticInfo.h 236 const Module &M;
243 DiagnosticInfoDebugMetadataVersion(const Module &M, unsigned MetadataVersion,
248 const Module &getModule() const { return M; }
263 const Module &M;
268 const Module &M, DiagnosticSeverity Severity = DS_Warning)
271 const Module &getModule() const { return M; }
include/llvm/IR/DiagnosticPrinter.h 54 virtual DiagnosticPrinter &operator<<(const Module &M) = 0;
87 DiagnosticPrinter &operator<<(const Module &M) override;
include/llvm/IR/Dominators.h 282 void print(raw_ostream &OS, const Module *M = nullptr) const override;
include/llvm/IR/Function.h 123 const Twine &N = "", Module *M = nullptr);
137 Module *M = nullptr) {
143 const Twine &N = "", Module *M = nullptr) {
152 const Twine &N, Module &M);
include/llvm/IR/GlobalAlias.h 32 const Twine &Name, Constant *Aliasee, Module *Parent);
42 Constant *Aliasee, Module *Parent);
47 Module *Parent);
include/llvm/IR/GlobalIFunc.h 37 const Twine &Name, Constant *Resolver, Module *Parent);
47 Constant *Resolver, Module *Parent);
include/llvm/IR/GlobalValue.h 172 Module *Parent; // The containing module.
175 void setParent(Module *parent) {
575 Module *getParent() { return Parent; }
576 const Module *getParent() const { return Parent; }
include/llvm/IR/GlobalVariable.h 60 GlobalVariable(Module &M, Type *Ty, bool isConstant,
include/llvm/IR/IRBuilder.h 2440 Module *M = BB->getParent()->getParent();
2468 Module *M = BB->getParent()->getParent();
2540 Module *M = BB->getParent()->getParent();
2559 Module *M = BB->getParent()->getParent();
2583 Module *M = BB->getParent()->getParent();
include/llvm/IR/IRPrintingPasses.h 90 PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
90 PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
include/llvm/IR/InstVisitor.h 96 void visit(Module &M) {
110 void visit(Module *M) { visit(*M); }
143 void visitModule (Module &M) {}
include/llvm/IR/Instruction.h 74 const Module *getModule() const;
75 Module *getModule() {
include/llvm/IR/Intrinsics.h 80 Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None);
include/llvm/IR/LLVMContext.h 316 void addModule(Module*);
319 void removeModule(Module*);
include/llvm/IR/LegacyPassManager.h 58 bool run(Module &M);
71 explicit FunctionPassManager(Module *M);
92 Module *M;
include/llvm/IR/LegacyPassManagers.h 119 Module *M;
126 PassManagerPrettyStackEntry(Pass *p, Module &m)
409 Module &M,
422 Pass *P, Module &M, int64_t Delta, unsigned CountBefore,
475 bool runOnModule(Module &M) override;
487 bool doInitialization(Module &M) override;
496 bool doFinalization(Module &M) override;
include/llvm/IR/Metadata.h 111 void dump(const Module *M) const;
121 void print(raw_ostream &OS, const Module *M = nullptr,
123 void print(raw_ostream &OS, ModuleSlotTracker &MST, const Module *M = nullptr,
134 void printAsOperand(raw_ostream &OS, const Module *M = nullptr) const;
136 const Module *M = nullptr) const;
1330 Module *Parent = nullptr;
1333 void setParent(Module *M) { Parent = M; }
1391 inline Module *getParent() { return Parent; }
1392 inline const Module *getParent() const { return Parent; }
include/llvm/IR/Module.h 530 return &Module::GlobalList;
538 return &Module::FunctionList;
547 return &Module::AliasList;
556 return &Module::IFuncList;
565 return &Module::NamedMDList;
904 GlobalVariable *collectUsedGlobalVariables(const Module &M,
909 inline raw_ostream &operator<<(raw_ostream &O, const Module &M) {
920 inline Module *unwrap(LLVMModuleProviderRef MP) {
include/llvm/IR/ModuleSlotTracker.h 35 const Module *M = nullptr;
41 ModuleSlotTracker(SlotTracker &Machine, const Module *M,
51 explicit ModuleSlotTracker(const Module *M,
60 const Module *getModule() const { return M; }
include/llvm/IR/ModuleSummaryIndex.h 1269 bool hasExportedFunctions(const Module &M) const {
include/llvm/IR/PassInstrumentation.h 144 bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const {
158 void runAfterPass(const PassT &Pass, const IRUnitT &IR) const {
177 void runBeforeAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
186 void runAfterAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
198 bool invalidate(IRUnitT &, const class llvm::PreservedAnalyses &,
include/llvm/IR/PassManager.h 420 getAnalysisResultUnpackTuple(AnalysisManagerT &AM, IRUnitT &IR,
435 getAnalysisResult(AnalysisManager<IRUnitT, AnalysisArgTs...> &AM, IRUnitT &IR,
435 getAnalysisResult(AnalysisManager<IRUnitT, AnalysisArgTs...> &AM, IRUnitT &IR,
438 PassT, IRUnitT>)(AM, IR, Args,
466 PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {
489 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
502 dbgs() << "Starting " << getTypeName<IRUnitT>() << " pass manager run.\n";
513 if (!PI.runBeforePass<IRUnitT>(*P, IR))
520 PI.runAfterPass<IRUnitT>(*P, IR);
541 PA.preserveSet<AllAnalysesOn<IRUnitT>>();
544 dbgs() << "Finished " << getTypeName<IRUnitT>() << " pass manager run.\n";
551 detail::PassModel<IRUnitT, PassT, PreservedAnalyses, AnalysisManagerT,
559 detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
570 using ModulePassManager = PassManager<Module>;
598 Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
615 detail::AnalysisResultConcept<IRUnitT, PreservedAnalyses, Invalidator>;
617 detail::AnalysisPassConcept<IRUnitT, PreservedAnalyses, Invalidator,
630 using AnalysisResultListMapT = DenseMap<IRUnitT *, AnalysisResultListT>;
636 DenseMap<std::pair<AnalysisKey *, IRUnitT *>,
667 bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
669 detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
681 bool invalidate(AnalysisKey *ID, IRUnitT &IR, const PreservedAnalyses &PA) {
689 bool invalidateImpl(AnalysisKey *ID, IRUnitT &IR,
747 void clear(IRUnitT &IR, llvm::StringRef Name) {
777 typename PassT::Result &getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs) {
784 detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
796 typename PassT::Result *getCachedResult(IRUnitT &IR) const {
805 detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
832 detail::AnalysisPassModel<IRUnitT, PassT, PreservedAnalyses,
849 template <typename PassT> void invalidate(IRUnitT &IR) {
859 void invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
861 if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())
939 ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR,
977 ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {
984 void invalidateImpl(AnalysisKey *ID, IRUnitT &IR) {
1021 using ModuleAnalysisManager = AnalysisManager<Module>;
1047 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
1093 IRUnitT &IR, const PreservedAnalyses &PA,
1094 typename AnalysisManager<IRUnitT, ExtraArgTs...>::Invalidator &Inv);
1108 Result run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
1108 Result run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
1128 InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>;
1134 Module &M, const PreservedAnalyses &PA,
1290 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
1357 : PassInfoMixin<RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
1365 PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
1386 PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
1400 PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
1415 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, Ts &&... Args) {
1430 if (!PI.runBeforePass<IRUnitT>(P, IR))
include/llvm/IR/PassManagerInternal.h 46 virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
60 struct PassModel : PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...> {
77 PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT &AM,
110 virtual bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA,
128 std::declval<IRUnitT &>(), std::declval<PreservedAnalyses>()))>::Type
168 : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> {
191 bool invalidate(IRUnitT &, const PreservedAnalysesT &PA,
195 !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
207 : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> {
226 bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA,
247 AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
248 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
248 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
262 struct AnalysisPassModel : AnalysisPassConcept<IRUnitT, PreservedAnalysesT,
282 AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
289 AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
290 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
290 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
include/llvm/IR/TypeFinder.h 43 void run(const Module &M, bool onlyNamed);
include/llvm/IR/Value.h 240 const Module *M = nullptr) const;
include/llvm/IR/Verifier.h 100 bool verifyModule(const Module &M, raw_ostream *OS = nullptr,
117 Result run(Module &M, ModuleAnalysisManager &);
124 bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS);
142 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/IRReader/IRReader.h 35 std::unique_ptr<Module> getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer,
44 std::unique_ptr<Module>
55 std::unique_ptr<Module> parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
67 std::unique_ptr<Module> parseIRFile(StringRef Filename, SMDiagnostic &Err,
include/llvm/LTO/Config.h 153 using ModuleHookFn = std::function<bool(unsigned Task, const Module &)>;
include/llvm/LTO/LTO.h 320 std::unique_ptr<Module> CombinedModule;
328 std::unique_ptr<Module> M;
include/llvm/LTO/LTOBackend.h 40 std::unique_ptr<Module> M, ModuleSummaryIndex &CombinedIndex);
43 Error thinBackend(Config &C, unsigned Task, AddStreamFn AddStream, Module &M,
include/llvm/LTO/legacy/LTOCodeGenerator.h 204 Module &TheModule,
216 std::unique_ptr<Module> MergedModule;
include/llvm/LTO/legacy/LTOModule.h 53 std::unique_ptr<Module> Mod;
64 LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef,
117 const Module &getModule() const { return *Mod; }
118 Module &getModule() { return *Mod; }
120 std::unique_ptr<Module> takeModule() { return std::move(Mod); }
include/llvm/LTO/legacy/ThinLTOCodeGenerator.h 254 void promote(Module &Module, ModuleSummaryIndex &Index,
260 void emitImports(Module &Module, StringRef OutputName,
268 void crossModuleImport(Module &Module, ModuleSummaryIndex &Index,
275 Module &Module, ModuleSummaryIndex &Index,
282 void internalize(Module &Module, ModuleSummaryIndex &Index,
288 void optimize(Module &Module);
include/llvm/LTO/legacy/UpdateCompilerUsed.h 27 void updateCompilerUsed(Module &TheModule, const TargetMachine &TM,
include/llvm/LinkAllIR.h 44 (void)new llvm::Module("", Context);
include/llvm/Linker/IRMover.h 62 IRMover(Module &M);
75 Error move(std::unique_ptr<Module> Src, ArrayRef<GlobalValue *> ValuesToLink,
78 Module &getModule() { return Composite; }
81 Module &Composite;
include/llvm/Linker/Linker.h 34 Linker(Module &M);
46 bool linkInModule(std::unique_ptr<Module> Src, unsigned Flags = Flags::None,
47 std::function<void(Module &, const StringSet<> &)>
50 static bool linkModules(Module &Dest, std::unique_ptr<Module> Src,
50 static bool linkModules(Module &Dest, std::unique_ptr<Module> Src,
52 std::function<void(Module &, const StringSet<> &)>
include/llvm/Object/IRObjectFile.h 32 std::vector<std::unique_ptr<Module>> Mods;
35 std::vector<std::unique_ptr<Module>> Mods);
52 pointee_iterator<std::vector<std::unique_ptr<Module>>::const_iterator,
53 const Module>;
include/llvm/Object/IRSymtab.h 160 Error build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
include/llvm/Object/ModuleSymbolTable.h 38 Module *FirstMod = nullptr;
46 void addModule(Module *M);
57 const Module &M,
66 CollectAsmSymvers(const Module &M,
include/llvm/Pass.h 105 virtual bool doInitialization(Module &) { return false; }
109 virtual bool doFinalization(Module &) { return false; }
117 virtual void print(raw_ostream &OS, const Module *M) const;
237 virtual bool runOnModule(Module &M) = 0;
247 bool skipModule(Module &M) const;
272 bool runOnModule(Module &) override { return false; }
include/llvm/Passes/PassBuilder.h 743 PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...> &PM) {
include/llvm/Passes/StandardInstrumentations.h 45 using PrintModuleDesc = std::tuple<const Module *, std::string, StringRef>;
include/llvm/ProfileData/InstrProf.h 189 GlobalVariable *createPGOFuncNameVar(Module &M,
225 bool isIRPGOFlagSet(const Module *M);
240 void annotateValueSite(Module &M, Instruction &Inst,
246 void annotateValueSite(Module &M, Instruction &Inst,
271 bool needsComdatForCounter(const Function &F, const Module &M);
459 Error create(Module &M, bool InLTO = false);
530 Error InstrProfSymtab::create(const NameIterRange &IterRange) {
1133 void createIRLevelProfileFlagVar(Module &M, bool IsCS);
1136 void createProfileFileNameVar(Module &M, StringRef InstrProfileOutput);
include/llvm/ProfileData/SampleProf.h 466 void findInlinedFunctions(DenseSet<GlobalValue::GUID> &S, const Module *M,
493 StringRef getFuncNameInModule(const Module *M) const {
531 StringRef getNameInModule(StringRef Name, const Module *M) const {
include/llvm/ProfileData/SampleProfReader.h 347 virtual void collectFuncsFrom(const Module &M) {}
631 void collectFuncsFrom(const Module &M) override;
664 void collectFuncsFrom(const Module &M) override;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/YAMLTraits.h 313 using Signature_enumeration = void (*)(class IO&, T&);
322 (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
329 using Signature_bitset = void (*)(class IO&, T&);
337 static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
344 using Signature_input = StringRef (*)(StringRef, void*, T&);
345 using Signature_output = void (*)(const T&, void*, raw_ostream&);
357 (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
364 using Signature_input = StringRef (*)(StringRef, void *, T &);
365 using Signature_output = void (*)(const T &, void *, raw_ostream &);
375 (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
380 using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
381 using Signature_output = void (*)(const T &, void *, raw_ostream &,
383 using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
393 (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
412 using Signature_mapping = void (*)(class IO &, T &);
419 static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
438 using Signature_validate = StringRef (*)(class IO &, T &);
445 static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
452 using Signature_size = size_t (*)(class IO&, T&);
460 static bool const value = (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
467 using Signature_input = void (*)(IO &io, StringRef key, T &v);
476 (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
516 using Signature_size = size_t (*)(class IO &, T &);
524 static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
528 using Signature_getKind = NodeKind (*)(const T &);
535 static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
1008 typename std::enable_if<has_BlockScalarTraits<T>::value, void>::type
1009 yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) {
1013 BlockScalarTraits<T>::output(Val, YamlIO.getContext(), Buffer);
1020 BlockScalarTraits<T>::input(Str, YamlIO.getContext(), Val);
1822 typename std::enable_if<has_BlockScalarTraits<T>::value, Output &>::type
1823 operator<<(Output &Out, T &Val) {
include/llvm/Target/TargetIntrinsicInfo.h 63 virtual Function *getDeclaration(Module *M, unsigned ID, Type **Tys = nullptr,
include/llvm/Target/TargetLoweringObjectFile.h 81 virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const {}
84 virtual void getModuleMetadata(Module &M) {}
include/llvm/Target/TargetMachine.h 213 bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
include/llvm/Transforms/IPO/AlwaysInliner.h 36 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/Attributor.h 574 typename Analysis::Result *getAnalysis(const Module &M) {
599 InformationCache(const Module &M, AnalysisGetter &AG)
735 ChangeStatus run(Module &M);
1521 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/CalledValuePropagation.h 30 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/ConstantMerge.h 31 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/CrossDSOCFI.h 23 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/DeadArgumentElimination.h 79 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/ElimAvailExtern.h 27 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/ForceFunctionAttrs.h 24 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/FunctionAttrs.h 72 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/FunctionImport.h 105 std::function<Expected<std::unique_ptr<Module>>(StringRef Identifier)>;
112 Expected<bool> importFunctions(Module &M, const ImportMapTy &ImportList);
125 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
213 void thinLTOResolvePrevailingInModule(Module &TheModule,
218 void thinLTOInternalizeModule(Module &TheModule,
include/llvm/Transforms/IPO/GlobalDCE.h 31 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
60 void AddVirtualFunctionDependencies(Module &M);
61 void ScanVTables(Module &M);
62 void ScanTypeCheckedLoadIntrinsics(Module &M);
include/llvm/Transforms/IPO/GlobalOpt.h 27 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/GlobalSplit.h 28 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/HotColdSplitting.h 41 bool run(Module &M);
63 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/InferFunctionAttrs.h 26 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/Internalize.h 63 bool internalizeModule(Module &TheModule, CallGraph *CG = nullptr);
65 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
70 internalizeModule(Module &TheModule,
include/llvm/Transforms/IPO/LowerTypeTests.h 207 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/PartialInlining.h 26 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/SCCP.h 32 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/SampleProfile.h 32 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/StripDeadPrototypes.h 26 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/IPO/SyntheticCountsPropagation.h 16 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h 35 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/IPO/WholeProgramDevirt.h 231 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
include/llvm/Transforms/Instrumentation.h 41 GlobalVariable *createPrivateGlobalForString(Module &M, StringRef Str,
include/llvm/Transforms/Instrumentation/AddressSanitizer.h 51 GlobalsMetadata(Module &M);
61 bool invalidate(Module &, const PreservedAnalyses &,
85 Result run(Module &, ModuleAnalysisManager &);
124 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/CGProfile.h 21 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
25 Module &M,
include/llvm/Transforms/Instrumentation/GCOVProfiler.h 23 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h 29 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
include/llvm/Transforms/Instrumentation/InstrOrderFile.h 23 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/InstrProfiling.h 41 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
42 bool run(Module &M,
47 Module *M;
include/llvm/Transforms/Instrumentation/MemorySanitizer.h 43 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/PGOInstrumentation.h 40 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
50 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
63 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
78 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
93 void setProfMetadata(Module *M, Instruction *TI, ArrayRef<uint64_t> EdgeCounts,
96 void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count);
include/llvm/Transforms/Instrumentation/PoisonChecking.h 18 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/SanitizerCoverage.h 35 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/ThreadSanitizer.h 30 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h 30 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Scalar/SCCP.h 48 bool runIPSCCP(Module &M, const DataLayout &DL,
include/llvm/Transforms/Utils/BuildLibCalls.h 31 bool inferLibFuncAttributes(Module *M, StringRef Name, const TargetLibraryInfo &TLI);
include/llvm/Transforms/Utils/CanonicalizeAliases.h 26 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Utils/Cloning.h 52 std::unique_ptr<Module> CloneModule(const Module &M);
52 std::unique_ptr<Module> CloneModule(const Module &M);
53 std::unique_ptr<Module> CloneModule(const Module &M, ValueToValueMapTy &VMap);
53 std::unique_ptr<Module> CloneModule(const Module &M, ValueToValueMapTy &VMap);
59 std::unique_ptr<Module>
60 CloneModule(const Module &M, ValueToValueMapTy &VMap,
include/llvm/Transforms/Utils/CodeExtractor.h 217 Function *oldFunction, Module *M);
include/llvm/Transforms/Utils/CtorUtils.h 26 bool optimizeGlobalCtorsList(Module &M,
include/llvm/Transforms/Utils/FunctionImportUtils.h 27 Module &M;
91 Module &M, const ModuleSummaryIndex &Index,
118 Module &M, const ModuleSummaryIndex &Index,
include/llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h 69 void setModuleInfo(const Module &M);
include/llvm/Transforms/Utils/ModuleUtils.h 36 void appendToGlobalCtors(Module &M, Function *F, int Priority,
40 void appendToGlobalDtors(Module &M, Function *F, int Priority,
43 FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName,
51 Module &M, StringRef CtorName, StringRef InitName,
63 Module &M, StringRef CtorName, StringRef InitName,
71 Function *getOrCreateInitFunction(Module &M, StringRef Name);
75 bool nameUnamedGlobals(Module &M);
78 void appendToUsed(Module &M, ArrayRef<GlobalValue *> Values);
81 void appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values);
97 Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions);
109 std::string getUniqueModuleId(Module *M);
include/llvm/Transforms/Utils/NameAnonGlobals.h 27 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
include/llvm/Transforms/Utils/SanitizerStats.h 33 SanitizerStatReport(Module *M);
43 Module *M;
include/llvm/Transforms/Utils/SplitModule.h 36 std::unique_ptr<Module> M, unsigned N,
37 function_ref<void(std::unique_ptr<Module> MPart)> ModuleCallback,
include/llvm/Transforms/Utils/SymbolRewriter.h 83 virtual bool performOnModule(Module &M) = 0;
128 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
131 bool runImpl(Module &M);
lib/Analysis/AliasAnalysisEvaluator.cpp 44 const Value *V2, const Module *M) {
60 Value *Ptr, Module *M) {
69 CallBase *CallB, Module *M) {
77 const Module *M) {
409 bool doInitialization(Module &M) override {
418 bool doFinalization(Module &M) override {
lib/Analysis/BlockFrequencyInfo.cpp 306 const Module *) const {
lib/Analysis/BranchProbabilityInfo.cpp 1038 const Module *) const {
lib/Analysis/CFGPrinter.cpp 46 void print(raw_ostream &OS, const Module* = nullptr) const override {}
76 void print(raw_ostream &OS, const Module* = nullptr) const override {}
123 void print(raw_ostream &OS, const Module* = nullptr) const override {}
152 void print(raw_ostream &OS, const Module* = nullptr) const override {}
lib/Analysis/CGSCCPassManager.cpp 132 Module &M, const PreservedAnalyses &PA,
147 if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Module>>()) ||
205 CGSCCAnalysisManagerModuleProxy::run(Module &M, ModuleAnalysisManager &AM) {
227 Module &M = *C.begin()->getFunction().getParent();
lib/Analysis/CallGraph.cpp 30 CallGraph::CallGraph(Module &M)
246 PreservedAnalyses CallGraphPrinterPass::run(Module &M,
270 bool CallGraphWrapperPass::runOnModule(Module &M) {
283 void CallGraphWrapperPass::print(raw_ostream &OS, const Module *) const {
312 bool runOnModule(Module &M) override {
lib/Analysis/CallGraphSCCPass.cpp 64 bool runOnModule(Module &M) override;
123 Module &M = CG.getModule();
463 bool CGPassManager::runOnModule(Module &M) {
lib/Analysis/CostModel.cpp 63 void print(raw_ostream &OS, const Module*) const override;
96 void CostModelAnalysis::print(raw_ostream &OS, const Module*) const {
lib/Analysis/Delinearization.cpp 53 void print(raw_ostream &O, const Module *M = nullptr) const override;
71 void Delinearization::print(raw_ostream &O, const Module *) const {
lib/Analysis/DemandedBits.cpp 76 void DemandedBitsWrapperPass::print(raw_ostream &OS, const Module *M) const {
lib/Analysis/DependenceAnalysis.cpp 200 const Module *) const {
lib/Analysis/DivergenceAnalysis.cpp 421 void DivergenceAnalysis::print(raw_ostream &OS, const Module *) const {
462 void GPUDivergenceAnalysis::print(raw_ostream &OS, const Module *mod) const {
lib/Analysis/DominanceFrontier.cpp 58 void DominanceFrontierWrapperPass::print(raw_ostream &OS, const Module *) const {
lib/Analysis/GlobalsModRef.cpp 286 void GlobalsAAResult::AnalyzeGlobals(Module &M) {
486 void GlobalsAAResult::AnalyzeCallGraph(CallGraph &CG, Module &M) {
964 Module &M, std::function<const TargetLibraryInfo &(Function &F)> GetTLI,
982 GlobalsAAResult GlobalsAA::run(Module &M, ModuleAnalysisManager &AM) {
1008 bool GlobalsAAWrapperPass::runOnModule(Module &M) {
1017 bool GlobalsAAWrapperPass::doFinalization(Module &M) {
lib/Analysis/IVUsers.cpp 318 void IVUsers::print(raw_ostream &OS, const Module *M) const {
376 void IVUsersWrapperPass::print(raw_ostream &OS, const Module *M) const {
lib/Analysis/InlineCost.cpp 254 void visit(Module *);
255 void visit(Module &);
lib/Analysis/InstCount.cpp 61 void print(raw_ostream &O, const Module *M) const override {}
lib/Analysis/LazyBlockFrequencyInfo.cpp 38 void LazyBlockFrequencyInfoPass::print(raw_ostream &OS, const Module *) const {
lib/Analysis/LazyBranchProbabilityInfo.cpp 40 const Module *) const {
lib/Analysis/LazyCallGraph.cpp 154 Module &M, function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
1770 PreservedAnalyses LazyCallGraphPrinterPass::run(Module &M,
1804 PreservedAnalyses LazyCallGraphDOTPrinterPass::run(Module &M,
lib/Analysis/LegacyDivergenceAnalysis.cpp 368 void LegacyDivergenceAnalysis::print(raw_ostream &OS, const Module *) const {
lib/Analysis/Lint.cpp 128 Module *Mod;
152 void print(raw_ostream &O, const Module *M) const override {}
751 void llvm::lintModule(const Module &M) {
lib/Analysis/LoopAccessAnalysis.cpp 2409 void LoopAccessLegacyAnalysis::print(raw_ostream &OS, const Module *M) const {
lib/Analysis/LoopInfo.cpp 1084 void LoopInfoWrapperPass::print(raw_ostream &OS, const Module *) const {
lib/Analysis/LoopPass.cpp 164 Module &M = *F.getParent();
lib/Analysis/MemDepPrinter.cpp 47 void print(raw_ostream &OS, const Module * = nullptr) const override;
133 void MemDepPrinter::print(raw_ostream &OS, const Module *M) const {
lib/Analysis/MemDerefPrinter.cpp 33 void print(raw_ostream &OS, const Module * = nullptr) const override;
66 void MemDerefPrinter::print(raw_ostream &OS, const Module *M) const {
lib/Analysis/MemorySSA.cpp 2322 void MemorySSAWrapperPass::print(raw_ostream &OS, const Module *M) const {
lib/Analysis/ModuleSummaryAnalysis.cpp 241 static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M,
487 const Module &M, ModuleSummaryIndex &Index,
528 const GlobalVariable &V, const Module &M,
571 const Module &M,
639 const Module &M,
829 ModuleSummaryIndexAnalysis::run(Module &M, ModuleAnalysisManager &AM) {
859 bool ModuleSummaryIndexWrapperPass::runOnModule(Module &M) {
872 bool ModuleSummaryIndexWrapperPass::doFinalization(Module &M) {
lib/Analysis/MustExecute.cpp 323 bool runOnModule(Module &M) override;
355 bool MustBeExecutedContextPrinter::runOnModule(Module &M) {
398 MustExecuteAnnotatedWriter(const Module &M,
lib/Analysis/ObjCARCAliasAnalysis.cpp 152 bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
157 bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
lib/Analysis/PostDominators.cpp 59 void PostDominatorTreeWrapperPass::print(raw_ostream &OS, const Module *) const {
lib/Analysis/ProfileSummaryInfo.cpp 360 bool ProfileSummaryInfoWrapperPass::doInitialization(Module &M) {
365 bool ProfileSummaryInfoWrapperPass::doFinalization(Module &M) {
371 ProfileSummaryInfo ProfileSummaryAnalysis::run(Module &M,
376 PreservedAnalyses ProfileSummaryPrinterPass::run(Module &M,
lib/Analysis/RegionInfo.cpp 151 void RegionInfoPass::print(raw_ostream &OS, const Module *) const {
lib/Analysis/ScalarEvolution.cpp12045 void ScalarEvolutionWrapperPass::print(raw_ostream &OS, const Module *) const {
lib/Analysis/ScopedNoAliasAA.cpp 198 bool ScopedNoAliasAAWrapperPass::doInitialization(Module &M) {
203 bool ScopedNoAliasAAWrapperPass::doFinalization(Module &M) {
lib/Analysis/StackSafetyAnalysis.cpp 424 Module &M, std::function<const StackSafetyInfo &(Function &)> FI);
429 Module &M, std::function<const StackSafetyInfo &(Function &)> FI)
549 void print(const StackSafetyGlobalInfo &SSI, raw_ostream &O, const Module &M) {
604 void StackSafetyInfoWrapperPass::print(raw_ostream &O, const Module *M) const {
618 StackSafetyGlobalAnalysis::run(Module &M, ModuleAnalysisManager &AM) {
629 PreservedAnalyses StackSafetyGlobalPrinterPass::run(Module &M,
645 const Module *M) const {
654 bool StackSafetyGlobalInfoWrapperPass::runOnModule(Module &M) {
lib/Analysis/TargetLibraryInfo.cpp 1608 unsigned TargetLibraryInfoImpl::getWCharSize(const Module &M) const {
lib/Analysis/TypeBasedAliasAnalysis.cpp 728 bool TypeBasedAAWrapperPass::doInitialization(Module &M) {
733 bool TypeBasedAAWrapperPass::doFinalization(Module &M) {
lib/Analysis/TypeMetadataUtils.cpp 52 const Module *M, SmallVectorImpl<DevirtCallSite> &DevirtCalls, Value *VPtr,
79 const Module *M = CI->getParent()->getParent()->getParent();
131 Constant *llvm::getPointerAtOffset(Constant *I, uint64_t Offset, Module &M) {
lib/AsmParser/LLParser.cpp 235 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
241 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) {
649 Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
650 Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
1364 static inline GlobalValue *createGlobalFwdRef(Module *M, PointerType *PTy,
1467 Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
1468 Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
lib/AsmParser/LLParser.h 94 Module *M;
169 LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M,
lib/AsmParser/Parser.cpp 25 bool llvm::parseAssemblyInto(MemoryBufferRef F, Module *M,
40 std::unique_ptr<Module>
44 std::unique_ptr<Module> M =
45 std::make_unique<Module>(F.getBufferIdentifier(), Context);
54 std::unique_ptr<Module>
73 std::unique_ptr<Module> M =
74 std::make_unique<Module>(F.getBufferIdentifier(), Context);
101 std::unique_ptr<Module>
148 const Module &M, const SlotMapping *Slots) {
159 Type *llvm::parseType(StringRef Asm, SMDiagnostic &Err, const Module &M,
176 SMDiagnostic &Err, const Module &M,
lib/Bitcode/Reader/BitReader.cpp 42 Expected<std::unique_ptr<Module>> ModuleOrErr = parseBitcodeFile(Buf, Ctx);
64 ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
83 Expected<std::unique_ptr<Module>> ModuleOrErr =
111 ErrorOr<std::unique_ptr<Module>> ModuleOrErr = expectedToErrorOrAndEmitErrors(
lib/Bitcode/Reader/BitcodeReader.cpp 162 static void stripTBAA(Module *M) {
485 Module *TheModule = nullptr;
581 Error parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata = false,
3659 Error BitcodeReader::parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata,
6442 Expected<std::unique_ptr<Module>>
6464 std::unique_ptr<Module> M =
6465 std::make_unique<Module>(ModuleIdentifier, Context);
6485 Expected<std::unique_ptr<Module>>
6633 Expected<std::unique_ptr<Module>>
6643 Expected<std::unique_ptr<Module>> llvm::getOwningLazyBitcodeModule(
6653 Expected<std::unique_ptr<Module>>
6660 Expected<std::unique_ptr<Module>> llvm::parseBitcodeFile(MemoryBufferRef Buffer,
lib/Bitcode/Reader/MetadataLoader.cpp 426 Module &TheModule;
635 MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
2132 MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
lib/Bitcode/Reader/MetadataLoader.h 42 MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
lib/Bitcode/Writer/BitcodeWriter.cpp 155 const Module &M;
178 ModuleBitcodeWriterBase(const Module &M, StringTableBuilder &StrtabBuilder,
263 ModuleBitcodeWriter(const Module &M, SmallVectorImpl<char> &Buffer,
4266 for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
4384 for (Module *M : Mods) {
4429 void BitcodeWriter::writeModule(const Module &M,
4457 void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
4523 ThinLinkBitcodeWriter(const Module &M, StringTableBuilder &StrtabBuilder,
4641 void BitcodeWriter::writeThinLinkBitcode(const Module &M,
4661 void llvm::WriteThinLinkBitcodeToFile(const Module &M, raw_ostream &Out,
lib/Bitcode/Writer/BitcodeWriterPass.cpp 21 PreservedAnalyses BitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
52 bool runOnModule(Module &M) override {
lib/Bitcode/Writer/ValueEnumerator.cpp 102 static OrderMap orderModule(const Module &M) {
260 static UseListOrderStack predictUseListOrder(const Module &M) {
320 ValueEnumerator::ValueEnumerator(const Module &M,
556 void ValueEnumerator::EnumerateNamedMetadata(const Module &M) {
lib/Bitcode/Writer/ValueEnumerator.h 142 ValueEnumerator(const Module &M, bool ShouldPreserveUseListOrder);
298 void EnumerateNamedMetadata(const Module &M);
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 253 bool AsmPrinter::doInitialization(Module &M) {
1267 void AsmPrinter::computeGlobalGOTEquivs(Module &M) {
1301 void AsmPrinter::emitGlobalIndirectSymbol(Module &M,
1383 bool AsmPrinter::doFinalization(Module &M) {
2049 void AsmPrinter::EmitModuleIdents(Module &M) {
2064 void AsmPrinter::EmitModuleCommandLines(Module &M) {
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 343 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
937 const Module *M = MMI->getModule();
lib/CodeGen/AsmPrinter/DwarfDebug.h 598 DwarfDebug(AsmPrinter *A, Module *M);
lib/CodeGen/AsmPrinter/ErlangGCPrinter.cpp 36 void finishAssembly(Module &M, GCModuleInfo &Info, AsmPrinter &AP) override;
44 void ErlangGCPrinter::finishAssembly(Module &M, GCModuleInfo &Info,
lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp 40 void beginAssembly(Module &M, GCModuleInfo &Info, AsmPrinter &AP) override;
41 void finishAssembly(Module &M, GCModuleInfo &Info, AsmPrinter &AP) override;
51 static void EmitCamlGlobal(const Module &M, AsmPrinter &AP, const char *Id) {
73 void OcamlGCMetadataPrinter::beginAssembly(Module &M, GCModuleInfo &Info,
98 void OcamlGCMetadataPrinter::finishAssembly(Module &M, GCModuleInfo &Info,
lib/CodeGen/AsmPrinter/WinCFGuard.cpp 45 const Module *M = Asm->MMI->getModule();
lib/CodeGen/AsmPrinter/WinException.cpp 53 const Module *M = MMI->getModule();
lib/CodeGen/AtomicExpandPass.cpp 373 auto *M = LI->getModule();
461 auto *M = SI->getModule();
645 Module *M = I->getModule();
1054 auto *M = CI->getModule();
1616 Module *M = I->getModule();
lib/CodeGen/DwarfEHPrepare.cpp 67 bool doFinalization(Module &M) override {
lib/CodeGen/GCRootLowering.cpp 49 bool doInitialization(Module &M) override;
105 bool LowerIntrinsics::doInitialization(Module &M) {
108 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
lib/CodeGen/GlobalMerge.cpp 159 Module &M, bool isConst, unsigned AddrSpace) const;
164 const BitVector &GlobalSet, Module &M, bool isConst,
176 void setMustKeepGlobalVariables(Module &M);
179 void collectUsedGlobalVariables(Module &M, StringRef Name);
200 bool doInitialization(Module &M) override;
202 bool doFinalization(Module &M) override;
219 Module &M, bool isConst, unsigned AddrSpace) const {
437 const BitVector &GlobalSet, Module &M, bool isConst,
563 void GlobalMerge::collectUsedGlobalVariables(Module &M, StringRef Name) {
577 void GlobalMerge::setMustKeepGlobalVariables(Module &M) {
597 bool GlobalMerge::doInitialization(Module &M) {
670 bool GlobalMerge::doFinalization(Module &M) {
lib/CodeGen/HardwareLoops.cpp 118 Module *M = nullptr;
161 Module *M = nullptr;
lib/CodeGen/IntrinsicLowering.cpp 36 Module *M = CI->getModule();
500 Module *M = CI->getModule();
lib/CodeGen/LazyMachineBlockFrequencyInfo.cpp 38 const Module *M) const {
lib/CodeGen/LiveDebugVariables.cpp 1413 bool LiveDebugVariables::doInitialization(Module &M) {
lib/CodeGen/LiveDebugVariables.h 59 bool doInitialization(Module &) override;
lib/CodeGen/LiveIntervals.cpp 154 void LiveIntervals::print(raw_ostream &OS, const Module* ) const {
lib/CodeGen/LiveStacks.cpp 76 void LiveStacks::print(raw_ostream &OS, const Module*) const {
lib/CodeGen/LowerEmuTLS.cpp 37 bool runOnModule(Module &M) override;
39 bool addEmuTlsVar(Module &M, const GlobalVariable *GV);
40 static void copyLinkageVisibility(Module &M,
61 bool LowerEmuTLS::runOnModule(Module &M) {
84 bool LowerEmuTLS::addEmuTlsVar(Module &M, const GlobalVariable *GV) {
lib/CodeGen/MIRParser/MIParser.cpp 1734 const Module *M = MF.getFunction().getParent();
lib/CodeGen/MIRParser/MIRParser.cpp 93 std::unique_ptr<Module> parseIRModule();
95 bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI);
101 bool parseMachineFunction(Module &M, MachineModuleInfo &MMI);
213 std::unique_ptr<Module> MIRParserImpl::parseIRModule() {
219 return std::make_unique<Module>(Filename, Context);
222 std::unique_ptr<Module> M;
239 M = std::make_unique<Module>(Filename, Context);
245 bool MIRParserImpl::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
260 static Function *createDummyFunction(StringRef Name, Module &M) {
270 bool MIRParserImpl::parseMachineFunction(Module &M, MachineModuleInfo &MMI) {
813 const auto &M = *MF.getFunction().getParent();
920 std::unique_ptr<Module> MIRParser::parseIRModule() {
924 bool MIRParser::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
lib/CodeGen/MIRPrinter.cpp 176 static void output(const Module &Mod, void *Ctxt, raw_ostream &OS) {
180 static StringRef input(StringRef Str, void *Ctxt, Module &Mod) {
870 void llvm::printMIR(raw_ostream &OS, const Module &M) {
lib/CodeGen/MachineBasicBlock.cpp 284 const Module *M = F.getParent();
lib/CodeGen/MachineInstr.cpp 1457 const Module *M = nullptr;
lib/CodeGen/MachineModuleInfo.cpp 346 bool MachineModuleInfoWrapperPass::doInitialization(Module &M) {
353 bool MachineModuleInfoWrapperPass::doFinalization(Module &M) {
360 MachineModuleInfo MachineModuleAnalysis::run(Module &M,
lib/CodeGen/MachineOperand.cpp 449 } else if (const Module *M = F->getParent()) {
lib/CodeGen/MachineOutliner.cpp 889 bool outline(Module &M, std::vector<OutlinedFunction> &FunctionList,
893 MachineFunction *createOutlinedFunction(Module &M, OutlinedFunction &OF,
898 bool runOnModule(Module &M) override;
902 bool doOutline(Module &M, unsigned &OutlinedFunctionNum);
916 void populateMapper(InstructionMapper &Mapper, Module &M,
923 void initSizeRemarkInfo(const Module &M, const MachineModuleInfo &MMI,
929 emitInstrCountChangedRemark(const Module &M, const MachineModuleInfo &MMI,
1091 Module &M, OutlinedFunction &OF, InstructionMapper &Mapper, unsigned Name) {
1189 bool MachineOutliner::outline(Module &M,
1291 void MachineOutliner::populateMapper(InstructionMapper &Mapper, Module &M,
1352 const Module &M, const MachineModuleInfo &MMI,
1368 const Module &M, const MachineModuleInfo &MMI,
1419 bool MachineOutliner::runOnModule(Module &M) {
1433 bool MachineOutliner::doOutline(Module &M, unsigned &OutlinedFunctionNum) {
lib/CodeGen/MachineRegionInfo.cpp 117 void MachineRegionInfoPass::print(raw_ostream &OS, const Module *) const {
lib/CodeGen/MachineScheduler.cpp 157 void print(raw_ostream &O, const Module* = nullptr) const override;
591 void MachineSchedulerBase::print(raw_ostream &O, const Module* m) const {
lib/CodeGen/ParallelCG.cpp 27 static void codegen(Module *M, llvm::raw_pwrite_stream &OS,
37 std::unique_ptr<Module> llvm::splitCodeGen(
38 std::unique_ptr<Module> M, ArrayRef<llvm::raw_pwrite_stream *> OSs,
80 Expected<std::unique_ptr<Module>> MOrErr = parseBitcodeFile(
86 std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
lib/CodeGen/PreISelIntrinsicLowering.cpp 66 Module *M = F.getParent();
96 static bool lowerIntrinsics(Module &M) {
194 bool runOnModule(Module &M) override { return lowerIntrinsics(M); }
209 PreservedAnalyses PreISelIntrinsicLoweringPass::run(Module &M,
lib/CodeGen/RegUsageInfoPropagate.cpp 88 static const Function *findCalledFunction(const Module &M,
102 const Module &M = *MF.getFunction().getParent();
lib/CodeGen/RegisterCoalescer.cpp 343 void print(raw_ostream &O, const Module* = nullptr) const override;
3750 void RegisterCoalescer::print(raw_ostream &O, const Module* m) const {
lib/CodeGen/RegisterUsageInfo.cpp 46 bool PhysicalRegisterUsageInfo::doInitialization(Module &M) {
51 bool PhysicalRegisterUsageInfo::doFinalization(Module &M) {
72 void PhysicalRegisterUsageInfo::print(raw_ostream &OS, const Module *M) const {
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 2516 const Module &M = *ParentBB->getParent()->getFunction().getParent();
6369 const Module &M = *MF.getFunction().getParent();
lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp 467 const MachineFunction *MF, const Module *M,
lib/CodeGen/SelectionDAG/TargetLowering.cpp 6831 Module *VariableModule = const_cast<Module*>(GA->getGlobal()->getParent());
lib/CodeGen/ShadowStackGCLowering.cpp 68 bool doInitialization(Module &M) override;
167 bool ShadowStackGCLowering::doInitialization(Module &M) {
lib/CodeGen/SjLjEHPrepare.cpp 56 bool doInitialization(Module &M) override;
82 bool SjLjEHPrepare::doInitialization(Module &M) {
473 Module &M = *F.getParent();
lib/CodeGen/StackProtector.cpp 349 static Value *getStackGuard(const TargetLoweringBase *TLI, Module *M,
382 static bool CreatePrologue(Function *F, Module *M, ReturnInst *RI,
lib/CodeGen/TargetLoweringBase.cpp 1681 Module *M = IRB.GetInsertBlock()->getParent()->getParent();
1715 Module *M = IRB.GetInsertBlock()->getParent()->getParent();
1771 Module &M = *IRB.GetInsertBlock()->getParent()->getParent();
1780 void TargetLoweringBase::insertSSPDeclarations(Module &M) const {
1789 Value *TargetLoweringBase::getSDagStackGuard(const Module &M) const {
1793 Function *TargetLoweringBase::getSSPStackGuardCheck(const Module &M) const {
lib/CodeGen/TargetLoweringObjectFileImpl.cpp 65 static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
67 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
72 if (MFE.Behavior == Module::Require)
267 Module &M) const {
313 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
885 Module &M) const {
1445 Module &M) const {
lib/CodeGen/VirtRegMap.cpp 137 void VirtRegMap::print(raw_ostream &OS, const Module*) const {
lib/CodeGen/WasmEHPrepare.cpp 127 bool doInitialization(Module &M) override;
142 bool WasmEHPrepare::doInitialization(Module &M) {
173 Module &M = *F.getParent();
202 Module &M = *F.getParent();
lib/CodeGen/WinEHPrepare.cpp 65 bool doFinalization(Module &M) override;
125 bool WinEHPrepare::doFinalization(Module &M) { return false; }
lib/ExecutionEngine/ExecutionEngine.cpp 49 std::unique_ptr<Module> M, std::string *ErrorStr,
59 ExecutionEngine *(*ExecutionEngine::InterpCtor)(std::unique_ptr<Module> M,
66 void ExecutionEngine::Init(std::unique_ptr<Module> M) {
83 ExecutionEngine::ExecutionEngine(std::unique_ptr<Module> M)
88 ExecutionEngine::ExecutionEngine(DataLayout DL, std::unique_ptr<Module> M)
143 bool ExecutionEngine::removeModule(Module *M) {
145 Module *Found = I->get();
237 void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) {
370 void ExecutionEngine::runStaticConstructorsDestructors(Module &module,
411 for (std::unique_ptr<Module> &M : Modules)
475 EngineBuilder::EngineBuilder(std::unique_ptr<Module> M)
1197 Module &M = *Modules[m];
1227 Module &M = *Modules[m];
lib/ExecutionEngine/ExecutionEngineBindings.cpp 183 std::unique_ptr<Module> Mod(unwrap(M));
263 Module *Mod = unwrap(M);
lib/ExecutionEngine/Interpreter/Interpreter.cpp 34 ExecutionEngine *Interpreter::create(std::unique_ptr<Module> M,
54 Interpreter::Interpreter(std::unique_ptr<Module> M)
lib/ExecutionEngine/Interpreter/Interpreter.h 88 explicit Interpreter(std::unique_ptr<Module> M);
102 static ExecutionEngine *create(std::unique_ptr<Module> M,
lib/ExecutionEngine/MCJIT/MCJIT.cpp 42 MCJIT::createJIT(std::unique_ptr<Module> M, std::string *ErrorStr,
63 MCJIT::MCJIT(std::unique_ptr<Module> M, std::unique_ptr<TargetMachine> TM,
80 std::unique_ptr<Module> First = std::move(Modules[0]);
102 void MCJIT::addModule(std::unique_ptr<Module> M) {
111 bool MCJIT::removeModule(Module *M) {
143 std::unique_ptr<MemoryBuffer> MCJIT::emitObject(Module *M) {
186 void MCJIT::generateCodeForModule(Module *M) {
257 SmallVector<Module*, 16> ModsToAdd;
267 void MCJIT::finalizeModule(Module *M) {
289 Module *MCJIT::findModuleForSymbol(const std::string &Name,
301 Module *M = *I;
371 Module *M = findModuleForSymbol(Name, CheckFunctionsOnly);
421 Module *M = F->getParent();
lib/ExecutionEngine/MCJIT/MCJIT.h 68 MCJIT(std::unique_ptr<Module> M, std::unique_ptr<TargetMachine> tm,
72 typedef llvm::SmallPtrSet<Module *, 4> ModulePtrSet;
96 void addModule(std::unique_ptr<Module> M) {
100 bool removeModule(Module *M) {
105 bool hasModuleBeenAddedButNotLoaded(Module *M) {
109 bool hasModuleBeenLoaded(Module *M) {
115 bool hasModuleBeenFinalized(Module *M) {
119 bool ownsModule(Module* M) {
124 void markModuleAsLoaded(Module *M) {
138 void markModuleAsFinalized(Module *M) {
158 Module *M = *I;
172 Module *M = *I;
215 void addModule(std::unique_ptr<Module> M) override;
219 bool removeModule(Module *M) override;
239 void generateCodeForModule(Module *M) override;
251 virtual void finalizeModule(Module *);
304 createJIT(std::unique_ptr<Module> M, std::string *ErrorStr,
331 std::unique_ptr<MemoryBuffer> emitObject(Module *M);
338 Module *findModuleForSymbol(const std::string &Name, bool CheckFunctionsOnly);
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp 193 void CompileOnDemandLayer::cleanUpModule(Module &M) {
215 const Module &M = *(*Partition.begin())->getParent();
lib/ExecutionEngine/Orc/CompileUtils.cpp 28 SimpleCompiler::CompileResult SimpleCompiler::operator()(Module &M) {
62 SimpleCompiler::tryToLoadFromObjectCache(const Module &M) {
69 void SimpleCompiler::notifyObjectCompiled(const Module &M,
79 std::unique_ptr<MemoryBuffer> ConcurrentIRCompiler::operator()(Module &M) {
lib/ExecutionEngine/Orc/ExecutionUtils.cpp 78 iterator_range<CtorDtorIterator> getConstructors(const Module &M) {
84 iterator_range<CtorDtorIterator> getDestructors(const Module &M) {
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 228 GlobalVariable* createImplPointer(PointerType &PT, Module &M,
240 Module &M = *F.getParent();
256 std::vector<GlobalValue *> SymbolLinkagePromoter::operator()(Module &M) {
286 Function* cloneFunctionDecl(Module &Dst, const Function &F,
323 GlobalVariable* cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
353 GlobalAlias* cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
364 void cloneModuleFlagsMetadata(Module &Dst, const Module &Src,
364 void cloneModuleFlagsMetadata(Module &Dst, const Module &Src,
lib/ExecutionEngine/Orc/LLJIT.cpp 152 Error LLJIT::applyDataLayout(Module &M) {
164 void LLJIT::recordCtorDtors(Module &M) {
lib/ExecutionEngine/Orc/OrcCBindings.cpp 75 std::unique_ptr<Module> M(unwrap(Mod));
90 std::unique_ptr<Module> M(unwrap(Mod));
lib/ExecutionEngine/Orc/OrcCBindingsStack.h 286 addIRModule(LayerT &Layer, std::unique_ptr<Module> M,
326 addIRModuleEager(std::unique_ptr<Module> M,
335 addIRModuleLazy(std::unique_ptr<Module> M,
lib/ExecutionEngine/Orc/OrcMCJITReplacement.h 258 void addModule(std::unique_ptr<Module> M) override {
314 bool removeModule(Module *M) override {
475 std::map<Module*, bool> ShouldDelete;
lib/FuzzMutate/FuzzerCLI.cpp 169 std::unique_ptr<Module> llvm::parseModule(
174 return std::make_unique<Module>("M", Context);
189 size_t llvm::writeModule(const Module &M, uint8_t *Dest, size_t MaxSize) {
201 std::unique_ptr<Module> llvm::parseAndVerify(const uint8_t *Data, size_t Size,
lib/FuzzMutate/IRMutator.cpp 25 static void createEmptyFunction(Module &M) {
35 void IRMutationStrategy::mutate(Module &M, RandomIRBuilder &IB) {
54 void IRMutator::mutateModule(Module &M, int Seed, size_t CurSize,
lib/IR/AsmWriter.cpp 134 static OrderMap orderModule(const Module *M) {
265 static UseListOrderStack predictUseListOrder(const Module *M) {
318 static const Module *getModuleFromVal(const Value *V) {
336 if (const Module *M = getModuleFromVal(U))
466 TypePrinting(const Module *M = nullptr) : DeferredM(M) {}
487 const Module *DeferredM;
677 const Module* TheModule;
721 explicit SlotTracker(const Module *M,
823 ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
827 ModuleSlotTracker::ModuleSlotTracker(const Module *M,
898 SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
1243 const Module *Context);
1247 SlotTracker *Machine, const Module *Context,
1292 const Module *Context) {
1554 const Module *Context) {
1597 const Module *Context = nullptr;
1601 SlotTracker *Machine, const Module *Context)
1664 const Module *Context) {
1767 const Module *Context) {
1786 const Module *Context) {
1801 const Module *Context) {
1814 TypePrinting *, SlotTracker *, const Module *) {
1829 TypePrinting *, SlotTracker *, const Module *) {
1845 const Module *Context) {
1868 SlotTracker *Machine, const Module *Context) {
1893 SlotTracker *Machine, const Module *Context) {
1904 SlotTracker *, const Module *) {
1921 const Module *Context) {
1950 const Module *Context) {
1977 const Module *Context) {
1991 const Module *Context) {
2003 const Module *Context) {
2014 const Module *Context) {
2027 const Module *Context) {
2039 const Module *Context) {
2050 const Module *Context) {
2066 const Module *Context) {
2078 const Module *Context) {
2091 SlotTracker *Machine, const Module *Context) {
2110 SlotTracker *Machine, const Module *Context) {
2126 SlotTracker *Machine, const Module *Context) {
2138 const Module *Context) {
2166 const Module *Context) {
2176 const Module *Context) {
2191 SlotTracker *Machine, const Module *Context) {
2206 const Module *Context) {
2228 const Module *Context) {
2305 SlotTracker *Machine, const Module *Context,
2355 const Module *TheModule = nullptr;
2372 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2382 void printModule(const Module *M);
2452 const Module *M, AssemblyAnnotationWriter *AAW,
2575 void AssemblyWriter::printModule(const Module *M) {
3489 const Module *Mod = F->getParent();
3646 const Module *Mod = getModuleFromVal(I);
4336 SlotTracker *Machine, const Module *M) {
4358 const Module *M) const {
4382 ModuleSlotTracker &MST, const Module *M,
4399 void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
4405 const Module *M) const {
4409 void Metadata::print(raw_ostream &OS, const Module *M,
4416 const Module *M, bool /*IsForDebug*/) const {
4455 void Metadata::dump(const Module *M) const {
lib/IR/AutoUpgrade.cpp 1669 Module *M = F->getParent();
1696 Module *M = F->getParent();
3023 Module *M = F->getParent();
3809 bool llvm::UpgradeDebugInfo(Module &M) {
3835 static bool UpgradeRetainReleaseMarker(Module &M) {
3850 M.addModuleFlag(Module::Error, MarkerKey, ID);
3859 void llvm::UpgradeARCRuntime(Module &M) {
3980 bool llvm::UpgradeModuleFlags(Module &M) {
4002 if (Behavior->getLimitedValue() == Module::Error) {
4005 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Module::Max)),
4039 M.addModuleFlag(llvm::Module::Override, "Objective-C Class Properties",
4047 void llvm::UpgradeSectionAttributes(Module &M) {
lib/IR/ConstantFold.cpp 1150 if (Module *TheModule = GV->getParent()) {
lib/IR/Core.cpp 231 return wrap(new Module(ModuleID, *GlobalContext));
236 return wrap(new Module(ModuleID, *unwrap(C)));
293 static Module::ModFlagBehavior
297 return Module::ModFlagBehavior::Error;
299 return Module::ModFlagBehavior::Warning;
301 return Module::ModFlagBehavior::Require;
303 return Module::ModFlagBehavior::Override;
305 return Module::ModFlagBehavior::Append;
307 return Module::ModFlagBehavior::AppendUnique;
313 map_from_llvmModFlagBehavior(Module::ModFlagBehavior Behavior) {
315 case Module::ModFlagBehavior::Error:
317 case Module::ModFlagBehavior::Warning:
319 case Module::ModFlagBehavior::Require:
321 case Module::ModFlagBehavior::Override:
323 case Module::ModFlagBehavior::Append:
325 case Module::ModFlagBehavior::AppendUnique:
333 SmallVector<Module::ModuleFlagEntry, 8> MFEs;
1131 Module *Mod = unwrap(M);
1132 Module::named_metadata_iterator I = Mod->named_metadata_begin();
1139 Module *Mod = unwrap(M);
1140 Module::named_metadata_iterator I = Mod->named_metadata_end();
1148 Module::named_metadata_iterator I(NamedNode);
1156 Module::named_metadata_iterator I(NamedNode);
2087 Module *Mod = unwrap(M);
2088 Module::global_iterator I = Mod->global_begin();
2095 Module *Mod = unwrap(M);
2096 Module::global_iterator I = Mod->global_end();
2104 Module::global_iterator I(GV);
2112 Module::global_iterator I(GV);
2213 Module *Mod = unwrap(M);
2214 Module::alias_iterator I = Mod->alias_begin();
2221 Module *Mod = unwrap(M);
2222 Module::alias_iterator I = Mod->alias_end();
2230 Module::alias_iterator I(Alias);
2238 Module::alias_iterator I(Alias);
2265 Module *Mod = unwrap(M);
2266 Module::iterator I = Mod->begin();
2273 Module *Mod = unwrap(M);
2274 Module::iterator I = Mod->end();
2282 Module::iterator I(Func);
2290 Module::iterator I(Func);
2513 Module *Mod = unwrap(M);
2514 Module::ifunc_iterator I = Mod->ifunc_begin();
2521 Module *Mod = unwrap(M);
2522 Module::ifunc_iterator I = Mod->ifunc_end();
2530 Module::ifunc_iterator I(GIF);
2538 Module::ifunc_iterator I(GIF);
lib/IR/DIBuilder.cpp 33 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes, DICompileUnit *CU)
914 static Function *getDeclareIntrin(Module &M) {
lib/IR/DataLayout.cpp 456 DataLayout::DataLayout(const Module *M) {
460 void DataLayout::init(const Module *M) { *this = M->getDataLayout(); }
lib/IR/DebugInfo.cpp 62 void DebugInfoFinder::processModule(const Module &M) {
106 void DebugInfoFinder::processInstruction(const Module &M,
117 void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
197 void DebugInfoFinder::processDeclare(const Module &M,
213 void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
350 bool llvm::StripDebugInfo(Module &M) {
353 for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
589 bool llvm::stripNonLineTableDebugInfo(Module &M) {
682 unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
lib/IR/DiagnosticPrinter.cpp 104 DiagnosticPrinter &DiagnosticPrinterRawOStream::operator<<(const Module &M) {
lib/IR/Dominators.cpp 375 void DominatorTreeWrapperPass::print(raw_ostream &OS, const Module *) const {
lib/IR/Function.cpp 218 const Twine &N, Module &M) {
234 static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
243 const Twine &name, Module *ParentModule)
1093 Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
lib/IR/Globals.cpp 355 GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant,
478 Module *ParentModule)
487 Constant *Aliasee, Module *ParentModule) {
493 Module *Parent) {
534 Module *ParentModule)
543 Constant *Resolver, Module *ParentModule) {
lib/IR/IRBuilder.cpp 46 Module &M = *BB->getParent()->getParent();
106 Module *M = BB->getParent()->getParent();
136 Module *M = BB->getParent()->getParent();
168 Module *M = BB->getParent()->getParent();
209 Module *M = BB->getParent()->getParent();
248 Module *M = BB->getParent()->getParent();
285 Module *M = BB->getParent()->getParent();
316 Module *M = Builder->GetInsertBlock()->getParent()->getParent();
324 Module *M = GetInsertBlock()->getParent()->getParent();
333 Module *M = GetInsertBlock()->getParent()->getParent();
410 Module *M = BB->getParent()->getParent();
426 Module *M = BB->getParent()->getParent();
446 Module *M = BB->getParent()->getParent();
457 Module *M = BB->getParent()->getParent();
509 Module *M = BB->getParent()->getParent();
611 Module *M = Builder->GetInsertBlock()->getParent()->getParent();
662 Module *M = Builder->GetInsertBlock()->getParent()->getParent();
709 Module *M = BB->getParent()->getParent();
722 Module *M = BB->getParent()->getParent();
736 Module *M = BB->getModule();
745 Module *M = BB->getModule();
755 Module *M = BB->getModule();
lib/IR/IRPrintingPasses.cpp 28 PreservedAnalyses PrintModulePass::run(Module &M, ModuleAnalysisManager &) {
76 bool runOnModule(Module &M) override {
lib/IR/Instructions.cpp 568 Module *M = BB->getParent()->getParent();
662 Module *M = BB->getParent()->getParent();
lib/IR/IntrinsicInst.cpp 100 const Module *M = getModule();
lib/IR/LLVMContext.cpp 85 void LLVMContext::addModule(Module *M) {
89 void LLVMContext::removeModule(Module *M) {
lib/IR/LLVMContextImpl.h 1246 SmallPtrSet<Module*, 4> OwnedModules;
lib/IR/LegacyPassManager.cpp 144 Module &M, StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount) {
166 Pass *P, Module &M, int64_t Delta, unsigned CountBefore,
341 bool doInitialization(Module &M) override;
343 bool doFinalization(Module &M) override;
414 bool doInitialization(Module &M) override;
418 bool doFinalization(Module &M) override;
474 bool runOnModule(Module &M);
562 bool run(Module &M);
1381 Module &M = *F.getParent();
1440 bool BBPassManager::doInitialization(Module &M) {
1449 bool BBPassManager::doFinalization(Module &M) {
1485 FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
1529 bool FunctionPassManagerImpl::doInitialization(Module &M) {
1544 bool FunctionPassManagerImpl::doFinalization(Module &M) {
1619 Module &M = *F.getParent();
1680 bool FPPassManager::runOnModule(Module &M) {
1689 bool FPPassManager::doInitialization(Module &M) {
1698 bool FPPassManager::doFinalization(Module &M) {
1714 MPPassManager::runOnModule(Module &M) {
1851 bool PassManagerImpl::run(Module &M) {
1892 bool PassManager::run(Module &M) {
lib/IR/Module.cpp 311 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
599 const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
lib/IR/Pass.cpp 58 static std::string getDescription(const Module &M) {
62 bool ModulePass::skipModule(Module &M) const {
128 void Pass::print(raw_ostream &OS, const Module *) const {
lib/IR/PassManager.cpp 29 Module &M, const PreservedAnalyses &PA,
44 if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Module>>()) {
lib/IR/TypeFinder.cpp 31 void TypeFinder::run(const Module &M, bool onlyNamed) {
lib/IR/Value.cpp 174 if (Module *P = GV->getParent())
356 const Module *M = GV->getParent();
lib/IR/ValueSymbolTable.cpp 57 const Module *M = GV->getParent();
lib/IR/Verifier.cpp 120 const Module &M;
133 explicit VerifierSupport(raw_ostream *OS, const Module &M)
138 void Write(const Module *M) {
315 const Module &M)
410 void visitModuleIdents(const Module &M);
411 void visitModuleCommandLines(const Module &M);
412 void visitModuleFlags(const Module &M);
1324 void Verifier::visitModuleIdents(const Module &M) {
1341 void Verifier::visitModuleCommandLines(const Module &M) {
1359 void Verifier::visitModuleFlags(const Module &M) {
1398 Module::ModFlagBehavior MFB;
1399 if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) {
1414 case Module::Error:
1415 case Module::Warning:
1416 case Module::Override:
1420 case Module::Max: {
1427 case Module::Require: {
1445 case Module::Append:
1446 case Module::AppendUnique: {
1457 if (MFB != Module::Require) {
5120 bool llvm::verifyModule(const Module &M, raw_ostream *OS,
5154 bool doInitialization(Module &M) override {
5168 bool doFinalization(Module &M) override {
5541 VerifierAnalysis::Result VerifierAnalysis::run(Module &M,
5553 PreservedAnalyses VerifierPass::run(Module &M, ModuleAnalysisManager &AM) {
lib/IRReader/IRReader.cpp 32 std::unique_ptr<Module>
37 Expected<std::unique_ptr<Module>> ModuleOrErr = getOwningLazyBitcodeModule(
52 std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
68 std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
77 Expected<std::unique_ptr<Module>> ModuleOrErr =
95 std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
lib/LTO/LTO.cpp 470 Ctx(Conf), CombinedModule(std::make_unique<Module>("ld-temp.o", Ctx)),
666 Expected<std::unique_ptr<Module>> MOrErr =
671 Module &M = **MOrErr;
1007 RegularLTO.CombinedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
1088 Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
lib/LTO/LTOBackend.cpp 128 createTargetMachine(Config &Conf, const Target *TheTarget, Module &M) {
153 static void runNewPMPasses(Config &Conf, Module &Mod, TargetMachine *TM,
226 static void runNewPMCustomPasses(Module &Mod, TargetMachine *TM,
269 static void runOldPMPasses(Config &Conf, Module &Mod, TargetMachine *TM,
300 bool opt(Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
316 unsigned Task, Module &Mod) {
355 std::unique_ptr<Module> Mod) {
377 Expected<std::unique_ptr<Module>> MOrErr = parseBitcodeFile(
382 std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
401 Expected<const Target *> initAndLookupTarget(Config &C, Module &Mod) {
429 std::unique_ptr<Module> Mod,
460 static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals,
482 Module &Mod, const ModuleSummaryIndex &CombinedIndex,
lib/LTO/LTOCodeGenerator.cpp 112 : Context(Context), MergedModule(new Module("ld-temp.o", Context)),
386 Module &TheModule,
466 MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
lib/LTO/LTOModule.cpp 45 LTOModule::LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef,
168 static ErrorOr<std::unique_ptr<Module>>
195 ErrorOr<std::unique_ptr<Module>> MOrErr =
199 std::unique_ptr<Module> &M = *MOrErr;
lib/LTO/ThinLTOCodeGenerator.cpp 87 static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
153 static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index) {
170 static void verifyLoadedModule(Module &TheModule) {
181 static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile *Input,
187 Expected<std::unique_ptr<Module>> ModuleOrErr =
205 crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
228 static void optimizeModule(Module &TheModule, TargetMachine &TM,
281 std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule,
399 ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
633 void ThinLTOCodeGenerator::promote(Module &TheModule, ModuleSummaryIndex &Index,
681 void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
714 Module &TheModule, ModuleSummaryIndex &Index,
747 void ThinLTOCodeGenerator::emitImports(Module &TheModule, StringRef OutputName,
788 void ThinLTOCodeGenerator::internalize(Module &TheModule,
847 void ThinLTOCodeGenerator::optimize(Module &TheModule) {
lib/LTO/UpdateCompilerUsed.cpp 33 void findInModule(Module &TheModule) {
58 void initializeLibCalls(const Module &TheModule) {
122 void llvm::updateCompilerUsed(Module &TheModule, const TargetMachine &TM,
lib/Linker/IRMover.cpp 383 Module &DstM;
384 std::unique_ptr<Module> SrcM;
519 IRLinker(Module &DstM, MDMapT &SharedMDs,
520 IRMover::IdentifiedStructTypeSet &Set, std::unique_ptr<Module> SrcM,
553 Module *M = GV->getParent();
1216 if (Behavior->getZExtValue() == Module::Require) {
1236 if (SrcBehaviorValue == Module::Require) {
1263 if (DstBehaviorValue == Module::Override) {
1265 if (SrcBehaviorValue == Module::Override &&
1272 } else if (SrcBehaviorValue == Module::Override) {
1294 case Module::Require:
1295 case Module::Override:
1297 case Module::Error: {
1306 case Module::Warning: {
1320 case Module::Max: {
1329 case Module::Append: {
1340 case Module::AppendUnique: {
1538 IRMover::IRMover(Module &M) : Composite(M) {
1556 std::unique_ptr<Module> Src, ArrayRef<GlobalValue *> ValuesToLink,
lib/Linker/LinkModules.cpp 31 std::unique_ptr<Module> SrcM;
44 std::function<void(Module &, const StringSet<> &)> InternalizeCallback;
64 bool getComdatLeader(Module &M, StringRef ComdatName,
81 Module &DstM = Mover.getModule();
109 ModuleLinker(IRMover &Mover, std::unique_ptr<Module> SrcM, unsigned Flags,
110 std::function<void(Module &, const StringSet<> &)>
130 bool ModuleLinker::getComdatLeader(Module &M, StringRef ComdatName,
155 Module &DstM = Mover.getModule();
221 Module &DstM = Mover.getModule();
224 Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
225 Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(ComdatName);
440 Module &M = *Alias.getParent();
458 Module &DstM = Mover.getModule();
474 Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
475 Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(C.getName());
572 Linker::Linker(Module &M) : Mover(M) {}
575 std::unique_ptr<Module> Src, unsigned Flags,
576 std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
592 Module &Dest, std::unique_ptr<Module> Src, unsigned Flags,
592 Module &Dest, std::unique_ptr<Module> Src, unsigned Flags,
593 std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
603 Module *D = unwrap(Dest);
604 std::unique_ptr<Module> M(unwrap(Src));
lib/Object/IRObjectFile.cpp 29 std::vector<std::unique_ptr<Module>> Mods)
120 std::vector<std::unique_ptr<Module>> Mods;
122 Expected<std::unique_ptr<Module>> MOrErr =
lib/Object/IRSymtab.cpp 107 Expected<int> getComdatIndex(const Comdat *C, const Module *M);
109 Error addModule(Module *M);
114 Error build(ArrayRef<Module *> Mods);
117 Error Builder::addModule(Module *M) {
166 Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {
307 Error Builder::build(ArrayRef<Module *> IRMods) {
317 for (auto *M : IRMods)
338 Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
350 std::vector<Module *> Mods;
351 std::vector<std::unique_ptr<Module>> OwnedMods;
353 Expected<std::unique_ptr<Module>> MOrErr =
lib/Object/ModuleSymbolTable.cpp 56 void ModuleSymbolTable::addModule(Module *M) {
71 initializeRecordStreamer(const Module &M,
126 const Module &M,
163 const Module &M, function_ref<void(StringRef, StringRef)> AsmSymver) {
lib/Object/RecordStreamer.cpp 75 RecordStreamer::RecordStreamer(MCContext &Context, const Module &M)
lib/Object/RecordStreamer.h 31 const Module &M;
47 RecordStreamer(MCContext &Context, const Module &M);
lib/Passes/PassBuilder.cpp 257 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
270 Result run(Module &, ModuleAnalysisManager &) { return Result(); }
lib/Passes/StandardInstrumentations.cpp 34 Optional<std::pair<const Module *, std::string>> unwrapModule(Any IR) {
35 if (any_isa<const Module *>(IR))
36 return std::make_pair(any_cast<const Module *>(IR), std::string());
42 const Module *M = F->getParent();
51 const Module *M = F.getParent();
63 const Module *M = F->getParent();
73 void printIR(const Module *M, StringRef Banner, StringRef Extra = StringRef()) {
113 if (any_isa<const Module *>(IR)) {
114 const Module *M = any_cast<const Module *>(IR);
114 const Module *M = any_cast<const Module *>(IR);
152 const Module *M = nullptr;
207 const Module *M;
lib/ProfileData/InstrProf.cpp 305 GlobalVariable *createPGOFuncNameVar(Module &M,
336 Error InstrProfSymtab::create(Module &M, bool InLTO) {
931 void annotateValueSite(Module &M, Instruction &Inst,
947 void annotateValueSite(Module &M, Instruction &Inst,
1044 bool needsComdatForCounter(const Function &F, const Module &M) {
1070 bool isIRPGOFlagSet(const Module *M) {
1133 void createIRLevelProfileFlagVar(Module &M, bool IsCS) {
1151 void createProfileFileNameVar(Module &M, StringRef InstrProfileOutput) {
lib/ProfileData/SampleProfReader.cpp 505 void SampleProfileReaderExtBinary::collectFuncsFrom(const Module &M) {
885 void SampleProfileReaderCompactBinary::collectFuncsFrom(const Module &M) {
lib/Target/AArch64/AArch64AsmPrinter.cpp 105 void EmitHwasanMemaccessSymbols(Module &M);
167 void EmitEndOfAsmFile(Module &M) override;
263 void AArch64AsmPrinter::EmitHwasanMemaccessSymbols(Module &M) {
450 void AArch64AsmPrinter::EmitEndOfAsmFile(Module &M) {
lib/Target/AArch64/AArch64ISelLowering.cpp12171 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
12210 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
12217 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
12261 Module *M = IRB.GetInsertBlock()->getParent()->getParent();
12285 void AArch64TargetLowering::insertSSPDeclarations(Module &M) const {
12305 Value *AArch64TargetLowering::getSDagStackGuard(const Module &M) const {
12312 Function *AArch64TargetLowering::getSSPStackGuardCheck(const Module &M) const {
lib/Target/AArch64/AArch64ISelLowering.h 441 void insertSSPDeclarations(Module &M) const override;
442 Value *getSDagStackGuard(const Module &M) const override;
443 Function *getSSPStackGuardCheck(const Module &M) const override;
lib/Target/AArch64/AArch64PromoteConstant.cpp 120 bool runOnModule(Module &M) override {
lib/Target/AMDGPU/AMDGPUAliasAnalysis.h 86 bool doInitialization(Module &M) override {
92 bool doFinalization(Module &M) override {
lib/Target/AMDGPU/AMDGPUAlwaysInlinePass.cpp 42 bool runOnModule(Module &M) override;
87 bool AMDGPUAlwaysInline::runOnModule(Module &M) {
lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp 43 bool doInitialization(Module &M) override;
161 bool AMDGPUAnnotateUniformValues::doInitialization(Module &M) {
lib/Target/AMDGPU/AMDGPUArgumentUsageInfo.h 169 bool doInitialization(Module &M) override;
170 bool doFinalization(Module &M) override;
172 void print(raw_ostream &OS, const Module *M = nullptr) const override;
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp 124 void AMDGPUAsmPrinter::EmitStartOfAsmFile(Module &M) {
156 void AMDGPUAsmPrinter::EmitEndOfAsmFile(Module &M) {
325 bool AMDGPUAsmPrinter::doFinalization(Module &M) {
lib/Target/AMDGPU/AMDGPUAsmPrinter.h 106 bool doFinalization(Module &M) override;
136 void EmitStartOfAsmFile(Module &M) override;
138 void EmitEndOfAsmFile(Module &M) override;
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp 285 Module *M = B.GetInsertBlock()->getModule();
344 Module *M = B.GetInsertBlock()->getModule();
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp 69 Module *Mod = nullptr;
188 bool doInitialization(Module &M) override;
1017 bool AMDGPUCodeGenPrepare::doInitialization(Module &M) {
lib/Target/AMDGPU/AMDGPUFixFunctionBitcasts.cpp 29 bool runOnModule(Module &M) override;
58 bool AMDGPUFixFunctionBitcasts::runOnModule(Module &M) {
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp 253 void MetadataStreamerV2::emitPrintf(const Module &Mod) {
449 void MetadataStreamerV2::begin(const Module &Mod) {
659 void MetadataStreamerV3::emitPrintf(const Module &Mod) {
914 void MetadataStreamerV3::begin(const Module &Mod) {
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h 44 virtual void begin(const Module &Mod) = 0;
79 void emitPrintf(const Module &Mod);
113 void begin(const Module &Mod) override;
151 void emitPrintf(const Module &Mod);
179 void begin(const Module &Mod) override;
lib/Target/AMDGPU/AMDGPULibCalls.cpp 73 FunctionCallee getFunction(Module *M, const FuncInfo &fInfo);
143 FunctionCallee getNativeFunction(Module *M, const FuncInfo &FInfo);
478 FunctionCallee AMDGPULibCalls::getFunction(Module *M, const FuncInfo &fInfo) {
516 Module *M = aCI->getModule();
585 auto *M = Callee->getParent();
800 Module *M = CI->getModule();
943 Module *M = CI->getModule();
1170 Module *M = CI->getModule();
1179 Module *M = CI->getModule();
1195 Module *M = CI->getModule();
1253 FunctionCallee AMDGPULibCalls::getNativeFunction(Module *M,
1310 Module *M = CI->getModule();
lib/Target/AMDGPU/AMDGPULibFunc.cpp 914 FunctionType *AMDGPUMangledLibFunc::getFunctionType(Module &M) const {
942 Function *AMDGPULibFunc::getFunction(Module *M, const AMDGPULibFunc &fInfo) {
956 FunctionCallee AMDGPULibFunc::getOrInsertFunction(Module *M,
lib/Target/AMDGPU/AMDGPULibFunc.h 347 virtual FunctionType *getFunctionType(Module &M) const = 0;
391 FunctionType *getFunctionType(Module &M) const {
394 static Function *getFunction(llvm::Module *M, const AMDGPULibFunc &fInfo);
396 static FunctionCallee getOrInsertFunction(llvm::Module *M,
416 FunctionType *getFunctionType(Module &M) const override;
446 FunctionType *getFunctionType(Module &M) const override { return FuncTy; }
lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp 36 bool runOnModule(Module &M) override;
131 bool AMDGPULowerIntrinsics::runOnModule(Module &M) {
lib/Target/AMDGPU/AMDGPULowerKernelAttributes.cpp 44 Module *Mod = nullptr;
53 bool doInitialization(Module &M) override;
54 bool runOnModule(Module &M) override;
67 bool AMDGPULowerKernelAttributes::doInitialization(Module &M) {
238 bool AMDGPULowerKernelAttributes::runOnModule(Module &M) {
lib/Target/AMDGPU/AMDGPUOpenCLEnqueuedBlockLowering.cpp 61 bool runOnModule(Module &M) override;
105 bool AMDGPUOpenCLEnqueuedBlockLowering::runOnModule(Module &M) {
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp 261 const Module &M = *F.getParent();
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 55 bool runOnModule(Module &M) override;
61 lowerPrintfForGpu(Module &M,
149 Module &M, function_ref<const TargetLibraryInfo &(Function &)> GetTLI) {
565 bool AMDGPUPrintfRuntimeBinding::runOnModule(Module &M) {
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp 81 Module *Mod = nullptr;
116 bool doInitialization(Module &M) override;
138 bool AMDGPUPromoteAlloca::doInitialization(Module &M) {
lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp 104 bool process(Module &M);
140 bool runOnModule(Module &M) override;
168 bool AMDGPUPropagateAttributes::process(Module &M) {
188 Module &M = *(*Roots.begin())->getParent();
321 bool AMDGPUPropagateAttributesLate::runOnModule(Module &M) {
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp 121 bool doInitialization(Module &M) override;
203 bool AMDGPURewriteOutArguments::doInitialization(Module &M) {
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp 622 Module *M = II->getParent()->getParent()->getParent();
lib/Target/AMDGPU/AMDGPUUnifyMetadata.cpp 47 bool runOnModule(Module &M) override;
58 bool unifyVersionMD(Module &M, StringRef Name, bool PickFirst) {
91 bool unifyExtensionMD(Module &M, StringRef Name) {
125 bool AMDGPUUnifyMetadata::runOnModule(Module &M) {
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp 331 bool transformKernels(Module &M) {
368 bool runOnModule(Module &M) override {
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp 79 void initialize(Module &M, const GCNSubtarget &ST);
137 void SIAnnotateControlFlow::initialize(Module &M, const GCNSubtarget &ST) {
lib/Target/AMDGPU/SIISelLowering.cpp 6060 const Module *M = MF.getFunction().getParent();
lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp 33 void AMDGPUPALMetadata::readFromIR(Module &M) {
lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h 37 void readFromIR(Module &M);
lib/Target/ARM/ARMAsmPrinter.cpp 474 void ARMAsmPrinter::EmitStartOfAsmFile(Module &M) {
514 void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) {
581 static bool checkFunctionsAttributeConsistency(const Module &M, StringRef Attr,
726 if (const Module *SourceModule = MMI->getModule()) {
lib/Target/ARM/ARMAsmPrinter.h 98 void EmitStartOfAsmFile(Module &M) override;
99 void EmitEndOfAsmFile(Module &M) override;
lib/Target/ARM/ARMCodeGenPrepare.cpp 114 Module *M = nullptr;
137 IRPromoter(Module *M) : M(M), Ctx(M->getContext()),
174 bool doInitialization(Module &M) override;
176 bool doFinalization(Module &M) override;
1003 bool ARMCodeGenPrepare::doInitialization(Module &M) {
1054 bool ARMCodeGenPrepare::doFinalization(Module &M) {
lib/Target/ARM/ARMFastISel.cpp 112 Module &M;
lib/Target/ARM/ARMISelLowering.cpp 2271 const Module *Mod = MF.getFunction().getParent();
16403 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
16535 void ARMTargetLowering::insertSSPDeclarations(Module &M) const {
16551 Value *ARMTargetLowering::getSDagStackGuard(const Module &M) const {
16558 Function *ARMTargetLowering::getSSPStackGuardCheck(const Module &M) const {
16608 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
16646 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
16653 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
lib/Target/ARM/ARMISelLowering.h 571 void insertSSPDeclarations(Module &M) const override;
572 Value *getSDagStackGuard(const Module &M) const override;
573 Function *getSSPStackGuardCheck(const Module &M) const override;
lib/Target/ARM/ARMParallelDSP.cpp 217 Module *M;
lib/Target/ARM/MVETailPredication.cpp 450 Module *M = L->getHeader()->getModule();
lib/Target/BPF/BPFAbstractMemberAccess.cpp 107 bool runOnModule(Module &M) override;
141 bool doTransformation(Module &M);
148 void collectAICallChains(Module &M, Function &F);
153 bool removePreserveAccessIndexIntrinsic(Module &M);
166 bool transformGEPChain(Module &M, CallInst *Call, CallInfo &CInfo);
178 bool BPFAbstractMemberAccess::runOnModule(Module &M) {
302 bool BPFAbstractMemberAccess::removePreserveAccessIndexIntrinsic(Module &M) {
489 void BPFAbstractMemberAccess::collectAICallChains(Module &M, Function &F) {
840 bool BPFAbstractMemberAccess::transformGEPChain(Module &M, CallInst *Call,
910 bool BPFAbstractMemberAccess::doTransformation(Module &M) {
lib/Target/BPF/BPFAsmPrinter.cpp 44 bool doInitialization(Module &M) override;
58 bool BPFAsmPrinter::doInitialization(Module &M) {
lib/Target/BPF/BTFDebug.cpp 1056 const Module *M = MMI->getModule();
lib/Target/Hexagon/HexagonGenExtract.cpp 212 Module *Mod = BB->getParent()->getParent();
lib/Target/Hexagon/HexagonISelLowering.cpp 1817 const Module &M = *I.getParent()->getParent()->getParent();
3242 Module *M = BB->getParent()->getParent();
3265 Module *M = BB->getParent()->getParent();
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 1525 Module *M = At->getParent()->getParent()->getParent();
2255 Module *M = Func->getParent();
2408 const Module &M = *L->getHeader()->getParent()->getParent();
lib/Target/Hexagon/HexagonTargetMachine.h 37 static unsigned getModuleMatchQuality(const Module &M);
lib/Target/Mips/Mips16HardFloat.cpp 41 bool runOnModule(Module &M) override;
186 static std::string swapFPIntParams(FPParamVariant PV, Module *M, bool LE,
256 static void assureFPCallStub(Function &F, Module *M,
377 static bool fixupFPReturnAndCall(Function &F, Module *M,
446 static void createFPFnStub(Function *F, Module *M, FPParamVariant PV,
511 bool Mips16HardFloat::runOnModule(Module &M) {
516 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
lib/Target/Mips/MipsAsmPrinter.cpp 767 void MipsAsmPrinter::EmitStartOfAsmFile(Module &M) {
1119 void MipsAsmPrinter::EmitEndOfAsmFile(Module &M) {
lib/Target/Mips/MipsAsmPrinter.h 157 void EmitStartOfAsmFile(Module &M) override;
158 void EmitEndOfAsmFile(Module &M) override;
lib/Target/Mips/MipsOs16.cpp 39 bool runOnModule(Module &M) override;
109 bool MipsOs16::runOnModule(Module &M) {
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 701 void NVPTXAsmPrinter::emitDeclarations(const Module &M, raw_ostream &O) {
703 for (Module::const_iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) {
765 bool NVPTXAsmPrinter::doInitialization(Module &M) {
812 void NVPTXAsmPrinter::emitGlobals(const Module &M) {
844 void NVPTXAsmPrinter::emitHeader(Module &M, raw_ostream &O,
890 bool NVPTXAsmPrinter::doFinalization(Module &M) {
903 Module::GlobalListType &global_list = M.getGlobalList();
909 for (Module::global_iterator I = global_list.begin(), E = global_list.end();
lib/Target/NVPTX/NVPTXAsmPrinter.h 221 void emitGlobals(const Module &M);
222 void emitHeader(Module &M, raw_ostream &O, const NVPTXSubtarget &STI);
240 bool doInitialization(Module &M) override;
241 bool doFinalization(Module &M) override;
267 void emitDeclarations(const Module &, raw_ostream &O);
lib/Target/NVPTX/NVPTXAssignValidGlobalNames.cpp 36 bool runOnModule(Module &M) override;
52 bool NVPTXAssignValidGlobalNames::runOnModule(Module &M) {
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp 42 bool runOnModule(Module &M) override;
47 Value *remapConstant(Module *M, Function *F, Constant *C,
49 Value *remapConstantVectorOrConstantAggregate(Module *M, Function *F,
52 Value *remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
71 bool GenericToNVVM::runOnModule(Module &M) {
77 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
102 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
156 Value *GenericToNVVM::remapConstant(Module *M, Function *F, Constant *C,
196 Module *M, Function *F, Constant *C, IRBuilder<> &Builder) {
234 Value *GenericToNVVM::remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
lib/Target/NVPTX/NVPTXISelLowering.cpp 2440 static bool isImageOrSamplerVal(const Value *arg, const Module *context) {
lib/Target/NVPTX/NVPTXUtilities.cpp 35 typedef std::map<const Module *, global_val_annot_t> per_module_annot_t;
41 void clearAnnotationCache(const Module *Mod) {
72 static void cacheAnnotationFromMD(const Module *m, const GlobalValue *gv) {
108 const Module *m = gv->getParent();
122 const Module *m = gv->getParent();
lib/Target/NVPTX/NVPTXUtilities.h 27 void clearAnnotationCache(const Module *);
lib/Target/PowerPC/PPCAsmPrinter.cpp 94 bool doInitialization(Module &M) override {
113 void EmitEndOfAsmFile(Module &M) override;
137 bool doFinalization(Module &M) override;
138 void EmitStartOfAsmFile(Module &M) override;
159 bool doFinalization(Module &M) override;
160 void EmitStartOfAsmFile(Module &M) override;
176 void EmitEndOfAsmFile(Module &) override;
348 void PPCAsmPrinter::EmitEndOfAsmFile(Module &M) {
482 const Module *M = MF->getFunction().getParent();
541 const Module *M = MF->getFunction().getParent();
1322 void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
1431 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
1581 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
1653 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1809 void PPCAIXAsmPrinter::EmitEndOfAsmFile(Module &M) {
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 436 const Module *M = MF->getFunction().getParent();
4389 const Module *Mod = MF->getFunction().getParent();
lib/Target/PowerPC/PPCISelLowering.cpp 2852 const Module *M = DAG.getMachineFunction().getFunction().getParent();
4976 const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
10261 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
15076 void PPCTargetLowering::insertSSPDeclarations(Module &M) const {
lib/Target/PowerPC/PPCISelLowering.h 946 void insertSSPDeclarations(Module &M) const override;
lib/Target/PowerPC/PPCMCInstLower.cpp 113 const Module *M = MF->getFunction().getParent();
lib/Target/RISCV/RISCVTargetObjectFile.cpp 87 void RISCVELFTargetObjectFile::getModuleMetadata(Module &M) {
88 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
lib/Target/RISCV/RISCVTargetObjectFile.h 41 void getModuleMetadata(Module &M) override;
lib/Target/Sparc/SparcISelLowering.cpp 705 const Module *M = Fn.getParent();
1947 const Module *M = DAG.getMachineFunction().getFunction().getParent();
3416 void SparcTargetLowering::insertSSPDeclarations(Module &M) const {
lib/Target/Sparc/SparcISelLowering.h 120 void insertSSPDeclarations(Module &M) const override;
lib/Target/SystemZ/SystemZAsmPrinter.cpp 703 void SystemZAsmPrinter::EmitEndOfAsmFile(Module &M) {
lib/Target/SystemZ/SystemZAsmPrinter.h 37 void EmitEndOfAsmFile(Module &M) override;
43 bool doInitialization(Module &M) override {
lib/Target/SystemZ/SystemZISelLowering.h 473 void insertSSPDeclarations(Module &M) const override {
lib/Target/SystemZ/SystemZTDC.cpp 97 auto &M = *I->getFunction()->getParent();
343 Module &M = *F.getParent();
lib/Target/TargetMachine.cpp 94 bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
lib/Target/TargetMachineC.cpp 190 Module* Mod = unwrap(M);
lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp 45 bool runOnModule(Module &M) override;
61 bool WebAssemblyAddMissingPrototypes::runOnModule(Module &M) {
lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp 88 void WebAssemblyAsmPrinter::EmitEndOfAsmFile(Module &M) {
169 void WebAssemblyAsmPrinter::EmitProducerInfo(Module &M) {
220 void WebAssemblyAsmPrinter::EmitTargetFeatures(Module &M) {
lib/Target/WebAssembly/WebAssemblyAsmPrinter.h 60 void EmitEndOfAsmFile(Module &M) override;
61 void EmitProducerInfo(Module &M);
62 void EmitTargetFeatures(Module &M);
lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp 182 void WebAssemblyExceptionInfo::print(raw_ostream &OS, const Module *) const {
lib/Target/WebAssembly/WebAssemblyExceptionInfo.h 164 void print(raw_ostream &OS, const Module *M = nullptr) const override;
lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp 49 bool runOnModule(Module &M) override;
119 Module *M = F->getParent();
237 bool FixFunctionBitcasts::runOnModule(Module &M) {
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp 258 Function *getFindMatchingCatch(Module &M, unsigned NumClauses);
267 bool canLongjmp(Module &M, const Value *Callee) const;
268 bool isEmAsmCall(Module &M, const Value *Callee) const;
279 bool runOnModule(Module &M) override;
314 static GlobalVariable *getGlobalVariableI32(Module &M, IRBuilder<> &IRB,
352 WebAssemblyLowerEmscriptenEHSjLj::getFindMatchingCatch(Module &M,
447 Module *M = CI->getModule();
475 bool WebAssemblyLowerEmscriptenEHSjLj::canLongjmp(Module &M,
514 bool WebAssemblyLowerEmscriptenEHSjLj::isEmAsmCall(Module &M,
624 bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
740 Module &M = *F.getParent();
874 Module &M = *F.getParent();
lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp 44 bool runOnModule(Module &M) override;
60 bool LowerGlobalDtors::runOnModule(Module &M) {
lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp 182 bool runOnModule(Module &M) override {
210 FeatureBitset coalesceFeatures(const Module &M) {
236 bool stripAtomics(Module &M) {
263 bool stripThreadLocals(Module &M) {
275 void recordFeatures(Module &M, const FeatureBitset &Features, bool Stripped) {
284 M.addModuleFlag(Module::ModFlagBehavior::Error, MDKey,
288 M.addModuleFlag(Module::ModFlagBehavior::Error, MDKey,
lib/Target/X86/X86AsmPrinter.cpp 556 void X86AsmPrinter::EmitStartOfAsmFile(Module &M) {
679 void X86AsmPrinter::EmitEndOfAsmFile(Module &M) {
lib/Target/X86/X86AsmPrinter.h 126 void EmitStartOfAsmFile(Module &M) override;
128 void EmitEndOfAsmFile(Module &M) override;
142 bool doInitialization(Module &M) override {
lib/Target/X86/X86ISelLowering.cpp 2317 void X86TargetLowering::insertSSPDeclarations(Module &M) const {
2341 Value *X86TargetLowering::getSDagStackGuard(const Module &M) const {
2350 Function *X86TargetLowering::getSSPStackGuardCheck(const Module &M) const {
3629 const Module *M = MF.getMMI().getModule();
17874 const Module &Mod = *DAG.getMachineFunction().getFunction().getParent();
26541 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
45088 const Module *M = DAG.getMachineFunction().getMMI().getModule();
lib/Target/X86/X86ISelLowering.h 1194 void insertSSPDeclarations(Module &M) const override;
1195 Value *getSDagStackGuard(const Module &M) const override;
1196 Function *getSSPStackGuardCheck(const Module &M) const override;
lib/Target/X86/X86InsertPrefetch.cpp 43 bool doInitialization(Module &) override;
156 bool X86InsertPrefetch::doInitialization(Module &M) {
lib/Target/X86/X86RetpolineThunks.cpp 56 bool doInitialization(Module &M) override;
74 void createThunkFunction(Module &M, StringRef Name);
87 bool X86RetpolineThunks::doInitialization(Module &M) {
101 Module &M = const_cast<Module &>(*MMI->getModule());
195 void X86RetpolineThunks::createThunkFunction(Module &M, StringRef Name) {
lib/Target/X86/X86Subtarget.cpp 123 const Module &M) const {
178 const Module &M) const {
lib/Target/X86/X86Subtarget.h 847 const Module &M) const;
852 const Module &M) const;
lib/Target/X86/X86WinEHState.cpp 47 bool doInitialization(Module &M) override;
49 bool doFinalization(Module &M) override;
83 Module *TheModule = nullptr;
120 bool WinEHStatePass::doInitialization(Module &M) {
125 bool WinEHStatePass::doFinalization(Module &M) {
lib/Target/XCore/XCoreLowerThreadLocal.cpp 50 bool runOnModule(Module &M) override;
180 Module *M = GV->getParent();
222 bool XCoreLowerThreadLocal::runOnModule(Module &M) {
lib/Transforms/CFGuard/CFGuard.cpp 144 bool doInitialization(Module &M) override;
226 bool CFGuard::doInitialization(Module &M) {
lib/Transforms/Coroutines/CoroCleanup.cpp 26 Lowerer(Module &M) : LowererBase(M), Builder(Context) {}
113 bool doInitialization(Module &M) override {
lib/Transforms/Coroutines/CoroEarly.cpp 37 Lowerer(Module &M)
111 Module &M = *II->getModule();
238 bool doInitialization(Module &M) override {
lib/Transforms/Coroutines/CoroElide.cpp 35 Lowerer(Module &M) : LowererBase(M) {}
266 Module &M = *F.getParent();
287 bool doInitialization(Module &M) override {
lib/Transforms/Coroutines/CoroInternal.h 46 bool declaresIntrinsics(Module &M, std::initializer_list<StringRef>);
55 Module &TheModule;
61 LowererBase(Module &M);
lib/Transforms/Coroutines/CoroSplit.cpp 395 Module::iterator InsertBefore) {
396 Module *M = OrigF.getParent();
796 Module *M = SizeIntrin->getModule();
827 Module *M = Part->getParent();
1383 Module &M = *F.getParent();
1414 Module &M = CG.getModule();
lib/Transforms/Coroutines/Coroutines.cpp 94 coro::LowererBase::LowererBase(Module &M)
153 bool coro::declaresIntrinsics(Module &M,
238 Module *M = SuspendInst->getModule();
lib/Transforms/IPO/AlwaysInliner.cpp 34 PreservedAnalyses AlwaysInlinerPass::run(Module &M,
lib/Transforms/IPO/Attributor.cpp 3609 Module *M = F->getParent();
4447 ChangeStatus Attributor::run(Module &M) {
4921 static bool runAttributorOnModule(Module &M, AnalysisGetter &AG) {
4960 PreservedAnalyses AttributorPass::run(Module &M, ModuleAnalysisManager &AM) {
4978 bool runOnModule(Module &M) override {
lib/Transforms/IPO/BlockExtractor.cpp 82 bool runOnModule(Module &M) override;
164 bool BlockExtractor::runOnModule(Module &M) {
lib/Transforms/IPO/CalledValuePropagation.cpp 370 static bool runCVP(Module &M) {
403 PreservedAnalyses CalledValuePropagationPass::run(Module &M,
423 bool runOnModule(Module &M) override {
lib/Transforms/IPO/ConstantMerge.cpp 115 static void replace(Module &M, GlobalVariable *Old, GlobalVariable *New) {
134 static bool mergeConstants(Module &M) {
155 for (Module::global_iterator GVI = M.global_begin(), E = M.global_end();
201 for (Module::global_iterator GVI = M.global_begin(), E = M.global_end();
254 PreservedAnalyses ConstantMergePass::run(Module &M, ModuleAnalysisManager &) {
271 bool runOnModule(Module &M) override {
lib/Transforms/IPO/CrossDSOCFI.cpp 51 void buildCFICheck(Module &M);
52 bool runOnModule(Module &M) override;
79 void CrossDSOCFI::buildCFICheck(Module &M) {
159 bool CrossDSOCFI::runOnModule(Module &M) {
168 PreservedAnalyses CrossDSOCFIPass::run(Module &M, ModuleAnalysisManager &AM) {
lib/Transforms/IPO/DeadArgumentElimination.cpp 75 bool runOnModule(Module &M) override {
1084 PreservedAnalyses DeadArgumentEliminationPass::run(Module &M,
1093 for (Module::iterator I = M.begin(), E = M.end(); I != E; ) {
1109 for (Module::iterator I = M.begin(), E = M.end(); I != E; ) {
lib/Transforms/IPO/ElimAvailExtern.cpp 32 static bool eliminateAvailableExternally(Module &M) {
67 EliminateAvailableExternallyPass::run(Module &M, ModuleAnalysisManager &) {
85 bool runOnModule(Module &M) override {
lib/Transforms/IPO/ExtractGV.cpp 67 bool runOnModule(Module &M) override {
83 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
122 for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
124 Module::alias_iterator CurI = I;
lib/Transforms/IPO/ForceFunctionAttrs.cpp 89 PreservedAnalyses ForceFunctionAttrsPass::run(Module &M,
109 bool runOnModule(Module &M) override {
lib/Transforms/IPO/FunctionAttrs.cpp 1532 bool runOnModule(Module &M) override;
1584 static bool deduceFunctionAttributeInRPO(Module &M, CallGraph &CG) {
1610 bool ReversePostOrderFunctionAttrsLegacyPass::runOnModule(Module &M) {
1620 ReversePostOrderFunctionAttrsPass::run(Module &M, ModuleAnalysisManager &AM) {
lib/Transforms/IPO/FunctionImport.cpp 148 static std::unique_ptr<Module> loadFile(const std::string &FileName,
154 std::unique_ptr<Module> Result =
945 Module &TheModule, const GVSummaryMapTy &DefinedGlobals) {
1009 void llvm::thinLTOInternalizeModule(Module &TheModule,
1048 static Function *replaceAliasWithAliasee(Module *SrcModule, GlobalAlias *GA) {
1064 static void internalizeGVsAfterImport(Module &M) {
1077 Module &DestModule, const FunctionImporter::ImportMapTy &ImportList) {
1092 Expected<std::unique_ptr<Module>> SrcModuleOrErr = ModuleLoader(Name);
1095 std::unique_ptr<Module> SrcModule = std::move(*SrcModuleOrErr);
1211 static bool doImportingForModule(Module &M) {
1283 bool runOnModule(Module &M) override {
1293 PreservedAnalyses FunctionImportPass::run(Module &M,
lib/Transforms/IPO/GlobalDCE.cpp 55 bool runOnModule(Module &M) override {
158 void GlobalDCEPass::ScanVTables(Module &M) {
231 void GlobalDCEPass::ScanTypeCheckedLoadIntrinsics(Module &M) {
260 void GlobalDCEPass::AddVirtualFunctionDependencies(Module &M) {
278 PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) {
lib/Transforms/IPO/GlobalOpt.cpp 472 Module::GlobalListType &Globals = GV->getParent()->getGlobalList();
2246 OptimizeFunctions(Module &M,
2256 for (Module::iterator FI = M.begin(), E = M.end(); FI != E;) {
2263 for (Module::iterator FI = M.begin(), E = M.end(); FI != E; ) {
2351 OptimizeGlobalVars(Module &M,
2357 for (Module::global_iterator GVI = M.global_begin(), E = M.global_end();
2619 Module *M = V.getParent();
2639 LLVMUsed(Module &M) {
2752 OptimizeGlobalAliases(Module &M,
2760 for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
2823 FindCXAAtExit(Module &M, function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
2912 Module &M, const DataLayout &DL,
2968 PreservedAnalyses GlobalOptPass::run(Module &M, ModuleAnalysisManager &AM) {
3000 bool runOnModule(Module &M) override {
lib/Transforms/IPO/GlobalSplit.cpp 140 static bool splitGlobals(Module &M) {
170 bool runOnModule(Module &M) override {
188 PreservedAnalyses GlobalSplitPass::run(Module &M, ModuleAnalysisManager &AM) {
lib/Transforms/IPO/HotColdSplitting.cpp 180 bool runOnModule(Module &M) override;
636 bool HotColdSplitting::run(Module &M) {
667 bool HotColdSplittingLegacyPass::runOnModule(Module &M) {
694 HotColdSplittingPass::run(Module &M, ModuleAnalysisManager &AM) {
lib/Transforms/IPO/IPConstantPropagation.cpp 42 bool runOnModule(Module &M) override;
286 bool IPCP::runOnModule(Module &M) {
lib/Transforms/IPO/InferFunctionAttrs.cpp 22 Module &M, function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
34 PreservedAnalyses InferFunctionAttrsPass::run(Module &M,
63 bool runOnModule(Module &M) override {
lib/Transforms/IPO/Inliner.cpp 881 Module &M = *InitialC.begin()->getFunction().getParent();
lib/Transforms/IPO/Internalize.cpp 149 bool InternalizePass::internalizeModule(Module &M, CallGraph *CG) {
238 PreservedAnalyses InternalizePass::run(Module &M, ModuleAnalysisManager &AM) {
262 bool runOnModule(Module &M) override {
lib/Transforms/IPO/LowerTypeTests.cpp 337 Module &M;
341 ScopedSaveAliaseesAndUsed(Module &M) : M(M) {
380 Module &M;
501 LowerTypeTestsModule(Module &M, ModuleSummaryIndex *ExportSummary,
508 static bool runForTesting(Module &M);
530 bool runOnModule(Module &M) override {
1656 Module &M, ModuleSummaryIndex *ExportSummary,
1666 bool LowerTypeTestsModule::runForTesting(Module &M) {
2196 PreservedAnalyses LowerTypeTestsPass::run(Module &M,
lib/Transforms/IPO/MergeFunctions.cpp 207 bool runOnModule(Module &M) override;
388 bool MergeFunctions::runOnModule(Module &M) {
lib/Transforms/IPO/PartialInlining.cpp 209 bool run(Module &M);
359 bool runOnModule(Module &M) override {
1450 bool PartialInlinerImpl::run(Module &M) {
1501 PreservedAnalyses PartialInlinerPass::run(Module &M,
lib/Transforms/IPO/SCCP.cpp 10 PreservedAnalyses IPSCCPPass::run(Module &M, ModuleAnalysisManager &AM) {
48 bool runOnModule(Module &M) override {
lib/Transforms/IPO/SampleProfile.cpp 204 GUIDToFuncNameMapper(Module &M, SampleProfileReader &Reader,
266 Module &CurrentModule;
286 bool doInitialization(Module &M);
287 bool runOnModule(Module &M, ModuleAnalysisManager *AM,
456 bool doInitialization(Module &M) override {
461 bool runOnModule(Module &M) override;
1676 bool SampleProfileLoader::doInitialization(Module &M) {
1712 bool SampleProfileLoader::runOnModule(Module &M, ModuleAnalysisManager *AM,
1762 bool SampleProfileLoaderLegacyPass::runOnModule(Module &M) {
1830 PreservedAnalyses SampleProfileLoaderPass::run(Module &M,
lib/Transforms/IPO/StripDeadPrototypes.cpp 28 static bool stripDeadPrototypes(Module &M) {
32 for (Module::iterator I = M.begin(), E = M.end(); I != E; ) {
43 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
55 PreservedAnalyses StripDeadPrototypesPass::run(Module &M,
71 bool runOnModule(Module &M) override {
lib/Transforms/IPO/StripSymbols.cpp 45 bool runOnModule(Module &M) override;
60 bool runOnModule(Module &M) override;
75 bool runOnModule(Module &M) override;
90 bool runOnModule(Module &M) override;
174 static void StripTypeNames(Module &M, bool PreserveDbgInfo) {
204 static bool StripSymbolNames(Module &M, bool PreserveDbgInfo) {
210 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
231 bool StripSymbols::runOnModule(Module &M) {
242 bool StripNonDebugSymbols::runOnModule(Module &M) {
249 bool StripDebugDeclare::runOnModule(Module &M) {
296 bool StripDeadDebugInfo::runOnModule(Module &M) {
lib/Transforms/IPO/SyntheticCountsPropagation.cpp 66 initializeCounts(Module &M, function_ref<void(Function *, uint64_t)> SetCount) {
97 PreservedAnalyses SyntheticCountsPropagation::run(Module &M,
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp 36 void promoteInternals(Module &ExportM, Module &ImportM, StringRef ModuleId,
36 void promoteInternals(Module &ExportM, Module &ImportM, StringRef ModuleId,
86 void promoteTypeIds(Module &M, StringRef ModuleId) {
140 void simplifyExternals(Module &M) {
175 filterModule(Module *M,
201 function_ref<AAResults &(Function &)> AARGetter, Module &M) {
207 M.addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
274 std::unique_ptr<Module> MergedM(
395 MergedM->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
430 bool enableSplitLTOUnit(Module &M) {
439 bool hasTypeMetadata(Module &M) {
449 Module &M, const ModuleSummaryIndex *Index) {
509 bool runOnModule(Module &M) override {
539 llvm::ThinLTOBitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
lib/Transforms/IPO/WholeProgramDevirt.cpp 443 Module &M;
471 DevirtModule(Module &M, function_ref<AAResults &(Function &)> AARGetter,
576 runForTesting(Module &M, function_ref<AAResults &(Function &)> AARGetter,
632 bool runOnModule(Module &M) override {
684 PreservedAnalyses WholeProgramDevirtPass::run(Module &M,
739 Module &M, function_ref<AAResults &(Function &)> AARGetter,
lib/Transforms/InstCombine/InstCombineCalls.cpp 805 Module *M = II.getModule();
906 Module *M = II.getModule();
1828 Module *M = CI.getModule();
1969 Module *Mod = II->getModule();
1989 Module *Mod = II->getModule();
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp 1035 Module *M = II->getParent()->getParent()->getParent();
lib/Transforms/InstCombine/InstructionCombining.cpp 2416 Module *M = II->getModule();
lib/Transforms/Instrumentation/AddressSanitizer.cpp 560 bool runOnModule(Module &M) override {
583 AddressSanitizer(Module &M, const GlobalsMetadata *GlobalsMD,
649 void initializeCallbacks(Module &M);
738 ModuleAddressSanitizer(Module &M, const GlobalsMetadata *GlobalsMD,
764 bool instrumentModule(Module &);
767 void initializeCallbacks(Module &M);
769 bool InstrumentGlobals(IRBuilder<> &IRB, Module &M, bool *CtorComdat);
770 void InstrumentGlobalsCOFF(IRBuilder<> &IRB, Module &M,
773 void InstrumentGlobalsELF(IRBuilder<> &IRB, Module &M,
777 void InstrumentGlobalsMachO(IRBuilder<> &IRB, Module &M,
781 InstrumentGlobalsWithMetadataArray(IRBuilder<> &IRB, Module &M,
785 GlobalVariable *CreateMetadataGlobal(Module &M, Constant *Initializer,
789 IRBuilder<> CreateAsanModuleDtor(Module &M);
795 void createInitializerPoisonCalls(Module &M, GlobalValue *ModuleName);
799 int GetAsanVersion(const Module &M) const;
845 bool runOnModule(Module &M) override {
1089 void initializeCallbacks(Module &M);
1125 GlobalsMetadata::GlobalsMetadata(Module &M) {
1157 GlobalsMetadata ASanGlobalsMetadataAnalysis::run(Module &M,
1171 Module &M = *F.getParent();
1193 PreservedAnalyses ModuleAddressSanitizerPass::run(Module &M,
1194 AnalysisManager<Module> &AM) {
1250 static GlobalVariable *createPrivateGlobalForSourceLoc(Module &M,
1777 Module &M, GlobalValue *ModuleName) {
1948 void ModuleAddressSanitizer::initializeCallbacks(Module &M) {
1982 Module &M = *G->getParent();
2018 ModuleAddressSanitizer::CreateMetadataGlobal(Module &M, Constant *Initializer,
2030 IRBuilder<> ModuleAddressSanitizer::CreateAsanModuleDtor(Module &M) {
2040 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2064 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2123 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2180 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2213 bool ModuleAddressSanitizer::InstrumentGlobals(IRBuilder<> &IRB, Module &M,
2416 int ModuleAddressSanitizer::GetAsanVersion(const Module &M) const {
2426 bool ModuleAddressSanitizer::instrumentModule(Module &M) {
2469 void AddressSanitizer::initializeCallbacks(Module &M) {
2759 void FunctionStackPoisoner::initializeCallbacks(Module &M) {
lib/Transforms/Instrumentation/CGProfile.cpp 26 PreservedAnalyses CGProfilePass::run(Module &M, ModuleAnalysisManager &MAM) {
80 Module &M,
97 M.addModuleFlag(Module::Append, "CG Profile", MDNode::get(Context, Nodes));
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 208 bool isIn(const Module &M, StringRef Category) const {
323 Module *Mod;
380 bool doInitialization(Module &M) override;
381 bool runOnModule(Module &M) override;
541 bool DataFlowSanitizer::doInitialization(Module &M) {
712 bool DataFlowSanitizer::runOnModule(Module &M) {
798 for (Module::alias_iterator i = M.alias_begin(), e = M.alias_end(); i != e;) {
lib/Transforms/Instrumentation/GCOVProfiling.cpp 90 runOnModule(Module &M,
131 Module *M;
151 bool runOnModule(Module &M) override {
562 Module &M, std::function<const TargetLibraryInfo &(Function &F)> GetTLI) {
577 PreservedAnalyses GCOVProfilerPass::run(Module &M,
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 189 explicit HWAddressSanitizer(Module &M, bool CompileKernel = false,
201 void initializeCallbacks(Module &M);
244 Module &M;
307 bool doInitialization(Module &M) override {
316 bool doFinalization(Module &M) override {
349 PreservedAnalyses HWAddressSanitizerPass::run(Module &M,
434 void HWAddressSanitizer::initializeCallbacks(Module &M) {
618 Module *M = IRB.GetInsertBlock()->getParent()->getParent();
837 Module *M = IRB.GetInsertBlock()->getParent()->getParent();
904 Module *M = IRB.GetInsertBlock()->getParent()->getParent();
973 Module *M = F->getParent();
1021 Module *M = IRB.GetInsertBlock()->getParent()->getParent();
lib/Transforms/Instrumentation/IndirectCallPromotion.cpp 135 bool runOnModule(Module &M) override;
172 Module *M;
206 ICallPromotionFunc(Function &Func, Module *Modu, InstrProfSymtab *Symtab,
382 static bool promoteIndirectCalls(Module &M, ProfileSummaryInfo *PSI,
425 bool PGOIndirectCallPromotionLegacyPass::runOnModule(Module &M) {
434 PreservedAnalyses PGOIndirectCallPromotion::run(Module &M,
lib/Transforms/Instrumentation/InstrOrderFile.cpp 67 void createOrderFileData(Module &M) {
99 void generateCodeSequence(Module &M, Function &F, int FuncId) {
159 bool run(Module &M) {
184 bool runOnModule(Module &M) override;
189 bool InstrOrderFileLegacyPass::runOnModule(Module &M) {
197 InstrOrderFilePass::run(Module &M, ModuleAnalysisManager &AM) {
lib/Transforms/Instrumentation/InstrProfiling.cpp 159 bool runOnModule(Module &M) override {
375 PreservedAnalyses InstrProfiling::run(Module &M, ModuleAnalysisManager &AM) {
476 static bool containsProfilingIntrinsics(Module &M) {
493 Module &M, std::function<const TargetLibraryInfo &(Function &F)> GetTLI) {
551 getOrInsertValueProfilingCall(Module &M, const TargetLibraryInfo &TLI,
678 Module *M = F->getParent();
lib/Transforms/Instrumentation/Instrumentation.cpp 60 GlobalVariable *llvm::createPrivateGlobalForString(Module &M, StringRef Str,
80 Module *M = F.getParent();
lib/Transforms/Instrumentation/MemorySanitizer.cpp 465 MemorySanitizer(Module &M, MemorySanitizerOptions Options)
486 void initializeModule(Module &M);
487 void initializeCallbacks(Module &M);
488 void createKernelApi(Module &M);
489 void createUserspaceApi(Module &M);
592 void insertModuleCtor(Module &M) {
629 bool doInitialization(Module &M) override;
654 PreservedAnalyses MemorySanitizerPass::run(Module &M,
682 static GlobalVariable *createPrivateNonConstGlobalForString(Module &M,
690 void MemorySanitizer::createKernelApi(Module &M) {
748 static Constant *getOrInsertGlobal(Module &M, StringRef Name, Type *Ty) {
757 void MemorySanitizer::createUserspaceApi(Module &M) {
816 void MemorySanitizer::initializeCallbacks(Module &M) {
873 void MemorySanitizer::initializeModule(Module &M) {
963 bool MemorySanitizerLegacyPass::doInitialization(Module &M) {
lib/Transforms/Instrumentation/PGOInstrumentation.cpp 374 bool runOnModule(Module &M) override;
401 bool runOnModule(Module &M) override;
422 bool runOnModule(Module &M) override {
683 Module *M = F.getParent();
804 Function &F, Module *M, BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFI,
955 PGOUseFunc(Function &Func, Module *Modu,
1012 Module *M;
1348 Module *M = F.getParent();
1446 Module &M,
1462 Module &M, function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
1482 PGOInstrumentationGenCreateVar::run(Module &M, ModuleAnalysisManager &AM) {
1488 bool PGOInstrumentationGenLegacyPass::runOnModule(Module &M) {
1501 PreservedAnalyses PGOInstrumentationGen::run(Module &M,
1519 Module &M, StringRef ProfileFileName, StringRef ProfileRemappingFileName,
1649 PreservedAnalyses PGOInstrumentationUse::run(Module &M,
1670 bool PGOInstrumentationUseLegacyPass::runOnModule(Module &M) {
1696 void llvm::setProfMetadata(Module *M, Instruction *TI,
1744 void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count) {
lib/Transforms/Instrumentation/PoisonChecking.cpp 243 Module *M = B.GetInsertBlock()->getModule();
316 PreservedAnalyses PoisonCheckingPass::run(Module &M,
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 189 bool instrumentModule(Module &M, DomTreeCallback DTCallback,
213 Function *CreateInitCallsForSections(Module &M, const char *CtorName,
216 std::pair<Value *, Value *> CreateSecStartEnd(Module &M, const char *Section,
238 Module *CurModule;
261 bool runOnModule(Module &M) override {
287 PreservedAnalyses ModuleSanitizerCoveragePass::run(Module &M,
303 ModuleSanitizerCoverage::CreateSecStartEnd(Module &M, const char *Section,
327 Module &M, const char *CtorName, const char *InitFunctionName, Type *Ty,
359 Module &M, DomTreeCallback DTCallback, PostDomTreeCallback PDTCallback) {
890 Module *M = F.getParent();
lib/Transforms/Instrumentation/ThreadSanitizer.cpp 98 void initialize(Module &M);
137 bool doInitialization(Module &M) override;
143 void insertModuleCtor(Module &M) {
162 PreservedAnalyses ThreadSanitizerPass::run(Module &M,
183 bool ThreadSanitizerLegacyPass::doInitialization(Module &M) {
199 void ThreadSanitizer::initialize(Module &M) {
307 static bool shouldInstrumentReadWriteFromAddress(const Module *M, Value *Addr) {
lib/Transforms/ObjCARC/ARCRuntimeEntryPoints.h 59 void init(Module *M) {
105 Module *TheModule = nullptr;
lib/Transforms/ObjCARC/ObjCARCAPElim.cpp 41 bool runOnModule(Module &M) override;
128 bool ObjCARCAPElim::runOnModule(Module &M) {
lib/Transforms/ObjCARC/ObjCARCContract.cpp 101 bool doInitialization(Module &M) override;
769 bool ObjCARCContract::doInitialization(Module &M) {
lib/Transforms/ObjCARC/ObjCARCExpand.cpp 52 bool doInitialization(Module &M) override;
78 bool ObjCARCExpand::doInitialization(Module &M) {
lib/Transforms/ObjCARC/ObjCARCOpts.cpp 531 SmallVectorImpl<Instruction *> &DeadInsts, Module *M);
536 DenseMap<Value *, RRInfo> &Releases, Module *M,
545 DenseMap<Value *, RRInfo> &Releases, Module *M);
558 bool doInitialization(Module &M) override;
1570 Module *M) {
1624 DenseMap<Value *, RRInfo> &Releases, Module *M,
1823 DenseMap<Value *, RRInfo> &Releases, Module *M) {
2231 bool ObjCARCOpt::doInitialization(Module &M) {
lib/Transforms/Scalar/InferAddressSpaces.cpp 266 Module *M = II->getParent()->getParent()->getParent();
lib/Transforms/Scalar/LoopDataPrefetch.cpp 313 Module *M = BB->getParent()->getParent();
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 1014 Module *M = TheStore->getModule();
1639 Module *M = IRBuilder.GetInsertBlock()->getParent()->getParent();
1653 Module *M = IRBuilder.GetInsertBlock()->getParent()->getParent();
lib/Transforms/Scalar/LoopPredication.cpp 962 Module *M = L->getHeader()->getModule();
lib/Transforms/Scalar/NaryReassociate.cpp 126 bool doInitialization(Module &M) override {
lib/Transforms/Scalar/PlaceSafepoints.cpp 624 Module *M = InsertBefore->getModule();
lib/Transforms/Scalar/Reassociate.cpp 76 Module *M = I->getModule();
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 123 static void stripNonValidData(Module &M);
127 PreservedAnalyses RewriteStatepointsForGC::run(Module &M,
173 bool runOnModule(Module &M) override {
1283 Module *M = StatepointToken->getModule();
1896 Module *M = Call->getModule();
2504 static void stripNonValidData(Module &M) {
lib/Transforms/Scalar/SCCP.cpp 2005 Module &M, const DataLayout &DL,
lib/Transforms/Scalar/Scalarizer.cpp 303 Module &M = *F.getParent();
486 static Function *getScalarIntrinsicDeclaration(Module *M,
856 Module &M = *F.getParent();
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 362 bool doInitialization(Module &M) override {
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp 160 bool doInitialization(Module &M) override {
lib/Transforms/Utils/BuildLibCalls.cpp 139 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
835 Module *M = B.GetInsertBlock()->getModule();
911 Module *M = B.GetInsertBlock()->getModule();
1047 Module *M = B.GetInsertBlock()->getModule();
1089 Module *M = B.GetInsertBlock()->getModule();
1134 Module *M = B.GetInsertBlock()->getModule();
1157 Module *M = B.GetInsertBlock()->getModule();
1174 Module *M = B.GetInsertBlock()->getModule();
1195 Module *M = B.GetInsertBlock()->getModule();
1215 Module *M = B.GetInsertBlock()->getModule();
1234 Module *M = B.GetInsertBlock()->getModule();
1253 Module *M = B.GetInsertBlock()->getModule();
1277 Module *M = B.GetInsertBlock()->getModule();
1297 Module *M = B.GetInsertBlock()->getModule();
1319 Module *M = B.GetInsertBlock()->getModule();
1341 Module *M = B.GetInsertBlock()->getModule();
1360 Module *M = B.GetInsertBlock()->getModule();
1381 Module *M = B.GetInsertBlock()->getModule();
lib/Transforms/Utils/CanonicalizeAliases.cpp 63 static bool canonicalizeAliases(Module &M) {
82 bool runOnModule(Module &M) override { return canonicalizeAliases(M); }
88 PreservedAnalyses CanonicalizeAliasesPass::run(Module &M,
lib/Transforms/Utils/CloneFunction.cpp 50 Module *TheModule = F ? F->getParent() : nullptr;
216 auto* NewModule = NewFunc->getParent();
lib/Transforms/Utils/CloneModule.cpp 34 std::unique_ptr<Module> llvm::CloneModule(const Module &M) {
34 std::unique_ptr<Module> llvm::CloneModule(const Module &M) {
41 std::unique_ptr<Module> llvm::CloneModule(const Module &M,
41 std::unique_ptr<Module> llvm::CloneModule(const Module &M,
46 std::unique_ptr<Module> llvm::CloneModule(
47 const Module &M, ValueToValueMapTy &VMap,
50 std::unique_ptr<Module> New =
51 std::make_unique<Module>(M.getModuleIdentifier(), M.getContext());
61 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
84 for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end();
118 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
173 for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end();
185 for (Module::const_named_metadata_iterator I = M.named_metadata_begin(),
lib/Transforms/Utils/CodeExtractor.cpp 772 Module *M) {
1008 Module *M, ArrayRef<Value *> LifetimesStart, ArrayRef<Value *> LifetimesEnd,
1068 Module *M = newFunction->getParent();
lib/Transforms/Utils/CtorUtils.cpp 80 static GlobalVariable *findGlobalCtors(Module &M) {
117 Module &M, function_ref<bool(Function *)> ShouldRemove) {
lib/Transforms/Utils/EntryExitInstrumenter.cpp 22 Module &M = *InsertionPt->getParent()->getParent()->getParent();
lib/Transforms/Utils/EscapeEnumerator.cpp 21 static FunctionCallee getDefaultPersonalityFn(Module *M) {
lib/Transforms/Utils/FunctionImportUtils.cpp 315 bool llvm::renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index,
lib/Transforms/Utils/ImportedFunctionsInliningStatistics.cpp 61 void ImportedFunctionsInliningStatistics::setModuleInfo(const Module &M) {
lib/Transforms/Utils/InlineFunction.cpp 1246 static void HandleByValArgumentInit(Value *Dst, Value *Src, Module *M,
2010 Module *M = Caller->getParent();
lib/Transforms/Utils/Local.cpp 1644 auto &M = *I.getModule();
1837 Module &M = *From.getModule();
lib/Transforms/Utils/MetaRenamer.cpp 84 bool runOnModule(Module &M) override {
lib/Transforms/Utils/ModuleUtils.cpp 22 static void appendToGlobalArray(const char *Array, Module &M, Function *F,
63 void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data) {
67 void llvm::appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data) {
71 static void appendToUsedList(Module &M, StringRef Name, ArrayRef<GlobalValue *> Values) {
101 void llvm::appendToUsed(Module &M, ArrayRef<GlobalValue *> Values) {
105 void llvm::appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values) {
110 llvm::declareSanitizerInitFunction(Module &M, StringRef InitName,
120 Module &M, StringRef CtorName, StringRef InitName,
145 Module &M, StringRef CtorName, StringRef InitName,
166 Function *llvm::getOrCreateInitFunction(Module &M, StringRef Name) {
189 Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions) {
252 std::string llvm::getUniqueModuleId(Module *M) {
lib/Transforms/Utils/NameAnonGlobals.cpp 27 Module &TheModule;
31 ModuleHasher(Module &M) : TheModule(M) {}
65 bool llvm::nameUnamedGlobals(Module &M) {
97 bool runOnModule(Module &M) override { return nameUnamedGlobals(M); }
103 PreservedAnalyses NameAnonGlobalPass::run(Module &M,
lib/Transforms/Utils/PredicateInfo.cpp 522 static Function *getCopyDeclaration(Module *M, Type *Ty) {
lib/Transforms/Utils/SanitizerStats.cpp 24 SanitizerStatReport::SanitizerStatReport(Module *M) : M(M) {
44 Module *M = F->getParent();
lib/Transforms/Utils/SimplifyCFG.cpp 4922 Module &M, uint64_t TableSize, ConstantInt *Offset,
4976 Module &M, uint64_t TableSize, ConstantInt *Offset,
5391 Module &Mod = *CommonDest->getParent()->getParent();
lib/Transforms/Utils/SimplifyLibCalls.cpp 744 Module &M = *CI->getModule();
1221 Module *M = CI->getModule();
1297 Module *M = CI->getModule();
1432 Module *Mod = Pow->getModule();
1570 Module *M, IRBuilder<> &B,
1594 Module *Mod = Pow->getModule();
1628 static Value *createPowWithIntegerExponent(Value *Base, Value *Expo, Module *M,
1641 Module *M = Pow->getModule();
1816 Module *Mod = Log->getModule();
2016 Module *M = Callee->getParent();
2091 Module *M = OrigCallee->getParent();
2389 Module *M = B.GetInsertBlock()->getParent()->getParent();
2401 Module *M = B.GetInsertBlock()->getParent()->getParent();
2484 Module *M = B.GetInsertBlock()->getParent()->getParent();
2496 Module *M = B.GetInsertBlock()->getParent()->getParent();
2657 Module *M = B.GetInsertBlock()->getParent()->getParent();
2669 Module *M = B.GetInsertBlock()->getParent()->getParent();
lib/Transforms/Utils/SplitModule.cpp 98 static void findPartitions(Module *M, ClusterIDMapType &ClusterIDMap,
250 std::unique_ptr<Module> M, unsigned N,
251 function_ref<void(std::unique_ptr<Module> MPart)> ModuleCallback,
273 std::unique_ptr<Module> MPart(
lib/Transforms/Utils/SymbolRewriter.cpp 95 static void rewriteComdat(Module &M, GlobalObject *GO,
122 bool performOnModule(Module &M) override;
133 bool ExplicitRewriteDescriptor<DT, ValueType, Get>::performOnModule(Module &M) {
133 bool ExplicitRewriteDescriptor<DT, ValueType, Get>::performOnModule(Module &M) {
135 if (ValueType *S = (M.*Get)(Source)) {
139 if (Value *T = (M.*Get)(Target))
163 bool performOnModule(Module &M) override;
176 bool PatternRewriteDescriptor<DT, ValueType, Get, Iterator>::
176 bool PatternRewriteDescriptor<DT, ValueType, Get, Iterator>::
177 performOnModule(Module &M) {
179 for (auto &C : (M.*Iterator)()) {
193 if (Value *V = (M.*Get)(Name))
210 &Module::getFunction>;
217 GlobalVariable, &Module::getGlobalVariable>;
223 &Module::getNamedAlias>;
230 &Module::getFunction, &Module::functions>;
230 &Module::getFunction, &Module::functions>;
238 GlobalVariable, &Module::getGlobalVariable,
239 &Module::globals>;
246 &Module::getNamedAlias, &Module::aliases>;
246 &Module::getNamedAlias, &Module::aliases>;
527 bool runOnModule(Module &M) override;
545 bool RewriteSymbolsLegacyPass::runOnModule(Module &M) {
549 PreservedAnalyses RewriteSymbolPass::run(Module &M, ModuleAnalysisManager &AM) {
556 bool RewriteSymbolPass::runImpl(Module &M) {
lib/Transforms/Vectorize/LoopVectorize.cpp 4263 Module *M = I.getParent()->getParent()->getParent();
lib/Transforms/Vectorize/SLPVectorizer.cpp 4135 Module *M = F->getParent();
5200 bool doInitialization(Module &M) override {
tools/bugpoint-passes/TestPasses.cpp 86 bool runOnModule(Module &M) override {
110 bool runOnModule(Module &M) override {
tools/bugpoint/BugDriver.cpp 60 void BugDriver::setNewProgram(std::unique_ptr<Module> M) {
92 std::unique_ptr<Module> llvm::parseInputFile(StringRef Filename,
95 std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
121 std::unique_ptr<Module> BugDriver::swapProgramIn(std::unique_ptr<Module> M) {
121 std::unique_ptr<Module> BugDriver::swapProgramIn(std::unique_ptr<Module> M) {
122 std::unique_ptr<Module> OldProgram = std::move(Program);
144 std::unique_ptr<Module> M = parseInputFile(Filenames[i], Context);
tools/bugpoint/BugDriver.h 52 std::unique_ptr<Module> Program; // The raw program, linked together
130 Module &getProgram() const { return *Program; }
133 std::unique_ptr<Module> swapProgramIn(std::unique_ptr<Module> M);
133 std::unique_ptr<Module> swapProgramIn(std::unique_ptr<Module> M);
146 void setNewProgram(std::unique_ptr<Module> M);
150 Error compileProgram(Module &M) const;
154 Expected<std::string> executeProgram(const Module &Program,
164 executeProgramSafely(const Module &Program,
170 Error createReferenceFile(Module &M, const std::string &Filename =
177 Expected<bool> diffProgram(const Module &Program,
183 void EmitProgressBitcode(const Module &M, const std::string &ID,
191 std::unique_ptr<Module> deleteInstructionFromProgram(const Instruction *I,
199 std::unique_ptr<Module> performFinalCleanups(std::unique_ptr<Module> M,
199 std::unique_ptr<Module> performFinalCleanups(std::unique_ptr<Module> M,
205 std::unique_ptr<Module> extractLoop(Module *M);
205 std::unique_ptr<Module> extractLoop(Module *M);
212 std::unique_ptr<Module>
214 Module *M);
218 std::unique_ptr<Module> runPassesOn(Module *M,
218 std::unique_ptr<Module> runPassesOn(Module *M,
231 bool runPasses(Module &Program, const std::vector<std::string> &PassesToRun,
240 bool runPasses(Module &M, const std::vector<std::string> &PassesToRun) const {
255 bool writeProgramToFile(const std::string &Filename, const Module &M) const;
257 const Module &M) const;
258 bool writeProgramToFile(int FD, const Module &M) const;
275 std::unique_ptr<Module> parseInputFile(StringRef InputFilename,
303 std::unique_ptr<Module>
304 SplitFunctionsOutOfModule(Module *M, const std::vector<Function *> &F,
tools/bugpoint/CrashDebugger.cpp 87 std::unique_ptr<Module> OrigProgram;
117 using BugTester = bool (*)(const BugDriver &, Module *);
148 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
211 static void RemoveFunctionReferences(Module *M, const char *Name) {
242 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
347 std::unique_ptr<Module> M = CloneModule(BD.getProgram());
445 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
505 std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
564 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
612 std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
668 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
704 std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
760 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
775 for (Module::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI)
835 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
914 std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);
950 Module &OrigM = BD.getProgram();
956 std::unique_ptr<Module> M = CloneModule(OrigM);
1044 for (Module::const_iterator FI = BD.getProgram().begin(),
1064 std::unique_ptr<Module> M =
1208 std::unique_ptr<Module> M = CloneModule(BD.getProgram());
1254 std::unique_ptr<Module> M = CloneModule(BD.getProgram());
1268 static bool TestForOptimizerCrash(const BugDriver &BD, Module *M) {
1295 static bool TestForCodeGenCrash(const BugDriver &BD, Module *M) {
tools/bugpoint/ExtractFunction.cpp 83 std::unique_ptr<Module>
87 std::unique_ptr<Module> Clone = CloneModule(*Program);
92 Module::iterator RFI = Clone->begin(); // Get iterator to corresponding fn
120 std::unique_ptr<Module> New = runPassesOn(Clone.get(), Passes);
128 std::unique_ptr<Module>
129 BugDriver::performFinalCleanups(std::unique_ptr<Module> M,
132 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
143 std::unique_ptr<Module> New = runPassesOn(M.get(), CleanupPasses);
151 std::unique_ptr<Module> BugDriver::extractLoop(Module *M) {
151 std::unique_ptr<Module> BugDriver::extractLoop(Module *M) {
155 std::unique_ptr<Module> NewM = runPassesOn(M, LoopExtractPasses);
171 Module::iterator MI = NewM->begin();
185 Module *M = GV->getParent();
186 for (Module::alias_iterator I = M->alias_begin(), E = M->alias_end();
247 static void SplitStaticCtorDtor(const char *GlobalName, Module *M1, Module *M2,
247 static void SplitStaticCtorDtor(const char *GlobalName, Module *M1, Module *M2,
305 std::unique_ptr<Module>
306 llvm::SplitFunctionsOutOfModule(Module *M, const std::vector<Function *> &F,
310 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
312 for (Module::global_iterator I = M->global_begin(), E = M->global_end();
320 std::unique_ptr<Module> New = CloneModule(*M, NewVMap);
371 std::unique_ptr<Module>
373 Module *M) {
413 std::unique_ptr<Module> Ret = runPassesOn(M, PI, {uniqueFN});
tools/bugpoint/Miscompilation.cpp 137 std::unique_ptr<Module> PrefixOutput =
154 std::unique_ptr<Module> OriginalInput =
188 Expected<bool> (*TestFn)(BugDriver &, std::unique_ptr<Module>,
189 std::unique_ptr<Module>);
194 std::unique_ptr<Module>,
195 std::unique_ptr<Module>))
227 static Expected<std::unique_ptr<Module>> testMergedProgram(const BugDriver &BD,
228 const Module &M1,
229 const Module &M2,
267 std::unique_ptr<Module> Clone = CloneModule(BD.getProgram(), VMap);
268 std::unique_ptr<Module> Orig = BD.swapProgramIn(std::move(Clone));
278 std::unique_ptr<Module> ToNotOptimize = CloneModule(BD.getProgram(), VMap);
279 std::unique_ptr<Module> ToOptimize =
291 static void DisambiguateGlobalSymbols(Module &M) {
292 for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E;
296 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
307 Expected<bool> (*TestFn)(BugDriver &, std::unique_ptr<Module>,
308 std::unique_ptr<Module>),
316 std::unique_ptr<Module> ToNotOptimize = CloneModule(BD.getProgram(), VMap);
317 std::unique_ptr<Module> ToOptimize = SplitFunctionsOutOfModule(
319 std::unique_ptr<Module> ToOptimizeLoopExtracted =
335 Expected<std::unique_ptr<Module>> New = testMergedProgram(
343 std::unique_ptr<Module> Old = BD.swapProgramIn(std::move(*New));
370 std::unique_ptr<Module> TOLEBackup =
372 std::unique_ptr<Module> TNOBackup = CloneModule(*ToNotOptimize, VMap);
414 for (Module::iterator I = ToOptimizeLoopExtracted->begin(),
446 Expected<bool> (*TestFn)(BugDriver &, std::unique_ptr<Module>,
447 std::unique_ptr<Module>);
453 std::unique_ptr<Module>,
454 std::unique_ptr<Module>),
502 std::unique_ptr<Module> Clone = CloneModule(BD.getProgram(), VMap);
503 std::unique_ptr<Module> Orig = BD.swapProgramIn(std::move(Clone));
516 std::unique_ptr<Module> ToNotOptimize = CloneModule(BD.getProgram(), VMap);
517 std::unique_ptr<Module> ToOptimize =
522 if (std::unique_ptr<Module> New =
537 Expected<bool> (*TestFn)(BugDriver &, std::unique_ptr<Module>,
538 std::unique_ptr<Module>),
571 std::unique_ptr<Module> ProgClone = CloneModule(BD.getProgram(), VMap);
572 std::unique_ptr<Module> ToExtract =
574 std::unique_ptr<Module> Extracted =
586 for (Module::iterator I = Extracted->begin(), E = Extracted->end(); I != E;
614 Expected<bool> (*TestFn)(BugDriver &, std::unique_ptr<Module>,
615 std::unique_ptr<Module>)) {
621 Module &Prog = BD.getProgram();
698 static Expected<bool> TestOptimizer(BugDriver &BD, std::unique_ptr<Module> Test,
699 std::unique_ptr<Module> Safe) {
703 std::unique_ptr<Module> Optimized =
760 Module *ToNotOptimize = CloneModule(getProgram(), VMap).release();
761 Module *ToOptimize =
778 static std::unique_ptr<Module>
779 CleanupAndPrepareModules(BugDriver &BD, std::unique_ptr<Module> Test,
780 Module *Safe) {
834 for (Module::iterator F = Safe->begin(), E = Safe->end(); F != E; ++F) {
943 std::unique_ptr<Module> Test,
944 std::unique_ptr<Module> Safe) {
1031 std::unique_ptr<Module> ToNotCodeGen = CloneModule(getProgram(), VMap);
1032 std::unique_ptr<Module> ToCodeGen =
tools/bugpoint/OptimizerDriver.cpp 53 static bool writeProgramToFileAux(ToolOutputFile &Out, const Module &M) {
64 const Module &M) const {
69 bool BugDriver::writeProgramToFile(int FD, const Module &M) const {
80 const Module &M) const {
90 void BugDriver::EmitProgressBitcode(const Module &M, const std::string &ID,
130 bool BugDriver::runPasses(Module &Program,
267 std::unique_ptr<Module>
268 BugDriver::runPassesOn(Module *M, const std::vector<std::string> &Passes,
276 std::unique_ptr<Module> Ret = parseInputFile(BitcodeResult, Context);
tools/clang/examples/clang-interpreter/main.cpp 212 std::unique_ptr<llvm::Module> Module = Act->takeModule();
tools/clang/include/clang/CodeGen/BackendUtil.h 42 const llvm::DataLayout &TDesc, llvm::Module *M,
46 void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
tools/clang/include/clang/CodeGen/CodeGenAction.h 31 std::unique_ptr<llvm::Module> Module;
46 std::unique_ptr<llvm::Module> TheModule;
53 std::unique_ptr<llvm::Module> loadModule(llvm::MemoryBufferRef MBRef);
75 std::unique_ptr<llvm::Module> takeModule();
tools/clang/include/clang/CodeGen/ModuleBuilder.h 60 llvm::Module *GetModule();
66 llvm::Module *ReleaseModule();
89 llvm::Module* StartModule(llvm::StringRef ModuleName, llvm::LLVMContext &C);
tools/clang/lib/CodeGen/BackendUtil.cpp 89 Module *TheModule;
136 const LangOptions &LOpts, Module *M)
850 TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
864 TheModule->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
865 TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
1273 TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
1287 TheModule->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
1288 TheModule->addModuleFlag(Module::Error, "EnableSplitLTOUnit",
1362 static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M,
1497 const llvm::DataLayout &TDesc, Module *M,
1503 std::unique_ptr<llvm::Module> EmptyModule;
1534 EmptyModule = std::make_unique<llvm::Module>("empty", M->getContext());
1594 void clang::EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
tools/clang/lib/CodeGen/CGCUDANV.cpp 43 llvm::Module &TheModule;
tools/clang/lib/CodeGen/CGExpr.cpp 3164 llvm::Module *M = &CGM.getModule();
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp 23 static llvm::Function *GetVprintfDeclaration(llvm::Module &M) {
tools/clang/lib/CodeGen/CGObjC.cpp 2185 CGF.CGM.getModule().addModuleFlag(llvm::Module::Error, markerKey, str);
tools/clang/lib/CodeGen/CGObjCGNU.cpp 108 llvm::Module &TheModule;
tools/clang/lib/CodeGen/CGObjCMac.cpp 4976 llvm::Module &Mod = CGM.getModule();
4979 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4980 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4982 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4987 Mod.addModuleFlag(llvm::Module::Override,
4991 Mod.addModuleFlag(llvm::Module::Error,
4997 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
5005 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
5012 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
5016 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 4020 llvm::Module &M = CGM.getModule();
4061 llvm::Module &M = CGM.getModule();
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 1842 llvm::Module &M = CGM.getModule();
3172 llvm::Module &M = CGM.getModule();
tools/clang/lib/CodeGen/CodeGenAction.cpp 112 llvm::Module *CurLinkModule = nullptr;
136 llvm::Module *getModule() const { return Gen->GetModule(); }
137 std::unique_ptr<llvm::Module> takeModule() {
861 std::unique_ptr<llvm::Module> CodeGenAction::takeModule() {
912 Expected<std::unique_ptr<llvm::Module>> ModuleOrErr =
978 std::unique_ptr<llvm::Module>
1007 auto M = std::make_unique<llvm::Module>("empty", *VMContext);
1011 Expected<std::unique_ptr<llvm::Module>> MOrErr =
1019 if (std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext))
tools/clang/lib/CodeGen/CodeGenModule.cpp 93 const CodeGenOptions &CGO, llvm::Module &M,
468 getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
474 getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
479 getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
482 getModule().addModuleFlag(llvm::Module::Warning, "CodeViewGHash", 1);
486 getModule().addModuleFlag(llvm::Module::Warning, "cfguard", 2);
489 getModule().addModuleFlag(llvm::Module::Warning, "cfguard", 1);
496 getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1);
503 getModule().addModuleFlag(llvm::Module::Require,
511 getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
519 getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
528 getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
533 getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
537 getModule().addModuleFlag(llvm::Module::Override,
545 getModule().addModuleFlag(llvm::Module::Override, "cf-protection-return",
552 getModule().addModuleFlag(llvm::Module::Override, "cf-protection-branch",
560 getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
4891 llvm::Module &M = CGM.getModule();
tools/clang/lib/CodeGen/CodeGenModule.h 301 llvm::Module &TheModule;
553 const CodeGenOptions &CodeGenOpts, llvm::Module &M,
674 llvm::Module &getModule() const { return TheModule; }
tools/clang/lib/CodeGen/CodeGenTBAA.cpp 32 CodeGenTBAA::CodeGenTBAA(ASTContext &Ctx, llvm::Module &M,
tools/clang/lib/CodeGen/CodeGenTBAA.h 119 llvm::Module &Module;
171 CodeGenTBAA(ASTContext &Ctx, llvm::Module &M, const CodeGenOptions &CGO,
tools/clang/lib/CodeGen/CodeGenTypes.h 63 llvm::Module &TheModule;
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 3497 llvm::Module &M = CGM.getModule();
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 3521 llvm::Module &Module;
tools/clang/lib/CodeGen/ModuleBuilder.cpp 62 std::unique_ptr<llvm::Module> M;
84 M(new llvm::Module(ExpandModuleName(ModuleName, CGO), C)) {
98 llvm::Module *GetModule() {
106 llvm::Module *ReleaseModule() {
129 llvm::Module *StartModule(llvm::StringRef ModuleName,
132 M.reset(new llvm::Module(ExpandModuleName(ModuleName, CodeGenOpts), C));
308 llvm::Module *CodeGenerator::GetModule() {
312 llvm::Module *CodeGenerator::ReleaseModule() {
330 llvm::Module *CodeGenerator::StartModule(llvm::StringRef ModuleName,
tools/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp 54 std::unique_ptr<llvm::Module> M;
168 M.reset(new llvm::Module(MainFileName, *VMContext));
241 std::unique_ptr<llvm::Module> M = std::move(this->M);
tools/clang/lib/CodeGen/TargetInfo.cpp 6516 llvm::Module *M = F->getParent();
tools/clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp 98 std::unique_ptr<Module> M = parseIR(MemoryBufferRef(IR, "IR"), Err, Context);
147 std::unique_ptr<Module> M = parseIR(MemoryBufferRef(IR, "IR"), Err, Context);
tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp 66 Module M;
294 const Module &wrapBinaries(ArrayRef<ArrayRef<char>> Binaries) {
tools/clang/unittests/CodeGen/IncrementalProcessingTest.cpp 48 static std::unique_ptr<llvm::Module>
95 std::unique_ptr<llvm::Module> M(CG.ReleaseModule());
102 const Function* getGlobalInit(llvm::Module& M) {
148 std::array<std::unique_ptr<llvm::Module>, 3> M;
tools/clang/unittests/CodeGen/TBAAMetadataTest.cpp 31 llvm::Module *M = nullptr;
tools/llc/llc.cpp 394 std::unique_ptr<Module> M;
596 std::unique_ptr<Module> M2(llvm::CloneModule(*M));
tools/lldb/include/lldb/Expression/IRExecutionUnit.h 62 std::unique_ptr<llvm::Module> &module_up, ConstString &name,
71 llvm::Module *GetModule() { return m_module; }
374 std::unique_ptr<llvm::Module>
376 llvm::Module *m_module; ///< Owned by the execution engine
tools/lldb/include/lldb/Expression/IRInterpreter.h 38 static bool CanInterpret(llvm::Module &module, llvm::Function &function,
42 static bool Interpret(llvm::Module &module, llvm::Function &function,
tools/lldb/source/Expression/IRExecutionUnit.cpp 40 std::unique_ptr<llvm::Module> &module_up,
299 void notifyObjectCompiled(const llvm::Module *module,
311 getObject(const llvm::Module *module) override {
tools/lldb/source/Expression/IRInterpreter.cpp 165 Module &module) {
200 Module &module) {
409 lldb::addr_t ResolveValue(const Value *value, Module &module) {
486 bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
494 for (Module::iterator fi = module.begin(), fe = module.end(); fi != fe;
638 bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
tools/lldb/source/Expression/LLVMUserExpression.cpp 89 llvm::Module *module = m_execution_unit_sp->GetModule();
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp 1153 llvm::Module *module, const char *orig_name) {
1175 std::unique_ptr<llvm::Module> llvm_module_up(
1318 llvm::Module *module = execution_unit_sp->GetModule();
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp 139 Instrumenter(llvm::Module &module,
301 llvm::Module &m_module; ///< The module which is being instrumented
312 ValidPointerChecker(llvm::Module &module,
370 ObjcObjectChecker(llvm::Module &module,
542 bool IRDynamicChecks::runOnModule(llvm::Module &M) {
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.h 98 bool runOnModule(llvm::Module &M) override;
122 bool FindDataLoads(llvm::Module &M, llvm::BasicBlock &BB);
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp 117 Module *module) {
1843 bool IRForTarget::runOnModule(Module &llvm_module) {
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h 114 bool runOnModule(llvm::Module &llvm_module) override;
197 llvm::Module *module);
444 llvm::Module *m_module; ///< The module being processed, or NULL if that has
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp 80 bool RenderScriptRuntimeModulePass::runOnModule(llvm::Module &module) {
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h 37 bool runOnModule(llvm::Module &module) override;
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp 28 bool isRSAPICall(llvm::Module &module, llvm::CallInst *call_inst) {
42 bool isRSLargeReturnCall(llvm::Module &module, llvm::CallInst *call_inst) {
71 bool isRSAllocationTyCallSite(llvm::Module &module, llvm::CallInst *call_inst) {
126 bool findRSCallSites(llvm::Module &module,
128 bool (*predicate)(llvm::Module &, llvm::CallInst *)) {
147 bool fixupX86StructRetCalls(llvm::Module &module) {
210 bool fixupRSAllocationStructByValCalls(llvm::Module &module) {
268 bool fixupX86FunctionCalls(llvm::Module &module) {
272 bool fixupX86_64FunctionCalls(llvm::Module &module) {
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.h 17 bool fixupX86FunctionCalls(llvm::Module &module);
19 bool fixupX86_64FunctionCalls(llvm::Module &module);
tools/lli/lli.cpp 244 void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) override {
259 std::unique_ptr<MemoryBuffer> getObject(const Module* M) override {
311 std::unique_ptr<Module> M = std::make_unique<Module>("CygMingHelper", Context);
311 std::unique_ptr<Module> M = std::make_unique<Module>("CygMingHelper", Context);
387 std::unique_ptr<Module> Owner = parseIRFile(InputFile, Err, Context);
388 Module *Mod = Owner.get();
470 std::unique_ptr<Module> XMod = parseIRFile(ExtraModules[i], Err, Context);
698 static std::function<void(Module &)> createDebugDumper() {
tools/llvm-as/llvm-as.cpp 71 static void WriteOutputFile(const Module *M, const ModuleSummaryIndex *Index) {
124 std::unique_ptr<Module> M = std::move(ModuleAndIndex.Mod);
tools/llvm-cat/llvm-cat.cpp 73 std::vector<std::unique_ptr<Module>> OwnedMods;
76 std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
tools/llvm-diff/DifferenceEngine.cpp 684 void DifferenceEngine::diff(Module *L, Module *R) {
684 void DifferenceEngine::diff(Module *L, Module *R) {
691 for (Module::iterator I = L->begin(), E = L->end(); I != E; ++I) {
707 for (Module::iterator I = R->begin(), E = R->end(); I != E; ++I) {
tools/llvm-diff/DifferenceEngine.h 62 void diff(Module *L, Module *R);
62 void diff(Module *L, Module *R);
tools/llvm-diff/llvm-diff.cpp 32 static std::unique_ptr<Module> readModule(LLVMContext &Context,
35 std::unique_ptr<Module> M = parseIRFile(Name, Diag, Context);
41 static void diffGlobal(DifferenceEngine &Engine, Module &L, Module &R,
41 static void diffGlobal(DifferenceEngine &Engine, Module &L, Module &R,
73 std::unique_ptr<Module> LModule = readModule(Context, LeftFilename);
74 std::unique_ptr<Module> RModule = readModule(Context, RightFilename);
tools/llvm-dis/llvm-dis.cpp 161 std::unique_ptr<Module> M = ExitOnErr(getLazyBitcodeModule(
tools/llvm-exegesis/lib/Assembler.cpp 74 Module *Module,
150 static std::unique_ptr<Module>
152 auto Mod = std::make_unique<Module>(ModuleID, *Context);
159 std::unique_ptr<Module> Module = createModule(Context, TM.createDataLayout());
176 std::unique_ptr<Module> Module =
tools/llvm-exegesis/lib/Assembler.h 125 Module *Module,
tools/llvm-extract/llvm-extract.cpp 143 std::unique_ptr<Module> M = getLazyIRFileModule(InputFilename, Err, Context);
173 for (Module::alias_iterator GA = M->alias_begin(), E = M->alias_end();
240 for (Module::iterator F = M->begin(), E = M->end(); F != E;
tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp 68 std::unique_ptr<Module> M;
71 M.reset(new Module("M", Context));
tools/llvm-link/llvm-link.cpp 116 static std::unique_ptr<Module> loadFile(const char *argv0,
123 std::unique_ptr<Module> Result;
148 StringMap<std::unique_ptr<Module>> ModuleMap;
151 std::function<std::unique_ptr<Module>(const char *argv0,
157 ModuleLazyLoaderCache(std::function<std::unique_ptr<Module>(
163 Module &operator()(const char *argv0, const std::string &FileName);
165 std::unique_ptr<Module> takeModule(const std::string &FileName) {
168 std::unique_ptr<Module> Ret = std::move(I->second);
175 Module &ModuleLazyLoaderCache::operator()(const char *argv0,
211 static bool importFunctions(const char *argv0, Module &DestModule) {
237 auto &SrcModule = ModuleLoaderCache(argv0, FileName);
283 std::unique_ptr<Module> M = loadFile(argv0, File, Context);
360 auto Composite = std::make_unique<Module>("llvm-link", Context);
tools/llvm-lto/llvm-lto.cpp 305 static void maybeVerifyModule(const Module &Mod) {
490 static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile &File,
511 static void writeModuleToFile(Module &TheModule, StringRef Filename) {
tools/llvm-modextract/llvm-modextract.cpp 71 std::unique_ptr<Module> M = ExitOnErr(Ms[ModuleIndex].parseModule(Context));
tools/llvm-reduce/TestRunner.h 34 Module *getProgram() const { return Program.get(); }
36 void setProgram(std::unique_ptr<Module> P) { Program = std::move(P); }
41 std::unique_ptr<Module> Program;
tools/llvm-reduce/deltas/Delta.cpp 24 bool IsReduced(Module &M, TestRunner &Test, SmallString<128> &CurrentFilepath) {
92 std::function<void(const std::vector<Chunk> &, Module *)>
100 if (Module *Program = Test.getProgram()) {
110 std::unique_ptr<Module> ReducedProgram;
130 std::unique_ptr<Module> Clone = CloneModule(*Test.getProgram());
tools/llvm-reduce/deltas/Delta.h 72 std::function<void(const std::vector<Chunk> &, Module *)>
tools/llvm-reduce/deltas/ReduceArguments.cpp 44 Module *Program) {
104 static int countArguments(Module *Program) {
tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp 84 Module *Program) {
127 static int countBasicBlocks(Module *Program) {
tools/llvm-reduce/deltas/ReduceFunctions.cpp 25 Module *Program) {
60 static int countFunctions(Module *Program) {
tools/llvm-reduce/deltas/ReduceGlobalVars.cpp 21 Module *Program) {
58 static int countGVs(Module *Program) {
tools/llvm-reduce/deltas/ReduceInstructions.cpp 21 Module *Program) {
49 static unsigned countInstructions(Module *Program) {
tools/llvm-reduce/deltas/ReduceMetadata.cpp 55 Module *Program) {
114 static int countMetadataTargets(Module *Program) {
tools/llvm-reduce/llvm-reduce.cpp 57 static std::unique_ptr<Module> parseInputFile(StringRef Filename,
60 std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
80 std::unique_ptr<Module> OriginalProgram =
tools/llvm-split/llvm-split.cpp 47 std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
tools/llvm-stress/llvm-stress.cpp 154 Function *GenEmptyFunction(Module *M) {
738 auto M = std::make_unique<Module>("/tmp/autogen.bc", Context);
tools/opt/AnalysisWrappers.cpp 34 bool runOnModule(Module &M) override {
35 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
tools/opt/BreakpointPrinter.cpp 44 bool runOnModule(Module &M) override {
tools/opt/Debugify.cpp 42 uint64_t getAllocSizeInBits(Module &M, Type *Ty) {
62 bool applyDebugifyMetadata(Module &M,
63 iterator_range<Module::iterator> Functions,
164 M.addModuleFlag(Module::Warning, DIVersionKey, DEBUG_METADATA_VERSION);
170 bool diagnoseMisSizedDbgValue(Module &M, DbgValueInst *DVI) {
209 bool checkDebugifyMetadata(Module &M,
210 iterator_range<Module::iterator> Functions,
310 bool runOnModule(Module &M) override {
327 Module &M = *F.getParent();
345 bool runOnModule(Module &M) override {
371 Module &M = *F.getParent();
425 PreservedAnalyses NewPMDebugifyPass::run(Module &M, ModuleAnalysisManager &) {
442 PreservedAnalyses NewPMCheckDebugifyPass::run(Module &M,
tools/opt/Debugify.h 25 llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
71 llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
tools/opt/NewPMDriver.cpp 211 bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
tools/opt/NewPMDriver.h 60 bool runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
tools/opt/PassPrinters.cpp 114 bool runOnModule(Module &M) override {
tools/opt/PrintSCC.cpp 41 void print(raw_ostream &O, const Module* = nullptr) const override { }
53 bool runOnModule(Module &M) override;
55 void print(raw_ostream &O, const Module* = nullptr) const override { }
92 bool CallGraphSCC::runOnModule(Module &M) {
tools/opt/opt.cpp 568 std::unique_ptr<Module> M =
662 M->addModuleFlag(Module::Error, "EnableSplitLTOUnit", SplitLTOUnit);
897 std::unique_ptr<Module> M2(CloneModule(*M));
tools/polly/include/polly/CodeGen/LoopGenerators.h 158 Module *M;
tools/polly/include/polly/CodeGen/PerfMonitor.h 23 PerfMonitor(const Scop &S, llvm::Module *M);
42 llvm::Module *M;
tools/polly/include/polly/DependenceInfo.h 288 void print(raw_ostream &OS, const Module *M = nullptr) const override;
tools/polly/include/polly/PolyhedralInfo.h 74 const llvm::Module *M = nullptr) const override;
tools/polly/include/polly/ScopDetection.h 635 void print(raw_ostream &OS, const Module *) const override;
tools/polly/include/polly/ScopInfo.h 2790 void print(raw_ostream &O, const Module *M = nullptr) const override;
2895 void print(raw_ostream &O, const Module *M = nullptr) const override;
tools/polly/include/polly/ScopPass.h 169 void print(raw_ostream &OS, const Module *) const override;
tools/polly/lib/Analysis/DependenceInfo.cpp 938 void DependenceInfoWrapperPass::print(raw_ostream &OS, const Module *M) const {
tools/polly/lib/Analysis/PolyhedralInfo.cpp 59 void PolyhedralInfo::print(raw_ostream &OS, const Module *) const {
tools/polly/lib/Analysis/ScopDetection.cpp 1873 void ScopDetectionWrapperPass::print(raw_ostream &OS, const Module *) const {
tools/polly/lib/Analysis/ScopInfo.cpp 2693 void ScopInfoRegionPass::print(raw_ostream &OS, const Module *) const {
2819 void ScopInfoWrapperPass::print(raw_ostream &OS, const Module *) const {
tools/polly/lib/Analysis/ScopPass.cpp 36 void ScopPass::print(raw_ostream &OS, const Module *M) const {
tools/polly/lib/CodeGen/CodegenCleanup.cpp 44 virtual bool doInitialization(Module &M) override {
108 virtual bool doFinalization(Module &M) override {
tools/polly/lib/CodeGen/IslExprBuilder.cpp 116 Module *M = Builder.GetInsertBlock()->getModule();
tools/polly/lib/CodeGen/PerfMonitor.cpp 64 PerfMonitor::PerfMonitor(const Scop &S, Module *M)
72 static void TryRegisterGlobal(Module *M, const char *Name,
tools/polly/lib/CodeGen/RuntimeDebugBuilder.cpp 21 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
40 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
245 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
270 Module *M = Builder.GetInsertBlock()->getParent()->getParent();
tools/polly/lib/Exchange/JSONExporter.cpp 809 PA.preserveSet<AllAnalysesOn<Module>>();
tools/polly/lib/Support/DumpModulePass.cpp 53 virtual bool runOnModule(llvm::Module &M) override {
tools/polly/lib/Transform/Canonicalization.cpp 70 virtual bool runOnModule(Module &M);
71 virtual void print(raw_ostream &OS, const Module *) const;
82 bool PollyCanonicalize::runOnModule(Module &M) {
90 void PollyCanonicalize::print(raw_ostream &OS, const Module *) const {}
tools/polly/lib/Transform/CodePreparation.cpp 53 virtual void print(raw_ostream &OS, const Module *) const;
108 void CodePreparation::print(raw_ostream &OS, const Module *) const {}
tools/polly/lib/Transform/ScopInliner.cpp 88 Module *M = F->getParent();
tools/verify-uselistorder/verify-uselistorder.cpp 75 bool writeBitcode(const Module &M) const;
76 bool writeAssembly(const Module &M) const;
77 std::unique_ptr<Module> readBitcode(LLVMContext &Context) const;
78 std::unique_ptr<Module> readAssembly(LLVMContext &Context) const;
96 ValueMapping(const Module &M);
123 bool TempFile::writeBitcode(const Module &M) const {
136 bool TempFile::writeAssembly(const Module &M) const {
149 std::unique_ptr<Module> TempFile::readBitcode(LLVMContext &Context) const {
160 Expected<std::unique_ptr<Module>> ModuleOr =
170 std::unique_ptr<Module> TempFile::readAssembly(LLVMContext &Context) const {
173 std::unique_ptr<Module> M = parseAssemblyFile(Filename, Err, Context);
179 ValueMapping::ValueMapping(const Module &M) {
342 static void verifyAfterRoundTrip(const Module &M,
343 std::unique_ptr<Module> OtherM) {
352 static void verifyBitcodeUseListOrder(const Module &M) {
364 static void verifyAssemblyUseListOrder(const Module &M) {
376 static void verifyUseListOrder(const Module &M) {
460 static void changeUseLists(Module &M, Changer changeValueUseList) {
513 static void shuffleUseLists(Module &M, unsigned SeedOffset) {
520 static void reverseUseLists(Module &M) {
540 std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
unittests/Analysis/AliasAnalysisTest.cpp 117 bool doInitialization(Module &M) override {
122 bool doFinalization(Module &M) override {
144 Module M;
212 std::unique_ptr<Module> M;
unittests/Analysis/BasicAliasAnalysisTest.cpp 35 Module M;
unittests/Analysis/BlockFrequencyInfoTest.cpp 40 std::unique_ptr<Module> makeLLVMModule() {
unittests/Analysis/BranchProbabilityInfoTest.cpp 40 std::unique_ptr<Module> makeLLVMModule() {
unittests/Analysis/CFGTest.cpp 128 std::unique_ptr<Module> M;
unittests/Analysis/CGSCCPassManagerTest.cpp 34 Result run(Module &M, ModuleAnalysisManager &AM) {
129 PreservedAnalyses run(Module &F, ModuleAnalysisManager &AM) {
133 std::function<PreservedAnalyses(Module &, ModuleAnalysisManager &)> Func;
160 std::unique_ptr<Module> parseIR(const char *IR) {
176 std::unique_ptr<Module> M;
623 std::unique_ptr<Module> M = parseIR("declare void @g()\n"
668 std::unique_ptr<Module> M = parseIR("declare void @g()\n"
unittests/Analysis/CallGraphTest.cpp 47 Module M("", Context);
55 Module M("", Context);
unittests/Analysis/DivergenceAnalysisTest.cpp 46 Module M;
66 Module &M, StringRef FuncName, bool IsLCSSA,
113 std::unique_ptr<Module> M = parseAssemblyString(
163 std::unique_ptr<Module> M = parseAssemblyString(
217 std::unique_ptr<Module> M = parseAssemblyString(
386 std::unique_ptr<Module> M = parseAssemblyString(
unittests/Analysis/DomTreeUpdaterTest.cpp 23 static std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context,
26 std::unique_ptr<Module> M = parseAssemblyString(ModuleStr, Err, Context);
50 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
161 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
235 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
324 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
453 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
536 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
625 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
714 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
744 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
unittests/Analysis/IVDescriptorsTest.cpp 23 Module &M, StringRef FuncName,
38 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
40 std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
54 std::unique_ptr<Module> M = parseIR(
unittests/Analysis/LazyCallGraphTest.cpp 24 std::unique_ptr<Module> parseAssembly(LLVMContext &Context,
27 std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
218 static LazyCallGraph buildCG(Module &M) {
229 std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
395 static Function &lookupFunction(Module &M, StringRef Name) {
404 std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n"
455 std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
527 std::unique_ptr<Module> M = parseAssembly(Context, "define void @f1() {\n"
584 std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n"
749 std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
840 std::unique_ptr<Module> M =
930 std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n"
1003 std::unique_ptr<Module> M =
1087 std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
1218 std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n"
1305 std::unique_ptr<Module> M = parseAssembly(
1383 std::unique_ptr<Module> M = parseAssembly(
1453 std::unique_ptr<Module> M = parseAssembly(
1528 std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n"
1617 std::unique_ptr<Module> M =
1706 std::unique_ptr<Module> M =
1843 std::unique_ptr<Module> M =
1955 std::unique_ptr<Module> M =
1986 std::unique_ptr<Module> M =
2015 std::unique_ptr<Module> M =
2095 std::unique_ptr<Module> M =
unittests/Analysis/LoopInfoTest.cpp 22 runWithLoopInfo(Module &M, StringRef FuncName,
34 Module &M, StringRef FuncName,
48 static std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context,
77 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
127 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
183 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
257 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
315 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
373 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
431 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
489 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
548 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
606 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
661 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
719 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
777 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
837 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
897 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
959 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1012 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1066 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1135 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1227 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1296 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1338 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1386 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
1429 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
unittests/Analysis/MemoryBuiltinsTest.cpp 25 Module M("", Context);
unittests/Analysis/MemorySSATest.cpp 32 Module M;
unittests/Analysis/OrderedBasicBlockTest.cpp 26 std::unique_ptr<Module> makeLLVMModule() {
unittests/Analysis/OrderedInstructionsTest.cpp 24 Module M("test", Ctx);
unittests/Analysis/PhiValuesTest.cpp 21 Module M("PhiValuesTest", C);
88 Module M("PhiValuesTest", C);
unittests/Analysis/ProfileSummaryInfoTest.cpp 37 ProfileSummaryInfo buildPSI(Module *M) {
46 std::unique_ptr<Module> makeLLVMModule(const char *ProfKind = nullptr) {
unittests/Analysis/ScalarEvolutionTest.cpp 35 Module M;
53 Module &M, StringRef FuncName,
220 std::unique_ptr<Module> M = parseAssemblyString(
481 std::unique_ptr<Module> M = parseAssemblyString(
745 Module NIM("nonintegral", Context);
820 Module NIM("nonintegral", Context);
918 Module NIM("nonintegral", Context);
1146 Module NIM("nonintegral", Context);
1213 Module M("SCEVExpanderNUW", Context);
1265 Module M("SCEVExpanderNSW", Context);
1315 Module M("SCEVCacheNUW", Context);
1366 Module M("SCEVCacheNUW", Context);
1416 Module M("SCEVComputeExpressionSize", Context);
1460 std::unique_ptr<Module> M =
1501 std::unique_ptr<Module> M = parseAssemblyString(
1579 std::unique_ptr<Module> M = parseAssemblyString(
1650 std::unique_ptr<Module> M = parseAssemblyString(str, Err, C);
1689 std::unique_ptr<Module> M = parseAssemblyString(
1759 std::unique_ptr<Module> M =
1798 std::unique_ptr<Module> M = parseAssemblyString(
1849 std::unique_ptr<Module> M = parseAssemblyString(
unittests/Analysis/SparsePropagation.cpp 229 Module M;
unittests/Analysis/TBAATest.cpp 29 Module M;
33 static StoreInst *getFunctionWithSingleStore(Module *M, StringRef Name) {
unittests/Analysis/TargetLibraryInfoTest.cpp 27 std::unique_ptr<Module> M;
unittests/Analysis/UnrollAnalyzerTest.cpp 62 std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context,
88 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
94 Module::iterator MI = M->begin();
151 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
156 Module::iterator MI = M->begin();
196 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
202 Module::iterator MI = M->begin();
243 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
249 Module::iterator MI = M->begin();
289 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleStr);
295 Module::iterator MI = M->begin();
unittests/Analysis/ValueLatticeTest.cpp 26 Module M;
unittests/Analysis/ValueTrackingTest.cpp 26 std::unique_ptr<Module> parseModule(StringRef Assembly) {
28 std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
58 std::unique_ptr<Module> M;
unittests/Analysis/VectorUtilsTest.cpp 57 std::unique_ptr<Module> M;
63 std::unique_ptr<Module> M;
69 : M(new Module("VectorUtils", Ctx)),
unittests/AsmParser/AsmParserTest.cpp 39 std::unique_ptr<Module> Mod;
73 auto &M = *Mod;
138 auto &M = *Mod;
174 auto &M = *Mod;
298 auto &M = *Mod;
unittests/Bitcode/BitReaderTest.cpp 27 std::unique_ptr<Module> parseAssembly(LLVMContext &Context,
30 std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
43 static void writeModuleToBuffer(std::unique_ptr<Module> Mod,
49 static std::unique_ptr<Module> getLazyModuleFromAssembly(LLVMContext &Context,
53 Expected<std::unique_ptr<Module>> ModuleOrErr =
64 std::unique_ptr<Module> M = getLazyModuleFromAssembly(
128 std::unique_ptr<Module> M = getLazyModuleFromAssembly(
143 std::unique_ptr<Module> M = getLazyModuleFromAssembly(
170 std::unique_ptr<Module> M = getLazyModuleFromAssembly(
unittests/CodeGen/AArch64SelectionDAGTest.cpp 74 std::unique_ptr<Module> M;
unittests/CodeGen/GlobalISel/GISelMITest.h 70 static std::unique_ptr<Module> parseMIR(LLVMContext &Context,
81 std::unique_ptr<Module> M = MIR->parseIRModule();
93 static std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
115 std::unique_ptr<Module> M =
120 static MachineFunction *getMFFromMMI(const Module *M,
154 std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
unittests/CodeGen/MachineInstrTest.cpp 155 Module M("Module", Ctx);
unittests/CodeGen/MachineOperandTest.cpp 242 Module M("MachineOperandGVTest", Ctx);
295 Module M("MachineOperandMDNodeTest", Ctx);
unittests/ExecutionEngine/ExecutionEngineTest.cpp 30 auto Owner = std::make_unique<Module>("<main>", Context);
47 Module *M; // Owned by ExecutionEngine.
unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp 92 std::unique_ptr<Module> A, B;
112 std::unique_ptr<Module> A, B;
133 std::unique_ptr<Module> A, B;
154 std::unique_ptr<Module> A, B;
174 std::unique_ptr<Module> A, B;
202 std::unique_ptr<Module> A, B;
251 std::unique_ptr<Module> A, B, C;
276 std::unique_ptr<Module> A, B, C;
301 std::unique_ptr<Module> A, B, C;
326 std::unique_ptr<Module> A, B, C;
351 std::unique_ptr<Module> A, B;
372 std::unique_ptr<Module> A, B;
393 std::unique_ptr<Module> A, B;
414 std::unique_ptr<Module> A, B;
unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp 26 void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) override {
35 std::unique_ptr<MemoryBuffer> getObject(const Module *M) override {
48 bool wasModuleLookedUp(const Module *M) {
53 const MemoryBuffer* getObjectInternal(const Module* M) {
126 const Module * SavedModulePointer = M.get();
169 const Module * SecondModulePointer = M.get();
204 const Module * SecondModulePointer = M.get();
unittests/ExecutionEngine/MCJIT/MCJITTestBase.h 41 Module *createEmptyModule(StringRef Name = StringRef()) {
42 Module * M = new Module(Name, Context);
42 Module * M = new Module(Name, Context);
47 Function *startFunction(Module *M, FunctionType *FT, StringRef Name) {
63 Function *insertSimpleCallFunction(Module *M, Function *Callee) {
79 Function *insertMainFunction(Module *M, uint32_t returnCode) {
92 Function *insertAddFunction(Module *M, StringRef Name = "add") {
111 Function *insertExternalReferenceToFunction(Module *M, FunctionType *FTy,
119 Function *insertExternalReferenceToFunction(Module *M, Function *Func) {
128 GlobalVariable *insertGlobalInt32(Module *M,
152 Function *insertAccumulateFunction(Module *M,
191 void createCrossModuleRecursiveCase(std::unique_ptr<Module> &A, Function *&FA,
192 std::unique_ptr<Module> &B,
216 createThreeModuleChainedCallsCase(std::unique_ptr<Module> &A, Function *&FA,
217 std::unique_ptr<Module> &B, Function *&FB,
218 std::unique_ptr<Module> &C, Function *&FC) {
234 void createTwoModuleCase(std::unique_ptr<Module> &A, Function *&FA,
235 std::unique_ptr<Module> &B, Function *&FB) {
245 void createTwoModuleExternCase(std::unique_ptr<Module> &A, Function *&FA,
246 std::unique_ptr<Module> &B, Function *&FB) {
258 void createThreeModuleCase(std::unique_ptr<Module> &A, Function *&FA,
259 std::unique_ptr<Module> &B, Function *&FB,
260 std::unique_ptr<Module> &C, Function *&FC) {
301 void createJIT(std::unique_ptr<Module> M) {
328 std::unique_ptr<Module> M;
unittests/ExecutionEngine/Orc/GlobalMappingLayerTest.cpp 19 MockBaseLayer<int, std::shared_ptr<Module>> TestBaseLayer;
unittests/ExecutionEngine/Orc/LazyEmittingLayerTest.cpp 18 std::shared_ptr<llvm::Module>) {
unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp 57 MockBaseLayer<int, std::shared_ptr<Module>> TestBaseLayer;
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp 78 auto M = std::make_unique<Module>("", Context);
unittests/ExecutionEngine/Orc/OrcCAPITest.cpp 27 std::unique_ptr<Module> createTestModule(const Triple &TT) {
72 std::unique_ptr<Module> M;
101 std::unique_ptr<Module> M = createTestModule(TM->getTargetTriple());
141 std::unique_ptr<Module> M = createTestModule(TM->getTargetTriple());
unittests/ExecutionEngine/Orc/OrcTestCommon.cpp 26 : M(new Module(Name, Context)) {
unittests/ExecutionEngine/Orc/OrcTestCommon.h 174 Module* getModule() { return M.get(); }
175 const Module* getModule() const { return M.get(); }
176 std::unique_ptr<Module> takeModule() { return std::move(M); }
179 std::unique_ptr<Module> M;
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp 74 auto M = std::make_unique<Module>("", Context);
117 CompileResult operator()(Module &M) {
185 CompileResult operator()(Module &M) {
unittests/ExecutionEngine/Orc/ThreadSafeModuleTest.cpp 25 auto M = std::make_unique<Module>("M", *TSCtx.getContext());
34 auto M1 = std::make_unique<Module>("M1", *TSCtx.getContext());
37 auto M2 = std::make_unique<Module>("M2", *TSCtx.getContext());
48 auto M1 = std::make_unique<Module>("M1", *TSCtx.getContext());
53 auto M2 = std::make_unique<Module>("M2", *TSCtx.getContext());
62 auto M = std::make_unique<Module>("M", *TSCtx.getContext());
70 auto M = std::make_unique<Module>("M", *TSCtx.getContext());
90 auto M = std::make_unique<Module>("M", Ctx);
unittests/FuzzMutate/OperationsTest.cpp 57 std::unique_ptr<Module> parseAssembly(
61 std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
177 Module M("M", Ctx);
247 Module M("M", Ctx);
285 Module M("M", Ctx);
unittests/FuzzMutate/RandomIRBuilderTest.cpp 31 std::unique_ptr<Module> parseAssembly(
35 std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
unittests/FuzzMutate/StrategiesTest.cpp 52 std::unique_ptr<Module> parseAssembly(
56 std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
82 auto M = std::make_unique<Module>("M", Ctx);
unittests/IR/BasicBlockTest.cpp 97 Module *M = new Module("MyModule", Ctx);
97 Module *M = new Module("MyModule", Ctx);
unittests/IR/CFGBuilder.cpp 24 M(std::make_unique<Module>(ModuleName, *Context)) {
unittests/IR/CFGBuilder.h 38 std::unique_ptr<Module> M;
unittests/IR/ConstantsTest.cpp 193 std::unique_ptr<Module> M(new Module("MyModule", Context));
193 std::unique_ptr<Module> M(new Module("MyModule", Context));
306 std::unique_ptr<Module> M(new Module("MyModule", Context));
306 std::unique_ptr<Module> M(new Module("MyModule", Context));
326 std::unique_ptr<Module> M(new Module("MyModule", Context));
326 std::unique_ptr<Module> M(new Module("MyModule", Context));
351 std::unique_ptr<Module> M(new Module("MyModule", Context));
351 std::unique_ptr<Module> M(new Module("MyModule", Context));
374 std::unique_ptr<Module> M(new Module("MyModule", Context));
374 std::unique_ptr<Module> M(new Module("MyModule", Context));
400 std::unique_ptr<Module> M =
420 std::unique_ptr<Module> M(new Module("MyModule", Context));
420 std::unique_ptr<Module> M(new Module("MyModule", Context));
443 std::unique_ptr<Module> M(new Module("MyModule", Context));
443 std::unique_ptr<Module> M(new Module("MyModule", Context));
464 std::unique_ptr<Module> M(new Module("MyModule", Context));
464 std::unique_ptr<Module> M(new Module("MyModule", Context));
478 bool foldFuncPtrAndConstToNull(LLVMContext &Context, Module *TheModule,
509 Module TheModule("TestModule", Context);
520 Module TheModule("TestModule", Context);
526 Module TheModule("TestModule", Context);
539 Module TheModule("TestModule", Context);
550 Module TheModule("TestModule", Context);
557 Module TheModule("TestModule", Context);
unittests/IR/DominatorTreeTest.cpp 27 Module &M, StringRef FuncName,
38 static std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context,
41 std::unique_ptr<Module> M = parseAssemblyString(ModuleStr, Err, Context);
73 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
293 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
377 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
471 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
560 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
634 std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
unittests/IR/FunctionTest.cpp 123 Module M("test", C);
unittests/IR/IRBuilderTest.cpp 29 M.reset(new Module("MyModule", Ctx));
44 std::unique_ptr<Module> M;
357 std::unique_ptr<Module> M(new Module("test", Ctx));
357 std::unique_ptr<Module> M(new Module("test", Ctx));
unittests/IR/InstructionsTest.cpp 32 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
34 std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
68 ModuleWithFunctionTest() : M(new Module("MyModule", Ctx)) {
78 std::unique_ptr<Module> M;
1000 std::unique_ptr<Module> M = parseIR(C,
1069 std::unique_ptr<Module> M = parseIR(Context, R"(
unittests/IR/LegacyPassManagerTest.cpp 51 bool runOnModule(Module &M) override {
67 bool runOnModule(Module &M) override {
80 bool runOnModule(Module &M) override {
95 bool runOnModule(Module &M) override {
153 bool doInitialization(T &t) override {
158 bool doFinalization(T &t) override {
177 struct FPass : public PassTest<Module, FunctionPass> {
236 bool doInitialization(Module &M) override {
253 bool doFinalization(Module &M) override {
269 bool runOnModule(Module &M) override {
270 for (Module::iterator I=M.begin(),E=M.end(); I != E; ++I) {
287 Module M("test-once", Context);
311 Module M("test-rerun", Context);
334 Module *makeLLVMModule(LLVMContext &Context);
339 std::unique_ptr<Module> M(makeLLVMModule(Context));
350 Module *M = makeLLVMModule(Context);
386 Module *M = makeLLVMModule(Context);
416 bool runOnModule(Module &M) override {
431 Module M0("custom-opt-bisect", Context0);
432 Module M1("custom-opt-bisect", Context1);
433 Module M2("custom-opt-bisect2", Context2);
465 Module *makeLLVMModule(LLVMContext &Context) {
467 Module *mod = new Module("test-mem", Context);
467 Module *mod = new Module("test-mem", Context);
unittests/IR/ManglerTest.cpp 29 llvm::CallingConv::ID CC, Module &Mod,
50 Module Mod("test", Ctx);
70 Module Mod("test", Ctx);
106 Module Mod("test", Ctx);
unittests/IR/MetadataTest.cpp 70 Module M;
308 Module M("test", Context);
329 Module M("test", Context);
347 Module M("test", Context);
369 Module M("test", Context);
405 Module M("test", Context);
2630 Module M("MyModule", Context);
unittests/IR/ModuleTest.cpp 32 Module M("M", Context);
56 bool runOnModule(Module &) { return true; }
59 Module M("R", Context);
unittests/IR/PassBuilderCallbacksTest.cpp 71 bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
77 Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
91 static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
95 !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
137 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
204 : MockPassHandleBase<MockPassHandle<Module>, Module> {
204 : MockPassHandleBase<MockPassHandle<Module>, Module> {
256 : MockAnalysisHandleBase<MockAnalysisHandle<Module>, Module> {
256 : MockAnalysisHandleBase<MockAnalysisHandle<Module>, Module> {
265 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
272 template <typename IRUnitT> std::string getName(const IRUnitT &IR) {
279 if (any_isa<const Module *>(WrappedIR))
280 return any_cast<const Module *>(WrappedIR)->getName().str();
374 using IRUnitT = TestIRUnitT;
375 using AnalysisManagerT = AnalysisManager<TestIRUnitT, ExtraAnalysisArgTs...>;
377 PassManager<TestIRUnitT, AnalysisManagerT, ExtraPassArgTs...>;
381 std::unique_ptr<Module> M;
unittests/IR/PassManagerTest.cpp 59 Result run(Module &M, ModuleAnalysisManager &AM) {
62 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
79 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
88 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
144 std::unique_ptr<Module> parseIR(LLVMContext &Context, const char *IR) {
152 std::unique_ptr<Module> M;
243 PA.preserveSet<AllAnalysesOn<Module>>();
257 PA.preserveSet<AllAnalysesOn<Module>>();
268 PA1.preserveSet<AllAnalysesOn<Module>>();
273 PA2.preserveSet<AllAnalysesOn<Module>>();
383 PA.preserveSet<AllAnalysesOn<Module>>();
unittests/IR/PatternMatch.cpp 35 std::unique_ptr<Module> M;
41 : M(new Module("PatternMatchTestModule", Ctx)),
unittests/IR/TimePassesTest.cpp 35 bool runOnModule(Module &M) override { return false; }
48 bool runOnModule(Module &M) override { return false; }
68 Module M("TestModule", Context);
121 Module M("TestModule", Context);
unittests/IR/UseTest.cpp 39 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
84 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
unittests/IR/UserTest.cpp 67 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
122 Module M("", Context);
unittests/IR/ValueTest.cpp 37 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
48 std::unique_ptr<Module> M(new Module("TestModule", Ctx));
48 std::unique_ptr<Module> M(new Module("TestModule", Ctx));
96 std::unique_ptr<Module> M(new Module("TestModule", Ctx));
96 std::unique_ptr<Module> M(new Module("TestModule", Ctx));
127 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
202 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
237 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
unittests/IR/VerifierTest.cpp 27 Module M("M", C);
50 Module M("M", C);
66 Module M1("M1", C);
67 Module M2("M2", C);
68 Module M3("M3", C);
125 Module M("M", C);
138 Module M("M", C);
153 Module M("M", C);
168 Module M("M", C);
unittests/Linker/LinkModulesTest.cpp 29 M.reset(new Module("MyModule", Ctx));
64 std::unique_ptr<Module> M;
99 Module *LinkedModule = new Module("MyModuleLinked", Ctx);
99 Module *LinkedModule = new Module("MyModuleLinked", Ctx);
132 static Module *getExternal(LLVMContext &Ctx, StringRef FuncName) {
134 Module *M = new Module("ExternalModule", Ctx);
134 Module *M = new Module("ExternalModule", Ctx);
148 static Module *getInternal(LLVMContext &Ctx) {
149 Module *InternalM = new Module("InternalModule", Ctx);
149 Module *InternalM = new Module("InternalModule", Ctx);
172 std::unique_ptr<Module> InternalM(getInternal(Ctx));
173 std::unique_ptr<Module> EmptyM(new Module("EmptyModule1", Ctx));
173 std::unique_ptr<Module> EmptyM(new Module("EmptyModule1", Ctx));
179 std::unique_ptr<Module> InternalM(getInternal(Ctx));
180 std::unique_ptr<Module> EmptyM(new Module("EmptyModule1", Ctx));
180 std::unique_ptr<Module> EmptyM(new Module("EmptyModule1", Ctx));
191 std::unique_ptr<Module> M1 = parseAssemblyString(M1Str, Err, C);
195 std::unique_ptr<Module> M2 = parseAssemblyString(M2Str, Err, C);
205 std::unique_ptr<Module> DestM(getExternal(Ctx, "foo"));
206 std::unique_ptr<Module> SourceM(getExternal(Ctx, "bar"));
227 std::unique_ptr<Module> DestM(getExternal(Ctx, "foo"));
228 std::unique_ptr<Module> SourceM(getExternal(Ctx, "foo"));
252 std::unique_ptr<Module> Src = parseAssemblyString(SrcStr, Err, C);
280 auto Dst = std::make_unique<Module>("Linked", C);
332 std::unique_ptr<Module> Foo = parseAssemblyString(FooStr, Err, C);
340 std::unique_ptr<Module> Bar = parseAssemblyString(BarStr, Err, C);
349 auto Dst = std::make_unique<Module>("Linked", C);
unittests/MI/LiveIntervalTest.cpp 51 std::unique_ptr<Module> parseMIR(LLVMContext &Context,
60 std::unique_ptr<Module> M = MIR->parseIRModule();
150 std::unique_ptr<Module> M = parseMIR(Context, PM, MIR, *TM, MIRString,
unittests/Passes/TestPlugin.cpp 17 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM) {
unittests/ProfileData/InstrProfTest.cpp 191 Module M("my_module", Context);
288 std::unique_ptr<Module> M(new Module("MyModule", Ctx));
288 std::unique_ptr<Module> M(new Module("MyModule", Ctx));
892 std::unique_ptr<Module> M = std::make_unique<Module>("MyModule.cpp", Ctx);
892 std::unique_ptr<Module> M = std::make_unique<Module>("MyModule.cpp", Ctx);
unittests/ProfileData/SampleProfTest.cpp 53 void readProfile(const Module &M, StringRef Profile,
127 Module M("my_module", Context);
283 void createFunctionWithSampleProfileElisionPolicy(Module *M,
294 void setupModuleForElisionTest(Module *M, StringRef Policy) {
308 Module M("my_module", Context);
unittests/Target/AArch64/InstSizes.cpp 62 std::unique_ptr<Module> M = MParser->parseIRModule();
unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp 42 std::unique_ptr<Module> parseMIR(LLVMContext &Context,
52 std::unique_ptr<Module> M = MIR->parseIRModule();
159 std::unique_ptr<Module> M =
334 std::unique_ptr<Module> M =
unittests/Target/X86/MachineSizeOptsTest.cpp 45 std::unique_ptr<Module> M;
83 MachineFunction *getMachineFunction(Module *M, StringRef Name) {
unittests/Transforms/Scalar/LoopPassManagerTest.cpp 164 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
199 struct MockModulePassHandle : MockPassHandleBase<MockModulePassHandle, Module> {
225 std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
233 std::unique_ptr<Module> M;
unittests/Transforms/Utils/BasicBlockUtilsTest.cpp 20 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
22 std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
31 std::unique_ptr<Module> M = parseIR(
61 std::unique_ptr<Module> M = parseIR(
89 std::unique_ptr<Module> M = parseIR(
115 std::unique_ptr<Module> M = parseIR(
unittests/Transforms/Utils/CloningTest.cpp 361 Module &M, StringRef FuncName,
372 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
374 std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
384 std::unique_ptr<Module> M = parseIR(
457 M = new Module("", C);
547 Module* M;
655 static int GetDICompileUnitCount(const Module& M) {
719 void SetupModule() { OldM = new Module("", C); }
780 Module *OldM;
781 Module *NewM;
unittests/Transforms/Utils/CodeExtractorTest.cpp 35 std::unique_ptr<Module> M(parseAssemblyString(R"invalid(
83 std::unique_ptr<Module> M(parseAssemblyString(R"invalid(
134 std::unique_ptr<Module> M(parseAssemblyString(R"invalid(
201 std::unique_ptr<Module> M(parseAssemblyString(R"invalid(
236 std::unique_ptr<Module> M(parseAssemblyString(R"ir(
unittests/Transforms/Utils/FunctionComparatorTest.cpp 26 TestFunction(LLVMContext &Ctx, Module &M, int addVal) {
110 Module M("test", C);
unittests/Transforms/Utils/IntegerDivisionTest.cpp 24 Module M("test division", C);
54 Module M("test division", C);
84 Module M("test remainder", C);
114 Module M("test remainder", C);
145 Module M("test division", C);
175 Module M("test division", C);
205 Module M("test remainder", C);
235 Module M("test remainder", C);
unittests/Transforms/Utils/LocalTest.cpp 105 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
107 std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
118 std::unique_ptr<Module> M = parseIR(C,
168 Module &M, StringRef FuncName,
179 std::unique_ptr<Module> M;
337 std::unique_ptr<Module> M = parseIR(C,
488 std::unique_ptr<Module> M;
587 std::unique_ptr<Module> M = parseIR(Ctx,
638 std::unique_ptr<Module> M = parseIR(Ctx,
827 std::unique_ptr<Module> M = parseIR(C,
unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp 24 Module M("SSAUpdaterTest", C);
111 Module M("SSAUpdaterTest", C);
unittests/Transforms/Utils/SizeOptsTest.cpp 32 std::unique_ptr<Module> M;
unittests/Transforms/Utils/UnrollLoopTest.cpp 23 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
25 std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
34 std::unique_ptr<Module> M = parseIR(
unittests/Transforms/Vectorize/VPlanDominatorTreeTest.cpp 38 Module &M = parseModule(ModuleString);
unittests/Transforms/Vectorize/VPlanHCFGTest.cpp 37 Module &M = parseModule(ModuleString);
114 Module &M = parseModule(ModuleString);
unittests/Transforms/Vectorize/VPlanLoopInfoTest.cpp 38 Module &M = parseModule(ModuleString);
unittests/Transforms/Vectorize/VPlanPredicatorTest.cpp 63 Module &M = parseModule(ModuleString);
158 Module &M = parseModule(ModuleString);
unittests/Transforms/Vectorize/VPlanSlpTest.cpp 93 Module &M = parseModule(ModuleString);
161 Module &M = parseModule(ModuleString);
227 Module &M = parseModule(ModuleString);
286 Module &M = parseModule(ModuleString);
415 Module &M = parseModule(ModuleString);
487 Module &M = parseModule(ModuleString);
559 Module &M = parseModule(ModuleString);
635 Module &M = parseModule(ModuleString);
695 Module &M = parseModule(ModuleString);
758 Module &M = parseModule(ModuleString);
818 Module &M = parseModule(ModuleString);
877 Module &M = parseModule(ModuleString);
unittests/Transforms/Vectorize/VPlanTestBase.h 30 std::unique_ptr<Module> M;
36 Module &parseModule(const char *ModuleString) {
unittests/tools/llvm-exegesis/X86/SnippetRepetitorTest.cpp 38 std::make_unique<Module>("X86SnippetRepetitorTest", *Context);
56 std::unique_ptr<Module> Mod;
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/bits/shared_ptr.h 93 class shared_ptr : public __shared_ptr<_Tp>
107 using element_type = typename __shared_ptr<_Tp>::element_type;
236 shared_ptr(const shared_ptr<_Yp>& __r) noexcept
253 shared_ptr(shared_ptr<_Yp>&& __r) noexcept
352 shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
usr/include/c++/7.4.0/bits/shared_ptr_base.h 882 : is_convertible<_Yp*, _Tp*>::type
882 : is_convertible<_Yp*, _Tp*>::type
956 using element_type = _Tp;
1035 : public __shared_ptr_access<_Tp, _Lp>
1038 using element_type = typename remove_extent<_Tp>::type;
1126 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1138 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
1192 _Assignable<_Yp>
1193 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1218 _Assignable<_Yp>
1219 operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
1272 swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
1344 __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
usr/include/c++/7.4.0/bits/std_function.h 299 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
314 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
628 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
usr/include/c++/7.4.0/bits/unique_ptr.h 68 default_delete(const default_delete<_Up>&) noexcept { }
72 operator()(_Tp* __ptr) const
74 static_assert(!is_void<_Tp>::value,
76 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
297 __safe_conversion_up<_Up, _Ep>,
301 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
689 operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
706 operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
811 { typedef unique_ptr<_Tp> __single_object; };
823 inline typename _MakeUniq<_Tp>::__single_object
824 make_unique(_Args&&... __args)
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/tuple 125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
248 const _Head& __head, const _Tail&... __tail)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
646 constexpr tuple(_UElements&&... __elements)
730 const _Elements&... __elements)
741 const _Elements&... __elements)
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
1078 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1302 constexpr _Head&
1307 constexpr const _Head&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1633 { typedef _Tp type; };
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1659 { typedef _Tp&& type; };
1942 { typedef _Tp type; };
1983 { typedef _Up type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 366 void UniversalPrint(const T& value, ::std::ostream* os);
373 const C& container, ::std::ostream* os) {
377 for (typename C::const_iterator it = container.begin();
439 const T& value, ::std::ostream* os) {
455 void PrintTo(const T& value, ::std::ostream* os) {
478 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
699 static void Print(const T& value, ::std::ostream* os) {
765 static void Print(const T& value, ::std::ostream* os) {
856 typedef T T1;
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 933 typename C::iterator* /* it */ = NULL,