1//===- lib/Transforms/Utils/FunctionImportUtils.cpp - Importing utilities -===// 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 implements the FunctionImportGlobalProcessing class, used 11// to perform the necessary global value handling for function importing. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/Analysis/ModuleSummaryAnalysis.h" 16#include "llvm/Transforms/Utils/FunctionImportUtils.h" 17#include "llvm/IR/InstIterator.h" 18#include "llvm/IR/Instructions.h" 19using namespace llvm; 20 21/// Checks if we should import SGV as a definition, otherwise import as a 22/// declaration. 23bool FunctionImportGlobalProcessing::doImportAsDefinition( 24 const GlobalValue *SGV, DenseSet<const GlobalValue *> *GlobalsToImport) { 25 26 // For alias, we tie the definition to the base object. Extract it and recurse 27 if (auto *GA = dyn_cast<GlobalAlias>(SGV)) { 28 if (GA->hasWeakAnyLinkage()) 29 return false; 30 const GlobalObject *GO = GA->getBaseObject(); 31 if (!GO->hasLinkOnceODRLinkage()) 32 return false; 33 return FunctionImportGlobalProcessing::doImportAsDefinition( 34 GO, GlobalsToImport); 35 } 36 // Only import the globals requested for importing. 37 if (GlobalsToImport->count(SGV)) 38 return true; 39 // Otherwise no. 40 return false; 41} 42 43bool FunctionImportGlobalProcessing::doImportAsDefinition( 44 const GlobalValue *SGV) { 45 if (!isPerformingImport()) 46 return false; 47 return FunctionImportGlobalProcessing::doImportAsDefinition(SGV, 48 GlobalsToImport); 49} 50 51bool FunctionImportGlobalProcessing::doPromoteLocalToGlobal( 52 const GlobalValue *SGV) { 53 assert(SGV->hasLocalLinkage()); 54 // Both the imported references and the original local variable must 55 // be promoted. 56 if (!isPerformingImport() && !isModuleExporting()) 57 return false; 58 59 // Local const variables never need to be promoted unless they are address 60 // taken. The imported uses can simply use the clone created in this module. 61 // For now we are conservative in determining which variables are not 62 // address taken by checking the unnamed addr flag. To be more aggressive, 63 // the address taken information must be checked earlier during parsing 64 // of the module and recorded in the summary index for use when importing 65 // from that module. 66 auto *GVar = dyn_cast<GlobalVariable>(SGV); 67 if (GVar && GVar->isConstant() && GVar->hasGlobalUnnamedAddr()) 68 return false; 69 70 if (GVar && GVar->hasSection()) 71 // Some sections like "__DATA,__cfstring" are "magic" and promotion is not 72 // allowed. Just disable promotion on any GVar with sections right now. 73 return false; 74 75 // Eventually we only need to promote functions in the exporting module that 76 // are referenced by a potentially exported function (i.e. one that is in the 77 // summary index). 78 return true; 79} 80 81std::string FunctionImportGlobalProcessing::getName(const GlobalValue *SGV) { 82 // For locals that must be promoted to global scope, ensure that 83 // the promoted name uniquely identifies the copy in the original module, 84 // using the ID assigned during combined index creation. When importing, 85 // we rename all locals (not just those that are promoted) in order to 86 // avoid naming conflicts between locals imported from different modules. 87 if (SGV->hasLocalLinkage() && 88 (doPromoteLocalToGlobal(SGV) || isPerformingImport())) 89 return ModuleSummaryIndex::getGlobalNameForLocal( 90 SGV->getName(), 91 ImportIndex.getModuleHash(SGV->getParent()->getModuleIdentifier())); 92 return SGV->getName(); 93} 94 95GlobalValue::LinkageTypes 96FunctionImportGlobalProcessing::getLinkage(const GlobalValue *SGV) { 97 // Any local variable that is referenced by an exported function needs 98 // to be promoted to global scope. Since we don't currently know which 99 // functions reference which local variables/functions, we must treat 100 // all as potentially exported if this module is exporting anything. 101 if (isModuleExporting()) { 102 if (SGV->hasLocalLinkage() && doPromoteLocalToGlobal(SGV)) 103 return GlobalValue::ExternalLinkage; 104 return SGV->getLinkage(); 105 } 106 107 // Otherwise, if we aren't importing, no linkage change is needed. 108 if (!isPerformingImport()) 109 return SGV->getLinkage(); 110 111 switch (SGV->getLinkage()) { 112 case GlobalValue::ExternalLinkage: 113 // External defnitions are converted to available_externally 114 // definitions upon import, so that they are available for inlining 115 // and/or optimization, but are turned into declarations later 116 // during the EliminateAvailableExternally pass. 117 if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV)) 118 return GlobalValue::AvailableExternallyLinkage; 119 // An imported external declaration stays external. 120 return SGV->getLinkage(); 121 122 case GlobalValue::AvailableExternallyLinkage: 123 // An imported available_externally definition converts 124 // to external if imported as a declaration. 125 if (!doImportAsDefinition(SGV)) 126 return GlobalValue::ExternalLinkage; 127 // An imported available_externally declaration stays that way. 128 return SGV->getLinkage(); 129 130 case GlobalValue::LinkOnceAnyLinkage: 131 case GlobalValue::LinkOnceODRLinkage: 132 // These both stay the same when importing the definition. 133 // The ThinLTO pass will eventually force-import their definitions. 134 return SGV->getLinkage(); 135 136 case GlobalValue::WeakAnyLinkage: 137 // Can't import weak_any definitions correctly, or we might change the 138 // program semantics, since the linker will pick the first weak_any 139 // definition and importing would change the order they are seen by the 140 // linker. The module linking caller needs to enforce this. 141 assert(!doImportAsDefinition(SGV)); 142 // If imported as a declaration, it becomes external_weak. 143 return SGV->getLinkage(); 144 145 case GlobalValue::WeakODRLinkage: 146 // For weak_odr linkage, there is a guarantee that all copies will be 147 // equivalent, so the issue described above for weak_any does not exist, 148 // and the definition can be imported. It can be treated similarly 149 // to an imported externally visible global value. 150 if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV)) 151 return GlobalValue::AvailableExternallyLinkage; 152 else 153 return GlobalValue::ExternalLinkage; 154 155 case GlobalValue::AppendingLinkage: 156 // It would be incorrect to import an appending linkage variable, 157 // since it would cause global constructors/destructors to be 158 // executed multiple times. This should have already been handled 159 // by linkIfNeeded, and we will assert in shouldLinkFromSource 160 // if we try to import, so we simply return AppendingLinkage. 161 return GlobalValue::AppendingLinkage; 162 163 case GlobalValue::InternalLinkage: 164 case GlobalValue::PrivateLinkage: 165 // If we are promoting the local to global scope, it is handled 166 // similarly to a normal externally visible global. 167 if (doPromoteLocalToGlobal(SGV)) { 168 if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV)) 169 return GlobalValue::AvailableExternallyLinkage; 170 else 171 return GlobalValue::ExternalLinkage; 172 } 173 // A non-promoted imported local definition stays local. 174 // The ThinLTO pass will eventually force-import their definitions. 175 return SGV->getLinkage(); 176 177 case GlobalValue::ExternalWeakLinkage: 178 // External weak doesn't apply to definitions, must be a declaration. 179 assert(!doImportAsDefinition(SGV)); 180 // Linkage stays external_weak. 181 return SGV->getLinkage(); 182 183 case GlobalValue::CommonLinkage: 184 // Linkage stays common on definitions. 185 // The ThinLTO pass will eventually force-import their definitions. 186 return SGV->getLinkage(); 187 } 188 189 llvm_unreachable("unknown linkage type"); 190} 191 192void FunctionImportGlobalProcessing::processGlobalForThinLTO(GlobalValue &GV) { 193 if (GV.hasLocalLinkage() && 194 (doPromoteLocalToGlobal(&GV) || isPerformingImport())) { 195 GV.setName(getName(&GV)); 196 GV.setLinkage(getLinkage(&GV)); 197 if (!GV.hasLocalLinkage()) 198 GV.setVisibility(GlobalValue::HiddenVisibility); 199 } else 200 GV.setLinkage(getLinkage(&GV)); 201 202 // Remove functions imported as available externally defs from comdats, 203 // as this is a declaration for the linker, and will be dropped eventually. 204 // It is illegal for comdats to contain declarations. 205 auto *GO = dyn_cast_or_null<GlobalObject>(&GV); 206 if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) { 207 // The IRMover should not have placed any imported declarations in 208 // a comdat, so the only declaration that should be in a comdat 209 // at this point would be a definition imported as available_externally. 210 assert(GO->hasAvailableExternallyLinkage() && 211 "Expected comdat on definition (possibly available external)"); 212 GO->setComdat(nullptr); 213 } 214} 215 216void FunctionImportGlobalProcessing::processGlobalsForThinLTO() { 217 if (!moduleCanBeRenamedForThinLTO(M)) { 218 // We would have blocked importing from this module by suppressing index 219 // generation. We still may be able to import into this module though. 220 assert(!isPerformingImport() && 221 "Should have blocked importing from module with local used in ASM"); 222 return; 223 } 224 225 for (GlobalVariable &GV : M.globals()) 226 processGlobalForThinLTO(GV); 227 for (Function &SF : M) 228 processGlobalForThinLTO(SF); 229 for (GlobalAlias &GA : M.aliases()) 230 processGlobalForThinLTO(GA); 231} 232 233bool FunctionImportGlobalProcessing::run() { 234 processGlobalsForThinLTO(); 235 return false; 236} 237 238bool llvm::renameModuleForThinLTO( 239 Module &M, const ModuleSummaryIndex &Index, 240 DenseSet<const GlobalValue *> *GlobalsToImport) { 241 FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport); 242 return ThinLTOProcessing.run(); 243} 244