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