LCOV - code coverage report
Current view: top level - include/llvm/Transforms/IPO - FunctionImport.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 3 3 100.0 %
Date: 2018-10-20 13:21:21 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/Transforms/IPO/FunctionImport.h - ThinLTO importing -*- C++ -*-===//
       2             : //
       3             : //                      The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #ifndef LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H
      11             : #define LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H
      12             : 
      13             : #include "llvm/ADT/DenseSet.h"
      14             : #include "llvm/ADT/StringMap.h"
      15             : #include "llvm/ADT/StringRef.h"
      16             : #include "llvm/IR/GlobalValue.h"
      17             : #include "llvm/IR/ModuleSummaryIndex.h"
      18             : #include "llvm/IR/PassManager.h"
      19             : #include "llvm/Support/Error.h"
      20             : #include <functional>
      21             : #include <map>
      22             : #include <memory>
      23             : #include <string>
      24             : #include <system_error>
      25             : #include <unordered_set>
      26             : #include <utility>
      27             : 
      28             : namespace llvm {
      29             : 
      30             : class Module;
      31             : 
      32             : /// The function importer is automatically importing function from other modules
      33             : /// based on the provided summary informations.
      34         290 : class FunctionImporter {
      35             : public:
      36             :   /// Set of functions to import from a source module. Each entry is a set
      37             :   /// containing all the GUIDs of all functions to import for a source module.
      38             :   using FunctionsToImportTy = std::unordered_set<GlobalValue::GUID>;
      39             : 
      40             :   /// The different reasons selectCallee will chose not to import a
      41             :   /// candidate.
      42             :   enum ImportFailureReason {
      43             :     None,
      44             :     // We can encounter a global variable instead of a function in rare
      45             :     // situations with SamplePGO. See comments where this failure type is
      46             :     // set for more details.
      47             :     GlobalVar,
      48             :     // Found to be globally dead, so we don't bother importing.
      49             :     NotLive,
      50             :     // Instruction count over the current threshold.
      51             :     TooLarge,
      52             :     // Don't import something with interposable linkage as we can't inline it
      53             :     // anyway.
      54             :     InterposableLinkage,
      55             :     // Generally we won't end up failing due to this reason, as we expect
      56             :     // to find at least one summary for the GUID that is global or a local
      57             :     // in the referenced module for direct calls.
      58             :     LocalLinkageNotInModule,
      59             :     // This corresponse to the NotEligibleToImport being set on the summary,
      60             :     // which can happen in a few different cases (e.g. local that can't be
      61             :     // renamed or promoted because it is referenced on a llvm*.used variable).
      62             :     NotEligible
      63             :   };
      64             : 
      65             :   /// Information optionally tracked for candidates the importer decided
      66             :   /// not to import. Used for optional stat printing.
      67             :   struct ImportFailureInfo {
      68             :     // The ValueInfo corresponding to the candidate. We save an index hash
      69             :     // table lookup for each GUID by stashing this here.
      70             :     ValueInfo VI;
      71             :     // The maximum call edge hotness for all failed imports of this candidate.
      72             :     CalleeInfo::HotnessType MaxHotness;
      73             :     // most recent reason for failing to import (doesn't necessarily correspond
      74             :     // to the attempt with the maximum hotness).
      75             :     ImportFailureReason Reason;
      76             :     // The number of times we tried to import candidate but failed.
      77             :     unsigned Attempts;
      78             :     ImportFailureInfo(ValueInfo VI, CalleeInfo::HotnessType MaxHotness,
      79             :                       ImportFailureReason Reason, unsigned Attempts)
      80           1 :         : VI(VI), MaxHotness(MaxHotness), Reason(Reason), Attempts(Attempts) {}
      81             :   };
      82             : 
      83             :   /// Map of callee GUID considered for import into a given module to a pair
      84             :   /// consisting of the largest threshold applied when deciding whether to
      85             :   /// import it and, if we decided to import, a pointer to the summary instance
      86             :   /// imported. If we decided not to import, the summary will be nullptr.
      87             :   using ImportThresholdsTy =
      88             :       DenseMap<GlobalValue::GUID,
      89             :                std::tuple<unsigned, const GlobalValueSummary *,
      90             :                           std::unique_ptr<ImportFailureInfo>>>;
      91             : 
      92             :   /// The map contains an entry for every module to import from, the key being
      93             :   /// the module identifier to pass to the ModuleLoader. The value is the set of
      94             :   /// functions to import.
      95             :   using ImportMapTy = StringMap<FunctionsToImportTy>;
      96             : 
      97             :   /// The set contains an entry for every global value the module exports.
      98             :   using ExportSetTy = std::unordered_set<GlobalValue::GUID>;
      99             : 
     100             :   /// A function of this type is used to load modules referenced by the index.
     101             :   using ModuleLoaderTy =
     102             :       std::function<Expected<std::unique_ptr<Module>>(StringRef Identifier)>;
     103             : 
     104             :   /// Create a Function Importer.
     105             :   FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader)
     106         357 :       : Index(Index), ModuleLoader(std::move(ModuleLoader)) {}
     107             : 
     108             :   /// Import functions in Module \p M based on the supplied import list.
     109             :   Expected<bool> importFunctions(Module &M, const ImportMapTy &ImportList);
     110             : 
     111             : private:
     112             :   /// The summaries index used to trigger importing.
     113             :   const ModuleSummaryIndex &Index;
     114             : 
     115             :   /// Factory function to load a Module for a given identifier
     116             :   ModuleLoaderTy ModuleLoader;
     117             : };
     118             : 
     119             : /// The function importing pass
     120             : class FunctionImportPass : public PassInfoMixin<FunctionImportPass> {
     121             : public:
     122             :   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
     123             : };
     124             : 
     125             : /// Compute all the imports and exports for every module in the Index.
     126             : ///
     127             : /// \p ModuleToDefinedGVSummaries contains for each Module a map
     128             : /// (GUID -> Summary) for every global defined in the module.
     129             : ///
     130             : /// \p ImportLists will be populated with an entry for every Module we are
     131             : /// importing into. This entry is itself a map that can be passed to
     132             : /// FunctionImporter::importFunctions() above (see description there).
     133             : ///
     134             : /// \p ExportLists contains for each Module the set of globals (GUID) that will
     135             : /// be imported by another module, or referenced by such a function. I.e. this
     136             : /// is the set of globals that need to be promoted/renamed appropriately.
     137             : void ComputeCrossModuleImport(
     138             :     const ModuleSummaryIndex &Index,
     139             :     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
     140             :     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
     141             :     StringMap<FunctionImporter::ExportSetTy> &ExportLists);
     142             : 
     143             : /// Compute all the imports for the given module using the Index.
     144             : ///
     145             : /// \p ImportList will be populated with a map that can be passed to
     146             : /// FunctionImporter::importFunctions() above (see description there).
     147             : void ComputeCrossModuleImportForModule(
     148             :     StringRef ModulePath, const ModuleSummaryIndex &Index,
     149             :     FunctionImporter::ImportMapTy &ImportList);
     150             : 
     151             : /// Mark all external summaries in \p Index for import into the given module.
     152             : /// Used for distributed builds using a distributed index.
     153             : ///
     154             : /// \p ImportList will be populated with a map that can be passed to
     155             : /// FunctionImporter::importFunctions() above (see description there).
     156             : void ComputeCrossModuleImportForModuleFromIndex(
     157             :     StringRef ModulePath, const ModuleSummaryIndex &Index,
     158             :     FunctionImporter::ImportMapTy &ImportList);
     159             : 
     160             : /// PrevailingType enum used as a return type of callback passed
     161             : /// to computeDeadSymbols. Yes and No values used when status explicitly
     162             : /// set by symbols resolution, otherwise status is Unknown.
     163             : enum class PrevailingType { Yes, No, Unknown };
     164             : 
     165             : /// Compute all the symbols that are "dead": i.e these that can't be reached
     166             : /// in the graph from any of the given symbols listed in
     167             : /// \p GUIDPreservedSymbols. Non-prevailing symbols are symbols without a
     168             : /// prevailing copy anywhere in IR and are normally dead, \p isPrevailing
     169             : /// predicate returns status of symbol.
     170             : void computeDeadSymbols(
     171             :     ModuleSummaryIndex &Index,
     172             :     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
     173             :     function_ref<PrevailingType(GlobalValue::GUID)> isPrevailing);
     174             : 
     175             : /// Converts value \p GV to declaration, or replaces with a declaration if
     176             : /// it is an alias. Returns true if converted, false if replaced.
     177             : bool convertToDeclaration(GlobalValue &GV);
     178             : 
     179             : /// Compute the set of summaries needed for a ThinLTO backend compilation of
     180             : /// \p ModulePath.
     181             : //
     182             : /// This includes summaries from that module (in case any global summary based
     183             : /// optimizations were recorded) and from any definitions in other modules that
     184             : /// should be imported.
     185             : //
     186             : /// \p ModuleToSummariesForIndex will be populated with the needed summaries
     187             : /// from each required module path. Use a std::map instead of StringMap to get
     188             : /// stable order for bitcode emission.
     189             : void gatherImportedSummariesForModule(
     190             :     StringRef ModulePath,
     191             :     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
     192             :     const FunctionImporter::ImportMapTy &ImportList,
     193             :     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
     194             : 
     195             : /// Emit into \p OutputFilename the files module \p ModulePath will import from.
     196             : std::error_code EmitImportsFiles(
     197             :     StringRef ModulePath, StringRef OutputFilename,
     198             :     const std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
     199             : 
     200             : /// Resolve WeakForLinker values in \p TheModule based on the information
     201             : /// recorded in the summaries during global summary-based analysis.
     202             : void thinLTOResolveWeakForLinkerModule(Module &TheModule,
     203             :                                        const GVSummaryMapTy &DefinedGlobals);
     204             : 
     205             : /// Internalize \p TheModule based on the information recorded in the summaries
     206             : /// during global summary-based analysis.
     207             : void thinLTOInternalizeModule(Module &TheModule,
     208             :                               const GVSummaryMapTy &DefinedGlobals);
     209             : 
     210             : } // end namespace llvm
     211             : 
     212             : #endif // LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H

Generated by: LCOV version 1.13