1//===-- CommandFlags.h - Command Line Flags Interface -----------*- C++ -*-===//
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 contains codegen-specific flags that are shared between different
11// command line tools. The tools "llc" and "opt" both use this file to prevent
12// flag duplication.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_CODEGEN_COMMANDFLAGS_H
17#define LLVM_CODEGEN_COMMANDFLAGS_H
18
19#include "llvm/MC/MCTargetOptionsCommandFlags.h"
20#include "llvm/Support/CodeGen.h"
21#include "llvm/Support/CommandLine.h"
22#include "llvm/Target/TargetMachine.h"
23#include "llvm/Target/TargetOptions.h"
24#include <string>
25using namespace llvm;
26
27cl::opt<std::string>
28MArch("march", cl::desc("Architecture to generate code for (see --version)"));
29
30cl::opt<std::string>
31MCPU("mcpu",
32     cl::desc("Target a specific cpu type (-mcpu=help for details)"),
33     cl::value_desc("cpu-name"),
34     cl::init(""));
35
36cl::list<std::string>
37MAttrs("mattr",
38       cl::CommaSeparated,
39       cl::desc("Target specific attributes (-mattr=help for details)"),
40       cl::value_desc("a1,+a2,-a3,..."));
41
42cl::opt<Reloc::Model>
43RelocModel("relocation-model",
44           cl::desc("Choose relocation model"),
45           cl::init(Reloc::Default),
46           cl::values(
47              clEnumValN(Reloc::Default, "default",
48                      "Target default relocation model"),
49              clEnumValN(Reloc::Static, "static",
50                      "Non-relocatable code"),
51              clEnumValN(Reloc::PIC_, "pic",
52                      "Fully relocatable, position independent code"),
53              clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
54                      "Relocatable external references, non-relocatable code"),
55              clEnumValEnd));
56
57cl::opt<llvm::CodeModel::Model>
58CMModel("code-model",
59        cl::desc("Choose code model"),
60        cl::init(CodeModel::Default),
61        cl::values(clEnumValN(CodeModel::Default, "default",
62                              "Target default code model"),
63                   clEnumValN(CodeModel::Small, "small",
64                              "Small code model"),
65                   clEnumValN(CodeModel::Kernel, "kernel",
66                              "Kernel code model"),
67                   clEnumValN(CodeModel::Medium, "medium",
68                              "Medium code model"),
69                   clEnumValN(CodeModel::Large, "large",
70                              "Large code model"),
71                   clEnumValEnd));
72
73cl::opt<TargetMachine::CodeGenFileType>
74FileType("filetype", cl::init(TargetMachine::CGFT_AssemblyFile),
75  cl::desc("Choose a file type (not all types are supported by all targets):"),
76  cl::values(
77             clEnumValN(TargetMachine::CGFT_AssemblyFile, "asm",
78                        "Emit an assembly ('.s') file"),
79             clEnumValN(TargetMachine::CGFT_ObjectFile, "obj",
80                        "Emit a native object ('.o') file"),
81             clEnumValN(TargetMachine::CGFT_Null, "null",
82                        "Emit nothing, for performance testing"),
83             clEnumValEnd));
84
85cl::opt<bool>
86DisableRedZone("disable-red-zone",
87               cl::desc("Do not emit code that uses the red zone."),
88               cl::init(false));
89
90cl::opt<bool>
91EnableFPMAD("enable-fp-mad",
92            cl::desc("Enable less precise MAD instructions to be generated"),
93            cl::init(false));
94
95cl::opt<bool>
96DisableFPElim("disable-fp-elim",
97              cl::desc("Disable frame pointer elimination optimization"),
98              cl::init(false));
99
100cl::opt<bool>
101EnableUnsafeFPMath("enable-unsafe-fp-math",
102                cl::desc("Enable optimizations that may decrease FP precision"),
103                cl::init(false));
104
105cl::opt<bool>
106EnableNoInfsFPMath("enable-no-infs-fp-math",
107                cl::desc("Enable FP math optimizations that assume no +-Infs"),
108                cl::init(false));
109
110cl::opt<bool>
111EnableNoNaNsFPMath("enable-no-nans-fp-math",
112                   cl::desc("Enable FP math optimizations that assume no NaNs"),
113                   cl::init(false));
114
115cl::opt<bool>
116EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math",
117      cl::Hidden,
118      cl::desc("Force codegen to assume rounding mode can change dynamically"),
119      cl::init(false));
120
121cl::opt<bool>
122GenerateSoftFloatCalls("soft-float",
123                    cl::desc("Generate software floating point library calls"),
124                    cl::init(false));
125
126cl::opt<llvm::FloatABI::ABIType>
127FloatABIForCalls("float-abi",
128                 cl::desc("Choose float ABI type"),
129                 cl::init(FloatABI::Default),
130                 cl::values(
131                     clEnumValN(FloatABI::Default, "default",
132                                "Target default float ABI type"),
133                     clEnumValN(FloatABI::Soft, "soft",
134                                "Soft float ABI (implied by -soft-float)"),
135                     clEnumValN(FloatABI::Hard, "hard",
136                                "Hard float ABI (uses FP registers)"),
137                     clEnumValEnd));
138
139cl::opt<llvm::FPOpFusion::FPOpFusionMode>
140FuseFPOps("fp-contract",
141          cl::desc("Enable aggressive formation of fused FP ops"),
142          cl::init(FPOpFusion::Standard),
143          cl::values(
144              clEnumValN(FPOpFusion::Fast, "fast",
145                         "Fuse FP ops whenever profitable"),
146              clEnumValN(FPOpFusion::Standard, "on",
147                         "Only fuse 'blessed' FP ops."),
148              clEnumValN(FPOpFusion::Strict, "off",
149                         "Only fuse FP ops when the result won't be effected."),
150              clEnumValEnd));
151
152cl::opt<bool>
153DontPlaceZerosInBSS("nozero-initialized-in-bss",
154              cl::desc("Don't place zero-initialized symbols into bss section"),
155              cl::init(false));
156
157cl::opt<bool>
158EnableGuaranteedTailCallOpt("tailcallopt",
159  cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."),
160  cl::init(false));
161
162cl::opt<bool>
163DisableTailCalls("disable-tail-calls",
164                 cl::desc("Never emit tail calls"),
165                 cl::init(false));
166
167cl::opt<unsigned>
168OverrideStackAlignment("stack-alignment",
169                       cl::desc("Override default stack alignment"),
170                       cl::init(0));
171
172cl::opt<std::string>
173TrapFuncName("trap-func", cl::Hidden,
174        cl::desc("Emit a call to trap function rather than a trap instruction"),
175        cl::init(""));
176
177cl::opt<bool>
178EnablePIE("enable-pie",
179          cl::desc("Assume the creation of a position independent executable."),
180          cl::init(false));
181
182cl::opt<bool>
183UseInitArray("use-init-array",
184             cl::desc("Use .init_array instead of .ctors."),
185             cl::init(false));
186
187cl::opt<std::string> StopAfter("stop-after",
188                            cl::desc("Stop compilation after a specific pass"),
189                            cl::value_desc("pass-name"),
190                                      cl::init(""));
191cl::opt<std::string> StartAfter("start-after",
192                          cl::desc("Resume compilation after a specific pass"),
193                          cl::value_desc("pass-name"),
194                          cl::init(""));
195
196cl::opt<bool> DataSections("data-sections",
197                           cl::desc("Emit data into separate sections"),
198                           cl::init(false));
199
200cl::opt<bool>
201FunctionSections("function-sections",
202                 cl::desc("Emit functions into separate sections"),
203                 cl::init(false));
204
205cl::opt<llvm::JumpTable::JumpTableType>
206JTableType("jump-table-type",
207          cl::desc("Choose the type of Jump-Instruction Table for jumptable."),
208          cl::init(JumpTable::Single),
209          cl::values(
210              clEnumValN(JumpTable::Single, "single",
211                         "Create a single table for all jumptable functions"),
212              clEnumValN(JumpTable::Arity, "arity",
213                         "Create one table per number of parameters."),
214              clEnumValN(JumpTable::Simplified, "simplified",
215                         "Create one table per simplified function type."),
216              clEnumValN(JumpTable::Full, "full",
217                         "Create one table per unique function type."),
218              clEnumValEnd));
219
220// Common utility function tightly tied to the options listed here. Initializes
221// a TargetOptions object with CodeGen flags and returns it.
222static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
223  TargetOptions Options;
224  Options.LessPreciseFPMADOption = EnableFPMAD;
225  Options.NoFramePointerElim = DisableFPElim;
226  Options.AllowFPOpFusion = FuseFPOps;
227  Options.UnsafeFPMath = EnableUnsafeFPMath;
228  Options.NoInfsFPMath = EnableNoInfsFPMath;
229  Options.NoNaNsFPMath = EnableNoNaNsFPMath;
230  Options.HonorSignDependentRoundingFPMathOption =
231      EnableHonorSignDependentRoundingFPMath;
232  Options.UseSoftFloat = GenerateSoftFloatCalls;
233  if (FloatABIForCalls != FloatABI::Default)
234    Options.FloatABIType = FloatABIForCalls;
235  Options.NoZerosInBSS = DontPlaceZerosInBSS;
236  Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
237  Options.DisableTailCalls = DisableTailCalls;
238  Options.StackAlignmentOverride = OverrideStackAlignment;
239  Options.TrapFuncName = TrapFuncName;
240  Options.PositionIndependentExecutable = EnablePIE;
241  Options.UseInitArray = UseInitArray;
242  Options.DataSections = DataSections;
243  Options.FunctionSections = FunctionSections;
244
245  Options.MCOptions = InitMCTargetOptionsFromFlags();
246  Options.JTType = JTableType;
247
248  return Options;
249}
250
251#endif
252