//===- llvm/Transforms/IPO/FunctionImport.h - ThinLTO importing -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H #define LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/MapVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/IR/GlobalValue.h" #include "llvm/IR/ModuleSummaryIndex.h" #include "llvm/IR/PassManager.h" #include "llvm/Support/Error.h" #include <functional> #include <map> #include <memory> #include <string> #include <system_error> #include <unordered_map> #include <unordered_set> #include <utility> namespace llvm { class Module; /// The function importer is automatically importing function from other modules /// based on the provided summary informations. class FunctionImporter { … }; /// The function importing pass class FunctionImportPass : public PassInfoMixin<FunctionImportPass> { … }; /// Compute all the imports and exports for every module in the Index. /// /// \p ModuleToDefinedGVSummaries contains for each Module a map /// (GUID -> Summary) for every global defined in the module. /// /// \p isPrevailing is a callback that will be called with a global value's GUID /// and summary and should return whether the module corresponding to the /// summary contains the linker-prevailing copy of that value. /// /// \p ImportLists will be populated with an entry for every Module we are /// importing into. This entry is itself a map that can be passed to /// FunctionImporter::importFunctions() above (see description there). /// /// \p ExportLists contains for each Module the set of globals (GUID) that will /// be imported by another module, or referenced by such a function. I.e. this /// is the set of globals that need to be promoted/renamed appropriately. /// /// The module identifier strings that are the keys of the above two maps /// are owned by the in-memory ModuleSummaryIndex the importing decisions /// are made from (the module path for each summary is owned by the index's /// module path string table). void ComputeCrossModuleImport( const ModuleSummaryIndex &Index, const DenseMap<StringRef, GVSummaryMapTy> &ModuleToDefinedGVSummaries, function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, FunctionImporter::ImportListsTy &ImportLists, DenseMap<StringRef, FunctionImporter::ExportSetTy> &ExportLists); /// PrevailingType enum used as a return type of callback passed /// to computeDeadSymbolsAndUpdateIndirectCalls. Yes and No values used when /// status explicitly set by symbols resolution, otherwise status is Unknown. enum class PrevailingType { … }; /// Update call edges for indirect calls to local functions added from /// SamplePGO when needed. Normally this is done during /// computeDeadSymbolsAndUpdateIndirectCalls, but can be called standalone /// when that is not called (e.g. during testing). void updateIndirectCalls(ModuleSummaryIndex &Index); /// Compute all the symbols that are "dead": i.e these that can't be reached /// in the graph from any of the given symbols listed in /// \p GUIDPreservedSymbols. Non-prevailing symbols are symbols without a /// prevailing copy anywhere in IR and are normally dead, \p isPrevailing /// predicate returns status of symbol. /// Also update call edges for indirect calls to local functions added from /// SamplePGO when needed. void computeDeadSymbolsAndUpdateIndirectCalls( ModuleSummaryIndex &Index, const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols, function_ref<PrevailingType(GlobalValue::GUID)> isPrevailing); /// Compute dead symbols and run constant propagation in combined index /// after that. void computeDeadSymbolsWithConstProp( ModuleSummaryIndex &Index, const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols, function_ref<PrevailingType(GlobalValue::GUID)> isPrevailing, bool ImportEnabled); /// Converts value \p GV to declaration, or replaces with a declaration if /// it is an alias. Returns true if converted, false if replaced. bool convertToDeclaration(GlobalValue &GV); /// Compute the set of summaries needed for a ThinLTO backend compilation of /// \p ModulePath. // /// This includes summaries from that module (in case any global summary based /// optimizations were recorded) and from any definitions in other modules that /// should be imported. // /// \p ModuleToSummariesForIndex will be populated with the needed summaries /// from each required module path. Use a std::map instead of StringMap to get /// stable order for bitcode emission. /// /// \p DecSummaries will be popluated with the subset of of summary pointers /// that have 'declaration' import type among all summaries the module need. void gatherImportedSummariesForModule( StringRef ModulePath, const DenseMap<StringRef, GVSummaryMapTy> &ModuleToDefinedGVSummaries, const FunctionImporter::ImportMapTy &ImportList, ModuleToSummariesForIndexTy &ModuleToSummariesForIndex, GVSummaryPtrSet &DecSummaries); /// Emit into \p OutputFilename the files module \p ModulePath will import from. std::error_code EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename, const ModuleToSummariesForIndexTy &ModuleToSummariesForIndex); /// Based on the information recorded in the summaries during global /// summary-based analysis: /// 1. Resolve prevailing symbol linkages and constrain visibility (CanAutoHide /// and consider visibility from other definitions for ELF) in \p TheModule /// 2. (optional) Apply propagated function attributes to \p TheModule if /// PropagateAttrs is true void thinLTOFinalizeInModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals, bool PropagateAttrs); /// Internalize \p TheModule based on the information recorded in the summaries /// during global summary-based analysis. void thinLTOInternalizeModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals); } // end namespace llvm #endif // LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H