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