1//===-- Flang.cpp - Flang+LLVM ToolChain Implementations --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Flang.h"
10#include "Arch/RISCV.h"
11
12#include "clang/Basic/CodeGenOptions.h"
13#include "clang/Driver/CommonArgs.h"
14#include "clang/Options/OptionUtils.h"
15#include "clang/Options/Options.h"
16#include "llvm/Frontend/Debug/Options.h"
17#include "llvm/Support/Path.h"
18#include "llvm/TargetParser/Host.h"
19#include "llvm/TargetParser/RISCVISAInfo.h"
20#include "llvm/TargetParser/RISCVTargetParser.h"
21
22#include <cassert>
23
24using namespace clang::driver;
25using namespace clang::driver::tools;
26using namespace clang;
27using namespace llvm::opt;
28
29/// Add -x lang to \p CmdArgs for \p Input.
30static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
31 ArgStringList &CmdArgs) {
32 CmdArgs.push_back(Elt: "-x");
33 // Map the driver type to the frontend type.
34 CmdArgs.push_back(Elt: types::getTypeName(Id: Input.getType()));
35}
36
37void Flang::addFortranDialectOptions(const ArgList &Args,
38 ArgStringList &CmdArgs) const {
39 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_ffixed_form,
40 options::OPT_ffree_form,
41 options::OPT_ffixed_line_length_EQ,
42 options::OPT_fopenacc,
43 options::OPT_finput_charset_EQ,
44 options::OPT_fimplicit_none,
45 options::OPT_fimplicit_none_ext,
46 options::OPT_fno_implicit_none,
47 options::OPT_fbackslash,
48 options::OPT_fno_backslash,
49 options::OPT_flogical_abbreviations,
50 options::OPT_fno_logical_abbreviations,
51 options::OPT_fxor_operator,
52 options::OPT_fno_xor_operator,
53 options::OPT_falternative_parameter_statement,
54 options::OPT_fdefault_integer_4,
55 options::OPT_fdefault_real_4,
56 options::OPT_fdefault_real_8,
57 options::OPT_fdefault_integer_8,
58 options::OPT_fdefault_double_8,
59 options::OPT_flarge_sizes,
60 options::OPT_fno_automatic,
61 options::OPT_fhermetic_module_files,
62 options::OPT_frealloc_lhs,
63 options::OPT_fno_realloc_lhs,
64 options::OPT_fsave_main_program,
65 options::OPT_fd_lines_as_code,
66 options::OPT_fd_lines_as_comments,
67 options::OPT_fno_save_main_program});
68}
69
70void Flang::addPreprocessingOptions(const ArgList &Args,
71 ArgStringList &CmdArgs) const {
72 Args.addAllArgs(Output&: CmdArgs,
73 Ids: {options::OPT_P, options::OPT_D, options::OPT_U,
74 options::OPT_I, options::OPT_cpp, options::OPT_nocpp});
75}
76
77/// @C shouldLoopVersion
78///
79/// Check if Loop Versioning should be enabled.
80/// We look for the last of one of the following:
81/// -Ofast, -O4, -O<number> and -f[no-]version-loops-for-stride.
82/// Loop versioning is disabled if the last option is
83/// -fno-version-loops-for-stride.
84/// Loop versioning is enabled if the last option is one of:
85/// -floop-versioning
86/// -Ofast
87/// -O4
88/// -O3
89/// For all other cases, loop versioning is is disabled.
90///
91/// The gfortran compiler automatically enables the option for -O3 or -Ofast.
92///
93/// @return true if loop-versioning should be enabled, otherwise false.
94static bool shouldLoopVersion(const ArgList &Args) {
95 const Arg *LoopVersioningArg = Args.getLastArg(
96 Ids: options::OPT_Ofast, Ids: options::OPT_O, Ids: options::OPT_O4,
97 Ids: options::OPT_floop_versioning, Ids: options::OPT_fno_loop_versioning);
98 if (!LoopVersioningArg)
99 return false;
100
101 if (LoopVersioningArg->getOption().matches(ID: options::OPT_fno_loop_versioning))
102 return false;
103
104 if (LoopVersioningArg->getOption().matches(ID: options::OPT_floop_versioning))
105 return true;
106
107 if (LoopVersioningArg->getOption().matches(ID: options::OPT_Ofast) ||
108 LoopVersioningArg->getOption().matches(ID: options::OPT_O4))
109 return true;
110
111 if (LoopVersioningArg->getOption().matches(ID: options::OPT_O)) {
112 StringRef S(LoopVersioningArg->getValue());
113 unsigned OptLevel = 0;
114 // Note -Os or Oz woould "fail" here, so return false. Which is the
115 // desiered behavior.
116 if (S.getAsInteger(Radix: 10, Result&: OptLevel))
117 return false;
118
119 return OptLevel > 2;
120 }
121
122 llvm_unreachable("We should not end up here");
123 return false;
124}
125
126void Flang::addDebugOptions(const llvm::opt::ArgList &Args, const JobAction &JA,
127 const InputInfo &Output, const InputInfo &Input,
128 llvm::opt::ArgStringList &CmdArgs) const {
129 const auto &TC = getToolChain();
130 const Driver &D = TC.getDriver();
131 Args.addAllArgs(Output&: CmdArgs,
132 Ids: {options::OPT_module_dir, options::OPT_fdebug_module_writer,
133 options::OPT_fintrinsic_modules_path, options::OPT_pedantic,
134 options::OPT_std_EQ, options::OPT_W_Joined,
135 options::OPT_fconvert_EQ, options::OPT_fpass_plugin_EQ,
136 options::OPT_funderscoring, options::OPT_fno_underscoring,
137 options::OPT_funsigned, options::OPT_fno_unsigned,
138 options::OPT_finstrument_functions});
139
140 llvm::codegenoptions::DebugInfoKind DebugInfoKind;
141 bool hasDwarfNArg = getDwarfNArg(Args) != nullptr;
142 if (Args.hasArg(Ids: options::OPT_gN_Group)) {
143 Arg *gNArg = Args.getLastArg(Ids: options::OPT_gN_Group);
144 DebugInfoKind = debugLevelToInfoKind(A: *gNArg);
145 } else if (Args.hasArg(Ids: options::OPT_g_Flag) || hasDwarfNArg) {
146 DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
147 } else {
148 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
149 }
150 addDebugInfoKind(CmdArgs, DebugInfoKind);
151 if (hasDwarfNArg) {
152 const unsigned DwarfVersion = getDwarfVersion(TC: getToolChain(), Args);
153 CmdArgs.push_back(
154 Elt: Args.MakeArgString(Str: "-dwarf-version=" + Twine(DwarfVersion)));
155 }
156 if (Args.hasArg(Ids: options::OPT_gsplit_dwarf) ||
157 Args.hasArg(Ids: options::OPT_gsplit_dwarf_EQ)) {
158 // FIXME: -gsplit-dwarf on AIX is currently unimplemented.
159 if (TC.getTriple().isOSAIX()) {
160 D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
161 << Args.getLastArg(Ids: options::OPT_gsplit_dwarf)->getSpelling()
162 << TC.getTriple().str();
163 return;
164 }
165 if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo)
166 return;
167
168 Arg *SplitDWARFArg;
169 DwarfFissionKind DwarfFission = getDebugFissionKind(D, Args, Arg&: SplitDWARFArg);
170
171 if (DwarfFission == DwarfFissionKind::None ||
172 !checkDebugInfoOption(A: SplitDWARFArg, Args, D, TC))
173 return;
174
175 if (!TC.getTriple().isOSBinFormatELF() &&
176 !TC.getTriple().isOSBinFormatWasm() &&
177 !TC.getTriple().isOSBinFormatCOFF()) {
178 D.Diag(DiagID: diag::warn_drv_unsupported_debug_info_opt_for_target)
179 << SplitDWARFArg->getSpelling() << TC.getTriple().str();
180 return;
181 }
182
183 if (!isa<AssembleJobAction>(Val: JA) && !isa<CompileJobAction>(Val: JA) &&
184 isa<BackendJobAction>(Val: JA))
185 return;
186
187 const char *SplitDWARFOut = SplitDebugName(JA, Args, Input, Output);
188 CmdArgs.push_back(Elt: "-split-dwarf-file");
189 CmdArgs.push_back(Elt: SplitDWARFOut);
190 if (DwarfFission == DwarfFissionKind::Split) {
191 CmdArgs.push_back(Elt: "-split-dwarf-output");
192 CmdArgs.push_back(Elt: SplitDWARFOut);
193 }
194 }
195}
196
197void Flang::addCodegenOptions(const ArgList &Args,
198 ArgStringList &CmdArgs) const {
199 Arg *stackArrays =
200 Args.getLastArg(Ids: options::OPT_Ofast, Ids: options::OPT_fstack_arrays,
201 Ids: options::OPT_fno_stack_arrays);
202 if (stackArrays &&
203 !stackArrays->getOption().matches(ID: options::OPT_fno_stack_arrays))
204 CmdArgs.push_back(Elt: "-fstack-arrays");
205
206 // -fno-protect-parens is the default for -Ofast.
207 if (!Args.hasFlag(Pos: options::OPT_fprotect_parens,
208 Neg: options::OPT_fno_protect_parens,
209 /*Default=*/!Args.hasArg(Ids: options::OPT_Ofast)))
210 CmdArgs.push_back(Elt: "-fno-protect-parens");
211
212 if (Args.hasFlag(Pos: options::OPT_funsafe_cray_pointers,
213 Neg: options::OPT_fno_unsafe_cray_pointers, Default: false)) {
214 // TODO: currently passed as MLIR option
215 CmdArgs.push_back(Elt: "-mmlir");
216 CmdArgs.push_back(Elt: "-unsafe-cray-pointers");
217 }
218
219 Args.addOptInFlag(Output&: CmdArgs, Pos: options::OPT_fexperimental_loop_fusion,
220 Neg: options::OPT_fno_experimental_loop_fusion);
221
222 handleInterchangeLoopsArgs(Args, CmdArgs);
223 handleVectorizeLoopsArgs(Args, CmdArgs);
224 handleVectorizeSLPArgs(Args, CmdArgs);
225
226 if (shouldLoopVersion(Args))
227 CmdArgs.push_back(Elt: "-fversion-loops-for-stride");
228
229 for (const auto &arg :
230 Args.getAllArgValues(Id: options::OPT_frepack_arrays_contiguity_EQ))
231 if (arg != "whole" && arg != "innermost") {
232 getToolChain().getDriver().Diag(DiagID: diag::err_drv_unsupported_option_argument)
233 << "-frepack-arrays-contiguity=" << arg;
234 }
235
236 Args.addAllArgs(
237 Output&: CmdArgs,
238 Ids: {options::OPT_fdo_concurrent_to_openmp_EQ,
239 options::OPT_flang_experimental_hlfir,
240 options::OPT_flang_deprecated_no_hlfir,
241 options::OPT_fno_ppc_native_vec_elem_order,
242 options::OPT_fppc_native_vec_elem_order, options::OPT_finit_global_zero,
243 options::OPT_fno_init_global_zero, options::OPT_frepack_arrays,
244 options::OPT_fno_repack_arrays,
245 options::OPT_frepack_arrays_contiguity_EQ,
246 options::OPT_fstack_repack_arrays, options::OPT_fno_stack_repack_arrays,
247 options::OPT_ftime_report, options::OPT_ftime_report_EQ,
248 options::OPT_funroll_loops, options::OPT_fno_unroll_loops});
249 if (Args.hasArg(Ids: options::OPT_fcoarray))
250 CmdArgs.push_back(Elt: "-fcoarray");
251}
252
253void Flang::addLTOOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
254 const ToolChain &TC = getToolChain();
255 const Driver &D = TC.getDriver();
256 DiagnosticsEngine &Diags = D.getDiags();
257 LTOKind LTOMode = D.getLTOMode();
258 // LTO mode is parsed by the Clang driver library.
259 assert(LTOMode != LTOK_Unknown && "Unknown LTO mode.");
260 if (LTOMode == LTOK_Full)
261 CmdArgs.push_back(Elt: "-flto=full");
262 else if (LTOMode == LTOK_Thin) {
263 Diags.Report(
264 DiagID: Diags.getCustomDiagID(L: DiagnosticsEngine::Warning,
265 FormatString: "the option '-flto=thin' is a work in progress"));
266 CmdArgs.push_back(Elt: "-flto=thin");
267 }
268 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_ffat_lto_objects,
269 options::OPT_fno_fat_lto_objects});
270}
271
272void Flang::addPicOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
273 // ParsePICArgs parses -fPIC/-fPIE and their variants and returns a tuple of
274 // (RelocationModel, PICLevel, IsPIE).
275 llvm::Reloc::Model RelocationModel;
276 unsigned PICLevel;
277 bool IsPIE;
278 std::tie(args&: RelocationModel, args&: PICLevel, args&: IsPIE) =
279 ParsePICArgs(ToolChain: getToolChain(), Args);
280
281 if (auto *RMName = RelocationModelName(Model: RelocationModel)) {
282 CmdArgs.push_back(Elt: "-mrelocation-model");
283 CmdArgs.push_back(Elt: RMName);
284 }
285 if (PICLevel > 0) {
286 CmdArgs.push_back(Elt: "-pic-level");
287 CmdArgs.push_back(Elt: PICLevel == 1 ? "1" : "2");
288 if (IsPIE)
289 CmdArgs.push_back(Elt: "-pic-is-pie");
290 }
291}
292
293void Flang::AddAArch64TargetArgs(const ArgList &Args,
294 ArgStringList &CmdArgs) const {
295 // Handle -msve_vector_bits=<bits>
296 if (Arg *A = Args.getLastArg(Ids: options::OPT_msve_vector_bits_EQ)) {
297 StringRef Val = A->getValue();
298 const Driver &D = getToolChain().getDriver();
299 if (Val == "128" || Val == "256" || Val == "512" || Val == "1024" ||
300 Val == "2048" || Val == "128+" || Val == "256+" || Val == "512+" ||
301 Val == "1024+" || Val == "2048+") {
302 unsigned Bits = 0;
303 if (!Val.consume_back(Suffix: "+")) {
304 [[maybe_unused]] bool Invalid = Val.getAsInteger(Radix: 10, Result&: Bits);
305 assert(!Invalid && "Failed to parse value");
306 CmdArgs.push_back(
307 Elt: Args.MakeArgString(Str: "-mvscale-max=" + llvm::Twine(Bits / 128)));
308 }
309
310 [[maybe_unused]] bool Invalid = Val.getAsInteger(Radix: 10, Result&: Bits);
311 assert(!Invalid && "Failed to parse value");
312 CmdArgs.push_back(
313 Elt: Args.MakeArgString(Str: "-mvscale-min=" + llvm::Twine(Bits / 128)));
314 // Silently drop requests for vector-length agnostic code as it's implied.
315 } else if (Val != "scalable")
316 // Handle the unsupported values passed to msve-vector-bits.
317 D.Diag(DiagID: diag::err_drv_unsupported_option_argument)
318 << A->getSpelling() << Val;
319 }
320}
321
322void Flang::AddLoongArch64TargetArgs(const ArgList &Args,
323 ArgStringList &CmdArgs) const {
324 const Driver &D = getToolChain().getDriver();
325 // Currently, flang only support `-mabi=lp64d` in LoongArch64.
326 if (const Arg *A = Args.getLastArg(Ids: options::OPT_mabi_EQ)) {
327 StringRef V = A->getValue();
328 if (V != "lp64d") {
329 D.Diag(DiagID: diag::err_drv_argument_not_allowed_with) << "-mabi" << V;
330 }
331 }
332
333 if (const Arg *A = Args.getLastArg(Ids: options::OPT_mannotate_tablejump,
334 Ids: options::OPT_mno_annotate_tablejump)) {
335 if (A->getOption().matches(ID: options::OPT_mannotate_tablejump)) {
336 CmdArgs.push_back(Elt: "-mllvm");
337 CmdArgs.push_back(Elt: "-loongarch-annotate-tablejump");
338 }
339 }
340}
341
342void Flang::AddPPCTargetArgs(const ArgList &Args,
343 ArgStringList &CmdArgs) const {
344 const Driver &D = getToolChain().getDriver();
345 bool VecExtabi = false;
346
347 if (const Arg *A = Args.getLastArg(Ids: options::OPT_mabi_EQ)) {
348 StringRef V = A->getValue();
349 if (V == "vec-extabi")
350 VecExtabi = true;
351 else if (V == "vec-default")
352 VecExtabi = false;
353 else
354 D.Diag(DiagID: diag::err_drv_unsupported_option_argument)
355 << A->getSpelling() << V;
356 }
357
358 const llvm::Triple &T = getToolChain().getTriple();
359 if (VecExtabi) {
360 if (!T.isOSAIX()) {
361 D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
362 << "-mabi=vec-extabi" << T.str();
363 }
364 CmdArgs.push_back(Elt: "-mabi=vec-extabi");
365 }
366}
367
368void Flang::AddRISCVTargetArgs(const ArgList &Args,
369 ArgStringList &CmdArgs) const {
370 const Driver &D = getToolChain().getDriver();
371 const llvm::Triple &Triple = getToolChain().getTriple();
372
373 StringRef ABIName = riscv::getRISCVABI(Args, Triple);
374 if (ABIName == "lp64" || ABIName == "lp64f" || ABIName == "lp64d")
375 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mabi=" + ABIName));
376 else
377 D.Diag(DiagID: diag::err_drv_unsupported_option_argument) << "-mabi=" << ABIName;
378
379 // Handle -mrvv-vector-bits=<bits>
380 if (Arg *A = Args.getLastArg(Ids: options::OPT_mrvv_vector_bits_EQ)) {
381 StringRef Val = A->getValue();
382
383 // Get minimum VLen from march.
384 unsigned MinVLen = 0;
385 std::string Arch = riscv::getRISCVArch(Args, Triple);
386 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
387 Arch, /*EnableExperimentalExtensions*/ EnableExperimentalExtension: true);
388 // Ignore parsing error.
389 if (!errorToBool(Err: ISAInfo.takeError()))
390 MinVLen = (*ISAInfo)->getMinVLen();
391
392 // If the value is "zvl", use MinVLen from march. Otherwise, try to parse
393 // as integer as long as we have a MinVLen.
394 unsigned Bits = 0;
395 if (Val == "zvl" && MinVLen >= llvm::RISCV::RVVBitsPerBlock) {
396 Bits = MinVLen;
397 } else if (!Val.getAsInteger(Radix: 10, Result&: Bits)) {
398 // Only accept power of 2 values beteen RVVBitsPerBlock and 65536 that
399 // at least MinVLen.
400 if (Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||
401 Bits > 65536 || !llvm::isPowerOf2_32(Value: Bits))
402 Bits = 0;
403 }
404
405 // If we got a valid value try to use it.
406 if (Bits != 0) {
407 unsigned VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;
408 CmdArgs.push_back(
409 Elt: Args.MakeArgString(Str: "-mvscale-max=" + llvm::Twine(VScaleMin)));
410 CmdArgs.push_back(
411 Elt: Args.MakeArgString(Str: "-mvscale-min=" + llvm::Twine(VScaleMin)));
412 } else if (Val != "scalable") {
413 // Handle the unsupported values passed to mrvv-vector-bits.
414 D.Diag(DiagID: diag::err_drv_unsupported_option_argument)
415 << A->getSpelling() << Val;
416 }
417 }
418}
419
420void Flang::AddX86_64TargetArgs(const ArgList &Args,
421 ArgStringList &CmdArgs) const {
422 if (Arg *A = Args.getLastArg(Ids: options::OPT_masm_EQ)) {
423 StringRef Value = A->getValue();
424 if (Value == "intel" || Value == "att") {
425 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mllvm"));
426 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-x86-asm-syntax=" + Value));
427 } else {
428 getToolChain().getDriver().Diag(DiagID: diag::err_drv_unsupported_option_argument)
429 << A->getSpelling() << Value;
430 }
431 }
432}
433
434static void addVSDefines(const ToolChain &TC, const ArgList &Args,
435 ArgStringList &CmdArgs) {
436
437 unsigned ver = 0;
438 const VersionTuple vt = TC.computeMSVCVersion(D: nullptr, Args);
439 ver = vt.getMajor() * 10000000 + vt.getMinor().value_or(u: 0) * 100000 +
440 vt.getSubminor().value_or(u: 0);
441 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-D_MSC_VER=" + Twine(ver / 100000)));
442 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-D_MSC_FULL_VER=" + Twine(ver)));
443 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-D_WIN32"));
444
445 const llvm::Triple &triple = TC.getTriple();
446 if (triple.isAArch64()) {
447 CmdArgs.push_back(Elt: "-D_M_ARM64=1");
448 } else if (triple.isX86() && triple.isArch32Bit()) {
449 CmdArgs.push_back(Elt: "-D_M_IX86=600");
450 } else if (triple.isX86() && triple.isArch64Bit()) {
451 CmdArgs.push_back(Elt: "-D_M_X64=100");
452 } else {
453 llvm_unreachable(
454 "Flang on Windows only supports X86_32, X86_64 and AArch64");
455 }
456}
457
458static void processVSRuntimeLibrary(const ToolChain &TC, const ArgList &Args,
459 ArgStringList &CmdArgs) {
460 assert(TC.getTriple().isKnownWindowsMSVCEnvironment() &&
461 "can only add VS runtime library on Windows!");
462
463 // Flang/Clang (including clang-cl) -compiled programs targeting the MSVC ABI
464 // should only depend on msv(u)crt. LLVM still emits libgcc/compiler-rt
465 // functions in some cases like 128-bit integer math (__udivti3, __modti3,
466 // __fixsfti, __floattidf, ...) that msvc does not support. We are injecting a
467 // dependency to Compiler-RT's builtin library where these are implemented.
468 CmdArgs.push_back(Elt: Args.MakeArgString(
469 Str: "--dependent-lib=" + TC.getCompilerRTBasename(Args, Component: "builtins")));
470
471 unsigned RTOptionID = options::OPT__SLASH_MT;
472 if (auto *rtl = Args.getLastArg(Ids: options::OPT_fms_runtime_lib_EQ)) {
473 RTOptionID = llvm::StringSwitch<unsigned>(rtl->getValue())
474 .Case(S: "static", Value: options::OPT__SLASH_MT)
475 .Case(S: "static_dbg", Value: options::OPT__SLASH_MTd)
476 .Case(S: "dll", Value: options::OPT__SLASH_MD)
477 .Case(S: "dll_dbg", Value: options::OPT__SLASH_MDd)
478 .Default(Value: options::OPT__SLASH_MT);
479 }
480 switch (RTOptionID) {
481 case options::OPT__SLASH_MT:
482 CmdArgs.push_back(Elt: "-D_MT");
483 CmdArgs.push_back(Elt: "--dependent-lib=libcmt");
484 CmdArgs.push_back(Elt: "--dependent-lib=flang_rt.runtime.static.lib");
485 break;
486 case options::OPT__SLASH_MTd:
487 CmdArgs.push_back(Elt: "-D_MT");
488 CmdArgs.push_back(Elt: "-D_DEBUG");
489 CmdArgs.push_back(Elt: "--dependent-lib=libcmtd");
490 CmdArgs.push_back(Elt: "--dependent-lib=flang_rt.runtime.static_dbg.lib");
491 break;
492 case options::OPT__SLASH_MD:
493 CmdArgs.push_back(Elt: "-D_MT");
494 CmdArgs.push_back(Elt: "-D_DLL");
495 CmdArgs.push_back(Elt: "--dependent-lib=msvcrt");
496 CmdArgs.push_back(Elt: "--dependent-lib=flang_rt.runtime.dynamic.lib");
497 break;
498 case options::OPT__SLASH_MDd:
499 CmdArgs.push_back(Elt: "-D_MT");
500 CmdArgs.push_back(Elt: "-D_DEBUG");
501 CmdArgs.push_back(Elt: "-D_DLL");
502 CmdArgs.push_back(Elt: "--dependent-lib=msvcrtd");
503 CmdArgs.push_back(Elt: "--dependent-lib=flang_rt.runtime.dynamic_dbg.lib");
504 break;
505 }
506}
507
508void Flang::AddAMDGPUTargetArgs(const ArgList &Args,
509 ArgStringList &CmdArgs) const {
510 if (Arg *A = Args.getLastArg(Ids: options::OPT_mcode_object_version_EQ)) {
511 StringRef Val = A->getValue();
512 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mcode-object-version=" + Val));
513 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mllvm"));
514 CmdArgs.push_back(
515 Elt: Args.MakeArgString(Str: "--amdhsa-code-object-version=" + Val));
516 }
517
518 const ToolChain &TC = getToolChain();
519 TC.addClangTargetOptions(DriverArgs: Args, CC1Args&: CmdArgs, DeviceOffloadKind: Action::OffloadKind::OFK_OpenMP);
520}
521
522void Flang::addTargetOptions(const ArgList &Args,
523 ArgStringList &CmdArgs) const {
524 const ToolChain &TC = getToolChain();
525 const llvm::Triple &Triple = TC.getEffectiveTriple();
526 const Driver &D = TC.getDriver();
527
528 std::string CPU = getCPUName(D, Args, T: Triple);
529 if (!CPU.empty()) {
530 CmdArgs.push_back(Elt: "-target-cpu");
531 CmdArgs.push_back(Elt: Args.MakeArgString(Str: CPU));
532 }
533
534 addOutlineAtomicsArgs(D, TC: getToolChain(), Args, CmdArgs, Triple);
535
536 // Add the target features.
537 switch (TC.getArch()) {
538 default:
539 getTargetFeatures(D, Triple, Args, CmdArgs, /*ForAs*/ ForAS: false);
540 break;
541 case llvm::Triple::aarch64:
542 getTargetFeatures(D, Triple, Args, CmdArgs, /*ForAs*/ ForAS: false);
543 AddAArch64TargetArgs(Args, CmdArgs);
544 break;
545
546 case llvm::Triple::r600:
547 case llvm::Triple::amdgcn:
548 getTargetFeatures(D, Triple, Args, CmdArgs, /*ForAs*/ ForAS: false);
549 AddAMDGPUTargetArgs(Args, CmdArgs);
550 break;
551 case llvm::Triple::riscv64:
552 getTargetFeatures(D, Triple, Args, CmdArgs, /*ForAs*/ ForAS: false);
553 AddRISCVTargetArgs(Args, CmdArgs);
554 break;
555 case llvm::Triple::x86_64:
556 getTargetFeatures(D, Triple, Args, CmdArgs, /*ForAs*/ ForAS: false);
557 AddX86_64TargetArgs(Args, CmdArgs);
558 break;
559 case llvm::Triple::ppc:
560 case llvm::Triple::ppc64:
561 case llvm::Triple::ppc64le:
562 AddPPCTargetArgs(Args, CmdArgs);
563 break;
564 case llvm::Triple::loongarch64:
565 getTargetFeatures(D, Triple, Args, CmdArgs, /*ForAs*/ ForAS: false);
566 AddLoongArch64TargetArgs(Args, CmdArgs);
567 break;
568 }
569
570 if (Arg *A = Args.getLastArg(Ids: options::OPT_fveclib)) {
571 StringRef Name = A->getValue();
572 if (Name == "SVML") {
573 if (Triple.getArch() != llvm::Triple::x86 &&
574 Triple.getArch() != llvm::Triple::x86_64)
575 D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
576 << Name << Triple.getArchName();
577 } else if (Name == "AMDLIBM") {
578 if (Triple.getArch() != llvm::Triple::x86 &&
579 Triple.getArch() != llvm::Triple::x86_64)
580 D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
581 << Name << Triple.getArchName();
582 } else if (Name == "libmvec") {
583 if (Triple.getArch() != llvm::Triple::x86 &&
584 Triple.getArch() != llvm::Triple::x86_64 &&
585 Triple.getArch() != llvm::Triple::aarch64 &&
586 Triple.getArch() != llvm::Triple::aarch64_be)
587 D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
588 << Name << Triple.getArchName();
589 } else if (Name == "SLEEF" || Name == "ArmPL") {
590 if (Triple.getArch() != llvm::Triple::aarch64 &&
591 Triple.getArch() != llvm::Triple::aarch64_be)
592 D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
593 << Name << Triple.getArchName();
594 }
595
596 if (Triple.isOSDarwin()) {
597 // flang doesn't currently suport nostdlib, nodefaultlibs. Adding these
598 // here incase they are added someday
599 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs)) {
600 if (A->getValue() == StringRef{"Accelerate"}) {
601 CmdArgs.push_back(Elt: "-framework");
602 CmdArgs.push_back(Elt: "Accelerate");
603 }
604 }
605 }
606 A->render(Args, Output&: CmdArgs);
607 }
608
609 if (Triple.isKnownWindowsMSVCEnvironment()) {
610 processVSRuntimeLibrary(TC, Args, CmdArgs);
611 addVSDefines(TC, Args, CmdArgs);
612 }
613
614 // TODO: Add target specific flags, ABI, mtune option etc.
615 if (const Arg *A = Args.getLastArg(Ids: options::OPT_mtune_EQ)) {
616 CmdArgs.push_back(Elt: "-tune-cpu");
617 if (A->getValue() == StringRef{"native"})
618 CmdArgs.push_back(Elt: Args.MakeArgString(Str: llvm::sys::getHostCPUName()));
619 else
620 CmdArgs.push_back(Elt: A->getValue());
621 }
622
623 Args.addAllArgs(Output&: CmdArgs,
624 Ids: {options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
625 options::OPT_fatomic_ignore_denormal_mode,
626 options::OPT_fno_atomic_ignore_denormal_mode,
627 options::OPT_fatomic_fine_grained_memory,
628 options::OPT_fno_atomic_fine_grained_memory,
629 options::OPT_fatomic_remote_memory,
630 options::OPT_fno_atomic_remote_memory,
631 options::OPT_munsafe_fp_atomics});
632}
633
634void Flang::addOffloadOptions(Compilation &C, const InputInfoList &Inputs,
635 const JobAction &JA, const ArgList &Args,
636 ArgStringList &CmdArgs) const {
637 bool IsOpenMPDevice = JA.isDeviceOffloading(OKind: Action::OFK_OpenMP);
638 bool IsHostOffloadingAction = JA.isHostOffloading(OKind: Action::OFK_OpenMP) ||
639 JA.isHostOffloading(OKind: C.getActiveOffloadKinds());
640
641 // Skips the primary input file, which is the input file that the compilation
642 // proccess will be executed upon (e.g. the host bitcode file) and
643 // adds other secondary input (e.g. device bitcode files for embedding to the
644 // -fembed-offload-object argument or the host IR file for proccessing
645 // during device compilation to the fopenmp-host-ir-file-path argument via
646 // OpenMPDeviceInput). This is condensed logic from the ConstructJob
647 // function inside of the Clang driver for pushing on further input arguments
648 // needed for offloading during various phases of compilation.
649 for (size_t i = 1; i < Inputs.size(); ++i) {
650 if (Inputs[i].getType() == types::TY_Nothing) {
651 // contains nothing, so it's skippable
652 } else if (IsHostOffloadingAction) {
653 CmdArgs.push_back(
654 Elt: Args.MakeArgString(Str: "-fembed-offload-object=" +
655 getToolChain().getInputFilename(Input: Inputs[i])));
656 } else if (IsOpenMPDevice) {
657 if (Inputs[i].getFilename()) {
658 CmdArgs.push_back(Elt: "-fopenmp-host-ir-file-path");
659 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Inputs[i].getFilename()));
660 } else {
661 llvm_unreachable("missing openmp host-ir file for device offloading");
662 }
663 } else {
664 llvm_unreachable(
665 "unexpectedly given multiple inputs or given unknown input");
666 }
667 }
668
669 if (IsOpenMPDevice) {
670 // -fopenmp-is-target-device is passed along to tell the frontend that it is
671 // generating code for a device, so that only the relevant code is emitted.
672 CmdArgs.push_back(Elt: "-fopenmp-is-target-device");
673
674 // When in OpenMP offloading mode, enable debugging on the device.
675 Args.AddAllArgs(Output&: CmdArgs, Id0: options::OPT_fopenmp_target_debug_EQ);
676 if (Args.hasFlag(Pos: options::OPT_fopenmp_target_debug,
677 Neg: options::OPT_fno_openmp_target_debug, /*Default=*/false))
678 CmdArgs.push_back(Elt: "-fopenmp-target-debug");
679
680 // When in OpenMP offloading mode, forward assumptions information about
681 // thread and team counts in the device.
682 if (Args.hasFlag(Pos: options::OPT_fopenmp_assume_teams_oversubscription,
683 Neg: options::OPT_fno_openmp_assume_teams_oversubscription,
684 /*Default=*/false))
685 CmdArgs.push_back(Elt: "-fopenmp-assume-teams-oversubscription");
686 if (Args.hasFlag(Pos: options::OPT_fopenmp_assume_threads_oversubscription,
687 Neg: options::OPT_fno_openmp_assume_threads_oversubscription,
688 /*Default=*/false))
689 CmdArgs.push_back(Elt: "-fopenmp-assume-threads-oversubscription");
690 if (Args.hasArg(Ids: options::OPT_fopenmp_assume_no_thread_state))
691 CmdArgs.push_back(Elt: "-fopenmp-assume-no-thread-state");
692 if (Args.hasArg(Ids: options::OPT_fopenmp_assume_no_nested_parallelism))
693 CmdArgs.push_back(Elt: "-fopenmp-assume-no-nested-parallelism");
694 if (!Args.hasFlag(Pos: options::OPT_offloadlib, Neg: options::OPT_no_offloadlib,
695 Default: true))
696 CmdArgs.push_back(Elt: "-nogpulib");
697 }
698
699 addOpenMPHostOffloadingArgs(C, JA, Args, CmdArgs);
700}
701
702static void addFloatingPointOptions(const Driver &D, const ArgList &Args,
703 ArgStringList &CmdArgs) {
704 StringRef FPContract;
705 bool HonorINFs = true;
706 bool HonorNaNs = true;
707 bool ApproxFunc = false;
708 bool SignedZeros = true;
709 bool AssociativeMath = false;
710 bool ReciprocalMath = false;
711
712 StringRef LastComplexRangeOption;
713 LangOptions::ComplexRangeKind Range = LangOptions::ComplexRangeKind::CX_None;
714
715 if (const Arg *A = Args.getLastArg(Ids: options::OPT_ffp_contract)) {
716 const StringRef Val = A->getValue();
717 if (Val == "fast" || Val == "off") {
718 FPContract = Val;
719 } else if (Val == "on") {
720 // Warn instead of error because users might have makefiles written for
721 // gfortran (which accepts -ffp-contract=on)
722 D.Diag(DiagID: diag::warn_drv_unsupported_option_for_flang)
723 << Val << A->getOption().getName() << "off";
724 FPContract = "off";
725 } else
726 // Clang's "fast-honor-pragmas" option is not supported because it is
727 // non-standard
728 D.Diag(DiagID: diag::err_drv_unsupported_option_argument)
729 << A->getSpelling() << Val;
730 }
731
732 for (const Arg *A : Args) {
733 auto optId = A->getOption().getID();
734 switch (optId) {
735 // if this isn't an FP option, skip the claim below
736 default:
737 continue;
738
739 case options::OPT_fcomplex_arithmetic_EQ: {
740 LangOptions::ComplexRangeKind NewRange;
741 StringRef Val = A->getValue();
742 if (Val == "full")
743 NewRange = LangOptions::ComplexRangeKind::CX_Full;
744 else if (Val == "improved")
745 NewRange = LangOptions::ComplexRangeKind::CX_Improved;
746 else if (Val == "basic")
747 NewRange = LangOptions::ComplexRangeKind::CX_Basic;
748 else {
749 D.Diag(DiagID: diag::err_drv_unsupported_option_argument)
750 << A->getSpelling() << Val;
751 break;
752 }
753
754 setComplexRange(D, NewOpt: Args.MakeArgString(Str: A->getSpelling() + Val), NewRange,
755 LastOpt&: LastComplexRangeOption, Range);
756 break;
757 }
758 case options::OPT_fhonor_infinities:
759 HonorINFs = true;
760 break;
761 case options::OPT_fno_honor_infinities:
762 HonorINFs = false;
763 break;
764 case options::OPT_fhonor_nans:
765 HonorNaNs = true;
766 break;
767 case options::OPT_fno_honor_nans:
768 HonorNaNs = false;
769 break;
770 case options::OPT_fapprox_func:
771 ApproxFunc = true;
772 break;
773 case options::OPT_fno_approx_func:
774 ApproxFunc = false;
775 break;
776 case options::OPT_fsigned_zeros:
777 SignedZeros = true;
778 break;
779 case options::OPT_fno_signed_zeros:
780 SignedZeros = false;
781 break;
782 case options::OPT_fassociative_math:
783 AssociativeMath = true;
784 break;
785 case options::OPT_fno_associative_math:
786 AssociativeMath = false;
787 break;
788 case options::OPT_freciprocal_math:
789 ReciprocalMath = true;
790 break;
791 case options::OPT_fno_reciprocal_math:
792 ReciprocalMath = false;
793 break;
794 case options::OPT_Ofast:
795 [[fallthrough]];
796 case options::OPT_ffast_math:
797 HonorINFs = false;
798 HonorNaNs = false;
799 AssociativeMath = true;
800 ReciprocalMath = true;
801 ApproxFunc = true;
802 SignedZeros = false;
803 FPContract = "fast";
804 setComplexRange(D, NewOpt: A->getSpelling(),
805 NewRange: LangOptions::ComplexRangeKind::CX_Basic,
806 LastOpt&: LastComplexRangeOption, Range);
807 break;
808 case options::OPT_fno_fast_math:
809 HonorINFs = true;
810 HonorNaNs = true;
811 AssociativeMath = false;
812 ReciprocalMath = false;
813 ApproxFunc = false;
814 SignedZeros = true;
815 // -fno-fast-math should undo -ffast-math so I return FPContract to the
816 // default. It is important to check it is "fast" (the default) so that
817 // --ffp-contract=off -fno-fast-math --> -ffp-contract=off
818 if (FPContract == "fast")
819 FPContract = "";
820 setComplexRange(D, NewOpt: A->getSpelling(),
821 NewRange: LangOptions::ComplexRangeKind::CX_None,
822 LastOpt&: LastComplexRangeOption, Range);
823 break;
824 }
825
826 // If we handled this option claim it
827 A->claim();
828 }
829
830 StringRef Recip = parseMRecipOption(Diags&: D.getDiags(), Args);
831 if (!Recip.empty())
832 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mrecip=" + Recip));
833
834 if (Range != LangOptions::ComplexRangeKind::CX_None) {
835 std::string ComplexRangeStr = renderComplexRangeOption(Range);
836 CmdArgs.push_back(Elt: Args.MakeArgString(Str: ComplexRangeStr));
837 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-fcomplex-arithmetic=" +
838 complexRangeKindToStr(Range)));
839 }
840
841 if (llvm::opt::Arg *A =
842 Args.getLastArg(Ids: clang::options::OPT_ffast_real_mod,
843 Ids: clang::options::OPT_fno_fast_real_mod)) {
844 if (A->getOption().matches(ID: clang::options::OPT_ffast_real_mod))
845 CmdArgs.push_back(Elt: "-ffast-real-mod");
846 else if (A->getOption().matches(ID: clang::options::OPT_fno_fast_real_mod))
847 CmdArgs.push_back(Elt: "-fno-fast-real-mod");
848 }
849
850 if (!HonorINFs && !HonorNaNs && AssociativeMath && ReciprocalMath &&
851 ApproxFunc && !SignedZeros &&
852 (FPContract == "fast" || FPContract.empty())) {
853 CmdArgs.push_back(Elt: "-ffast-math");
854 return;
855 }
856
857 if (!FPContract.empty())
858 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-ffp-contract=" + FPContract));
859
860 if (!HonorINFs)
861 CmdArgs.push_back(Elt: "-menable-no-infs");
862
863 if (!HonorNaNs)
864 CmdArgs.push_back(Elt: "-menable-no-nans");
865
866 if (ApproxFunc)
867 CmdArgs.push_back(Elt: "-fapprox-func");
868
869 if (!SignedZeros)
870 CmdArgs.push_back(Elt: "-fno-signed-zeros");
871
872 if (AssociativeMath && !SignedZeros)
873 CmdArgs.push_back(Elt: "-mreassociate");
874
875 if (ReciprocalMath)
876 CmdArgs.push_back(Elt: "-freciprocal-math");
877}
878
879static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs,
880 const InputInfo &Input) {
881 StringRef Format = "yaml";
882 if (const Arg *A = Args.getLastArg(Ids: options::OPT_fsave_optimization_record_EQ))
883 Format = A->getValue();
884
885 CmdArgs.push_back(Elt: "-opt-record-file");
886
887 const Arg *A = Args.getLastArg(Ids: options::OPT_foptimization_record_file_EQ);
888 if (A) {
889 CmdArgs.push_back(Elt: A->getValue());
890 } else {
891 SmallString<128> F;
892
893 if (Args.hasArg(Ids: options::OPT_c) || Args.hasArg(Ids: options::OPT_S)) {
894 if (Arg *FinalOutput = Args.getLastArg(Ids: options::OPT_o))
895 F = FinalOutput->getValue();
896 }
897
898 if (F.empty()) {
899 // Use the input filename.
900 F = llvm::sys::path::stem(path: Input.getBaseInput());
901 }
902
903 SmallString<32> Extension;
904 Extension += "opt.";
905 Extension += Format;
906
907 llvm::sys::path::replace_extension(path&: F, extension: Extension);
908 CmdArgs.push_back(Elt: Args.MakeArgString(Str: F));
909 }
910
911 if (const Arg *A =
912 Args.getLastArg(Ids: options::OPT_foptimization_record_passes_EQ)) {
913 CmdArgs.push_back(Elt: "-opt-record-passes");
914 CmdArgs.push_back(Elt: A->getValue());
915 }
916
917 if (!Format.empty()) {
918 CmdArgs.push_back(Elt: "-opt-record-format");
919 CmdArgs.push_back(Elt: Format.data());
920 }
921}
922
923void Flang::ConstructJob(Compilation &C, const JobAction &JA,
924 const InputInfo &Output, const InputInfoList &Inputs,
925 const ArgList &Args, const char *LinkingOutput) const {
926 const auto &TC = getToolChain();
927 const llvm::Triple &Triple = TC.getEffectiveTriple();
928 const std::string &TripleStr = Triple.getTriple();
929
930 const Driver &D = TC.getDriver();
931 ArgStringList CmdArgs;
932
933 // Invoke ourselves in -fc1 mode.
934 CmdArgs.push_back(Elt: "-fc1");
935
936 // Add the "effective" target triple.
937 CmdArgs.push_back(Elt: "-triple");
938 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TripleStr));
939
940 if (isa<PreprocessJobAction>(Val: JA)) {
941 CmdArgs.push_back(Elt: "-E");
942 if (Args.getLastArg(Ids: options::OPT_dM)) {
943 CmdArgs.push_back(Elt: "-dM");
944 }
945 } else if (isa<CompileJobAction>(Val: JA) || isa<BackendJobAction>(Val: JA)) {
946 if (JA.getType() == types::TY_Nothing) {
947 CmdArgs.push_back(Elt: "-fsyntax-only");
948 } else if (JA.getType() == types::TY_AST) {
949 CmdArgs.push_back(Elt: "-emit-ast");
950 } else if (JA.getType() == types::TY_LLVM_IR ||
951 JA.getType() == types::TY_LTO_IR) {
952 CmdArgs.push_back(Elt: "-emit-llvm");
953 } else if (JA.getType() == types::TY_LLVM_BC ||
954 JA.getType() == types::TY_LTO_BC) {
955 CmdArgs.push_back(Elt: "-emit-llvm-bc");
956 } else if (JA.getType() == types::TY_PP_Asm) {
957 CmdArgs.push_back(Elt: "-S");
958 } else {
959 assert(false && "Unexpected output type!");
960 }
961 } else if (isa<AssembleJobAction>(Val: JA)) {
962 CmdArgs.push_back(Elt: "-emit-obj");
963 } else if (isa<PrecompileJobAction>(Val: JA)) {
964 // The precompile job action is only needed for options such as -mcpu=help.
965 // Those will already have been handled by the fc1 driver.
966 } else {
967 assert(false && "Unexpected action class for Flang tool.");
968 }
969
970 // We support some options that are invalid for Fortran and have no effect.
971 // These are solely for compatibility with other compilers. Emit a warning if
972 // any such options are provided, then proceed normally.
973 for (options::ID Opt : {options::OPT_fbuiltin, options::OPT_fno_builtin})
974 if (const Arg *A = Args.getLastArg(Ids: Opt))
975 D.Diag(DiagID: diag::warn_drv_invalid_argument_for_flang) << A->getSpelling();
976
977 // Warn about options that are ignored by flang. These are options that are
978 // accepted by gfortran, but have no equivalent in flang.
979 for (const Arg *A :
980 Args.filtered(Ids: options::OPT_clang_ignored_gcc_optimization_f_Group)) {
981 D.Diag(DiagID: diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
982 A->claim();
983 }
984
985 const InputInfo &Input = Inputs[0];
986 types::ID InputType = Input.getType();
987
988 // Add preprocessing options like -I, -D, etc. if we are using the
989 // preprocessor (i.e. skip when dealing with e.g. binary files).
990 if (types::getPreprocessedType(Id: InputType) != types::TY_INVALID)
991 addPreprocessingOptions(Args, CmdArgs);
992
993 addFortranDialectOptions(Args, CmdArgs);
994
995 // 'flang -E' always produces output that is suitable for use as fixed form
996 // Fortran. However it is only valid free form source if the original is also
997 // free form. Ensure this logic does not incorrectly assume fixed-form for
998 // cases where it shouldn't, such as `flang -x f95 foo.f90`.
999 bool isAtemporaryPreprocessedFile =
1000 Input.isFilename() &&
1001 llvm::sys::path::extension(path: Input.getFilename())
1002 .ends_with(Suffix: types::getTypeTempSuffix(Id: InputType, /*CLStyle=*/false));
1003 if (InputType == types::TY_PP_Fortran && isAtemporaryPreprocessedFile &&
1004 !Args.getLastArg(Ids: options::OPT_ffixed_form, Ids: options::OPT_ffree_form))
1005 CmdArgs.push_back(Elt: "-ffixed-form");
1006
1007 handleColorDiagnosticsArgs(D, Args, CmdArgs);
1008
1009 addLTOOptions(Args, CmdArgs);
1010
1011 // -fPIC and related options.
1012 addPicOptions(Args, CmdArgs);
1013
1014 // Floating point related options
1015 addFloatingPointOptions(D, Args, CmdArgs);
1016
1017 // Add target args, features, etc.
1018 addTargetOptions(Args, CmdArgs);
1019
1020 llvm::Reloc::Model RelocationModel =
1021 std::get<0>(t: ParsePICArgs(ToolChain: getToolChain(), Args));
1022 // Add MCModel information
1023 addMCModel(D, Args, Triple, RelocationModel, CmdArgs);
1024
1025 // Add Codegen options
1026 addCodegenOptions(Args, CmdArgs);
1027
1028 // Add R Group options
1029 Args.AddAllArgs(Output&: CmdArgs, Id0: options::OPT_R_Group);
1030
1031 // Remarks can be enabled with any of the `-f.*optimization-record.*` flags.
1032 if (willEmitRemarks(Args))
1033 renderRemarksOptions(Args, CmdArgs, Input);
1034
1035 // Add debug compile options
1036 addDebugOptions(Args, JA, Output, Input, CmdArgs);
1037
1038 // Disable all warnings
1039 // TODO: Handle interactions between -w, -pedantic, -Wall, -WOption
1040 Args.AddLastArg(Output&: CmdArgs, Ids: options::OPT_w);
1041
1042 // recognise options: fprofile-generate -fprofile-use=
1043 Args.addAllArgs(
1044 Output&: CmdArgs, Ids: {options::OPT_fprofile_generate, options::OPT_fprofile_use_EQ});
1045
1046 // Forward flags for OpenMP. We don't do this if the current action is an
1047 // device offloading action other than OpenMP.
1048 if (Args.hasFlag(Pos: options::OPT_fopenmp, PosAlias: options::OPT_fopenmp_EQ,
1049 Neg: options::OPT_fno_openmp, Default: false) &&
1050 (JA.isDeviceOffloading(OKind: Action::OFK_None) ||
1051 JA.isDeviceOffloading(OKind: Action::OFK_OpenMP))) {
1052 switch (D.getOpenMPRuntime(Args)) {
1053 case Driver::OMPRT_OMP:
1054 case Driver::OMPRT_IOMP5:
1055 // Clang can generate useful OpenMP code for these two runtime libraries.
1056 CmdArgs.push_back(Elt: "-fopenmp");
1057 Args.AddAllArgs(Output&: CmdArgs, Id0: options::OPT_fopenmp_version_EQ);
1058
1059 if (Args.hasArg(Ids: options::OPT_fopenmp_force_usm))
1060 CmdArgs.push_back(Elt: "-fopenmp-force-usm");
1061 Args.AddLastArg(Output&: CmdArgs, Ids: options::OPT_fopenmp_simd,
1062 Ids: options::OPT_fno_openmp_simd);
1063
1064 // FIXME: Clang supports a whole bunch more flags here.
1065 break;
1066 default:
1067 // By default, if Clang doesn't know how to generate useful OpenMP code
1068 // for a specific runtime library, we just don't pass the '-fopenmp' flag
1069 // down to the actual compilation.
1070 // FIXME: It would be better to have a mode which *only* omits IR
1071 // generation based on the OpenMP support so that we get consistent
1072 // semantic analysis, etc.
1073 const Arg *A = Args.getLastArg(Ids: options::OPT_fopenmp_EQ);
1074 D.Diag(DiagID: diag::warn_drv_unsupported_openmp_library)
1075 << A->getSpelling() << A->getValue();
1076 break;
1077 }
1078 } else {
1079 Args.AddLastArg(Output&: CmdArgs, Ids: options::OPT_fopenmp_simd,
1080 Ids: options::OPT_fno_openmp_simd);
1081 }
1082
1083 // Pass the path to compiler resource files.
1084 CmdArgs.push_back(Elt: "-resource-dir");
1085 CmdArgs.push_back(Elt: D.ResourceDir.c_str());
1086
1087 // Offloading related options
1088 addOffloadOptions(C, Inputs, JA, Args, CmdArgs);
1089
1090 // Forward -Xflang arguments to -fc1
1091 Args.AddAllArgValues(Output&: CmdArgs, Id0: options::OPT_Xflang);
1092
1093 CodeGenOptions::FramePointerKind FPKeepKind =
1094 getFramePointerKind(Args, Triple);
1095
1096 const char *FPKeepKindStr = nullptr;
1097 switch (FPKeepKind) {
1098 case CodeGenOptions::FramePointerKind::None:
1099 FPKeepKindStr = "-mframe-pointer=none";
1100 break;
1101 case CodeGenOptions::FramePointerKind::Reserved:
1102 FPKeepKindStr = "-mframe-pointer=reserved";
1103 break;
1104 case CodeGenOptions::FramePointerKind::NonLeafNoReserve:
1105 FPKeepKindStr = "-mframe-pointer=non-leaf-no-reserve";
1106 break;
1107 case CodeGenOptions::FramePointerKind::NonLeaf:
1108 FPKeepKindStr = "-mframe-pointer=non-leaf";
1109 break;
1110 case CodeGenOptions::FramePointerKind::All:
1111 FPKeepKindStr = "-mframe-pointer=all";
1112 break;
1113 }
1114 assert(FPKeepKindStr && "unknown FramePointerKind");
1115 CmdArgs.push_back(Elt: FPKeepKindStr);
1116
1117 // Forward -mllvm options to the LLVM option parser. In practice, this means
1118 // forwarding to `-fc1` as that's where the LLVM parser is run.
1119 for (const Arg *A : Args.filtered(Ids: options::OPT_mllvm)) {
1120 A->claim();
1121 A->render(Args, Output&: CmdArgs);
1122 }
1123
1124 for (const Arg *A : Args.filtered(Ids: options::OPT_mmlir)) {
1125 A->claim();
1126 A->render(Args, Output&: CmdArgs);
1127 }
1128
1129 // Remove any unsupported gfortran diagnostic options
1130 for (const Arg *A : Args.filtered(Ids: options::OPT_flang_ignored_w_Group)) {
1131 A->claim();
1132 D.Diag(DiagID: diag::warn_drv_unsupported_diag_option_for_flang)
1133 << A->getOption().getName();
1134 }
1135
1136 // Optimization level for CodeGen.
1137 if (const Arg *A = Args.getLastArg(Ids: options::OPT_O_Group)) {
1138 if (A->getOption().matches(ID: options::OPT_O4)) {
1139 CmdArgs.push_back(Elt: "-O3");
1140 D.Diag(DiagID: diag::warn_O4_is_O3);
1141 } else if (A->getOption().matches(ID: options::OPT_Ofast)) {
1142 CmdArgs.push_back(Elt: "-O3");
1143 D.Diag(DiagID: diag::warn_drv_deprecated_arg_ofast_for_flang);
1144 } else {
1145 A->render(Args, Output&: CmdArgs);
1146 }
1147 }
1148
1149 renderGlobalISelOptions(D, Args, CmdArgs, Triple);
1150 renderCommonIntegerOverflowOptions(Args, CmdArgs);
1151
1152 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
1153 if (Output.isFilename()) {
1154 CmdArgs.push_back(Elt: "-o");
1155 CmdArgs.push_back(Elt: Output.getFilename());
1156 }
1157
1158 if (Args.getLastArg(Ids: options::OPT_save_temps_EQ))
1159 Args.AddLastArg(Output&: CmdArgs, Ids: options::OPT_save_temps_EQ);
1160
1161 addDashXForInput(Args, Input, CmdArgs);
1162
1163 bool FRecordCmdLine = false;
1164 bool GRecordCmdLine = false;
1165 if (shouldRecordCommandLine(TC, Args, FRecordCommandLine&: FRecordCmdLine, GRecordCommandLine&: GRecordCmdLine)) {
1166 const char *CmdLine = renderEscapedCommandLine(TC, Args);
1167 if (FRecordCmdLine) {
1168 CmdArgs.push_back(Elt: "-record-command-line");
1169 CmdArgs.push_back(Elt: CmdLine);
1170 }
1171 if (TC.UseDwarfDebugFlags() || GRecordCmdLine) {
1172 CmdArgs.push_back(Elt: "-dwarf-debug-flags");
1173 CmdArgs.push_back(Elt: CmdLine);
1174 }
1175 }
1176
1177 // The input could be Ty_Nothing when "querying" options such as -mcpu=help
1178 // are used.
1179 ArrayRef<InputInfo> FrontendInputs = Input;
1180 if (Input.isNothing())
1181 FrontendInputs = {};
1182
1183 for (const InputInfo &Input : FrontendInputs) {
1184 if (Input.isFilename())
1185 CmdArgs.push_back(Elt: Input.getFilename());
1186 else
1187 Input.getInputArg().renderAsInput(Args, Output&: CmdArgs);
1188 }
1189
1190 const char *Exec = Args.MakeArgString(Str: D.GetProgramPath(Name: "flang", TC));
1191 C.addCommand(C: std::make_unique<Command>(args: JA, args: *this,
1192 args: ResponseFileSupport::AtFileUTF8(),
1193 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
1194}
1195
1196Flang::Flang(const ToolChain &TC) : Tool("flang", "flang frontend", TC) {}
1197
1198Flang::~Flang() {}
1199