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 129static void addThreadSanitizerPass(const PassManagerBuilder &Builder, 130 PassManagerBase &PM) { 131 PM.add(createThreadSanitizerPass()); 132} 133 134void EmitAssemblyHelper::CreatePasses() { 135 unsigned OptLevel = CodeGenOpts.OptimizationLevel; 136 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining; 137 138 // Handle disabling of LLVM optimization, where we want to preserve the 139 // internal module before any optimization. 140 if (CodeGenOpts.DisableLLVMOpts) { 141 OptLevel = 0; 142 Inlining = CodeGenOpts.NoInlining; 143 } 144 145 PassManagerBuilder PMBuilder; 146 PMBuilder.OptLevel = OptLevel; 147 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize; 148 149 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls; 150 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime; 151 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops; 152 153 // In ObjC ARC mode, add the main ARC optimization passes. 154 if (LangOpts.ObjCAutoRefCount) { 155 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible, 156 addObjCARCExpandPass); 157 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly, 158 addObjCARCAPElimPass); 159 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate, 160 addObjCARCOptPass); 161 } 162 163 if (LangOpts.AddressSanitizer) { 164 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate, 165 addAddressSanitizerPass); 166 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0, 167 addAddressSanitizerPass); 168 } 169 170 if (LangOpts.ThreadSanitizer) { 171 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast, 172 addThreadSanitizerPass); 173 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0, 174 addThreadSanitizerPass); 175 } 176 177 // Figure out TargetLibraryInfo. 178 Triple TargetTriple(TheModule->getTargetTriple()); 179 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple); 180 if (!CodeGenOpts.SimplifyLibCalls) 181 PMBuilder.LibraryInfo->disableAllFunctions(); 182 183 switch (Inlining) { 184 case CodeGenOptions::NoInlining: break; 185 case CodeGenOptions::NormalInlining: { 186 // FIXME: Derive these constants in a principled fashion. 187 unsigned Threshold = 225; 188 if (CodeGenOpts.OptimizeSize == 1) // -Os 189 Threshold = 75; 190 else if (CodeGenOpts.OptimizeSize == 2) // -Oz 191 Threshold = 25; 192 else if (OptLevel > 2) 193 Threshold = 275; 194 PMBuilder.Inliner = createFunctionInliningPass(Threshold); 195 break; 196 } 197 case CodeGenOptions::OnlyAlwaysInlining: 198 // Respect always_inline. 199 if (OptLevel == 0) 200 // Do not insert lifetime intrinsics at -O0. 201 PMBuilder.Inliner = createAlwaysInlinerPass(false); 202 else 203 PMBuilder.Inliner = createAlwaysInlinerPass(); 204 break; 205 } 206 207 208 // Set up the per-function pass manager. 209 FunctionPassManager *FPM = getPerFunctionPasses(); 210 if (CodeGenOpts.VerifyModule) 211 FPM->add(createVerifierPass()); 212 PMBuilder.populateFunctionPassManager(*FPM); 213 214 // Set up the per-module pass manager. 215 PassManager *MPM = getPerModulePasses(); 216 217 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) { 218 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes, 219 CodeGenOpts.EmitGcovArcs, 220 TargetTriple.isMacOSX())); 221 222 if (!CodeGenOpts.DebugInfo) 223 MPM->add(createStripSymbolsPass(true)); 224 } 225 226 227 PMBuilder.populateModulePassManager(*MPM); 228} 229 230bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action, 231 formatted_raw_ostream &OS) { 232 // Create the TargetMachine for generating code. 233 std::string Error; 234 std::string Triple = TheModule->getTargetTriple(); 235 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error); 236 if (!TheTarget) { 237 Diags.Report(diag::err_fe_unable_to_create_target) << Error; 238 return false; 239 } 240 241 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just 242 // being gross, this is also totally broken if we ever care about 243 // concurrency. 244 245 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose); 246 247 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections); 248 TargetMachine::setDataSections (CodeGenOpts.DataSections); 249 250 // FIXME: Parse this earlier. 251 llvm::CodeModel::Model CM; 252 if (CodeGenOpts.CodeModel == "small") { 253 CM = llvm::CodeModel::Small; 254 } else if (CodeGenOpts.CodeModel == "kernel") { 255 CM = llvm::CodeModel::Kernel; 256 } else if (CodeGenOpts.CodeModel == "medium") { 257 CM = llvm::CodeModel::Medium; 258 } else if (CodeGenOpts.CodeModel == "large") { 259 CM = llvm::CodeModel::Large; 260 } else { 261 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!"); 262 CM = llvm::CodeModel::Default; 263 } 264 265 SmallVector<const char *, 16> BackendArgs; 266 BackendArgs.push_back("clang"); // Fake program name. 267 if (!CodeGenOpts.DebugPass.empty()) { 268 BackendArgs.push_back("-debug-pass"); 269 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str()); 270 } 271 if (!CodeGenOpts.LimitFloatPrecision.empty()) { 272 BackendArgs.push_back("-limit-float-precision"); 273 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str()); 274 } 275 if (llvm::TimePassesIsEnabled) 276 BackendArgs.push_back("-time-passes"); 277 for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i) 278 BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str()); 279 if (CodeGenOpts.NoGlobalMerge) 280 BackendArgs.push_back("-global-merge=false"); 281 BackendArgs.push_back(0); 282 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1, 283 BackendArgs.data()); 284 285 std::string FeaturesStr; 286 if (TargetOpts.Features.size()) { 287 SubtargetFeatures Features; 288 for (std::vector<std::string>::const_iterator 289 it = TargetOpts.Features.begin(), 290 ie = TargetOpts.Features.end(); it != ie; ++it) 291 Features.AddFeature(*it); 292 FeaturesStr = Features.getString(); 293 } 294 295 llvm::Reloc::Model RM = llvm::Reloc::Default; 296 if (CodeGenOpts.RelocationModel == "static") { 297 RM = llvm::Reloc::Static; 298 } else if (CodeGenOpts.RelocationModel == "pic") { 299 RM = llvm::Reloc::PIC_; 300 } else { 301 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" && 302 "Invalid PIC model!"); 303 RM = llvm::Reloc::DynamicNoPIC; 304 } 305 306 CodeGenOpt::Level OptLevel = CodeGenOpt::Default; 307 switch (CodeGenOpts.OptimizationLevel) { 308 default: break; 309 case 0: OptLevel = CodeGenOpt::None; break; 310 case 3: OptLevel = CodeGenOpt::Aggressive; break; 311 } 312 313 llvm::TargetOptions Options; 314 315 // Set frame pointer elimination mode. 316 if (!CodeGenOpts.DisableFPElim) { 317 Options.NoFramePointerElim = false; 318 Options.NoFramePointerElimNonLeaf = false; 319 } else if (CodeGenOpts.OmitLeafFramePointer) { 320 Options.NoFramePointerElim = false; 321 Options.NoFramePointerElimNonLeaf = true; 322 } else { 323 Options.NoFramePointerElim = true; 324 Options.NoFramePointerElimNonLeaf = true; 325 } 326 327 // Set float ABI type. 328 if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp") 329 Options.FloatABIType = llvm::FloatABI::Soft; 330 else if (CodeGenOpts.FloatABI == "hard") 331 Options.FloatABIType = llvm::FloatABI::Hard; 332 else { 333 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!"); 334 Options.FloatABIType = llvm::FloatABI::Default; 335 } 336 337 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD; 338 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath; 339 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath; 340 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS; 341 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath; 342 Options.UseSoftFloat = CodeGenOpts.SoftFloat; 343 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment; 344 Options.RealignStack = CodeGenOpts.StackRealignment; 345 Options.DisableTailCalls = CodeGenOpts.DisableTailCalls; 346 Options.TrapFuncName = CodeGenOpts.TrapFuncName; 347 Options.PositionIndependentExecutable = LangOpts.PIELevel != 0; 348 349 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU, 350 FeaturesStr, Options, 351 RM, CM, OptLevel); 352 353 if (CodeGenOpts.RelaxAll) 354 TM->setMCRelaxAll(true); 355 if (CodeGenOpts.SaveTempLabels) 356 TM->setMCSaveTempLabels(true); 357 if (CodeGenOpts.NoDwarf2CFIAsm) 358 TM->setMCUseCFI(false); 359 if (!CodeGenOpts.NoDwarfDirectoryAsm) 360 TM->setMCUseDwarfDirectory(true); 361 if (CodeGenOpts.NoExecStack) 362 TM->setMCNoExecStack(true); 363 364 // Create the code generator passes. 365 PassManager *PM = getCodeGenPasses(); 366 367 // Add LibraryInfo. 368 TargetLibraryInfo *TLI = new TargetLibraryInfo(); 369 if (!CodeGenOpts.SimplifyLibCalls) 370 TLI->disableAllFunctions(); 371 PM->add(TLI); 372 373 // Normal mode, emit a .s or .o file by running the code generator. Note, 374 // this also adds codegenerator level optimization passes. 375 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile; 376 if (Action == Backend_EmitObj) 377 CGFT = TargetMachine::CGFT_ObjectFile; 378 else if (Action == Backend_EmitMCNull) 379 CGFT = TargetMachine::CGFT_Null; 380 else 381 assert(Action == Backend_EmitAssembly && "Invalid action!"); 382 383 // Add ObjC ARC final-cleanup optimizations. This is done as part of the 384 // "codegen" passes so that it isn't run multiple times when there is 385 // inlining happening. 386 if (LangOpts.ObjCAutoRefCount && 387 CodeGenOpts.OptimizationLevel > 0) 388 PM->add(createObjCARCContractPass()); 389 390 if (TM->addPassesToEmitFile(*PM, OS, CGFT, 391 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) { 392 Diags.Report(diag::err_fe_unable_to_interface_with_target); 393 return false; 394 } 395 396 return true; 397} 398 399void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) { 400 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0); 401 llvm::formatted_raw_ostream FormattedOS; 402 403 CreatePasses(); 404 switch (Action) { 405 case Backend_EmitNothing: 406 break; 407 408 case Backend_EmitBC: 409 getPerModulePasses()->add(createBitcodeWriterPass(*OS)); 410 break; 411 412 case Backend_EmitLL: 413 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM); 414 getPerModulePasses()->add(createPrintModulePass(&FormattedOS)); 415 break; 416 417 default: 418 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM); 419 if (!AddEmitPasses(Action, FormattedOS)) 420 return; 421 } 422 423 // Before executing passes, print the final values of the LLVM options. 424 cl::PrintOptionValues(); 425 426 // Run passes. For now we do all passes at once, but eventually we 427 // would like to have the option of streaming code generation. 428 429 if (PerFunctionPasses) { 430 PrettyStackTraceString CrashInfo("Per-function optimization"); 431 432 PerFunctionPasses->doInitialization(); 433 for (Module::iterator I = TheModule->begin(), 434 E = TheModule->end(); I != E; ++I) 435 if (!I->isDeclaration()) 436 PerFunctionPasses->run(*I); 437 PerFunctionPasses->doFinalization(); 438 } 439 440 if (PerModulePasses) { 441 PrettyStackTraceString CrashInfo("Per-module optimization passes"); 442 PerModulePasses->run(*TheModule); 443 } 444 445 if (CodeGenPasses) { 446 PrettyStackTraceString CrashInfo("Code generation"); 447 CodeGenPasses->run(*TheModule); 448 } 449} 450 451void clang::EmitBackendOutput(DiagnosticsEngine &Diags, 452 const CodeGenOptions &CGOpts, 453 const clang::TargetOptions &TOpts, 454 const LangOptions &LOpts, 455 Module *M, 456 BackendAction Action, raw_ostream *OS) { 457 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M); 458 459 AsmHelper.EmitAssembly(Action, OS); 460} 461