BackendUtil.cpp revision 9875962295022661213153127eae961250fefd55
1//===--- BackendUtil.cpp - LLVM Backend 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#include "clang/CodeGen/BackendUtil.h" 11#include "clang/Basic/Diagnostic.h" 12#include "clang/Basic/TargetOptions.h" 13#include "clang/Basic/LangOptions.h" 14#include "clang/Frontend/CodeGenOptions.h" 15#include "clang/Frontend/FrontendDiagnostic.h" 16#include "llvm/Module.h" 17#include "llvm/PassManager.h" 18#include "llvm/Analysis/Verifier.h" 19#include "llvm/Assembly/PrintModulePass.h" 20#include "llvm/Bitcode/ReaderWriter.h" 21#include "llvm/CodeGen/RegAllocRegistry.h" 22#include "llvm/CodeGen/SchedulerRegistry.h" 23#include "llvm/MC/SubtargetFeature.h" 24#include "llvm/Support/CommandLine.h" 25#include "llvm/Support/FormattedStream.h" 26#include "llvm/Support/PrettyStackTrace.h" 27#include "llvm/Support/TargetRegistry.h" 28#include "llvm/Support/Timer.h" 29#include "llvm/Support/raw_ostream.h" 30#include "llvm/Target/TargetData.h" 31#include "llvm/Target/TargetLibraryInfo.h" 32#include "llvm/Target/TargetMachine.h" 33#include "llvm/Target/TargetOptions.h" 34#include "llvm/Transforms/Instrumentation.h" 35#include "llvm/Transforms/IPO.h" 36#include "llvm/Transforms/IPO/PassManagerBuilder.h" 37#include "llvm/Transforms/Scalar.h" 38using namespace clang; 39using namespace llvm; 40 41namespace { 42 43class EmitAssemblyHelper { 44 DiagnosticsEngine &Diags; 45 const CodeGenOptions &CodeGenOpts; 46 const clang::TargetOptions &TargetOpts; 47 const LangOptions &LangOpts; 48 Module *TheModule; 49 50 Timer CodeGenerationTime; 51 52 mutable PassManager *CodeGenPasses; 53 mutable PassManager *PerModulePasses; 54 mutable FunctionPassManager *PerFunctionPasses; 55 56private: 57 PassManager *getCodeGenPasses() const { 58 if (!CodeGenPasses) { 59 CodeGenPasses = new PassManager(); 60 CodeGenPasses->add(new TargetData(TheModule)); 61 } 62 return CodeGenPasses; 63 } 64 65 PassManager *getPerModulePasses() const { 66 if (!PerModulePasses) { 67 PerModulePasses = new PassManager(); 68 PerModulePasses->add(new TargetData(TheModule)); 69 } 70 return PerModulePasses; 71 } 72 73 FunctionPassManager *getPerFunctionPasses() const { 74 if (!PerFunctionPasses) { 75 PerFunctionPasses = new FunctionPassManager(TheModule); 76 PerFunctionPasses->add(new TargetData(TheModule)); 77 } 78 return PerFunctionPasses; 79 } 80 81 void CreatePasses(); 82 83 /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR. 84 /// 85 /// \return True on success. 86 bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS); 87 88public: 89 EmitAssemblyHelper(DiagnosticsEngine &_Diags, 90 const CodeGenOptions &CGOpts, 91 const clang::TargetOptions &TOpts, 92 const LangOptions &LOpts, 93 Module *M) 94 : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts), 95 TheModule(M), CodeGenerationTime("Code Generation Time"), 96 CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {} 97 98 ~EmitAssemblyHelper() { 99 delete CodeGenPasses; 100 delete PerModulePasses; 101 delete PerFunctionPasses; 102 } 103 104 void EmitAssembly(BackendAction Action, raw_ostream *OS); 105}; 106 107} 108 109static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) { 110 if (Builder.OptLevel > 0) 111 PM.add(createObjCARCAPElimPass()); 112} 113 114static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) { 115 if (Builder.OptLevel > 0) 116 PM.add(createObjCARCExpandPass()); 117} 118 119static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) { 120 if (Builder.OptLevel > 0) 121 PM.add(createObjCARCOptPass()); 122} 123 124static void addAddressSanitizerPass(const PassManagerBuilder &Builder, 125 PassManagerBase &PM) { 126 PM.add(createAddressSanitizerPass()); 127} 128 129void EmitAssemblyHelper::CreatePasses() { 130 unsigned OptLevel = CodeGenOpts.OptimizationLevel; 131 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining; 132 133 // Handle disabling of LLVM optimization, where we want to preserve the 134 // internal module before any optimization. 135 if (CodeGenOpts.DisableLLVMOpts) { 136 OptLevel = 0; 137 Inlining = CodeGenOpts.NoInlining; 138 } 139 140 PassManagerBuilder PMBuilder; 141 PMBuilder.OptLevel = OptLevel; 142 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize; 143 144 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls; 145 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime; 146 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops; 147 148 // In ObjC ARC mode, add the main ARC optimization passes. 149 if (LangOpts.ObjCAutoRefCount) { 150 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible, 151 addObjCARCExpandPass); 152 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly, 153 addObjCARCAPElimPass); 154 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate, 155 addObjCARCOptPass); 156 } 157 158 if (LangOpts.AddressSanitizer) { 159 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate, 160 addAddressSanitizerPass); 161 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0, 162 addAddressSanitizerPass); 163 } 164 165 // Figure out TargetLibraryInfo. 166 Triple TargetTriple(TheModule->getTargetTriple()); 167 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple); 168 if (!CodeGenOpts.SimplifyLibCalls) 169 PMBuilder.LibraryInfo->disableAllFunctions(); 170 171 switch (Inlining) { 172 case CodeGenOptions::NoInlining: break; 173 case CodeGenOptions::NormalInlining: { 174 // FIXME: Derive these constants in a principled fashion. 175 unsigned Threshold = 225; 176 if (CodeGenOpts.OptimizeSize == 1) // -Os 177 Threshold = 75; 178 else if (CodeGenOpts.OptimizeSize == 2) // -Oz 179 Threshold = 25; 180 else if (OptLevel > 2) 181 Threshold = 275; 182 PMBuilder.Inliner = createFunctionInliningPass(Threshold); 183 break; 184 } 185 case CodeGenOptions::OnlyAlwaysInlining: 186 // Respect always_inline. 187 if (OptLevel == 0) 188 // Do not insert lifetime intrinsics at -O0. 189 PMBuilder.Inliner = createAlwaysInlinerPass(false); 190 else 191 PMBuilder.Inliner = createAlwaysInlinerPass(); 192 break; 193 } 194 195 196 // Set up the per-function pass manager. 197 FunctionPassManager *FPM = getPerFunctionPasses(); 198 if (CodeGenOpts.VerifyModule) 199 FPM->add(createVerifierPass()); 200 PMBuilder.populateFunctionPassManager(*FPM); 201 202 // Set up the per-module pass manager. 203 PassManager *MPM = getPerModulePasses(); 204 205 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) { 206 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes, 207 CodeGenOpts.EmitGcovArcs, 208 TargetTriple.isMacOSX())); 209 210 if (!CodeGenOpts.DebugInfo) 211 MPM->add(createStripSymbolsPass(true)); 212 } 213 214 215 PMBuilder.populateModulePassManager(*MPM); 216} 217 218bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action, 219 formatted_raw_ostream &OS) { 220 // Create the TargetMachine for generating code. 221 std::string Error; 222 std::string Triple = TheModule->getTargetTriple(); 223 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error); 224 if (!TheTarget) { 225 Diags.Report(diag::err_fe_unable_to_create_target) << Error; 226 return false; 227 } 228 229 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just 230 // being gross, this is also totally broken if we ever care about 231 // concurrency. 232 233 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose); 234 235 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections); 236 TargetMachine::setDataSections (CodeGenOpts.DataSections); 237 238 // FIXME: Parse this earlier. 239 llvm::CodeModel::Model CM; 240 if (CodeGenOpts.CodeModel == "small") { 241 CM = llvm::CodeModel::Small; 242 } else if (CodeGenOpts.CodeModel == "kernel") { 243 CM = llvm::CodeModel::Kernel; 244 } else if (CodeGenOpts.CodeModel == "medium") { 245 CM = llvm::CodeModel::Medium; 246 } else if (CodeGenOpts.CodeModel == "large") { 247 CM = llvm::CodeModel::Large; 248 } else { 249 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!"); 250 CM = llvm::CodeModel::Default; 251 } 252 253 SmallVector<const char *, 16> BackendArgs; 254 BackendArgs.push_back("clang"); // Fake program name. 255 if (!CodeGenOpts.DebugPass.empty()) { 256 BackendArgs.push_back("-debug-pass"); 257 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str()); 258 } 259 if (!CodeGenOpts.LimitFloatPrecision.empty()) { 260 BackendArgs.push_back("-limit-float-precision"); 261 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str()); 262 } 263 if (llvm::TimePassesIsEnabled) 264 BackendArgs.push_back("-time-passes"); 265 for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i) 266 BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str()); 267 if (CodeGenOpts.NoGlobalMerge) 268 BackendArgs.push_back("-global-merge=false"); 269 BackendArgs.push_back(0); 270 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1, 271 BackendArgs.data()); 272 273 std::string FeaturesStr; 274 if (TargetOpts.Features.size()) { 275 SubtargetFeatures Features; 276 for (std::vector<std::string>::const_iterator 277 it = TargetOpts.Features.begin(), 278 ie = TargetOpts.Features.end(); it != ie; ++it) 279 Features.AddFeature(*it); 280 FeaturesStr = Features.getString(); 281 } 282 283 llvm::Reloc::Model RM = llvm::Reloc::Default; 284 if (CodeGenOpts.RelocationModel == "static") { 285 RM = llvm::Reloc::Static; 286 } else if (CodeGenOpts.RelocationModel == "pic") { 287 RM = llvm::Reloc::PIC_; 288 } else { 289 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" && 290 "Invalid PIC model!"); 291 RM = llvm::Reloc::DynamicNoPIC; 292 } 293 294 CodeGenOpt::Level OptLevel = CodeGenOpt::Default; 295 switch (CodeGenOpts.OptimizationLevel) { 296 default: break; 297 case 0: OptLevel = CodeGenOpt::None; break; 298 case 3: OptLevel = CodeGenOpt::Aggressive; break; 299 } 300 301 llvm::TargetOptions Options; 302 303 // Set frame pointer elimination mode. 304 if (!CodeGenOpts.DisableFPElim) { 305 Options.NoFramePointerElim = false; 306 Options.NoFramePointerElimNonLeaf = false; 307 } else if (CodeGenOpts.OmitLeafFramePointer) { 308 Options.NoFramePointerElim = false; 309 Options.NoFramePointerElimNonLeaf = true; 310 } else { 311 Options.NoFramePointerElim = true; 312 Options.NoFramePointerElimNonLeaf = true; 313 } 314 315 // Set float ABI type. 316 if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp") 317 Options.FloatABIType = llvm::FloatABI::Soft; 318 else if (CodeGenOpts.FloatABI == "hard") 319 Options.FloatABIType = llvm::FloatABI::Hard; 320 else { 321 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!"); 322 Options.FloatABIType = llvm::FloatABI::Default; 323 } 324 325 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD; 326 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath; 327 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath; 328 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS; 329 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath; 330 Options.UseSoftFloat = CodeGenOpts.SoftFloat; 331 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment; 332 Options.RealignStack = CodeGenOpts.StackRealignment; 333 Options.DisableTailCalls = CodeGenOpts.DisableTailCalls; 334 Options.TrapFuncName = CodeGenOpts.TrapFuncName; 335 336 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU, 337 FeaturesStr, Options, 338 RM, CM, OptLevel); 339 340 if (CodeGenOpts.RelaxAll) 341 TM->setMCRelaxAll(true); 342 if (CodeGenOpts.SaveTempLabels) 343 TM->setMCSaveTempLabels(true); 344 if (CodeGenOpts.NoDwarf2CFIAsm) 345 TM->setMCUseCFI(false); 346 if (!CodeGenOpts.NoDwarfDirectoryAsm) 347 TM->setMCUseDwarfDirectory(true); 348 if (CodeGenOpts.NoExecStack) 349 TM->setMCNoExecStack(true); 350 351 // Create the code generator passes. 352 PassManager *PM = getCodeGenPasses(); 353 354 // Normal mode, emit a .s or .o file by running the code generator. Note, 355 // this also adds codegenerator level optimization passes. 356 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile; 357 if (Action == Backend_EmitObj) 358 CGFT = TargetMachine::CGFT_ObjectFile; 359 else if (Action == Backend_EmitMCNull) 360 CGFT = TargetMachine::CGFT_Null; 361 else 362 assert(Action == Backend_EmitAssembly && "Invalid action!"); 363 364 // Add ObjC ARC final-cleanup optimizations. This is done as part of the 365 // "codegen" passes so that it isn't run multiple times when there is 366 // inlining happening. 367 if (LangOpts.ObjCAutoRefCount) 368 PM->add(createObjCARCContractPass()); 369 370 if (TM->addPassesToEmitFile(*PM, OS, CGFT, 371 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) { 372 Diags.Report(diag::err_fe_unable_to_interface_with_target); 373 return false; 374 } 375 376 return true; 377} 378 379void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) { 380 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0); 381 llvm::formatted_raw_ostream FormattedOS; 382 383 CreatePasses(); 384 switch (Action) { 385 case Backend_EmitNothing: 386 break; 387 388 case Backend_EmitBC: 389 getPerModulePasses()->add(createBitcodeWriterPass(*OS)); 390 break; 391 392 case Backend_EmitLL: 393 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM); 394 getPerModulePasses()->add(createPrintModulePass(&FormattedOS)); 395 break; 396 397 default: 398 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM); 399 if (!AddEmitPasses(Action, FormattedOS)) 400 return; 401 } 402 403 // Before executing passes, print the final values of the LLVM options. 404 cl::PrintOptionValues(); 405 406 // Run passes. For now we do all passes at once, but eventually we 407 // would like to have the option of streaming code generation. 408 409 if (PerFunctionPasses) { 410 PrettyStackTraceString CrashInfo("Per-function optimization"); 411 412 PerFunctionPasses->doInitialization(); 413 for (Module::iterator I = TheModule->begin(), 414 E = TheModule->end(); I != E; ++I) 415 if (!I->isDeclaration()) 416 PerFunctionPasses->run(*I); 417 PerFunctionPasses->doFinalization(); 418 } 419 420 if (PerModulePasses) { 421 PrettyStackTraceString CrashInfo("Per-module optimization passes"); 422 PerModulePasses->run(*TheModule); 423 } 424 425 if (CodeGenPasses) { 426 PrettyStackTraceString CrashInfo("Code generation"); 427 CodeGenPasses->run(*TheModule); 428 } 429} 430 431void clang::EmitBackendOutput(DiagnosticsEngine &Diags, 432 const CodeGenOptions &CGOpts, 433 const clang::TargetOptions &TOpts, 434 const LangOptions &LOpts, 435 Module *M, 436 BackendAction Action, raw_ostream *OS) { 437 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M); 438 439 AsmHelper.EmitAssembly(Action, OS); 440} 441