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