TargetMachine.cpp revision 51b198af83cb0080c2709b04c129a3d774c07765 
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/Target/TargetAsmInfo.h"
15#include "llvm/Target/TargetMachine.h"
16#include "llvm/Target/TargetOptions.h"
17#include "llvm/Support/CommandLine.h"
18using namespace llvm;
19
20//---------------------------------------------------------------------------
21// Command-line options that tend to be useful on more than one back-end.
22//
23
24namespace llvm {
25  bool LessPreciseFPMADOption;
26  bool PrintMachineCode;
27  bool NoFramePointerElim;
28  bool NoExcessFPPrecision;
29  bool UnsafeFPMath;
30  bool FiniteOnlyFPMathOption;
31  bool HonorSignDependentRoundingFPMathOption;
32  bool UseSoftFloat;
33  FloatABI::ABIType FloatABIType;
34  bool NoImplicitFloat;
35  bool NoZerosInBSS;
36  bool ExceptionHandling;
37  bool UnwindTablesMandatory;
38  Reloc::Model RelocationModel;
39  CodeModel::Model CMModel;
40  bool PerformTailCallOpt;
41  unsigned StackAlignment;
42  bool RealignStack;
43  bool DisableJumpTables;
44  bool StrongPHIElim;
45  bool AsmVerbosityDefault(false);
46}
47
48static cl::opt<bool, true>
49PrintCode("print-machineinstrs",
50  cl::desc("Print generated machine code"),
51  cl::location(PrintMachineCode), cl::init(false));
52static cl::opt<bool, true>
53DisableFPElim("disable-fp-elim",
54  cl::desc("Disable frame pointer elimination optimization"),
55  cl::location(NoFramePointerElim),
56  cl::init(false));
57static cl::opt<bool, true>
58DisableExcessPrecision("disable-excess-fp-precision",
59  cl::desc("Disable optimizations that may increase FP precision"),
60  cl::location(NoExcessFPPrecision),
61  cl::init(false));
62static cl::opt<bool, true>
63EnableFPMAD("enable-fp-mad",
64  cl::desc("Enable less precise MAD instructions to be generated"),
65  cl::location(LessPreciseFPMADOption),
66  cl::init(false));
67static cl::opt<bool, true>
68EnableUnsafeFPMath("enable-unsafe-fp-math",
69  cl::desc("Enable optimizations that may decrease FP precision"),
70  cl::location(UnsafeFPMath),
71  cl::init(false));
72static cl::opt<bool, true>
73EnableFiniteOnlyFPMath("enable-finite-only-fp-math",
74  cl::desc("Enable optimizations that assumes non- NaNs / +-Infs"),
75  cl::location(FiniteOnlyFPMathOption),
76  cl::init(false));
77static cl::opt<bool, true>
78EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math",
79  cl::Hidden,
80  cl::desc("Force codegen to assume rounding mode can change dynamically"),
81  cl::location(HonorSignDependentRoundingFPMathOption),
82  cl::init(false));
83static cl::opt<bool, true>
84GenerateSoftFloatCalls("soft-float",
85  cl::desc("Generate software floating point library calls"),
86  cl::location(UseSoftFloat),
87  cl::init(false));
88static cl::opt<llvm::FloatABI::ABIType, true>
89FloatABIForCalls("float-abi",
90  cl::desc("Choose float ABI type"),
91  cl::location(FloatABIType),
92  cl::init(FloatABI::Default),
93  cl::values(
94    clEnumValN(FloatABI::Default, "default",
95               "Target default float ABI type"),
96    clEnumValN(FloatABI::Soft, "soft",
97               "Soft float ABI (implied by -soft-float)"),
98    clEnumValN(FloatABI::Hard, "hard",
99               "Hard float ABI (uses FP registers)"),
100    clEnumValEnd));
101static cl::opt<bool, true>
102DontPlaceZerosInBSS("nozero-initialized-in-bss",
103  cl::desc("Don't place zero-initialized symbols into bss section"),
104  cl::location(NoZerosInBSS),
105  cl::init(false));
106static cl::opt<bool, true>
107EnableExceptionHandling("enable-eh",
108  cl::desc("Emit DWARF exception handling (default if target supports)"),
109  cl::location(ExceptionHandling),
110  cl::init(false));
111static cl::opt<bool, true>
112EnableUnwindTables("unwind-tables",
113  cl::desc("Generate unwinding tables for all functions"),
114  cl::location(UnwindTablesMandatory),
115  cl::init(false));
116
117static cl::opt<llvm::Reloc::Model, true>
118DefRelocationModel("relocation-model",
119  cl::desc("Choose relocation model"),
120  cl::location(RelocationModel),
121  cl::init(Reloc::Default),
122  cl::values(
123    clEnumValN(Reloc::Default, "default",
124               "Target default relocation model"),
125    clEnumValN(Reloc::Static, "static",
126               "Non-relocatable code"),
127    clEnumValN(Reloc::PIC_, "pic",
128               "Fully relocatable, position independent code"),
129    clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
130               "Relocatable external references, non-relocatable code"),
131    clEnumValEnd));
132static cl::opt<llvm::CodeModel::Model, true>
133DefCodeModel("code-model",
134  cl::desc("Choose code model"),
135  cl::location(CMModel),
136  cl::init(CodeModel::Default),
137  cl::values(
138    clEnumValN(CodeModel::Default, "default",
139               "Target default code model"),
140    clEnumValN(CodeModel::Small, "small",
141               "Small code model"),
142    clEnumValN(CodeModel::Kernel, "kernel",
143               "Kernel code model"),
144    clEnumValN(CodeModel::Medium, "medium",
145               "Medium code model"),
146    clEnumValN(CodeModel::Large, "large",
147               "Large code model"),
148    clEnumValEnd));
149static cl::opt<bool, true>
150EnablePerformTailCallOpt("tailcallopt",
151  cl::desc("Turn on tail call optimization."),
152  cl::location(PerformTailCallOpt),
153  cl::init(false));
154static cl::opt<unsigned, true>
155OverrideStackAlignment("stack-alignment",
156  cl::desc("Override default stack alignment"),
157  cl::location(StackAlignment),
158  cl::init(0));
159static cl::opt<bool, true>
160EnableRealignStack("realign-stack",
161  cl::desc("Realign stack if needed"),
162  cl::location(RealignStack),
163  cl::init(true));
164static cl::opt<bool, true>
165DisableSwitchTables(cl::Hidden, "disable-jump-tables",
166  cl::desc("Do not generate jump tables."),
167  cl::location(DisableJumpTables),
168  cl::init(false));
169static cl::opt<bool, true>
170EnableStrongPHIElim(cl::Hidden, "strong-phi-elim",
171  cl::desc("Use strong PHI elimination."),
172  cl::location(StrongPHIElim),
173  cl::init(false));
174
175//---------------------------------------------------------------------------
176// TargetMachine Class
177//
178
179TargetMachine::TargetMachine(const Target &T)
180  : TheTarget(T), AsmInfo(0) {
181  // Typically it will be subtargets that will adjust FloatABIType from Default
182  // to Soft or Hard.
183  if (UseSoftFloat)
184    FloatABIType = FloatABI::Soft;
185}
186
187TargetMachine::~TargetMachine() {
188  delete AsmInfo;
189}
190
191/// getRelocationModel - Returns the code generation relocation model. The
192/// choices are static, PIC, and dynamic-no-pic, and target default.
193Reloc::Model TargetMachine::getRelocationModel() {
194  return RelocationModel;
195}
196
197/// setRelocationModel - Sets the code generation relocation model.
198void TargetMachine::setRelocationModel(Reloc::Model Model) {
199  RelocationModel = Model;
200}
201
202/// getCodeModel - Returns the code model. The choices are small, kernel,
203/// medium, large, and target default.
204CodeModel::Model TargetMachine::getCodeModel() {
205  return CMModel;
206}
207
208/// setCodeModel - Sets the code model.
209void TargetMachine::setCodeModel(CodeModel::Model Model) {
210  CMModel = Model;
211}
212
213bool TargetMachine::getAsmVerbosityDefault() {
214  return AsmVerbosityDefault;
215}
216
217void TargetMachine::setAsmVerbosityDefault(bool V) {
218  AsmVerbosityDefault = V;
219}
220
221namespace llvm {
222  /// LessPreciseFPMAD - This flag return true when -enable-fp-mad option
223  /// is specified on the command line.  When this flag is off(default), the
224  /// code generator is not allowed to generate mad (multiply add) if the
225  /// result is "less precise" than doing those operations individually.
226  bool LessPreciseFPMAD() { return UnsafeFPMath || LessPreciseFPMADOption; }
227
228  /// FiniteOnlyFPMath - This returns true when the -enable-finite-only-fp-math
229  /// option is specified on the command line. If this returns false (default),
230  /// the code generator is not allowed to assume that FP arithmetic arguments
231  /// and results are never NaNs or +-Infs.
232  bool FiniteOnlyFPMath() { return UnsafeFPMath || FiniteOnlyFPMathOption; }
233
234  /// HonorSignDependentRoundingFPMath - Return true if the codegen must assume
235  /// that the rounding mode of the FPU can change from its default.
236  bool HonorSignDependentRoundingFPMath() {
237    return !UnsafeFPMath && HonorSignDependentRoundingFPMathOption;
238  }
239}
240
241