RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/Flang_8cpp_source.html below:

clang: lib/Driver/ToolChains/Flang.cpp Source File

15#include "llvm/Frontend/Debug/Options.h" 16#include "llvm/Support/FileSystem.h" 17#include "llvm/Support/Path.h" 18#include "llvm/TargetParser/Host.h" 19#include "llvm/TargetParser/RISCVISAInfo.h" 20#include "llvm/TargetParser/RISCVTargetParser.h" 26using namespace clang

;

31

ArgStringList &CmdArgs) {

32

CmdArgs.push_back(

"-x"

);

37void

Flang::addFortranDialectOptions(

const

ArgList &Args,

38

ArgStringList &CmdArgs)

const

{

39

Args.addAllArgs(CmdArgs, {options::OPT_ffixed_form,

40

options::OPT_ffree_form,

41

options::OPT_ffixed_line_length_EQ,

42

options::OPT_fopenacc,

43

options::OPT_finput_charset_EQ,

44

options::OPT_fimplicit_none,

45

options::OPT_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_fno_save_main_program});

65void

Flang::addPreprocessingOptions(

const

ArgList &Args,

66

ArgStringList &CmdArgs)

const

{

67

Args.addAllArgs(CmdArgs,

68

{options::OPT_P, options::OPT_D, options::OPT_U,

69

options::OPT_I, options::OPT_cpp, options::OPT_nocpp});

90 const

Arg *LoopVersioningArg = Args.getLastArg(

91

options::OPT_Ofast, options::OPT_O, options::OPT_O4,

92

options::OPT_floop_versioning, options::OPT_fno_loop_versioning);

93 if

(!LoopVersioningArg)

96 if

(LoopVersioningArg->getOption().matches(options::OPT_fno_loop_versioning))

99 if

(LoopVersioningArg->getOption().matches(options::OPT_floop_versioning))

102 if

(LoopVersioningArg->getOption().matches(options::OPT_Ofast) ||

103

LoopVersioningArg->getOption().matches(options::OPT_O4))

106 if

(LoopVersioningArg->getOption().matches(options::OPT_O)) {

107

StringRef S(LoopVersioningArg->getValue());

108 unsigned

OptLevel = 0;

111 if

(S.getAsInteger(10, OptLevel))

117

llvm_unreachable(

"We should not end up here"

);

121void

Flang::addOtherOptions(

const

ArgList &Args, ArgStringList &CmdArgs)

const

{

122

Args.addAllArgs(CmdArgs,

123

{options::OPT_module_dir, options::OPT_fdebug_module_writer,

124

options::OPT_fintrinsic_modules_path, options::OPT_pedantic,

125

options::OPT_std_EQ, options::OPT_W_Joined,

126

options::OPT_fconvert_EQ, options::OPT_fpass_plugin_EQ,

127

options::OPT_funderscoring, options::OPT_fno_underscoring,

128

options::OPT_funsigned, options::OPT_fno_unsigned});

130

llvm::codegenoptions::DebugInfoKind DebugInfoKind;

131 if

(Args.hasArg(options::OPT_gN_Group)) {

132

Arg *gNArg = Args.getLastArg(options::OPT_gN_Group);

134

}

else if

(Args.hasArg(options::OPT_g_Flag)) {

135

DebugInfoKind = llvm::codegenoptions::FullDebugInfo;

137

DebugInfoKind = llvm::codegenoptions::NoDebugInfo;

142void

Flang::addCodegenOptions(

const

ArgList &Args,

143

ArgStringList &CmdArgs)

const

{

145

Args.getLastArg(options::OPT_Ofast, options::OPT_fstack_arrays,

146

options::OPT_fno_stack_arrays);

148

!stackArrays->getOption().matches(options::OPT_fno_stack_arrays))

149

CmdArgs.push_back(

"-fstack-arrays"

);

152

CmdArgs.push_back(

"-fversion-loops-for-stride"

);

154

Args.addAllArgs(CmdArgs,

155

{options::OPT_flang_experimental_hlfir,

156

options::OPT_flang_deprecated_no_hlfir,

157

options::OPT_fno_ppc_native_vec_elem_order,

158

options::OPT_fppc_native_vec_elem_order,

159

options::OPT_finit_global_zero,

160

options::OPT_fno_init_global_zero, options::OPT_ftime_report,

161

options::OPT_ftime_report_EQ, options::OPT_funroll_loops,

162

options::OPT_fno_unroll_loops});

165void

Flang::addPicOptions(

const

ArgList &Args, ArgStringList &CmdArgs)

const

{

168

llvm::Reloc::Model RelocationModel;

171

std::tie(RelocationModel, PICLevel, IsPIE) =

175

CmdArgs.push_back(

"-mrelocation-model"

);

176

CmdArgs.push_back(RMName);

179

CmdArgs.push_back(

"-pic-level"

);

180

CmdArgs.push_back(PICLevel == 1 ?

"1"

"2"

);

182

CmdArgs.push_back(

"-pic-is-pie"

);

186void

Flang::AddAArch64TargetArgs(

const

ArgList &Args,

187

ArgStringList &CmdArgs)

const

{

189 if

(Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {

190

StringRef Val = A->getValue();

192 if

(Val ==

"128"

|| Val ==

"256"

|| Val ==

"512"

|| Val ==

"1024"

193

Val ==

"2048"

|| Val ==

"128+"

|| Val ==

"256+"

|| Val ==

"512+"

194

Val ==

"1024+"

|| Val ==

"2048+"

) {

196 if

(!Val.consume_back(

"+"

)) {

197

[[maybe_unused]]

bool Invalid

= Val.getAsInteger(10, Bits);

198

assert(!

Invalid

"Failed to parse value"

);

200

Args.MakeArgString(

"-mvscale-max="

+ llvm::Twine(Bits / 128)));

203

[[maybe_unused]]

bool Invalid

= Val.getAsInteger(10, Bits);

204

assert(!

Invalid

"Failed to parse value"

);

206

Args.MakeArgString(

"-mvscale-min="

+ llvm::Twine(Bits / 128)));

208

}

else if

(Val !=

"scalable"

)

210 D

.Diag(diag::err_drv_unsupported_option_argument)

211

<< A->getSpelling() << Val;

215void

Flang::AddLoongArch64TargetArgs(

const

ArgList &Args,

216

ArgStringList &CmdArgs)

const

{

219 if

(

const

Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {

220

StringRef

= A->getValue();

221 if

(

"lp64d"

) {

222 D

.Diag(diag::err_drv_argument_not_allowed_with) <<

"-mabi"

;

226 if

(

const

Arg *A = Args.getLastArg(options::OPT_mannotate_tablejump,

227

options::OPT_mno_annotate_tablejump)) {

228 if

(A->getOption().matches(options::OPT_mannotate_tablejump)) {

229

CmdArgs.push_back(

"-mllvm"

);

230

CmdArgs.push_back(

"-loongarch-annotate-tablejump"

);

235void

Flang::AddPPCTargetArgs(

const

ArgList &Args,

236

ArgStringList &CmdArgs)

const

{

238 bool

VecExtabi =

false

;

240 if

(

const

Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {

241

StringRef

= A->getValue();

242 if

(

"vec-extabi"

)

244 else if

(

"vec-default"

)

247 D

.Diag(diag::err_drv_unsupported_option_argument)

248

<< A->getSpelling() <<

;

253 if

.isOSAIX()) {

254 D

.Diag(diag::err_drv_unsupported_opt_for_target)

255

"-mabi=vec-extabi"

.str();

257

CmdArgs.push_back(

"-mabi=vec-extabi"

);

261void

Flang::AddRISCVTargetArgs(

const

ArgList &Args,

262

ArgStringList &CmdArgs)

const

{

265 if

(Arg *A = Args.getLastArg(options::OPT_mrvv_vector_bits_EQ)) {

266

StringRef Val = A->getValue();

270 unsigned

MinVLen = 0;

272 auto

ISAInfo = llvm::RISCVISAInfo::parseArchString(

275 if

(!errorToBool(ISAInfo.takeError()))

276

MinVLen = (*ISAInfo)->getMinVLen();

281 if

(Val ==

"zvl"

&& MinVLen >= llvm::RISCV::RVVBitsPerBlock) {

283

}

else if

(!Val.getAsInteger(10, Bits)) {

286 if

(Bits < MinVLen || Bits < llvm::RISCV::RVVBitsPerBlock ||

287

Bits > 65536 || !llvm::isPowerOf2_32(Bits))

293 unsigned

VScaleMin = Bits / llvm::RISCV::RVVBitsPerBlock;

295

Args.MakeArgString(

"-mvscale-max="

+ llvm::Twine(VScaleMin)));

297

Args.MakeArgString(

"-mvscale-min="

+ llvm::Twine(VScaleMin)));

298

}

else if

(Val !=

"scalable"

) {

300 D

.Diag(diag::err_drv_unsupported_option_argument)

301

<< A->getSpelling() << Val;

306void

Flang::AddX86_64TargetArgs(

const

ArgList &Args,

307

ArgStringList &CmdArgs)

const

{

308 if

(Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {

309

StringRef

Value

= A->getValue();

311

CmdArgs.push_back(Args.MakeArgString(

"-mllvm"

));

312

CmdArgs.push_back(Args.MakeArgString(

"-x86-asm-syntax="

Value

));

315

<< A->getSpelling() <<

Value

;

321

ArgStringList &CmdArgs) {

325

ver = vt.getMajor() * 10000000 + vt.getMinor().value_or(0) * 100000 +

326

vt.getSubminor().value_or(0);

327

CmdArgs.push_back(Args.MakeArgString(

"-D_MSC_VER="

+ Twine(ver / 100000)));

328

CmdArgs.push_back(Args.MakeArgString(

"-D_MSC_FULL_VER="

+ Twine(ver)));

329

CmdArgs.push_back(Args.MakeArgString(

"-D_WIN32"

));

331 const

llvm::Triple &triple = TC.

getTriple

();

332 if

(triple.isAArch64()) {

333

CmdArgs.push_back(

"-D_M_ARM64=1"

);

334

}

else if

(triple.isX86() && triple.isArch32Bit()) {

335

CmdArgs.push_back(

"-D_M_IX86=600"

);

336

}

else if

(triple.isX86() && triple.isArch64Bit()) {

337

CmdArgs.push_back(

"-D_M_X64=100"

);

340 "Flang on Windows only supports X86_32, X86_64 and AArch64"

);

345

ArgStringList &CmdArgs) {

346

assert(TC.

getTriple

().isKnownWindowsMSVCEnvironment() &&

347 "can only add VS runtime library on Windows!"

);

349 if

(TC.

getTriple

().isKnownWindowsMSVCEnvironment()) {

350

CmdArgs.push_back(Args.MakeArgString(

353 unsigned

RTOptionID = options::OPT__SLASH_MT;

354 if

(

auto

*rtl = Args.getLastArg(options::OPT_fms_runtime_lib_EQ)) {

355

RTOptionID = llvm::StringSwitch<unsigned>(rtl->getValue())

356

.Case(

"static"

, options::OPT__SLASH_MT)

357

.Case(

"static_dbg"

, options::OPT__SLASH_MTd)

358

.Case(

"dll"

, options::OPT__SLASH_MD)

359

.Case(

"dll_dbg"

, options::OPT__SLASH_MDd)

360

.Default(options::OPT__SLASH_MT);

362 switch

(RTOptionID) {

363 case

options::OPT__SLASH_MT:

364

CmdArgs.push_back(

"-D_MT"

);

365

CmdArgs.push_back(

"--dependent-lib=libcmt"

);

366

CmdArgs.push_back(

"--dependent-lib=FortranRuntime.static.lib"

);

367

CmdArgs.push_back(

"--dependent-lib=FortranDecimal.static.lib"

);

369 case

options::OPT__SLASH_MTd:

370

CmdArgs.push_back(

"-D_MT"

);

371

CmdArgs.push_back(

"-D_DEBUG"

);

372

CmdArgs.push_back(

"--dependent-lib=libcmtd"

);

373

CmdArgs.push_back(

"--dependent-lib=FortranRuntime.static_dbg.lib"

);

374

CmdArgs.push_back(

"--dependent-lib=FortranDecimal.static_dbg.lib"

);

376 case

options::OPT__SLASH_MD:

377

CmdArgs.push_back(

"-D_MT"

);

378

CmdArgs.push_back(

"-D_DLL"

);

379

CmdArgs.push_back(

"--dependent-lib=msvcrt"

);

380

CmdArgs.push_back(

"--dependent-lib=FortranRuntime.dynamic.lib"

);

381

CmdArgs.push_back(

"--dependent-lib=FortranDecimal.dynamic.lib"

);

383 case

options::OPT__SLASH_MDd:

384

CmdArgs.push_back(

"-D_MT"

);

385

CmdArgs.push_back(

"-D_DEBUG"

);

386

CmdArgs.push_back(

"-D_DLL"

);

387

CmdArgs.push_back(

"--dependent-lib=msvcrtd"

);

388

CmdArgs.push_back(

"--dependent-lib=FortranRuntime.dynamic_dbg.lib"

);

389

CmdArgs.push_back(

"--dependent-lib=FortranDecimal.dynamic_dbg.lib"

);

394void

Flang::AddAMDGPUTargetArgs(

const

ArgList &Args,

395

ArgStringList &CmdArgs)

const

{

396 if

(Arg *A = Args.getLastArg(options::OPT_mcode_object_version_EQ)) {

397

StringRef Val = A->getValue();

398

CmdArgs.push_back(Args.MakeArgString(

"-mcode-object-version="

+ Val));

405void

Flang::addTargetOptions(

const

ArgList &Args,

406

ArgStringList &CmdArgs)

const

{

413

CmdArgs.push_back(

"-target-cpu"

);

414

CmdArgs.push_back(Args.MakeArgString(CPU));

423 case

llvm::Triple::aarch64:

425

AddAArch64TargetArgs(Args, CmdArgs);

428 case

llvm::Triple::r600:

429 case

llvm::Triple::amdgcn:

431

AddAMDGPUTargetArgs(Args, CmdArgs);

433 case

llvm::Triple::riscv64:

435

AddRISCVTargetArgs(Args, CmdArgs);

437 case

llvm::Triple::x86_64:

439

AddX86_64TargetArgs(Args, CmdArgs);

441 case

llvm::Triple::ppc:

442 case

llvm::Triple::ppc64:

443 case

llvm::Triple::ppc64le:

444

AddPPCTargetArgs(Args, CmdArgs);

446 case

llvm::Triple::loongarch64:

448

AddLoongArch64TargetArgs(Args, CmdArgs);

452 if

(Arg *A = Args.getLastArg(options::OPT_fveclib)) {

453

StringRef Name = A->getValue();

454 if

(Name ==

"SVML"

) {

455 if

(Triple.getArch() != llvm::Triple::x86 &&

456

Triple.getArch() != llvm::Triple::x86_64)

457 D

.Diag(diag::err_drv_unsupported_opt_for_target)

458

<< Name << Triple.getArchName();

459

}

else if

(Name ==

"LIBMVEC-X86"

) {

460 if

(Triple.getArch() != llvm::Triple::x86 &&

461

Triple.getArch() != llvm::Triple::x86_64)

462 D

.Diag(diag::err_drv_unsupported_opt_for_target)

463

<< Name << Triple.getArchName();

464

}

else if

(Name ==

"SLEEF"

|| Name ==

"ArmPL"

) {

465 if

(Triple.getArch() != llvm::Triple::aarch64 &&

466

Triple.getArch() != llvm::Triple::aarch64_be)

467 D

.Diag(diag::err_drv_unsupported_opt_for_target)

468

<< Name << Triple.getArchName();

471 if

(Triple.isOSDarwin()) {

474 if

(!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {

475 if

(A->getValue() == StringRef{

"Accelerate"

}) {

476

CmdArgs.push_back(

"-framework"

);

477

CmdArgs.push_back(

"Accelerate"

);

481

A->render(Args, CmdArgs);

484 if

(Triple.isKnownWindowsMSVCEnvironment()) {

490 if

(

const

Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {

491

CmdArgs.push_back(

"-tune-cpu"

);

492 if

(A->getValue() == StringRef{

"native"

})

493

CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));

495

CmdArgs.push_back(A->getValue());

500 const JobAction

&JA,

const

ArgList &Args,

501

ArgStringList &CmdArgs)

const

{

514 for

(

size_t

i = 1; i < Inputs.size(); ++i) {

515 if

(Inputs[i].getType() == types::TY_Nothing) {

517

}

else if

(IsHostOffloadingAction) {

519

Args.MakeArgString(

"-fembed-offload-object="

521

}

else if

(IsOpenMPDevice) {

522 if

(Inputs[i].getFilename()) {

523

CmdArgs.push_back(

"-fopenmp-host-ir-file-path"

);

524

CmdArgs.push_back(Args.MakeArgString(Inputs[i].getFilename()));

526

llvm_unreachable(

"missing openmp host-ir file for device offloading"

);

530 "unexpectedly given multiple inputs or given unknown input"

);

534 if

(IsOpenMPDevice) {

537

CmdArgs.push_back(

"-fopenmp-is-target-device"

);

540

Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ);

541 if

(Args.hasFlag(options::OPT_fopenmp_target_debug,

542

options::OPT_fno_openmp_target_debug,

false

))

543

CmdArgs.push_back(

"-fopenmp-target-debug"

);

547 if

(Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,

548

options::OPT_fno_openmp_assume_teams_oversubscription,

550

CmdArgs.push_back(

"-fopenmp-assume-teams-oversubscription"

);

551 if

(Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,

552

options::OPT_fno_openmp_assume_threads_oversubscription,

554

CmdArgs.push_back(

"-fopenmp-assume-threads-oversubscription"

);

555 if

(Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))

556

CmdArgs.push_back(

"-fopenmp-assume-no-thread-state"

);

557 if

(Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))

558

CmdArgs.push_back(

"-fopenmp-assume-no-nested-parallelism"

);

559 if

(Args.hasArg(options::OPT_nogpulib))

560

CmdArgs.push_back(

"-nogpulib"

);

567

ArgStringList &CmdArgs) {

568

StringRef FPContract;

569 bool

HonorINFs =

true

;

570 bool

HonorNaNs =

true

;

571 bool

ApproxFunc =

false

;

572 bool

SignedZeros =

true

;

573 bool

AssociativeMath =

false

;

574 bool

ReciprocalMath =

false

;

576 if

(

const

Arg *A = Args.getLastArg(options::OPT_ffp_contract)) {

577 const

StringRef Val = A->getValue();

578 if

(Val ==

"fast"

|| Val ==

"off"

) {

580

}

else if

(Val ==

"on"

) {

583 D

.Diag(diag::warn_drv_unsupported_option_for_flang)

584

<< Val << A->getOption().getName() <<

"off"

;

589 D

.Diag(diag::err_drv_unsupported_option_argument)

590

<< A->getSpelling() << Val;

593 for

(

const

Arg *A : Args) {

594 auto

optId = A->getOption().

getID

();

600 case

options::OPT_fhonor_infinities:

603 case

options::OPT_fno_honor_infinities:

606 case

options::OPT_fhonor_nans:

609 case

options::OPT_fno_honor_nans:

612 case

options::OPT_fapprox_func:

615 case

options::OPT_fno_approx_func:

618 case

options::OPT_fsigned_zeros:

621 case

options::OPT_fno_signed_zeros:

622

SignedZeros =

false

;

624 case

options::OPT_fassociative_math:

625

AssociativeMath =

true

;

627 case

options::OPT_fno_associative_math:

628

AssociativeMath =

false

;

630 case

options::OPT_freciprocal_math:

631

ReciprocalMath =

true

;

633 case

options::OPT_fno_reciprocal_math:

634

ReciprocalMath =

false

;

636 case

options::OPT_Ofast:

638 case

options::OPT_ffast_math:

641

AssociativeMath =

true

;

642

ReciprocalMath =

true

;

644

SignedZeros =

false

;

645

FPContract =

"fast"

;

647 case

options::OPT_fno_fast_math:

650

AssociativeMath =

false

;

651

ReciprocalMath =

false

;

657 if

(FPContract ==

"fast"

)

666 if

(!HonorINFs && !HonorNaNs && AssociativeMath && ReciprocalMath &&

667

ApproxFunc && !SignedZeros &&

668

(FPContract ==

"fast"

|| FPContract.empty())) {

669

CmdArgs.push_back(

"-ffast-math"

);

673 if

(!FPContract.empty())

674

CmdArgs.push_back(Args.MakeArgString(

"-ffp-contract="

+ FPContract));

677

CmdArgs.push_back(

"-menable-no-infs"

);

680

CmdArgs.push_back(

"-menable-no-nans"

);

683

CmdArgs.push_back(

"-fapprox-func"

);

686

CmdArgs.push_back(

"-fno-signed-zeros"

);

688 if

(AssociativeMath && !SignedZeros)

689

CmdArgs.push_back(

"-mreassociate"

);

692

CmdArgs.push_back(

"-freciprocal-math"

);

697

StringRef Format =

"yaml"

;

698 if

(

const

Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))

699

Format = A->getValue();

701

CmdArgs.push_back(

"-opt-record-file"

);

703 const

Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);

705

CmdArgs.push_back(A->getValue());

709 if

(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {

710 if

(Arg *FinalOutput = Args.getLastArg(options::OPT_o))

711

F = FinalOutput->getValue();

720

Extension +=

"opt."

;

723

llvm::sys::path::replace_extension(F, Extension);

724

CmdArgs.push_back(Args.MakeArgString(F));

728

Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {

729

CmdArgs.push_back(

"-opt-record-passes"

);

730

CmdArgs.push_back(A->getValue());

733 if

(!Format.empty()) {

734

CmdArgs.push_back(

"-opt-record-format"

);

735

CmdArgs.push_back(Format.data());

741 const

ArgList &Args,

const char

*LinkingOutput)

const

{

744 const

std::string &TripleStr = Triple.getTriple();

747

ArgStringList CmdArgs;

751

CmdArgs.push_back(

"-fc1"

);

754

CmdArgs.push_back(

"-triple"

);

755

CmdArgs.push_back(Args.MakeArgString(TripleStr));

757 if

(isa<PreprocessJobAction>(JA)) {

758

CmdArgs.push_back(

"-E"

);

759 if

(Args.getLastArg(options::OPT_dM)) {

760

CmdArgs.push_back(

"-dM"

);

762

}

else if

(isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) {

763 if

(JA.

getType

() == types::TY_Nothing) {

764

CmdArgs.push_back(

"-fsyntax-only"

);

765

}

else if

(JA.

getType

() == types::TY_AST) {

766

CmdArgs.push_back(

"-emit-ast"

);

767

}

else if

(JA.

getType

() == types::TY_LLVM_IR ||

768

JA.

getType

() == types::TY_LTO_IR) {

769

CmdArgs.push_back(

"-emit-llvm"

);

770

}

else if

(JA.

getType

() == types::TY_LLVM_BC ||

771

JA.

getType

() == types::TY_LTO_BC) {

772

CmdArgs.push_back(

"-emit-llvm-bc"

);

773

}

else if

(JA.

getType

() == types::TY_PP_Asm) {

774

CmdArgs.push_back(

"-S"

);

776

assert(

false

"Unexpected output type!"

);

778

}

else if

(isa<AssembleJobAction>(JA)) {

779

CmdArgs.push_back(

"-emit-obj"

);

780

}

else if

(isa<PrecompileJobAction>(JA)) {

784

assert(

false

"Unexpected action class for Flang tool."

);

793

addPreprocessingOptions(Args, CmdArgs);

795

addFortranDialectOptions(Args, CmdArgs);

800 if

(InputType == types::TY_PP_Fortran &&

801

!Args.getLastArg(options::OPT_ffixed_form, options::OPT_ffree_form))

802

CmdArgs.push_back(

"-ffixed-form"

);

808

assert(LTOMode !=

LTOK_Unknown

"Unknown LTO mode."

);

810

CmdArgs.push_back(

"-flto=full"

);

814 "the option '-flto=thin' is a work in progress"

));

815

CmdArgs.push_back(

"-flto=thin"

);

819

addPicOptions(Args, CmdArgs);

825

addTargetOptions(Args, CmdArgs);

827

llvm::Reloc::Model RelocationModel =

830 addMCModel

(

, Args, Triple, RelocationModel, CmdArgs);

833

addCodegenOptions(Args, CmdArgs);

836

Args.AddAllArgs(CmdArgs, options::OPT_R_Group);

843

addOtherOptions(Args, CmdArgs);

847

Args.AddLastArg(CmdArgs, options::OPT_w);

851 if

(Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,

852

options::OPT_fno_openmp,

false

) &&

855 switch

(

.getOpenMPRuntime(Args)) {

859

CmdArgs.push_back(

"-fopenmp"

);

860

Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);

862 if

(Args.hasArg(options::OPT_fopenmp_force_usm))

863

CmdArgs.push_back(

"-fopenmp-force-usm"

);

866 D

.Diag(diag::warn_openmp_experimental);

877 const

Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);

878 D

.Diag(diag::warn_drv_unsupported_openmp_library)

879

<< A->getSpelling() << A->getValue();

885

CmdArgs.push_back(

"-resource-dir"

);

886

CmdArgs.push_back(

.ResourceDir.c_str());

889

addOffloadOptions(

, Inputs, JA, Args, CmdArgs);

892

Args.AddAllArgValues(CmdArgs, options::OPT_Xflang);

897 const char

*FPKeepKindStr =

nullptr

;

898 switch

(FPKeepKind) {

900

FPKeepKindStr =

"-mframe-pointer=none"

;

903

FPKeepKindStr =

"-mframe-pointer=reserved"

;

906

FPKeepKindStr =

"-mframe-pointer=non-leaf"

;

909

FPKeepKindStr =

"-mframe-pointer=all"

;

912

assert(FPKeepKindStr &&

"unknown FramePointerKind"

);

913

CmdArgs.push_back(FPKeepKindStr);

917 for

(

const

Arg *A : Args.filtered(options::OPT_mllvm)) {

919

A->render(Args, CmdArgs);

922 for

(

const

Arg *A : Args.filtered(options::OPT_mmlir)) {

924

A->render(Args, CmdArgs);

928 for

(

const

Arg *A : Args.filtered(options::OPT_flang_ignored_w_Group)) {

930 D

.Diag(diag::warn_drv_unsupported_diag_option_for_flang)

931

<< A->getOption().getName();

935 if

(

const

Arg *A = Args.getLastArg(options::OPT_O_Group)) {

936 if

(A->getOption().matches(options::OPT_O4)) {

937

CmdArgs.push_back(

"-O3"

);

938 D

.Diag(diag::warn_O4_is_O3);

939

}

else if

(A->getOption().matches(options::OPT_Ofast)) {

940

CmdArgs.push_back(

"-O3"

);

941 D

.Diag(diag::warn_drv_deprecated_arg_ofast_for_flang);

943

A->render(Args, CmdArgs);

951

CmdArgs.push_back(

"-o"

);

955 if

(Args.getLastArg(options::OPT_save_temps_EQ))

956

Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);

960 bool

FRecordCmdLine =

false

;

961 bool

GRecordCmdLine =

false

;

964 if

(FRecordCmdLine) {

965

CmdArgs.push_back(

"-record-command-line"

);

966

CmdArgs.push_back(CmdLine);

969

CmdArgs.push_back(

"-dwarf-debug-flags"

);

970

CmdArgs.push_back(CmdLine);

980 for

(

const InputInfo

&Input : FrontendInputs) {

984

Input.

getInputArg

().renderAsInput(Args, CmdArgs);

987 const char

*Exec = Args.MakeArgString(

.GetProgramPath(

"flang"

, TC));

988 C

.addCommand(std::make_unique<Command>(JA, *

this

990

Exec, CmdArgs, Inputs, Output));

static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)

Add -x lang to CmdArgs for Input.

static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)

clang::CodeGenOptions::FramePointerKind getFramePointerKind(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)

static void processVSRuntimeLibrary(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)

static void addVSDefines(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)

static bool shouldLoopVersion(const ArgList &Args)

@C shouldLoopVersion

static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)

Add -x lang to CmdArgs for Input.

static void addFloatingPointOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)

Concrete class used by the front-end to report problems and issues.

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.

types::ID getType() const

bool isHostOffloading(unsigned int OKind) const

Check if this action have any offload kinds.

bool isDeviceOffloading(OffloadKind OKind) const

Compilation - A set of tasks to perform for a single driver invocation.

Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...

DiagnosticBuilder Diag(unsigned DiagID) const

@ OMPRT_IOMP5

The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.

@ OMPRT_OMP

The LLVM OpenMP runtime.

InputInfo - Wrapper for information about an input source.

const char * getBaseInput() const

const llvm::opt::Arg & getInputArg() const

const char * getFilename() const

types::ID getType() const

ID getPreprocessedType(ID Id)

getPreprocessedType - Get the ID of the type for this input when it has been preprocessed,...

const char * getTypeName(ID Id)

getTypeName - Return the name of the type for Id.

LTOKind

Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options.

bool willEmitRemarks(const llvm::opt::ArgList &Args)

The JSON file list parser is used to communicate input to InstallAPI.

const FunctionProtoType * T

static constexpr ResponseFileSupport AtFileUTF8()

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4