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