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"
18 using namespace llvm;
19 
20 //---------------------------------------------------------------------------
21 // Command-line options that tend to be useful on more than one back-end.
22 //
23 
24 namespace 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 
48 static cl::opt<bool, true>
49 PrintCode("print-machineinstrs",
50   cl::desc("Print generated machine code"),
51   cl::location(PrintMachineCode), cl::init(false));
52 static cl::opt<bool, true>
53 DisableFPElim("disable-fp-elim",
54   cl::desc("Disable frame pointer elimination optimization"),
55   cl::location(NoFramePointerElim),
56   cl::init(false));
57 static cl::opt<bool, true>
58 DisableExcessPrecision("disable-excess-fp-precision",
59   cl::desc("Disable optimizations that may increase FP precision"),
60   cl::location(NoExcessFPPrecision),
61   cl::init(false));
62 static cl::opt<bool, true>
63 EnableFPMAD("enable-fp-mad",
64   cl::desc("Enable less precise MAD instructions to be generated"),
65   cl::location(LessPreciseFPMADOption),
66   cl::init(false));
67 static cl::opt<bool, true>
68 EnableUnsafeFPMath("enable-unsafe-fp-math",
69   cl::desc("Enable optimizations that may decrease FP precision"),
70   cl::location(UnsafeFPMath),
71   cl::init(false));
72 static cl::opt<bool, true>
73 EnableFiniteOnlyFPMath("enable-finite-only-fp-math",
74   cl::desc("Enable optimizations that assumes non- NaNs / +-Infs"),
75   cl::location(FiniteOnlyFPMathOption),
76   cl::init(false));
77 static cl::opt<bool, true>
78 EnableHonorSignDependentRoundingFPMath("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));
83 static cl::opt<bool, true>
84 GenerateSoftFloatCalls("soft-float",
85   cl::desc("Generate software floating point library calls"),
86   cl::location(UseSoftFloat),
87   cl::init(false));
88 static cl::opt<llvm::FloatABI::ABIType, true>
89 FloatABIForCalls("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));
101 static cl::opt<bool, true>
102 DontPlaceZerosInBSS("nozero-initialized-in-bss",
103   cl::desc("Don't place zero-initialized symbols into bss section"),
104   cl::location(NoZerosInBSS),
105   cl::init(false));
106 static cl::opt<bool, true>
107 EnableExceptionHandling("enable-eh",
108   cl::desc("Emit DWARF exception handling (default if target supports)"),
109   cl::location(ExceptionHandling),
110   cl::init(false));
111 static cl::opt<bool, true>
112 EnableUnwindTables("unwind-tables",
113   cl::desc("Generate unwinding tables for all functions"),
114   cl::location(UnwindTablesMandatory),
115   cl::init(false));
116 
117 static cl::opt<llvm::Reloc::Model, true>
118 DefRelocationModel("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));
132 static cl::opt<llvm::CodeModel::Model, true>
133 DefCodeModel("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));
149 static cl::opt<bool, true>
150 EnablePerformTailCallOpt("tailcallopt",
151   cl::desc("Turn on tail call optimization."),
152   cl::location(PerformTailCallOpt),
153   cl::init(false));
154 static cl::opt<unsigned, true>
155 OverrideStackAlignment("stack-alignment",
156   cl::desc("Override default stack alignment"),
157   cl::location(StackAlignment),
158   cl::init(0));
159 static cl::opt<bool, true>
160 EnableRealignStack("realign-stack",
161   cl::desc("Realign stack if needed"),
162   cl::location(RealignStack),
163   cl::init(true));
164 static cl::opt<bool, true>
165 DisableSwitchTables(cl::Hidden, "disable-jump-tables",
166   cl::desc("Do not generate jump tables."),
167   cl::location(DisableJumpTables),
168   cl::init(false));
169 static cl::opt<bool, true>
170 EnableStrongPHIElim(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 
179 TargetMachine::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 
187 TargetMachine::~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.
193 Reloc::Model TargetMachine::getRelocationModel() {
194   return RelocationModel;
195 }
196 
197 /// setRelocationModel - Sets the code generation relocation model.
198 void 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.
204 CodeModel::Model TargetMachine::getCodeModel() {
205   return CMModel;
206 }
207 
208 /// setCodeModel - Sets the code model.
209 void TargetMachine::setCodeModel(CodeModel::Model Model) {
210   CMModel = Model;
211 }
212 
213 bool TargetMachine::getAsmVerbosityDefault() {
214   return AsmVerbosityDefault;
215 }
216 
217 void TargetMachine::setAsmVerbosityDefault(bool V) {
218   AsmVerbosityDefault = V;
219 }
220 
221 namespace 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