include/llvm/Transforms/Utils/FunctionImportUtils.h

   1 //===- FunctionImportUtils.h - Importing support utilities -----*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the FunctionImportGlobalProcessing class which is used
  10 // to perform the necessary global value handling for function importing.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
  15 #define LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
  16
  17 #include "llvm/ADT/SetVector.h"
  18 #include "llvm/IR/ModuleSummaryIndex.h"
  19
  20 namespace llvm {
  21 class Module;
  22
  23 /// Class to handle necessary GlobalValue changes required by ThinLTO
  24 /// function importing, including linkage changes and any necessary renaming.
  25 class FunctionImportGlobalProcessing {
  26   /// The Module which we are exporting or importing functions from.
  27   Module &M;
  28
  29   /// Module summary index passed in for function importing/exporting handling.
  30   const ModuleSummaryIndex &ImportIndex;
  31
  32   /// Globals to import from this module, all other functions will be
  33   /// imported as declarations instead of definitions.
  34   SetVector<GlobalValue *> *GlobalsToImport;
  35
  36   /// Set to true if the given ModuleSummaryIndex contains any functions
  37   /// from this source module, in which case we must conservatively assume
  38   /// that any of its functions may be imported into another module
  39   /// as part of a different backend compilation process.
  40   bool HasExportedFunctions = false;
  41
  42   /// Set of llvm.*used values, in order to validate that we don't try
  43   /// to promote any non-renamable values.
  44   SmallPtrSet<GlobalValue *, 8> Used;
  45
  46   /// Keep track of any COMDATs that require renaming (because COMDAT
  47   /// leader was promoted and renamed). Maps from original COMDAT to one
  48   /// with new name.
  49   DenseMap<const Comdat *, Comdat *> RenamedComdats;
  50
  51   /// Check if we should promote the given local value to global scope.
  52   bool shouldPromoteLocalToGlobal(const GlobalValue *SGV);
  53
  54 #ifndef NDEBUG
  55   /// Check if the given value is a local that can't be renamed (promoted).
  56   /// Only used in assertion checking, and disabled under NDEBUG since the Used
  57   /// set will not be populated.
  58   bool isNonRenamableLocal(const GlobalValue &GV) const;
  59 #endif
  60
  61   /// Helper methods to check if we are importing from or potentially
  62   /// exporting from the current source module.
  63   bool isPerformingImport() const { return GlobalsToImport != nullptr; }
  64   bool isModuleExporting() const { return HasExportedFunctions; }
  65
  66   /// If we are importing from the source module, checks if we should
  67   /// import SGV as a definition, otherwise import as a declaration.
  68   bool doImportAsDefinition(const GlobalValue *SGV);
  69
  70   /// Get the name for SGV that should be used in the linked destination
  71   /// module. Specifically, this handles the case where we need to rename
  72   /// a local that is being promoted to global scope, which it will always
  73   /// do when \p DoPromote is true (or when importing a local).
  74   std::string getName(const GlobalValue *SGV, bool DoPromote);
  75
  76   /// Process globals so that they can be used in ThinLTO. This includes
  77   /// promoting local variables so that they can be reference externally by
  78   /// thin lto imported globals and converting strong external globals to
  79   /// available_externally.
  80   void processGlobalsForThinLTO();
  81   void processGlobalForThinLTO(GlobalValue &GV);
  82
  83   /// Get the new linkage for SGV that should be used in the linked destination
  84   /// module. Specifically, for ThinLTO importing or exporting it may need
  85   /// to be adjusted. When \p DoPromote is true then we must adjust the
  86   /// linkage for a required promotion of a local to global scope.
  87   GlobalValue::LinkageTypes getLinkage(const GlobalValue *SGV, bool DoPromote);
  88
  89 public:
  90   FunctionImportGlobalProcessing(
  91       Module &M, const ModuleSummaryIndex &Index,
  92       SetVector<GlobalValue *> *GlobalsToImport = nullptr)
  93       : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport) {
  94     // If we have a ModuleSummaryIndex but no function to import,
  95     // then this is the primary module being compiled in a ThinLTO
  96     // backend compilation, and we need to see if it has functions that
  97     // may be exported to another backend compilation.
  98     if (!GlobalsToImport)
  99       HasExportedFunctions = ImportIndex.hasExportedFunctions(M);
 100
 101 #ifndef NDEBUG
 102     // First collect those in the llvm.used set.
 103     collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
 104     // Next collect those in the llvm.compiler.used set.
 105     collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
 106 #endif
 107   }
 108
 109   bool run();
 110
 111   static bool doImportAsDefinition(const GlobalValue *SGV,
 112                                    SetVector<GlobalValue *> *GlobalsToImport);
 113 };
 114
 115 /// Perform in-place global value handling on the given Module for
 116 /// exported local functions renamed and promoted for ThinLTO.
 117 bool renameModuleForThinLTO(
 118     Module &M, const ModuleSummaryIndex &Index,
 119     SetVector<GlobalValue *> *GlobalsToImport = nullptr);
 120
 121 /// Compute synthetic function entry counts.
 122 void computeSyntheticCounts(ModuleSummaryIndex &Index);
 123
 124 } // End llvm namespace
 125
 126 #endif