1 //===-- TargetMachine.cpp - General Target Information ---------------------==// 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 describes the general parts of a Target machine. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/CodeGen/MachineFunction.h" 15 #include "llvm/CodeGen/MachineFrameInfo.h" 16 #include "llvm/MC/MCAsmInfo.h" 17 #include "llvm/Target/TargetMachine.h" 18 #include "llvm/Target/TargetOptions.h" 19 #include "llvm/Support/CommandLine.h" 20 using namespace llvm; 21 22 //--------------------------------------------------------------------------- 23 // Command-line options that tend to be useful on more than one back-end. 24 // 25 26 namespace llvm { 27 bool LessPreciseFPMADOption; 28 bool PrintMachineCode; 29 bool NoFramePointerElim; 30 bool NoFramePointerElimNonLeaf; 31 bool NoExcessFPPrecision; 32 bool UnsafeFPMath; 33 bool NoInfsFPMath; 34 bool NoNaNsFPMath; 35 bool HonorSignDependentRoundingFPMathOption; 36 bool UseSoftFloat; 37 FloatABI::ABIType FloatABIType; 38 bool NoImplicitFloat; 39 bool NoZerosInBSS; 40 bool JITExceptionHandling; 41 bool JITEmitDebugInfo; 42 bool JITEmitDebugInfoToDisk; 43 CodeModel::Model CMModel; 44 bool GuaranteedTailCallOpt; 45 unsigned StackAlignmentOverride; 46 bool RealignStack; 47 bool DisableJumpTables; 48 bool StrongPHIElim; 49 bool HasDivModLibcall; 50 bool AsmVerbosityDefault(false); 51 } 52 53 static cl::opt<bool, true> 54 PrintCode("print-machineinstrs", 55 cl::desc("Print generated machine code"), 56 cl::location(PrintMachineCode), cl::init(false)); 57 static cl::opt<bool, true> 58 DisableFPElim("disable-fp-elim", 59 cl::desc("Disable frame pointer elimination optimization"), 60 cl::location(NoFramePointerElim), 61 cl::init(false)); 62 static cl::opt<bool, true> 63 DisableFPElimNonLeaf("disable-non-leaf-fp-elim", 64 cl::desc("Disable frame pointer elimination optimization for non-leaf funcs"), 65 cl::location(NoFramePointerElimNonLeaf), 66 cl::init(false)); 67 static cl::opt<bool, true> 68 DisableExcessPrecision("disable-excess-fp-precision", 69 cl::desc("Disable optimizations that may increase FP precision"), 70 cl::location(NoExcessFPPrecision), 71 cl::init(false)); 72 static cl::opt<bool, true> 73 EnableFPMAD("enable-fp-mad", 74 cl::desc("Enable less precise MAD instructions to be generated"), 75 cl::location(LessPreciseFPMADOption), 76 cl::init(false)); 77 static cl::opt<bool, true> 78 EnableUnsafeFPMath("enable-unsafe-fp-math", 79 cl::desc("Enable optimizations that may decrease FP precision"), 80 cl::location(UnsafeFPMath), 81 cl::init(false)); 82 static cl::opt<bool, true> 83 EnableNoInfsFPMath("enable-no-infs-fp-math", 84 cl::desc("Enable FP math optimizations that assume no +-Infs"), 85 cl::location(NoInfsFPMath), 86 cl::init(false)); 87 static cl::opt<bool, true> 88 EnableNoNaNsFPMath("enable-no-nans-fp-math", 89 cl::desc("Enable FP math optimizations that assume no NaNs"), 90 cl::location(NoNaNsFPMath), 91 cl::init(false)); 92 static cl::opt<bool, true> 93 EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math", 94 cl::Hidden, 95 cl::desc("Force codegen to assume rounding mode can change dynamically"), 96 cl::location(HonorSignDependentRoundingFPMathOption), 97 cl::init(false)); 98 static cl::opt<bool, true> 99 GenerateSoftFloatCalls("soft-float", 100 cl::desc("Generate software floating point library calls"), 101 cl::location(UseSoftFloat), 102 cl::init(false)); 103 static cl::opt<llvm::FloatABI::ABIType, true> 104 FloatABIForCalls("float-abi", 105 cl::desc("Choose float ABI type"), 106 cl::location(FloatABIType), 107 cl::init(FloatABI::Default), 108 cl::values( 109 clEnumValN(FloatABI::Default, "default", 110 "Target default float ABI type"), 111 clEnumValN(FloatABI::Soft, "soft", 112 "Soft float ABI (implied by -soft-float)"), 113 clEnumValN(FloatABI::Hard, "hard", 114 "Hard float ABI (uses FP registers)"), 115 clEnumValEnd)); 116 static cl::opt<bool, true> 117 DontPlaceZerosInBSS("nozero-initialized-in-bss", 118 cl::desc("Don't place zero-initialized symbols into bss section"), 119 cl::location(NoZerosInBSS), 120 cl::init(false)); 121 static cl::opt<bool, true> 122 EnableJITExceptionHandling("jit-enable-eh", 123 cl::desc("Emit exception handling information"), 124 cl::location(JITExceptionHandling), 125 cl::init(false)); 126 // In debug builds, make this default to true. 127 #ifdef NDEBUG 128 #define EMIT_DEBUG false 129 #else 130 #define EMIT_DEBUG true 131 #endif 132 static cl::opt<bool, true> 133 EmitJitDebugInfo("jit-emit-debug", 134 cl::desc("Emit debug information to debugger"), 135 cl::location(JITEmitDebugInfo), 136 cl::init(EMIT_DEBUG)); 137 #undef EMIT_DEBUG 138 static cl::opt<bool, true> 139 EmitJitDebugInfoToDisk("jit-emit-debug-to-disk", 140 cl::Hidden, 141 cl::desc("Emit debug info objfiles to disk"), 142 cl::location(JITEmitDebugInfoToDisk), 143 cl::init(false)); 144 145 static cl::opt<llvm::CodeModel::Model, true> 146 DefCodeModel("code-model", 147 cl::desc("Choose code model"), 148 cl::location(CMModel), 149 cl::init(CodeModel::Default), 150 cl::values( 151 clEnumValN(CodeModel::Default, "default", 152 "Target default code model"), 153 clEnumValN(CodeModel::Small, "small", 154 "Small code model"), 155 clEnumValN(CodeModel::Kernel, "kernel", 156 "Kernel code model"), 157 clEnumValN(CodeModel::Medium, "medium", 158 "Medium code model"), 159 clEnumValN(CodeModel::Large, "large", 160 "Large code model"), 161 clEnumValEnd)); 162 static cl::opt<bool, true> 163 EnableGuaranteedTailCallOpt("tailcallopt", 164 cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."), 165 cl::location(GuaranteedTailCallOpt), 166 cl::init(false)); 167 static cl::opt<unsigned, true> 168 OverrideStackAlignment("stack-alignment", 169 cl::desc("Override default stack alignment"), 170 cl::location(StackAlignmentOverride), 171 cl::init(0)); 172 static cl::opt<bool, true> 173 EnableRealignStack("realign-stack", 174 cl::desc("Realign stack if needed"), 175 cl::location(RealignStack), 176 cl::init(true)); 177 static cl::opt<bool, true> 178 DisableSwitchTables(cl::Hidden, "disable-jump-tables", 179 cl::desc("Do not generate jump tables."), 180 cl::location(DisableJumpTables), 181 cl::init(false)); 182 static cl::opt<bool, true> 183 EnableStrongPHIElim(cl::Hidden, "strong-phi-elim", 184 cl::desc("Use strong PHI elimination."), 185 cl::location(StrongPHIElim), 186 cl::init(false)); 187 static cl::opt<std::string> 188 TrapFuncName("trap-func", cl::Hidden, 189 cl::desc("Emit a call to trap function rather than a trap instruction"), 190 cl::init("")); 191 static cl::opt<bool> 192 DataSections("fdata-sections", 193 cl::desc("Emit data into separate sections"), 194 cl::init(false)); 195 static cl::opt<bool> 196 FunctionSections("ffunction-sections", 197 cl::desc("Emit functions into separate sections"), 198 cl::init(false)); 199 //--------------------------------------------------------------------------- 200 // TargetMachine Class 201 // 202 203 TargetMachine::TargetMachine(const Target &T, 204 StringRef TT, StringRef CPU, StringRef FS) 205 : TheTarget(T), TargetTriple(TT), TargetCPU(CPU), TargetFS(FS), 206 CodeGenInfo(0), AsmInfo(0), 207 MCRelaxAll(false), 208 MCNoExecStack(false), 209 MCSaveTempLabels(false), 210 MCUseLoc(true), 211 MCUseCFI(true) { 212 // Typically it will be subtargets that will adjust FloatABIType from Default 213 // to Soft or Hard. 214 if (UseSoftFloat) 215 FloatABIType = FloatABI::Soft; 216 } 217 218 TargetMachine::~TargetMachine() { 219 delete CodeGenInfo; 220 delete AsmInfo; 221 } 222 223 /// getRelocationModel - Returns the code generation relocation model. The 224 /// choices are static, PIC, and dynamic-no-pic, and target default. 225 Reloc::Model TargetMachine::getRelocationModel() const { 226 if (!CodeGenInfo) 227 return Reloc::Default; 228 return CodeGenInfo->getRelocationModel(); 229 } 230 231 /// getCodeModel - Returns the code model. The choices are small, kernel, 232 /// medium, large, and target default. 233 CodeModel::Model TargetMachine::getCodeModel() { 234 return CMModel; 235 } 236 237 /// setCodeModel - Sets the code model. 238 void TargetMachine::setCodeModel(CodeModel::Model Model) { 239 CMModel = Model; 240 } 241 242 bool TargetMachine::getAsmVerbosityDefault() { 243 return AsmVerbosityDefault; 244 } 245 246 void TargetMachine::setAsmVerbosityDefault(bool V) { 247 AsmVerbosityDefault = V; 248 } 249 250 bool TargetMachine::getFunctionSections() { 251 return FunctionSections; 252 } 253 254 bool TargetMachine::getDataSections() { 255 return DataSections; 256 } 257 258 void TargetMachine::setFunctionSections(bool V) { 259 FunctionSections = V; 260 } 261 262 void TargetMachine::setDataSections(bool V) { 263 DataSections = V; 264 } 265 266 namespace llvm { 267 /// DisableFramePointerElim - This returns true if frame pointer elimination 268 /// optimization should be disabled for the given machine function. 269 bool DisableFramePointerElim(const MachineFunction &MF) { 270 // Check to see if we should eliminate non-leaf frame pointers and then 271 // check to see if we should eliminate all frame pointers. 272 if (NoFramePointerElimNonLeaf && !NoFramePointerElim) { 273 const MachineFrameInfo *MFI = MF.getFrameInfo(); 274 return MFI->hasCalls(); 275 } 276 277 return NoFramePointerElim; 278 } 279 280 /// LessPreciseFPMAD - This flag return true when -enable-fp-mad option 281 /// is specified on the command line. When this flag is off(default), the 282 /// code generator is not allowed to generate mad (multiply add) if the 283 /// result is "less precise" than doing those operations individually. 284 bool LessPreciseFPMAD() { return UnsafeFPMath || LessPreciseFPMADOption; } 285 286 /// HonorSignDependentRoundingFPMath - Return true if the codegen must assume 287 /// that the rounding mode of the FPU can change from its default. 288 bool HonorSignDependentRoundingFPMath() { 289 return !UnsafeFPMath && HonorSignDependentRoundingFPMathOption; 290 } 291 292 /// getTrapFunctionName - If this returns a non-empty string, this means isel 293 /// should lower Intrinsic::trap to a call to the specified function name 294 /// instead of an ISD::TRAP node. 295 StringRef getTrapFunctionName() { 296 return TrapFuncName; 297 } 298 } 299
