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/Transforms/Utils/FunctionImportUtils.h" 16 #include "llvm/IR/InstIterator.h" 17 using namespace llvm; 18 19 /// Checks if we should import SGV as a definition, otherwise import as a 20 /// declaration. 21 bool FunctionImportGlobalProcessing::doImportAsDefinition( 22 const GlobalValue *SGV, SetVector<GlobalValue *> *GlobalsToImport) { 23 24 // Only import the globals requested for importing. 25 if (!GlobalsToImport->count(const_cast<GlobalValue *>(SGV))) 26 return false; 27 28 assert(!isa<GlobalAlias>(SGV) && 29 "Unexpected global alias in the import list."); 30 31 // Otherwise yes. 32 return true; 33 } 34 35 bool FunctionImportGlobalProcessing::doImportAsDefinition( 36 const GlobalValue *SGV) { 37 if (!isPerformingImport()) 38 return false; 39 return FunctionImportGlobalProcessing::doImportAsDefinition(SGV, 40 GlobalsToImport); 41 } 42 43 bool FunctionImportGlobalProcessing::shouldPromoteLocalToGlobal( 44 const GlobalValue *SGV) { 45 assert(SGV->hasLocalLinkage()); 46 // Both the imported references and the original local variable must 47 // be promoted. 48 if (!isPerformingImport() && !isModuleExporting()) 49 return false; 50 51 if (isPerformingImport()) { 52 assert((!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)) || 53 !isNonRenamableLocal(*SGV)) && 54 "Attempting to promote non-renamable local"); 55 // We don't know for sure yet if we are importing this value (as either 56 // a reference or a def), since we are simply walking all values in the 57 // module. But by necessity if we end up importing it and it is local, 58 // it must be promoted, so unconditionally promote all values in the 59 // importing module. 60 return true; 61 } 62 63 // When exporting, consult the index. We can have more than one local 64 // with the same GUID, in the case of same-named locals in different but 65 // same-named source files that were compiled in their respective directories 66 // (so the source file name and resulting GUID is the same). Find the one 67 // in this module. 68 auto Summary = ImportIndex.findSummaryInModule( 69 SGV->getGUID(), SGV->getParent()->getModuleIdentifier()); 70 assert(Summary && "Missing summary for global value when exporting"); 71 auto Linkage = Summary->linkage(); 72 if (!GlobalValue::isLocalLinkage(Linkage)) { 73 assert(!isNonRenamableLocal(*SGV) && 74 "Attempting to promote non-renamable local"); 75 return true; 76 } 77 78 return false; 79 } 80 81 #ifndef NDEBUG 82 bool FunctionImportGlobalProcessing::isNonRenamableLocal( 83 const GlobalValue &GV) const { 84 if (!GV.hasLocalLinkage()) 85 return false; 86 // This needs to stay in sync with the logic in buildModuleSummaryIndex. 87 if (GV.hasSection()) 88 return true; 89 if (Used.count(const_cast<GlobalValue *>(&GV))) 90 return true; 91 return false; 92 } 93 #endif 94 95 std::string FunctionImportGlobalProcessing::getName(const GlobalValue *SGV, 96 bool DoPromote) { 97 // For locals that must be promoted to global scope, ensure that 98 // the promoted name uniquely identifies the copy in the original module, 99 // using the ID assigned during combined index creation. When importing, 100 // we rename all locals (not just those that are promoted) in order to 101 // avoid naming conflicts between locals imported from different modules. 102 if (SGV->hasLocalLinkage() && (DoPromote || isPerformingImport())) 103 return ModuleSummaryIndex::getGlobalNameForLocal( 104 SGV->getName(), 105 ImportIndex.getModuleHash(SGV->getParent()->getModuleIdentifier())); 106 return SGV->getName(); 107 } 108 109 GlobalValue::LinkageTypes 110 FunctionImportGlobalProcessing::getLinkage(const GlobalValue *SGV, 111 bool DoPromote) { 112 // Any local variable that is referenced by an exported function needs 113 // to be promoted to global scope. Since we don't currently know which 114 // functions reference which local variables/functions, we must treat 115 // all as potentially exported if this module is exporting anything. 116 if (isModuleExporting()) { 117 if (SGV->hasLocalLinkage() && DoPromote) 118 return GlobalValue::ExternalLinkage; 119 return SGV->getLinkage(); 120 } 121 122 // Otherwise, if we aren't importing, no linkage change is needed. 123 if (!isPerformingImport()) 124 return SGV->getLinkage(); 125 126 switch (SGV->getLinkage()) { 127 case GlobalValue::LinkOnceODRLinkage: 128 case GlobalValue::ExternalLinkage: 129 // External and linkonce definitions are converted to available_externally 130 // definitions upon import, so that they are available for inlining 131 // and/or optimization, but are turned into declarations later 132 // during the EliminateAvailableExternally pass. 133 if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV)) 134 return GlobalValue::AvailableExternallyLinkage; 135 // An imported external declaration stays external. 136 return SGV->getLinkage(); 137 138 case GlobalValue::AvailableExternallyLinkage: 139 // An imported available_externally definition converts 140 // to external if imported as a declaration. 141 if (!doImportAsDefinition(SGV)) 142 return GlobalValue::ExternalLinkage; 143 // An imported available_externally declaration stays that way. 144 return SGV->getLinkage(); 145 146 case GlobalValue::LinkOnceAnyLinkage: 147 case GlobalValue::WeakAnyLinkage: 148 // Can't import linkonce_any/weak_any definitions correctly, or we might 149 // change the program semantics, since the linker will pick the first 150 // linkonce_any/weak_any definition and importing would change the order 151 // they are seen by the linker. The module linking caller needs to enforce 152 // this. 153 assert(!doImportAsDefinition(SGV)); 154 // If imported as a declaration, it becomes external_weak. 155 return SGV->getLinkage(); 156 157 case GlobalValue::WeakODRLinkage: 158 // For weak_odr linkage, there is a guarantee that all copies will be 159 // equivalent, so the issue described above for weak_any does not exist, 160 // and the definition can be imported. It can be treated similarly 161 // to an imported externally visible global value. 162 if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV)) 163 return GlobalValue::AvailableExternallyLinkage; 164 else 165 return GlobalValue::ExternalLinkage; 166 167 case GlobalValue::AppendingLinkage: 168 // It would be incorrect to import an appending linkage variable, 169 // since it would cause global constructors/destructors to be 170 // executed multiple times. This should have already been handled 171 // by linkIfNeeded, and we will assert in shouldLinkFromSource 172 // if we try to import, so we simply return AppendingLinkage. 173 return GlobalValue::AppendingLinkage; 174 175 case GlobalValue::InternalLinkage: 176 case GlobalValue::PrivateLinkage: 177 // If we are promoting the local to global scope, it is handled 178 // similarly to a normal externally visible global. 179 if (DoPromote) { 180 if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV)) 181 return GlobalValue::AvailableExternallyLinkage; 182 else 183 return GlobalValue::ExternalLinkage; 184 } 185 // A non-promoted imported local definition stays local. 186 // The ThinLTO pass will eventually force-import their definitions. 187 return SGV->getLinkage(); 188 189 case GlobalValue::ExternalWeakLinkage: 190 // External weak doesn't apply to definitions, must be a declaration. 191 assert(!doImportAsDefinition(SGV)); 192 // Linkage stays external_weak. 193 return SGV->getLinkage(); 194 195 case GlobalValue::CommonLinkage: 196 // Linkage stays common on definitions. 197 // The ThinLTO pass will eventually force-import their definitions. 198 return SGV->getLinkage(); 199 } 200 201 llvm_unreachable("unknown linkage type"); 202 } 203 204 void FunctionImportGlobalProcessing::processGlobalForThinLTO(GlobalValue &GV) { 205 206 ValueInfo VI; 207 if (GV.hasName()) { 208 VI = ImportIndex.getValueInfo(GV.getGUID()); 209 // Set synthetic function entry counts. 210 if (VI && ImportIndex.hasSyntheticEntryCounts()) { 211 if (Function *F = dyn_cast<Function>(&GV)) { 212 if (!F->isDeclaration()) { 213 for (auto &S : VI.getSummaryList()) { 214 FunctionSummary *FS = dyn_cast<FunctionSummary>(S->getBaseObject()); 215 if (FS->modulePath() == M.getModuleIdentifier()) { 216 F->setEntryCount(Function::ProfileCount(FS->entryCount(), 217 Function::PCT_Synthetic)); 218 break; 219 } 220 } 221 } 222 } 223 } 224 // Check the summaries to see if the symbol gets resolved to a known local 225 // definition. 226 if (VI && VI.isDSOLocal()) { 227 GV.setDSOLocal(true); 228 if (GV.hasDLLImportStorageClass()) 229 GV.setDLLStorageClass(GlobalValue::DefaultStorageClass); 230 } 231 } 232 233 // Mark read-only variables which can be imported with specific attribute. 234 // We can't internalize them now because IRMover will fail to link variable 235 // definitions to their external declarations during ThinLTO import. We'll 236 // internalize read-only variables later, after import is finished. 237 // See internalizeImmutableGVs. 238 // 239 // If global value dead stripping is not enabled in summary then 240 // propagateConstants hasn't been run. We can't internalize GV 241 // in such case. 242 if (!GV.isDeclaration() && VI && ImportIndex.withGlobalValueDeadStripping()) { 243 const auto &SL = VI.getSummaryList(); 244 auto *GVS = SL.empty() ? nullptr : dyn_cast<GlobalVarSummary>(SL[0].get()); 245 if (GVS && GVS->isReadOnly()) 246 cast<GlobalVariable>(&GV)->addAttribute("thinlto-internalize"); 247 } 248 249 bool DoPromote = false; 250 if (GV.hasLocalLinkage() && 251 ((DoPromote = shouldPromoteLocalToGlobal(&GV)) || isPerformingImport())) { 252 // Save the original name string before we rename GV below. 253 auto Name = GV.getName().str(); 254 // Once we change the name or linkage it is difficult to determine 255 // again whether we should promote since shouldPromoteLocalToGlobal needs 256 // to locate the summary (based on GUID from name and linkage). Therefore, 257 // use DoPromote result saved above. 258 GV.setName(getName(&GV, DoPromote)); 259 GV.setLinkage(getLinkage(&GV, DoPromote)); 260 if (!GV.hasLocalLinkage()) 261 GV.setVisibility(GlobalValue::HiddenVisibility); 262 263 // If we are renaming a COMDAT leader, ensure that we record the COMDAT 264 // for later renaming as well. This is required for COFF. 265 if (const auto *C = GV.getComdat()) 266 if (C->getName() == Name) 267 RenamedComdats.try_emplace(C, M.getOrInsertComdat(GV.getName())); 268 } else 269 GV.setLinkage(getLinkage(&GV, /* DoPromote */ false)); 270 271 // Remove functions imported as available externally defs from comdats, 272 // as this is a declaration for the linker, and will be dropped eventually. 273 // It is illegal for comdats to contain declarations. 274 auto *GO = dyn_cast<GlobalObject>(&GV); 275 if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) { 276 // The IRMover should not have placed any imported declarations in 277 // a comdat, so the only declaration that should be in a comdat 278 // at this point would be a definition imported as available_externally. 279 assert(GO->hasAvailableExternallyLinkage() && 280 "Expected comdat on definition (possibly available external)"); 281 GO->setComdat(nullptr); 282 } 283 } 284 285 void FunctionImportGlobalProcessing::processGlobalsForThinLTO() { 286 for (GlobalVariable &GV : M.globals()) 287 processGlobalForThinLTO(GV); 288 for (Function &SF : M) 289 processGlobalForThinLTO(SF); 290 for (GlobalAlias &GA : M.aliases()) 291 processGlobalForThinLTO(GA); 292 293 // Replace any COMDATS that required renaming (because the COMDAT leader was 294 // promoted and renamed). 295 if (!RenamedComdats.empty()) 296 for (auto &GO : M.global_objects()) 297 if (auto *C = GO.getComdat()) { 298 auto Replacement = RenamedComdats.find(C); 299 if (Replacement != RenamedComdats.end()) 300 GO.setComdat(Replacement->second); 301 } 302 } 303 304 bool FunctionImportGlobalProcessing::run() { 305 processGlobalsForThinLTO(); 306 return false; 307 } 308 309 bool llvm::renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, 310 SetVector<GlobalValue *> *GlobalsToImport) { 311 FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport); 312 return ThinLTOProcessing.run(); 313 } 314