1 //===-LTOCodeGenerator.cpp - LLVM Link Time Optimizer ---------------------===// 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 Link Time Optimization library. This library is 11 // intended to be used by linker to optimize code at link time. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "LTOCodeGenerator.h" 16 #include "LTOModule.h" 17 #include "llvm/ADT/StringExtras.h" 18 #include "llvm/Analysis/Passes.h" 19 #include "llvm/Analysis/Verifier.h" 20 #include "llvm/Bitcode/ReaderWriter.h" 21 #include "llvm/Config/config.h" 22 #include "llvm/IR/Constants.h" 23 #include "llvm/IR/DataLayout.h" 24 #include "llvm/IR/DerivedTypes.h" 25 #include "llvm/IR/LLVMContext.h" 26 #include "llvm/IR/Module.h" 27 #include "llvm/Linker.h" 28 #include "llvm/MC/MCAsmInfo.h" 29 #include "llvm/MC/MCContext.h" 30 #include "llvm/MC/SubtargetFeature.h" 31 #include "llvm/PassManager.h" 32 #include "llvm/Support/CommandLine.h" 33 #include "llvm/Support/FormattedStream.h" 34 #include "llvm/Support/Host.h" 35 #include "llvm/Support/MemoryBuffer.h" 36 #include "llvm/Support/Signals.h" 37 #include "llvm/Support/TargetRegistry.h" 38 #include "llvm/Support/TargetSelect.h" 39 #include "llvm/Support/ToolOutputFile.h" 40 #include "llvm/Support/system_error.h" 41 #include "llvm/Target/Mangler.h" 42 #include "llvm/Target/TargetMachine.h" 43 #include "llvm/Target/TargetOptions.h" 44 #include "llvm/Target/TargetRegisterInfo.h" 45 #include "llvm/Transforms/IPO.h" 46 #include "llvm/Transforms/IPO/PassManagerBuilder.h" 47 using namespace llvm; 48 49 static cl::opt<bool> 50 DisableOpt("disable-opt", cl::init(false), 51 cl::desc("Do not run any optimization passes")); 52 53 static cl::opt<bool> 54 DisableInline("disable-inlining", cl::init(false), 55 cl::desc("Do not run the inliner pass")); 56 57 static cl::opt<bool> 58 DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false), 59 cl::desc("Do not run the GVN load PRE pass")); 60 61 const char* LTOCodeGenerator::getVersionString() { 62 #ifdef LLVM_VERSION_INFO 63 return PACKAGE_NAME " version " PACKAGE_VERSION ", " LLVM_VERSION_INFO; 64 #else 65 return PACKAGE_NAME " version " PACKAGE_VERSION; 66 #endif 67 } 68 69 LTOCodeGenerator::LTOCodeGenerator() 70 : _context(getGlobalContext()), 71 _linker("LinkTimeOptimizer", "ld-temp.o", _context), _target(NULL), 72 _emitDwarfDebugInfo(false), _scopeRestrictionsDone(false), 73 _codeModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC), 74 _nativeObjectFile(NULL) { 75 InitializeAllTargets(); 76 InitializeAllTargetMCs(); 77 InitializeAllAsmPrinters(); 78 } 79 80 LTOCodeGenerator::~LTOCodeGenerator() { 81 delete _target; 82 delete _nativeObjectFile; 83 84 for (std::vector<char*>::iterator I = _codegenOptions.begin(), 85 E = _codegenOptions.end(); I != E; ++I) 86 free(*I); 87 } 88 89 bool LTOCodeGenerator::addModule(LTOModule* mod, std::string& errMsg) { 90 bool ret = _linker.LinkInModule(mod->getLLVVMModule(), &errMsg); 91 92 const std::vector<const char*> &undefs = mod->getAsmUndefinedRefs(); 93 for (int i = 0, e = undefs.size(); i != e; ++i) 94 _asmUndefinedRefs[undefs[i]] = 1; 95 96 return ret; 97 } 98 99 bool LTOCodeGenerator::setDebugInfo(lto_debug_model debug, 100 std::string& errMsg) { 101 switch (debug) { 102 case LTO_DEBUG_MODEL_NONE: 103 _emitDwarfDebugInfo = false; 104 return false; 105 106 case LTO_DEBUG_MODEL_DWARF: 107 _emitDwarfDebugInfo = true; 108 return false; 109 } 110 llvm_unreachable("Unknown debug format!"); 111 } 112 113 bool LTOCodeGenerator::setCodePICModel(lto_codegen_model model, 114 std::string& errMsg) { 115 switch (model) { 116 case LTO_CODEGEN_PIC_MODEL_STATIC: 117 case LTO_CODEGEN_PIC_MODEL_DYNAMIC: 118 case LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC: 119 _codeModel = model; 120 return false; 121 } 122 llvm_unreachable("Unknown PIC model!"); 123 } 124 125 bool LTOCodeGenerator::writeMergedModules(const char *path, 126 std::string &errMsg) { 127 if (determineTarget(errMsg)) 128 return true; 129 130 // mark which symbols can not be internalized 131 applyScopeRestrictions(); 132 133 // create output file 134 std::string ErrInfo; 135 tool_output_file Out(path, ErrInfo, 136 raw_fd_ostream::F_Binary); 137 if (!ErrInfo.empty()) { 138 errMsg = "could not open bitcode file for writing: "; 139 errMsg += path; 140 return true; 141 } 142 143 // write bitcode to it 144 WriteBitcodeToFile(_linker.getModule(), Out.os()); 145 Out.os().close(); 146 147 if (Out.os().has_error()) { 148 errMsg = "could not write bitcode file: "; 149 errMsg += path; 150 Out.os().clear_error(); 151 return true; 152 } 153 154 Out.keep(); 155 return false; 156 } 157 158 bool LTOCodeGenerator::compile_to_file(const char** name, std::string& errMsg) { 159 // make unique temp .o file to put generated object file 160 sys::PathWithStatus uniqueObjPath("lto-llvm.o"); 161 if (uniqueObjPath.createTemporaryFileOnDisk(false, &errMsg)) { 162 uniqueObjPath.eraseFromDisk(); 163 return true; 164 } 165 sys::RemoveFileOnSignal(uniqueObjPath); 166 167 // generate object file 168 bool genResult = false; 169 tool_output_file objFile(uniqueObjPath.c_str(), errMsg); 170 if (!errMsg.empty()) { 171 uniqueObjPath.eraseFromDisk(); 172 return true; 173 } 174 175 genResult = this->generateObjectFile(objFile.os(), errMsg); 176 objFile.os().close(); 177 if (objFile.os().has_error()) { 178 objFile.os().clear_error(); 179 uniqueObjPath.eraseFromDisk(); 180 return true; 181 } 182 183 objFile.keep(); 184 if (genResult) { 185 uniqueObjPath.eraseFromDisk(); 186 return true; 187 } 188 189 _nativeObjectPath = uniqueObjPath.str(); 190 *name = _nativeObjectPath.c_str(); 191 return false; 192 } 193 194 const void* LTOCodeGenerator::compile(size_t* length, std::string& errMsg) { 195 const char *name; 196 if (compile_to_file(&name, errMsg)) 197 return NULL; 198 199 // remove old buffer if compile() called twice 200 delete _nativeObjectFile; 201 202 // read .o file into memory buffer 203 OwningPtr<MemoryBuffer> BuffPtr; 204 if (error_code ec = MemoryBuffer::getFile(name, BuffPtr, -1, false)) { 205 errMsg = ec.message(); 206 sys::Path(_nativeObjectPath).eraseFromDisk(); 207 return NULL; 208 } 209 _nativeObjectFile = BuffPtr.take(); 210 211 // remove temp files 212 sys::Path(_nativeObjectPath).eraseFromDisk(); 213 214 // return buffer, unless error 215 if (_nativeObjectFile == NULL) 216 return NULL; 217 *length = _nativeObjectFile->getBufferSize(); 218 return _nativeObjectFile->getBufferStart(); 219 } 220 221 bool LTOCodeGenerator::determineTarget(std::string& errMsg) { 222 if (_target != NULL) 223 return false; 224 225 std::string TripleStr = _linker.getModule()->getTargetTriple(); 226 if (TripleStr.empty()) 227 TripleStr = sys::getDefaultTargetTriple(); 228 llvm::Triple Triple(TripleStr); 229 230 // create target machine from info for merged modules 231 const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); 232 if (march == NULL) 233 return true; 234 235 // The relocation model is actually a static member of TargetMachine and 236 // needs to be set before the TargetMachine is instantiated. 237 Reloc::Model RelocModel = Reloc::Default; 238 switch (_codeModel) { 239 case LTO_CODEGEN_PIC_MODEL_STATIC: 240 RelocModel = Reloc::Static; 241 break; 242 case LTO_CODEGEN_PIC_MODEL_DYNAMIC: 243 RelocModel = Reloc::PIC_; 244 break; 245 case LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC: 246 RelocModel = Reloc::DynamicNoPIC; 247 break; 248 } 249 250 // construct LTOModule, hand over ownership of module and target 251 SubtargetFeatures Features; 252 Features.getDefaultSubtargetFeatures(Triple); 253 std::string FeatureStr = Features.getString(); 254 // Set a default CPU for Darwin triples. 255 if (_mCpu.empty() && Triple.isOSDarwin()) { 256 if (Triple.getArch() == llvm::Triple::x86_64) 257 _mCpu = "core2"; 258 else if (Triple.getArch() == llvm::Triple::x86) 259 _mCpu = "yonah"; 260 } 261 TargetOptions Options; 262 LTOModule::getTargetOptions(Options); 263 _target = march->createTargetMachine(TripleStr, _mCpu, FeatureStr, Options, 264 RelocModel, CodeModel::Default, 265 CodeGenOpt::Aggressive); 266 return false; 267 } 268 269 void LTOCodeGenerator:: 270 applyRestriction(GlobalValue &GV, 271 std::vector<const char*> &mustPreserveList, 272 SmallPtrSet<GlobalValue*, 8> &asmUsed, 273 Mangler &mangler) { 274 SmallString<64> Buffer; 275 mangler.getNameWithPrefix(Buffer, &GV, false); 276 277 if (GV.isDeclaration()) 278 return; 279 if (_mustPreserveSymbols.count(Buffer)) 280 mustPreserveList.push_back(GV.getName().data()); 281 if (_asmUndefinedRefs.count(Buffer)) 282 asmUsed.insert(&GV); 283 } 284 285 static void findUsedValues(GlobalVariable *LLVMUsed, 286 SmallPtrSet<GlobalValue*, 8> &UsedValues) { 287 if (LLVMUsed == 0) return; 288 289 ConstantArray *Inits = dyn_cast<ConstantArray>(LLVMUsed->getInitializer()); 290 if (Inits == 0) return; 291 292 for (unsigned i = 0, e = Inits->getNumOperands(); i != e; ++i) 293 if (GlobalValue *GV = 294 dyn_cast<GlobalValue>(Inits->getOperand(i)->stripPointerCasts())) 295 UsedValues.insert(GV); 296 } 297 298 void LTOCodeGenerator::applyScopeRestrictions() { 299 if (_scopeRestrictionsDone) return; 300 Module *mergedModule = _linker.getModule(); 301 302 // Start off with a verification pass. 303 PassManager passes; 304 passes.add(createVerifierPass()); 305 306 // mark which symbols can not be internalized 307 MCContext Context(*_target->getMCAsmInfo(), *_target->getRegisterInfo(),NULL); 308 Mangler mangler(Context, *_target->getDataLayout()); 309 std::vector<const char*> mustPreserveList; 310 SmallPtrSet<GlobalValue*, 8> asmUsed; 311 312 for (Module::iterator f = mergedModule->begin(), 313 e = mergedModule->end(); f != e; ++f) 314 applyRestriction(*f, mustPreserveList, asmUsed, mangler); 315 for (Module::global_iterator v = mergedModule->global_begin(), 316 e = mergedModule->global_end(); v != e; ++v) 317 applyRestriction(*v, mustPreserveList, asmUsed, mangler); 318 for (Module::alias_iterator a = mergedModule->alias_begin(), 319 e = mergedModule->alias_end(); a != e; ++a) 320 applyRestriction(*a, mustPreserveList, asmUsed, mangler); 321 322 GlobalVariable *LLVMCompilerUsed = 323 mergedModule->getGlobalVariable("llvm.compiler.used"); 324 findUsedValues(LLVMCompilerUsed, asmUsed); 325 if (LLVMCompilerUsed) 326 LLVMCompilerUsed->eraseFromParent(); 327 328 llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(_context); 329 std::vector<Constant*> asmUsed2; 330 for (SmallPtrSet<GlobalValue*, 16>::const_iterator i = asmUsed.begin(), 331 e = asmUsed.end(); i !=e; ++i) { 332 GlobalValue *GV = *i; 333 Constant *c = ConstantExpr::getBitCast(GV, i8PTy); 334 asmUsed2.push_back(c); 335 } 336 337 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, asmUsed2.size()); 338 LLVMCompilerUsed = 339 new llvm::GlobalVariable(*mergedModule, ATy, false, 340 llvm::GlobalValue::AppendingLinkage, 341 llvm::ConstantArray::get(ATy, asmUsed2), 342 "llvm.compiler.used"); 343 344 LLVMCompilerUsed->setSection("llvm.metadata"); 345 346 passes.add(createInternalizePass(mustPreserveList)); 347 348 // apply scope restrictions 349 passes.run(*mergedModule); 350 351 _scopeRestrictionsDone = true; 352 } 353 354 /// Optimize merged modules using various IPO passes 355 bool LTOCodeGenerator::generateObjectFile(raw_ostream &out, 356 std::string &errMsg) { 357 if (this->determineTarget(errMsg)) 358 return true; 359 360 Module* mergedModule = _linker.getModule(); 361 362 // if options were requested, set them 363 if (!_codegenOptions.empty()) 364 cl::ParseCommandLineOptions(_codegenOptions.size(), 365 const_cast<char **>(&_codegenOptions[0])); 366 367 // mark which symbols can not be internalized 368 this->applyScopeRestrictions(); 369 370 // Instantiate the pass manager to organize the passes. 371 PassManager passes; 372 373 // Start off with a verification pass. 374 passes.add(createVerifierPass()); 375 376 // Add an appropriate DataLayout instance for this module... 377 passes.add(new DataLayout(*_target->getDataLayout())); 378 _target->addAnalysisPasses(passes); 379 380 // Enabling internalize here would use its AllButMain variant. It 381 // keeps only main if it exists and does nothing for libraries. Instead 382 // we create the pass ourselves with the symbol list provided by the linker. 383 if (!DisableOpt) { 384 PassManagerBuilder().populateLTOPassManager(passes, 385 /*Internalize=*/false, 386 !DisableInline, 387 DisableGVNLoadPRE); 388 } 389 390 // Make sure everything is still good. 391 passes.add(createVerifierPass()); 392 393 PassManager codeGenPasses; 394 395 codeGenPasses.add(new DataLayout(*_target->getDataLayout())); 396 _target->addAnalysisPasses(codeGenPasses); 397 398 formatted_raw_ostream Out(out); 399 400 if (_target->addPassesToEmitFile(codeGenPasses, Out, 401 TargetMachine::CGFT_ObjectFile)) { 402 errMsg = "target file type not supported"; 403 return true; 404 } 405 406 // Run our queue of passes all at once now, efficiently. 407 passes.run(*mergedModule); 408 409 // Run the code generator, and write assembly file 410 codeGenPasses.run(*mergedModule); 411 412 return false; // success 413 } 414 415 /// setCodeGenDebugOptions - Set codegen debugging options to aid in debugging 416 /// LTO problems. 417 void LTOCodeGenerator::setCodeGenDebugOptions(const char *options) { 418 for (std::pair<StringRef, StringRef> o = getToken(options); 419 !o.first.empty(); o = getToken(o.second)) { 420 // ParseCommandLineOptions() expects argv[0] to be program name. Lazily add 421 // that. 422 if (_codegenOptions.empty()) 423 _codegenOptions.push_back(strdup("libLTO")); 424 _codegenOptions.push_back(strdup(o.first.str().c_str())); 425 } 426 } 427