RetroSearch Browse

= A->getValue();

286 if

(

"none"

) {

287

CmdArgs.push_back(

"-mprefer-vector-width=none"

);

290 if

(

.getAsInteger(10, Width)) {

291 D

.Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<

;

294

CmdArgs.push_back(Args.MakeArgString(

"-mprefer-vector-width="

));

300 const

llvm::Triple &Triple) {

307 if

(!Triple.isMacOSX())

310 return

(!Triple.isMacOSXVersionLT(10, 5) &&

311

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

312

Triple.getArch() == llvm::Triple::arm));

322

ArgStringList &CmdArgs) {

323 const

llvm::Triple &Triple = TC.

();

328

Args.ClaimAllArgs(options::OPT_fexceptions);

329

Args.ClaimAllArgs(options::OPT_fno_exceptions);

330

Args.ClaimAllArgs(options::OPT_fobjc_exceptions);

331

Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);

332

Args.ClaimAllArgs(options::OPT_fcxx_exceptions);

333

Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);

334

Args.ClaimAllArgs(options::OPT_fasync_exceptions);

335

Args.ClaimAllArgs(options::OPT_fno_async_exceptions);

340 bool

EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,

344 if

(Triple.isWindowsMSVCEnvironment()) {

345 bool

EHa = Args.hasFlag(options::OPT_fasync_exceptions,

346

options::OPT_fno_async_exceptions,

false

);

348

CmdArgs.push_back(

"-fasync-exceptions"

);

356

Args.hasFlag(options::OPT_fobjc_exceptions,

357

options::OPT_fno_objc_exceptions,

true

)) {

358

CmdArgs.push_back(

"-fobjc-exceptions"

);

365 bool

CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&

366

!Triple.isPS() && !Triple.isDriverKit();

367

Arg *ExceptionArg = Args.getLastArg(

368

options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,

369

options::OPT_fexceptions, options::OPT_fno_exceptions);

371

CXXExceptionsEnabled =

372

ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||

373

ExceptionArg->getOption().matches(options::OPT_fexceptions);

375 if

(CXXExceptionsEnabled) {

376

CmdArgs.push_back(

"-fcxx-exceptions"

);

385

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

387

Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,

388

options::OPT_fno_assume_nothrow_exception_dtor);

391

CmdArgs.push_back(

"-fexceptions"

);

407 return

Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,

413

ArgStringList &CmdArgs,

414 const

llvm::vfs::FileSystem &VFS) {

415 if

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

416

options::OPT_fdebug_compilation_dir_EQ)) {

417 if

(A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))

418

CmdArgs.push_back(Args.MakeArgString(Twine(

"-fdebug-compilation-dir="

) +

421

A->render(Args, CmdArgs);

422

}

else if

(llvm::ErrorOr<std::string> CWD =

423

VFS.getCurrentWorkingDirectory()) {

424

CmdArgs.push_back(Args.MakeArgString(

"-fdebug-compilation-dir="

+ *CWD));

426

StringRef

(CmdArgs.back());

427 return Path

.substr(

.find(

'='

) + 1).data();

431 const char

*DebugCompilationDir,

432 const char

*OutputFileName) {

434 for

(

auto

*Arg : Args.filtered(options::OPT_Xclang))

435 if

(StringRef(Arg->getValue()).starts_with(

"-object-file-name"

))

438 if

(Args.hasArg(options::OPT_object_file_name_EQ))

442 if

(ObjFileNameForDebug !=

"-"

443

!llvm::sys::path::is_absolute(ObjFileNameForDebug) &&

444

(!DebugCompilationDir ||

445

llvm::sys::path::is_absolute(DebugCompilationDir))) {

447

llvm::sys::fs::make_absolute(ObjFileNameForDebug);

453

llvm::sys::path::Style Style =

454

llvm::sys::path::is_absolute(ObjFileNameForDebug)

455

? llvm::sys::path::Style::native

456

: llvm::sys::path::Style::windows_backslash;

457

llvm::sys::path::remove_dots(ObjFileNameForDebug,

true

460

Args.MakeArgString(Twine(

"-object-file-name="

) + ObjFileNameForDebug));

465 const

ArgList &Args, ArgStringList &CmdArgs) {

466 auto

AddOneArg = [&](StringRef Map, StringRef Name) {

467 if

(!Map.contains(

'='

))

468 D

.Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;

470

CmdArgs.push_back(Args.MakeArgString(

"-fdebug-prefix-map="

+ Map));

473 for

(

const

Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

474

options::OPT_fdebug_prefix_map_EQ)) {

475

AddOneArg(A->getValue(), A->getOption().getName());

479 if

(GlobalRemapEntry.empty())

481

AddOneArg(GlobalRemapEntry,

"environment"

);

486

ArgStringList &CmdArgs) {

487 for

(

const

Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

488

options::OPT_fmacro_prefix_map_EQ)) {

489

StringRef Map = A->getValue();

490 if

(!Map.contains(

'='

))

491 D

.Diag(diag::err_drv_invalid_argument_to_option)

492

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

494

CmdArgs.push_back(Args.MakeArgString(

"-fmacro-prefix-map="

+ Map));

501

ArgStringList &CmdArgs) {

502 for

(

const

Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

503

options::OPT_fcoverage_prefix_map_EQ)) {

504

StringRef Map = A->getValue();

505 if

(!Map.contains(

'='

))

506 D

.Diag(diag::err_drv_invalid_argument_to_option)

507

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

509

CmdArgs.push_back(Args.MakeArgString(

"-fcoverage-prefix-map="

+ Map));

518 if

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

519 if

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

520

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

523 if

(A->getOption().matches(options::OPT_O0))

526

assert(A->getOption().matches(options::OPT_O) &&

"Must have a -O flag"

);

529

StringRef S(A->getValue());

537 unsigned

OptLevel = 0;

538 if

(S.getAsInteger(10, OptLevel))

549

ArgStringList &CmdArgs) {

552 if

(Args.hasArg(options::OPT_verify_pch) && Input.

() == types::TY_PCH)

555

CmdArgs.push_back(

"-x"

);

556 if

(Args.hasArg(options::OPT_rewrite_objc))

562 const char

*ClangType;

564 case

types::TY_CXXModule:

567 case

types::TY_PP_CXXModule:

568

ClangType =

"c++-cpp-output"

;

574

CmdArgs.push_back(ClangType);

581

ArgStringList &CmdArgs) {

583 auto

*PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,

584

options::OPT_fprofile_generate_EQ,

585

options::OPT_fno_profile_generate);

586 if

(PGOGenerateArg &&

587

PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))

588

PGOGenerateArg =

nullptr

;

592 auto

*ProfileGenerateArg = Args.getLastArg(

593

options::OPT_fprofile_instr_generate,

594

options::OPT_fprofile_instr_generate_EQ,

595

options::OPT_fno_profile_instr_generate);

596 if

(ProfileGenerateArg &&

597

ProfileGenerateArg->getOption().matches(

598

options::OPT_fno_profile_instr_generate))

599

ProfileGenerateArg =

nullptr

;

601 if

(PGOGenerateArg && ProfileGenerateArg)

602 D

.Diag(diag::err_drv_argument_not_allowed_with)

603

<< PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();

607 if

(PGOGenerateArg && ProfileUseArg)

608 D

.Diag(diag::err_drv_argument_not_allowed_with)

609

<< ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();

611 if

(ProfileGenerateArg && ProfileUseArg)

612 D

.Diag(diag::err_drv_argument_not_allowed_with)

613

<< ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();

615 if

(CSPGOGenerateArg && PGOGenerateArg) {

616 D

.Diag(diag::err_drv_argument_not_allowed_with)

617

<< CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();

618

PGOGenerateArg =

nullptr

;

623 D

.Diag(diag::err_drv_unsupported_opt_for_target)

624

<< ProfileSampleUseArg->getSpelling() << TC.

().str();

627 if

(ProfileGenerateArg) {

628 if

(ProfileGenerateArg->getOption().matches(

629

options::OPT_fprofile_instr_generate_EQ))

630

CmdArgs.push_back(Args.MakeArgString(Twine(

"-fprofile-instrument-path="

) +

631

ProfileGenerateArg->getValue()));

633

CmdArgs.push_back(

"-fprofile-instrument=clang"

);

634 if

(TC.

().isWindowsMSVCEnvironment() &&

635

Args.hasFlag(options::OPT_frtlib_defaultlib,

636

options::OPT_fno_rtlib_defaultlib,

true

)) {

638

CmdArgs.push_back(Args.MakeArgString(

643 if

(

auto

*ColdFuncCoverageArg = Args.getLastArg(

644

options::OPT_fprofile_generate_cold_function_coverage,

645

options::OPT_fprofile_generate_cold_function_coverage_EQ)) {

647

ColdFuncCoverageArg->getOption().matches(

648

options::OPT_fprofile_generate_cold_function_coverage_EQ)

649

? ColdFuncCoverageArg->getValue()

651

llvm::sys::path::append(

"default_%m.profraw"

);

656

CmdArgs.push_back(

"-mllvm"

);

657

CmdArgs.push_back(Args.MakeArgString(

658

Twine(

"--instrument-cold-function-only-path="

) +

));

659

CmdArgs.push_back(

"-mllvm"

);

660

CmdArgs.push_back(

"--pgo-instrument-cold-function-only"

);

661

CmdArgs.push_back(

"-mllvm"

);

662

CmdArgs.push_back(

"--pgo-function-entry-coverage"

);

665 if

(

auto

*A = Args.getLastArg(options::OPT_ftemporal_profile)) {

666 if

(!PGOGenerateArg && !CSPGOGenerateArg)

667 D

.Diag(clang::diag::err_drv_argument_only_allowed_with)

668

<< A->getSpelling() <<

"-fprofile-generate or -fcs-profile-generate"

;

669

CmdArgs.push_back(

"-mllvm"

);

670

CmdArgs.push_back(

"--pgo-temporal-instrumentation"

);

673

Arg *PGOGenArg =

nullptr

;

674 if

(PGOGenerateArg) {

675

assert(!CSPGOGenerateArg);

676

PGOGenArg = PGOGenerateArg;

677

CmdArgs.push_back(

"-fprofile-instrument=llvm"

);

679 if

(CSPGOGenerateArg) {

680

assert(!PGOGenerateArg);

681

PGOGenArg = CSPGOGenerateArg;

682

CmdArgs.push_back(

"-fprofile-instrument=csllvm"

);

685 if

(TC.

().isWindowsMSVCEnvironment() &&

686

Args.hasFlag(options::OPT_frtlib_defaultlib,

687

options::OPT_fno_rtlib_defaultlib,

true

)) {

689

CmdArgs.push_back(Args.MakeArgString(

692 if

(PGOGenArg->getOption().matches(

693

PGOGenerateArg ? options::OPT_fprofile_generate_EQ

694

: options::OPT_fcs_profile_generate_EQ)) {

696

llvm::sys::path::append(

"default_%m.profraw"

);

698

Args.MakeArgString(Twine(

"-fprofile-instrument-path="

) +

));

703 if

(ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))

704

CmdArgs.push_back(Args.MakeArgString(

705

Twine(

"-fprofile-instrument-use-path="

) + ProfileUseArg->getValue()));

706 else if

((ProfileUseArg->getOption().matches(

707

options::OPT_fprofile_use_EQ) ||

708

ProfileUseArg->getOption().matches(

709

options::OPT_fprofile_instr_use))) {

711

ProfileUseArg->getNumValues() == 0 ?

""

: ProfileUseArg->getValue());

712 if

(

.empty() || llvm::sys::fs::is_directory(

))

713

llvm::sys::path::append(

"default.profdata"

);

715

Args.MakeArgString(Twine(

"-fprofile-instrument-use-path="

) +

));

719 bool

EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,

720

options::OPT_fno_test_coverage,

false

) ||

721

Args.hasArg(options::OPT_coverage);

724 if

(Args.hasFlag(options::OPT_fcoverage_mapping,

725

options::OPT_fno_coverage_mapping,

false

)) {

726 if

(!ProfileGenerateArg)

727 D

.Diag(clang::diag::err_drv_argument_only_allowed_with)

728

"-fcoverage-mapping" 729

"-fprofile-instr-generate"

;

731

CmdArgs.push_back(

"-fcoverage-mapping"

);

734 if

(Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,

736 if

(!Args.hasFlag(options::OPT_fcoverage_mapping,

737

options::OPT_fno_coverage_mapping,

false

))

738 D

.Diag(clang::diag::err_drv_argument_only_allowed_with)

740

"-fcoverage-mapping"

;

742

CmdArgs.push_back(

"-fcoverage-mcdc"

);

745 if

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

746

options::OPT_fcoverage_compilation_dir_EQ)) {

747 if

(A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))

748

CmdArgs.push_back(Args.MakeArgString(

749

Twine(

"-fcoverage-compilation-dir="

) + A->getValue()));

751

A->render(Args, CmdArgs);

752

}

else if

(llvm::ErrorOr<std::string> CWD =

753 D

.getVFS().getCurrentWorkingDirectory()) {

754

CmdArgs.push_back(Args.MakeArgString(

"-fcoverage-compilation-dir="

+ *CWD));

757 if

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

758 auto

*Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);

759 if

(!Args.hasArg(options::OPT_coverage))

760 D

.Diag(clang::diag::err_drv_argument_only_allowed_with)

761

"-fprofile-exclude-files=" 764

StringRef

= Arg->getValue();

766

Args.MakeArgString(Twine(

"-fprofile-exclude-files="

)));

769 if

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

770 auto

*Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);

771 if

(!Args.hasArg(options::OPT_coverage))

772 D

.Diag(clang::diag::err_drv_argument_only_allowed_with)

773

"-fprofile-filter-files=" 776

StringRef

= Arg->getValue();

777

CmdArgs.push_back(Args.MakeArgString(Twine(

"-fprofile-filter-files="

)));

780 if

(

const auto

*A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {

781

StringRef Val = A->getValue();

782 if

(Val ==

"atomic"

|| Val ==

"prefer-atomic"

)

783

CmdArgs.push_back(

"-fprofile-update=atomic"

);

784 else if

(Val !=

"single"

)

785 D

.Diag(diag::err_drv_unsupported_option_argument)

786

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

789 int

FunctionGroups = 1;

790 int

SelectedFunctionGroup = 0;

791 if

(

const auto

*A = Args.getLastArg(options::OPT_fprofile_function_groups)) {

792

StringRef Val = A->getValue();

793 if

(Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)

794 D

.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;

797

Args.getLastArg(options::OPT_fprofile_selected_function_group)) {

798

StringRef Val = A->getValue();

799 if

(Val.getAsInteger(0, SelectedFunctionGroup) ||

800

SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)

801 D

.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;

803 if

(FunctionGroups != 1)

804

CmdArgs.push_back(Args.MakeArgString(

"-fprofile-function-groups="

805

Twine(FunctionGroups)));

806 if

(SelectedFunctionGroup != 0)

807

CmdArgs.push_back(Args.MakeArgString(

"-fprofile-selected-function-group="

808

Twine(SelectedFunctionGroup)));

814

Arg *FProfileDir =

nullptr

;

815 if

(Args.hasArg(options::OPT_fprofile_arcs) ||

816

Args.hasArg(options::OPT_coverage))

817

FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);

822 if

(EmitCovNotes || EmitCovData) {

824 if

(Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {

827

CoverageFilename = DumpDir->getValue();

828

CoverageFilename += llvm::sys::path::filename(Output.

getBaseInput

());

829

}

else if

(Arg *FinalOutput =

830 C

.getArgs().getLastArg(options::OPT__SLASH_Fo)) {

831

CoverageFilename = FinalOutput->getValue();

832

}

else if

(Arg *FinalOutput =

.getArgs().getLastArg(options::OPT_o)) {

833

CoverageFilename = FinalOutput->getValue();

835

CoverageFilename = llvm::sys::path::filename(Output.

getBaseInput

());

837 if

(llvm::sys::path::is_relative(CoverageFilename))

838

(void)

.getVFS().makeAbsolute(CoverageFilename);

839

llvm::sys::path::replace_extension(CoverageFilename,

"gcno"

);

842

Args.MakeArgString(

"-coverage-notes-file="

+ CoverageFilename));

848

CoverageFilename = FProfileDir->getValue();

849

llvm::sys::path::append(CoverageFilename, Gcno);

851

llvm::sys::path::replace_extension(CoverageFilename,

"gcda"

);

853

Args.MakeArgString(

"-coverage-data-file="

+ CoverageFilename));

860

llvm::codegenoptions::DebugInfoKind DebugInfoKind,

861 unsigned

DwarfVersion,

862

llvm::DebuggerKind DebuggerTuning) {

864 if

(DwarfVersion > 0)

866

Args.MakeArgString(

"-dwarf-version="

+ Twine(DwarfVersion)));

867 switch

(DebuggerTuning) {

868 case

llvm::DebuggerKind::GDB:

869

CmdArgs.push_back(

"-debugger-tuning=gdb"

);

871 case

llvm::DebuggerKind::LLDB:

872

CmdArgs.push_back(

"-debugger-tuning=lldb"

);

874 case

llvm::DebuggerKind::SCE:

875

CmdArgs.push_back(

"-debugger-tuning=sce"

);

877 case

llvm::DebuggerKind::DBX:

878

CmdArgs.push_back(

"-debugger-tuning=dbx"

);

887

assert(A &&

"Expected non-nullptr argument."

);

890 D

.Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)

896

ArgStringList &CmdArgs,

899 const

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

903

StringRef

= A->getValue();

904 if

(

"none"

) {

905

CmdArgs.push_back(

"--compress-debug-sections=none"

);

906

}

else if

(

"zlib"

) {

907 if

(llvm::compression::zlib::isAvailable()) {

909

Args.MakeArgString(

"--compress-debug-sections="

+ Twine(

)));

911 D

.Diag(diag::warn_debug_compression_unavailable) <<

"zlib"

;

913

}

else if

(

"zstd"

) {

914 if

(llvm::compression::zstd::isAvailable()) {

916

Args.MakeArgString(

"--compress-debug-sections="

+ Twine(

)));

918 D

.Diag(diag::warn_debug_compression_unavailable) <<

"zstd"

;

921 D

.Diag(diag::err_drv_unsupported_option_argument)

922

<< A->getSpelling() <<

;

929

ArgStringList &CmdArgs,

930 bool

IsCC1As =

false

) {

938

CmdArgs.insert(CmdArgs.begin() + 1,

939

Args.MakeArgString(Twine(

"--amdhsa-code-object-version="

) +

941

CmdArgs.insert(CmdArgs.begin() + 1,

"-mllvm"

);

944

CmdArgs.insert(CmdArgs.begin() + 1,

945

Args.MakeArgString(Twine(

"-mcode-object-version="

) +

951

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MemBuf =

952 D

.getVFS().getBufferForFile(

);

955

llvm::file_magic Magic = llvm::identify_magic((*MemBuf)->getBuffer());

956 if

(Magic == llvm::file_magic::unknown)

960 if

(Magic == llvm::file_magic::clang_ast)

963

llvm::object::ObjectFile::createObjectFile(**MemBuf, Magic);

964 return

!Obj.takeError();

968

llvm::ErrorOr<llvm::vfs::Status> Status =

.getVFS().status(

);

972 if

(Status->isDirectory()) {

974 for

(llvm::vfs::directory_iterator DI =

.getVFS().dir_begin(

, EC), DE;

975

!EC && DI != DE; DI = DI.increment(EC)) {

979 D

.Diag(diag::warn_drv_pch_ignoring_gch_dir) <<

;

985 D

.Diag(diag::warn_drv_pch_ignoring_gch_file) <<

;

990 const Driver

const

ArgList &Args,

991

ArgStringList &CmdArgs,

998

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

999

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

1002

Arg *ArgM = Args.getLastArg(options::OPT_MM);

1004

ArgM = Args.getLastArg(options::OPT_M);

1005

Arg *ArgMD = Args.getLastArg(options::OPT_MMD);

1007

ArgMD = Args.getLastArg(options::OPT_MD);

1011

CmdArgs.push_back(

"-w"

);

1017 const char

*DepFile;

1018 if

(Arg *MF = Args.getLastArg(options::OPT_MF)) {

1019

DepFile = MF->getValue();

1020 C

.addFailureResultFile(DepFile, &JA);

1021

}

else if

(Output.

() == types::TY_Dependencies) {

1023

}

else if

(!ArgMD) {

1027 C

.addFailureResultFile(DepFile, &JA);

1029

CmdArgs.push_back(

"-dependency-file"

);

1030

CmdArgs.push_back(DepFile);

1032 bool

HasTarget =

false

;

1033 for

(

const

Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {

1036 if

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

1037

A->render(Args, CmdArgs);

1039

CmdArgs.push_back(

"-MT"

);

1042

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

1048 const char

*DepTarget;

1052

Arg *OutputOpt = Args.getLastArg(options::OPT_o, options::OPT__SLASH_Fo);

1053 if

(OutputOpt && Output.

() != types::TY_Dependencies) {

1054

DepTarget = OutputOpt->getValue();

1060

llvm::sys::path::replace_extension(

"o"

);

1061

DepTarget = Args.MakeArgString(llvm::sys::path::filename(

));

1064

CmdArgs.push_back(

"-MT"

);

1067

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

1070 if

(ArgM->getOption().matches(options::OPT_M) ||

1071

ArgM->getOption().matches(options::OPT_MD))

1072

CmdArgs.push_back(

"-sys-header-deps"

);

1073 if

((isa<PrecompileJobAction>(JA) &&

1074

!Args.hasArg(options::OPT_fno_module_file_deps)) ||

1075

Args.hasArg(options::OPT_fmodule_file_deps))

1076

CmdArgs.push_back(

"-module-file-deps"

);

1079 if

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

1080 if

(!ArgM || ArgM->getOption().matches(options::OPT_MD) ||

1081

ArgM->getOption().matches(options::OPT_MMD))

1082 D

.Diag(diag::err_drv_mg_requires_m_or_mm);

1083

CmdArgs.push_back(

"-MG"

);

1086

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

1087

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

1103

!Args.hasArg(options::OPT_nostdinc) &&

1104

!Args.hasArg(options::OPT_nogpuinc) &&

1107 if

(!Args.hasArg(options::OPT_nobuiltininc)) {

1111

llvm::sys::path::append(

"include"

);

1112

llvm::sys::path::append(

"openmp_wrappers"

);

1113

CmdArgs.push_back(

"-internal-isystem"

);

1114

CmdArgs.push_back(Args.MakeArgString(

));

1117

CmdArgs.push_back(

"-include"

);

1118

CmdArgs.push_back(

"__clang_openmp_device_functions.h"

);

1121 if

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

1125

llvm::sys::path::append(

"include"

"llvm_offload_wrappers"

);

1126

CmdArgs.append({

"-internal-isystem"

, Args.MakeArgString(

"-include"

});

1128

CmdArgs.push_back(

"__llvm_offload_device.h"

);

1130

CmdArgs.push_back(

"__llvm_offload_host.h"

);

1140 const

Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);

1141 const

Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);

1144

CmdArgs.push_back(Args.MakeArgString(

"-building-pch-with-obj"

));

1147 if

(Args.hasFlag(options::OPT_fpch_instantiate_templates,

1148

options::OPT_fno_pch_instantiate_templates,

true

))

1149

CmdArgs.push_back(Args.MakeArgString(

"-fpch-instantiate-templates"

));

1151 if

(YcArg || YuArg) {

1152

StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();

1153 if

(!isa<PrecompileJobAction>(JA)) {

1154

CmdArgs.push_back(

"-include-pch"

);

1155

CmdArgs.push_back(Args.MakeArgString(

.GetClPchPath(

1156 C

, !ThroughHeader.empty()

1158

: llvm::sys::path::filename(Inputs[0].getBaseInput()))));

1161 if

(ThroughHeader.empty()) {

1162

CmdArgs.push_back(Args.MakeArgString(

1163

Twine(

"-pch-through-hdrstop-"

) + (YcArg ?

"create"

"use"

)));

1166

Args.MakeArgString(Twine(

"-pch-through-header="

) + ThroughHeader));

1171 bool

RenderedImplicitInclude =

false

;

1172 for

(

const

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

1173 if

(A->getOption().matches(options::OPT_include) &&

1174 D

.getProbePrecompiled()) {

1176 bool

IsFirstImplicitInclude = !RenderedImplicitInclude;

1177

RenderedImplicitInclude =

true

;

1179 bool

FoundPCH =

false

;

1184

llvm::sys::path::replace_extension(

"pch"

);

1185 if

(

.getVFS().exists(

))

1190

llvm::sys::path::replace_extension(

"gch"

);

1195 if

(IsFirstImplicitInclude) {

1197

CmdArgs.push_back(

"-include-pch"

);

1198

CmdArgs.push_back(Args.MakeArgString(

));

1202 D

.Diag(diag::warn_drv_pch_not_first_include) <<

P 1203

<< A->getAsString(Args);

1206

}

else if

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

1213

}

else if

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

1216

}

else if

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

1223

A->render(Args, CmdArgs);

1226

Args.addAllArgs(CmdArgs,

1227

{options::OPT_D, options::OPT_U, options::OPT_I_Group,

1228

options::OPT_F, options::OPT_embed_dir_EQ});

1236

Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,

1237

options::OPT_Xpreprocessor);

1240 if

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

1241 D

.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);

1245

StringRef sysroot =

.getSysRoot();

1246 if

(sysroot !=

""

) {

1247 if

(!Args.hasArg(options::OPT_isysroot)) {

1248

CmdArgs.push_back(

"-isysroot"

);

1249

CmdArgs.push_back(

.getArgs().MakeArgString(sysroot));

1266 addDirectoryList

(Args, CmdArgs,

"-objcxx-isystem"

"OBJCPLUS_INCLUDE_PATH"

);

1274 bool

HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);

1277

[&Args, &CmdArgs, HasStdlibxxIsystem](

const ToolChain

&TC) {

1287 if

(!Args.hasArg(options::OPT_nostdinc) &&

1288

!Args.hasArg(options::OPT_nogpuinc) &&

1289

!Args.hasArg(options::OPT_nobuiltininc)) {

1297

llvm::sys::path::append(

"include"

);

1298

llvm::sys::path::append(

().getTripleString());

1299

CmdArgs.push_back(

"-internal-isystem"

);

1300

CmdArgs.push_back(Args.MakeArgString(

));

1305

llvm::sys::path::append(

"include"

);

1306

llvm::sys::path::append(

"llvm_libc_wrappers"

);

1307

CmdArgs.push_back(

"-internal-isystem"

);

1308

CmdArgs.push_back(Args.MakeArgString(

));

1315

[&Args, &CmdArgs](

const ToolChain

&TC) {

1326

Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible,

1327

options::OPT_fno_file_reproducible);

1329 if

(

const char

*Epoch = std::getenv(

"SOURCE_DATE_EPOCH"

)) {

1330

CmdArgs.push_back(

"-source-date-epoch"

);

1331

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

1334

Args.addOptInFlag(CmdArgs, options::OPT_fdefine_target_os_macros,

1335

options::OPT_fno_define_target_os_macros);

1340 switch

(Triple.getArch()) {

1344 case

llvm::Triple::aarch64:

1345 case

llvm::Triple::aarch64_32:

1346 case

llvm::Triple::aarch64_be:

1347 case

llvm::Triple::arm:

1348 case

llvm::Triple::armeb:

1349 case

llvm::Triple::thumb:

1350 case

llvm::Triple::thumbeb:

1351 if

(Triple.isOSDarwin() || Triple.isOSWindows())

1355 case

llvm::Triple::ppc:

1356 case

llvm::Triple::ppc64:

1357 if

(Triple.isOSDarwin())

1361 case

llvm::Triple::hexagon:

1362 case

llvm::Triple::msp430:

1363 case

llvm::Triple::ppcle:

1364 case

llvm::Triple::ppc64le:

1365 case

llvm::Triple::riscv32:

1366 case

llvm::Triple::riscv64:

1367 case

llvm::Triple::systemz:

1368 case

llvm::Triple::xcore:

1369 case

llvm::Triple::xtensa:

1375 const

ArgList &Args) {

1378 if

(!Triple.isOSDarwin())

1382 return

Args.getAllArgValues(options::OPT_arch).size() > 1;

1386 const

llvm::Triple &Triple) {

1391 bool

hasExplicitOutputFile =

1392

Args.getLastArg(options::OPT_foptimization_record_file_EQ);

1394 D

.Diag(diag::err_drv_invalid_output_with_multiple_archs)

1395

"-foptimization-record-file"

;

1402 const

llvm::Triple &Triple,

1405

StringRef Format =

"yaml"

;

1406 if

(

const

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

1407

Format = A->getValue();

1409

CmdArgs.push_back(

"-opt-record-file"

);

1411 const

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

1413

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

1415 bool

hasMultipleArchs =

1416

Triple.isOSDarwin() &&

1417

Args.getAllArgValues(options::OPT_arch).size() > 1;

1421 if

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

1422 if

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

1423

F = FinalOutput->getValue();

1425 if

(Format !=

"yaml"

1426

Triple.isOSDarwin() &&

1440

llvm::sys::path::replace_extension(F,

""

);

1442

Triple.normalize());

1452 if

(hasMultipleArchs) {

1456

llvm::sys::path::replace_extension(F,

""

);

1459

F += Triple.getArchName();

1461

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

1465

Extension +=

"opt."

;

1466

Extension += Format;

1468

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

1469

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

1473

Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {

1474

CmdArgs.push_back(

"-opt-record-passes"

);

1475

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

1478 if

(!Format.empty()) {

1479

CmdArgs.push_back(

"-opt-record-format"

);

1480

CmdArgs.push_back(Format.data());

1485 if

(!Args.hasFlag(options::OPT_faapcs_bitfield_width,

1486

options::OPT_fno_aapcs_bitfield_width,

true

))

1487

CmdArgs.push_back(

"-fno-aapcs-bitfield-width"

);

1489 if

(Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad))

1490

CmdArgs.push_back(

"-faapcs-bitfield-load"

);

1494void

RenderARMABI(

const Driver

const

llvm::Triple &Triple,

1495 const

ArgList &Args, ArgStringList &CmdArgs) {

1499 const char

*ABIName =

nullptr

;

1500 if

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

1501

ABIName = A->getValue();

1503

std::string CPU =

getCPUName

(

, Args, Triple,

false

);

1504

ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();

1507

CmdArgs.push_back(

"-target-abi"

);

1508

CmdArgs.push_back(ABIName);

1511void

AddUnalignedAccessWarning(ArgStringList &CmdArgs) {

1512 auto

StrictAlignIter =

1513

llvm::find_if(llvm::reverse(CmdArgs), [](StringRef Arg) {

1514 return

Arg ==

"+strict-align"

|| Arg ==

"-strict-align"

;

1516 if

(StrictAlignIter != CmdArgs.rend() &&

1517

StringRef(*StrictAlignIter) ==

"+strict-align"

)

1518

CmdArgs.push_back(

"-Wunaligned-access"

);

1526 if

(!DriverArgs.hasArg(options::OPT_fptrauth_intrinsics,

1527

options::OPT_fno_ptrauth_intrinsics))

1528

CC1Args.push_back(

"-fptrauth-intrinsics"

);

1530 if

(!DriverArgs.hasArg(options::OPT_fptrauth_calls,

1531

options::OPT_fno_ptrauth_calls))

1532

CC1Args.push_back(

"-fptrauth-calls"

);

1534 if

(!DriverArgs.hasArg(options::OPT_fptrauth_returns,

1535

options::OPT_fno_ptrauth_returns))

1536

CC1Args.push_back(

"-fptrauth-returns"

);

1538 if

(!DriverArgs.hasArg(options::OPT_fptrauth_auth_traps,

1539

options::OPT_fno_ptrauth_auth_traps))

1540

CC1Args.push_back(

"-fptrauth-auth-traps"

);

1542 if

(!DriverArgs.hasArg(

1543

options::OPT_fptrauth_vtable_pointer_address_discrimination,

1544

options::OPT_fno_ptrauth_vtable_pointer_address_discrimination))

1545

CC1Args.push_back(

"-fptrauth-vtable-pointer-address-discrimination"

);

1547 if

(!DriverArgs.hasArg(

1548

options::OPT_fptrauth_vtable_pointer_type_discrimination,

1549

options::OPT_fno_ptrauth_vtable_pointer_type_discrimination))

1550

CC1Args.push_back(

"-fptrauth-vtable-pointer-type-discrimination"

);

1552 if

(!DriverArgs.hasArg(options::OPT_fptrauth_indirect_gotos,

1553

options::OPT_fno_ptrauth_indirect_gotos))

1554

CC1Args.push_back(

"-fptrauth-indirect-gotos"

);

1556 if

(!DriverArgs.hasArg(options::OPT_fptrauth_init_fini,

1557

options::OPT_fno_ptrauth_init_fini))

1558

CC1Args.push_back(

"-fptrauth-init-fini"

);

1562

ArgStringList &CmdArgs,

bool

isAArch64) {

1563 const

Arg *A = isAArch64

1564

? Args.getLastArg(options::OPT_msign_return_address_EQ,

1565

options::OPT_mbranch_protection_EQ)

1566

: Args.getLastArg(options::OPT_mbranch_protection_EQ);

1572 if

(!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass())))

1573 D

.Diag(diag::warn_incompatible_branch_protection_option)

1574

<< Triple.getArchName();

1576

StringRef

, Key;

1577 bool

IndirectBranches, BranchProtectionPAuthLR, GuardedControlStack;

1579 if

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

1580 Scope

= A->getValue();

1582 D

.Diag(diag::err_drv_unsupported_option_argument)

1583

<< A->getSpelling() <<

;

1585

IndirectBranches =

false

;

1586

BranchProtectionPAuthLR =

false

;

1587

GuardedControlStack =

false

;

1590

llvm::ARM::ParsedBranchProtection PBP;

1591 bool

EnablePAuthLR =

false

;

1598 auto

isPAuthLR = [](

const char

*member) {

1599

llvm::AArch64::ExtensionInfo pauthlr_extension =

1600

llvm::AArch64::getExtensionByID(llvm::AArch64::AEK_PAUTHLR);

1601 return

pauthlr_extension.PosTargetFeature == member;

1604 if

(std::any_of(CmdArgs.begin(), CmdArgs.end(), isPAuthLR))

1605

EnablePAuthLR =

true

;

1607 if

(!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg,

1609 D

.Diag(diag::err_drv_unsupported_option_argument)

1610

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

1611 if

(!isAArch64 && PBP.Key ==

"b_key"

)

1612 D

.Diag(diag::warn_unsupported_branch_protection)

1613

"b-key"

<< A->getAsString(Args);

1616

BranchProtectionPAuthLR = PBP.BranchProtectionPAuthLR;

1617

IndirectBranches = PBP.BranchTargetEnforcement;

1618

GuardedControlStack = PBP.GuardedControlStack;

1622

Args.MakeArgString(Twine(

"-msign-return-address="

) +

));

1623 if

(

"none"

) {

1624 if

(Triple.getEnvironment() == llvm::Triple::PAuthTest)

1625 D

.Diag(diag::err_drv_unsupported_opt_for_target)

1626

<< A->getAsString(Args) << Triple.getTriple();

1628

Args.MakeArgString(Twine(

"-msign-return-address-key="

) + Key));

1630 if

(BranchProtectionPAuthLR) {

1631 if

(Triple.getEnvironment() == llvm::Triple::PAuthTest)

1632 D

.Diag(diag::err_drv_unsupported_opt_for_target)

1633

<< A->getAsString(Args) << Triple.getTriple();

1635

Args.MakeArgString(Twine(

"-mbranch-protection-pauth-lr"

)));

1637 if

(IndirectBranches)

1638

CmdArgs.push_back(

"-mbranch-target-enforce"

);

1641 if

(GuardedControlStack) {

1642 if

(Triple.getEnvironment() == llvm::Triple::PAuthTest)

1643 D

.Diag(diag::err_drv_unsupported_opt_for_target)

1644

<< A->getAsString(Args) << Triple.getTriple();

1645

CmdArgs.push_back(

"-mguarded-control-stack"

);

1649void

Clang::AddARMTargetArgs(

const

llvm::Triple &Triple,

const

ArgList &Args,

1650

ArgStringList &CmdArgs,

bool

KernelOrKext)

const

{

1651

RenderARMABI(

().getDriver(), Triple, Args, CmdArgs);

1658

CmdArgs.push_back(

"-msoft-float"

);

1659

CmdArgs.push_back(

"-mfloat-abi"

);

1660

CmdArgs.push_back(

"soft"

);

1663

CmdArgs.push_back(

"-mfloat-abi"

);

1664

CmdArgs.push_back(

"soft"

);

1668

CmdArgs.push_back(

"-mfloat-abi"

);

1669

CmdArgs.push_back(

"hard"

);

1673 if

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

1674

options::OPT_mno_global_merge)) {

1675

CmdArgs.push_back(

"-mllvm"

);

1676 if

(A->getOption().matches(options::OPT_mno_global_merge))

1677

CmdArgs.push_back(

"-arm-global-merge=false"

);

1679

CmdArgs.push_back(

"-arm-global-merge=true"

);

1682 if

(!Args.hasFlag(options::OPT_mimplicit_float,

1683

options::OPT_mno_implicit_float,

true

))

1684

CmdArgs.push_back(

"-no-implicit-float"

);

1686 if

(Args.getLastArg(options::OPT_mcmse))

1687

CmdArgs.push_back(

"-mcmse"

);

1694

AddUnalignedAccessWarning(CmdArgs);

1697void

Clang::RenderTargetOptions(

const

llvm::Triple &EffectiveTriple,

1698 const

ArgList &Args,

bool

KernelOrKext,

1699

ArgStringList &CmdArgs)

const

{

1710 case

llvm::Triple::arm:

1711 case

llvm::Triple::armeb:

1712 case

llvm::Triple::thumb:

1713 case

llvm::Triple::thumbeb:

1715

AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);

1718 case

llvm::Triple::aarch64:

1719 case

llvm::Triple::aarch64_32:

1720 case

llvm::Triple::aarch64_be:

1721

AddAArch64TargetArgs(Args, CmdArgs);

1724 case

llvm::Triple::loongarch32:

1725 case

llvm::Triple::loongarch64:

1726

AddLoongArchTargetArgs(Args, CmdArgs);

1729 case

llvm::Triple::mips:

1730 case

llvm::Triple::mipsel:

1731 case

llvm::Triple::mips64:

1732 case

llvm::Triple::mips64el:

1733

AddMIPSTargetArgs(Args, CmdArgs);

1736 case

llvm::Triple::ppc:

1737 case

llvm::Triple::ppcle:

1738 case

llvm::Triple::ppc64:

1739 case

llvm::Triple::ppc64le:

1740

AddPPCTargetArgs(Args, CmdArgs);

1743 case

llvm::Triple::riscv32:

1744 case

llvm::Triple::riscv64:

1745

AddRISCVTargetArgs(Args, CmdArgs);

1748 case

llvm::Triple::sparc:

1749 case

llvm::Triple::sparcel:

1750 case

llvm::Triple::sparcv9:

1751

AddSparcTargetArgs(Args, CmdArgs);

1754 case

llvm::Triple::systemz:

1755

AddSystemZTargetArgs(Args, CmdArgs);

1758 case

llvm::Triple::x86:

1759 case

llvm::Triple::x86_64:

1760

AddX86TargetArgs(Args, CmdArgs);

1763 case

llvm::Triple::lanai:

1764

AddLanaiTargetArgs(Args, CmdArgs);

1767 case

llvm::Triple::hexagon:

1768

AddHexagonTargetArgs(Args, CmdArgs);

1771 case

llvm::Triple::wasm32:

1772 case

llvm::Triple::wasm64:

1773

AddWebAssemblyTargetArgs(Args, CmdArgs);

1776 case

llvm::Triple::ve:

1777

AddVETargetArgs(Args, CmdArgs);

1783void

RenderAArch64ABI(

const

llvm::Triple &Triple,

const

ArgList &Args,

1784

ArgStringList &CmdArgs) {

1785 const char

*ABIName =

nullptr

;

1786 if

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

1787

ABIName = A->getValue();

1788 else if

(Triple.isOSDarwin())

1789

ABIName =

"darwinpcs"

;

1790 else if

(Triple.getEnvironment() == llvm::Triple::PAuthTest)

1791

ABIName =

"pauthtest"

;

1795

CmdArgs.push_back(

"-target-abi"

);

1796

CmdArgs.push_back(ABIName);

1800void

Clang::AddAArch64TargetArgs(

const

ArgList &Args,

1801

ArgStringList &CmdArgs)

const

{

1804 if

(!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,

true

) ||

1805

Args.hasArg(options::OPT_mkernel) ||

1806

Args.hasArg(options::OPT_fapple_kext))

1807

CmdArgs.push_back(

"-disable-red-zone"

);

1809 if

(!Args.hasFlag(options::OPT_mimplicit_float,

1810

options::OPT_mno_implicit_float,

true

))

1811

CmdArgs.push_back(

"-no-implicit-float"

);

1813

RenderAArch64ABI(Triple, Args, CmdArgs);

1816 if

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

1817

options::OPT_mno_global_merge)) {

1818

CmdArgs.push_back(

"-mllvm"

);

1819 if

(A->getOption().matches(options::OPT_mno_global_merge))

1820

CmdArgs.push_back(

"-aarch64-enable-global-merge=false"

);

1822

CmdArgs.push_back(

"-aarch64-enable-global-merge=true"

);

1828 if

(Triple.getEnvironment() == llvm::Triple::PAuthTest)

1832 if

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

1833

StringRef Val = A->getValue();

1835 if

(Val ==

"128"

|| Val ==

"256"

|| Val ==

"512"

|| Val ==

"1024"

1836

Val ==

"2048"

|| Val ==

"128+"

|| Val ==

"256+"

|| Val ==

"512+"

1837

Val ==

"1024+"

|| Val ==

"2048+"

) {

1839 if

(!Val.consume_back(

"+"

)) {

1841

assert(!

Invalid

"Failed to parse value"

);

1843

Args.MakeArgString(

"-mvscale-max="

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

1847

assert(!

Invalid

"Failed to parse value"

);

1849

Args.MakeArgString(

"-mvscale-min="

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

1851

}

else if

(Val !=

"scalable"

)

1853 D

.Diag(diag::err_drv_unsupported_option_argument)

1854

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

1859 if

(

const

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

1860

CmdArgs.push_back(

"-tune-cpu"

);

1861 if

(strcmp(A->getValue(),

"native"

) == 0)

1862

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

1864

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

1867

AddUnalignedAccessWarning(CmdArgs);

1869

Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,

1870

options::OPT_fno_ptrauth_intrinsics);

1871

Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_calls,

1872

options::OPT_fno_ptrauth_calls);

1873

Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_returns,

1874

options::OPT_fno_ptrauth_returns);

1875

Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_auth_traps,

1876

options::OPT_fno_ptrauth_auth_traps);

1878

CmdArgs, options::OPT_fptrauth_vtable_pointer_address_discrimination,

1879

options::OPT_fno_ptrauth_vtable_pointer_address_discrimination);

1881

CmdArgs, options::OPT_fptrauth_vtable_pointer_type_discrimination,

1882

options::OPT_fno_ptrauth_vtable_pointer_type_discrimination);

1884

CmdArgs, options::OPT_fptrauth_type_info_vtable_pointer_discrimination,

1885

options::OPT_fno_ptrauth_type_info_vtable_pointer_discrimination);

1887

CmdArgs, options::OPT_fptrauth_function_pointer_type_discrimination,

1888

options::OPT_fno_ptrauth_function_pointer_type_discrimination);

1890

Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_indirect_gotos,

1891

options::OPT_fno_ptrauth_indirect_gotos);

1892

Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_init_fini,

1893

options::OPT_fno_ptrauth_init_fini);

1894

Args.addOptInFlag(CmdArgs,

1895

options::OPT_fptrauth_init_fini_address_discrimination,

1896

options::OPT_fno_ptrauth_init_fini_address_discrimination);

1897

Args.addOptInFlag(CmdArgs, options::OPT_faarch64_jump_table_hardening,

1898

options::OPT_fno_aarch64_jump_table_hardening);

1901void

Clang::AddLoongArchTargetArgs(

const

ArgList &Args,

1902

ArgStringList &CmdArgs)

const

{

1905

CmdArgs.push_back(

"-target-abi"

);

1911 if

(

const

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

1912

std::string TuneCPU = A->getValue();

1914

CmdArgs.push_back(

"-tune-cpu"

);

1915

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

1918 if

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

1919

options::OPT_mno_annotate_tablejump)) {

1920 if

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

1921

CmdArgs.push_back(

"-mllvm"

);

1922

CmdArgs.push_back(

"-loongarch-annotate-tablejump"

);

1927void

Clang::AddMIPSTargetArgs(

const

ArgList &Args,

1928

ArgStringList &CmdArgs)

const

{

1935

CmdArgs.push_back(

"-target-abi"

);

1936

CmdArgs.push_back(ABIName.data());

1941

CmdArgs.push_back(

"-msoft-float"

);

1942

CmdArgs.push_back(

"-mfloat-abi"

);

1943

CmdArgs.push_back(

"soft"

);

1947

CmdArgs.push_back(

"-mfloat-abi"

);

1948

CmdArgs.push_back(

"hard"

);

1951 if

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

1952

options::OPT_mno_ldc1_sdc1)) {

1953 if

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

1954

CmdArgs.push_back(

"-mllvm"

);

1955

CmdArgs.push_back(

"-mno-ldc1-sdc1"

);

1959 if

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

1960

options::OPT_mno_check_zero_division)) {

1961 if

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

1962

CmdArgs.push_back(

"-mllvm"

);

1963

CmdArgs.push_back(

"-mno-check-zero-division"

);

1967 if

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

1968

CmdArgs.push_back(

"-mllvm"

);

1969

CmdArgs.push_back(

"-mfix4300"

);

1972 if

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

1973

StringRef

= A->getValue();

1974

CmdArgs.push_back(

"-mllvm"

);

1975

CmdArgs.push_back(Args.MakeArgString(

"-mips-ssection-threshold="

));

1979

Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);

1981

Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);

1994

ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);

1996

llvm::Reloc::Model RelocationModel;

1999

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

2002

NoABICalls = NoABICalls ||

2003

(RelocationModel == llvm::Reloc::Static && ABIName ==

"n64"

);

2005 bool

WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);

2007 if

(NoABICalls && (!GPOpt || WantGPOpt)) {

2008

CmdArgs.push_back(

"-mllvm"

);

2009

CmdArgs.push_back(

"-mgpopt"

);

2011

Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,

2012

options::OPT_mno_local_sdata);

2013

Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,

2014

options::OPT_mno_extern_sdata);

2015

Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,

2016

options::OPT_mno_embedded_data);

2018

CmdArgs.push_back(

"-mllvm"

);

2019 if

(LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {

2020

CmdArgs.push_back(

"-mlocal-sdata=1"

);

2022

CmdArgs.push_back(

"-mlocal-sdata=0"

);

2024

LocalSData->claim();

2028

CmdArgs.push_back(

"-mllvm"

);

2029 if

(ExternSData->getOption().matches(options::OPT_mextern_sdata)) {

2030

CmdArgs.push_back(

"-mextern-sdata=1"

);

2032

CmdArgs.push_back(

"-mextern-sdata=0"

);

2034

ExternSData->claim();

2038

CmdArgs.push_back(

"-mllvm"

);

2039 if

(EmbeddedData->getOption().matches(options::OPT_membedded_data)) {

2040

CmdArgs.push_back(

"-membedded-data=1"

);

2042

CmdArgs.push_back(

"-membedded-data=0"

);

2044

EmbeddedData->claim();

2047

}

else if

((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)

2048 D

.Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);

2053 if

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

2054

StringRef Val = StringRef(A->getValue());

2056 if

(Val ==

"never"

|| Val ==

"always"

|| Val ==

"optimal"

) {

2057

CmdArgs.push_back(

"-mllvm"

);

2058

CmdArgs.push_back(Args.MakeArgString(

"-mips-compact-branches="

+ Val));

2060 D

.Diag(diag::err_drv_unsupported_option_argument)

2061

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

2063 D

.Diag(diag::warn_target_unsupported_compact_branches) << CPUName;

2066 if

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

2067

options::OPT_mno_relax_pic_calls)) {

2068 if

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

2069

CmdArgs.push_back(

"-mllvm"

);

2070

CmdArgs.push_back(

"-mips-jalr-reloc=0"

);

2075void

Clang::AddPPCTargetArgs(

const

ArgList &Args,

2076

ArgStringList &CmdArgs)

const

{

2079 if

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

2080

CmdArgs.push_back(

"-tune-cpu"

);

2081

StringRef CPU = llvm::PPC::getNormalizedPPCTuneCPU(

, A->getValue());

2082

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

2086 const char

*ABIName =

nullptr

;

2087 if

(

.isOSBinFormatELF()) {

2089 case

llvm::Triple::ppc64: {

2090 if

(

.isPPC64ELFv2ABI())

2096 case

llvm::Triple::ppc64le:

2105 bool

VecExtabi =

false

;

2106 for

(

const

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

2107

StringRef

= A->getValue();

2108 if

(

"ieeelongdouble"

) {

2109

IEEELongDouble =

true

;

2111

}

else if

(

"ibmlongdouble"

) {

2112

IEEELongDouble =

false

;

2114

}

else if

(

"vec-default"

) {

2117

}

else if

(

"vec-extabi"

) {

2120

}

else if

(

"elfv1"

) {

2123

}

else if

(

"elfv2"

) {

2126

}

else if

(

"altivec"

)

2130

ABIName = A->getValue();

2133

CmdArgs.push_back(

"-mabi=ieeelongdouble"

);

2136 D

.Diag(diag::err_drv_unsupported_opt_for_target)

2137

"-mabi=vec-extabi"

.str();

2138

CmdArgs.push_back(

"-mabi=vec-extabi"

);

2141 if

(!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,

true

))

2142

CmdArgs.push_back(

"-disable-red-zone"

);

2147

CmdArgs.push_back(

"-msoft-float"

);

2148

CmdArgs.push_back(

"-mfloat-abi"

);

2149

CmdArgs.push_back(

"soft"

);

2153

CmdArgs.push_back(

"-mfloat-abi"

);

2154

CmdArgs.push_back(

"hard"

);

2158

CmdArgs.push_back(

"-target-abi"

);

2159

CmdArgs.push_back(ABIName);

2163void

Clang::AddRISCVTargetArgs(

const

ArgList &Args,

2164

ArgStringList &CmdArgs)

const

{

2168

CmdArgs.push_back(

"-target-abi"

);

2169

CmdArgs.push_back(ABIName.data());

2171 if

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

2172

CmdArgs.push_back(

"-msmall-data-limit"

);

2173

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

2176 if

(!Args.hasFlag(options::OPT_mimplicit_float,

2177

options::OPT_mno_implicit_float,

true

))

2178

CmdArgs.push_back(

"-no-implicit-float"

);

2180 if

(

const

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

2181

CmdArgs.push_back(

"-tune-cpu"

);

2182 if

(strcmp(A->getValue(),

"native"

) == 0)

2183

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

2185

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

2189 if

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

2190

StringRef Val = A->getValue();

2194 unsigned

MinVLen = 0;

2196 auto

ISAInfo = llvm::RISCVISAInfo::parseArchString(

2199 if

(!errorToBool(ISAInfo.takeError()))

2200

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

2205 if

(Val ==

"zvl"

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

2207

}

else if

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

2210 if

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

2211

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

2217 unsigned

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

2219

Args.MakeArgString(

"-mvscale-max="

+ llvm::Twine(VScaleMin)));

2221

Args.MakeArgString(

"-mvscale-min="

+ llvm::Twine(VScaleMin)));

2222

}

else if

(Val !=

"scalable"

) {

2224 D

.Diag(diag::err_drv_unsupported_option_argument)

2225

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

2230void

Clang::AddSparcTargetArgs(

const

ArgList &Args,

2231

ArgStringList &CmdArgs)

const

{

2237

CmdArgs.push_back(

"-msoft-float"

);

2238

CmdArgs.push_back(

"-mfloat-abi"

);

2239

CmdArgs.push_back(

"soft"

);

2243

CmdArgs.push_back(

"-mfloat-abi"

);

2244

CmdArgs.push_back(

"hard"

);

2247 if

(

const

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

2248

StringRef Name = A->getValue();

2249

std::string TuneCPU;

2250 if

(Name ==

"native"

)

2251

TuneCPU = std::string(llvm::sys::getHostCPUName());

2253

TuneCPU = std::string(Name);

2255

CmdArgs.push_back(

"-tune-cpu"

);

2256

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

2260void

Clang::AddSystemZTargetArgs(

const

ArgList &Args,

2261

ArgStringList &CmdArgs)

const

{

2262 if

(

const

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

2263

CmdArgs.push_back(

"-tune-cpu"

);

2264 if

(strcmp(A->getValue(),

"native"

) == 0)

2265

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

2267

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

2271

Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain,

false

);

2272 bool

HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,

2273

options::OPT_mno_packed_stack,

false

);

2277 if

(HasBackchain && HasPackedStack && !HasSoftFloat) {

2279 D

.Diag(diag::err_drv_unsupported_opt)

2280

"-mpacked-stack -mbackchain -mhard-float"

;

2283

CmdArgs.push_back(

"-mbackchain"

);

2285

CmdArgs.push_back(

"-mpacked-stack"

);

2288

CmdArgs.push_back(

"-msoft-float"

);

2289

CmdArgs.push_back(

"-mfloat-abi"

);

2290

CmdArgs.push_back(

"soft"

);

2294void

Clang::AddX86TargetArgs(

const

ArgList &Args,

2295

ArgStringList &CmdArgs)

const

{

2299 if

(!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,

true

) ||

2300

Args.hasArg(options::OPT_mkernel) ||

2301

Args.hasArg(options::OPT_fapple_kext))

2302

CmdArgs.push_back(

"-disable-red-zone"

);

2304 if

(!Args.hasFlag(options::OPT_mtls_direct_seg_refs,

2305

options::OPT_mno_tls_direct_seg_refs,

true

))

2306

CmdArgs.push_back(

"-mno-tls-direct-seg-refs"

);

2310 bool

NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||

2311

Args.hasArg(options::OPT_fapple_kext));

2312 if

(Arg *A = Args.getLastArg(

2313

options::OPT_msoft_float, options::OPT_mno_soft_float,

2314

options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {

2315 const

Option &O = A->getOption();

2316

NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||

2317

O.matches(options::OPT_msoft_float));

2319 if

(NoImplicitFloat)

2320

CmdArgs.push_back(

"-no-implicit-float"

);

2322 if

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

2323

StringRef

= A->getValue();

2325

CmdArgs.push_back(

"-mllvm"

);

2326

CmdArgs.push_back(Args.MakeArgString(

"-x86-asm-syntax="

));

2327

CmdArgs.push_back(Args.MakeArgString(

"-inline-asm="

));

2329 D

.Diag(diag::err_drv_unsupported_option_argument)

2330

<< A->getSpelling() <<

;

2332

}

else if

(

.IsCLMode()) {

2333

CmdArgs.push_back(

"-mllvm"

);

2334

CmdArgs.push_back(

"-x86-asm-syntax=intel"

);

2337 if

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

2338

options::OPT_mno_skip_rax_setup))

2339 if

(A->getOption().matches(options::OPT_mskip_rax_setup))

2340

CmdArgs.push_back(Args.MakeArgString(

"-mskip-rax-setup"

));

2343 if

(Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu,

false

)) {

2344

CmdArgs.push_back(

"-mfloat-abi"

);

2345

CmdArgs.push_back(

"soft"

);

2346

CmdArgs.push_back(

"-mstack-alignment=4"

);

2352

std::string TuneCPU;

2353 if

(!Args.hasArg(clang::driver::options::OPT_march_EQ) &&

2355

TuneCPU =

"generic"

;

2358 if

(

const

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

2359

StringRef Name = A->getValue();

2361 if

(Name ==

"native"

) {

2362

Name = llvm::sys::getHostCPUName();

2364

TuneCPU = std::string(Name);

2366

TuneCPU = std::string(Name);

2369 if

(!TuneCPU.empty()) {

2370

CmdArgs.push_back(

"-tune-cpu"

);

2371

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

2375void

Clang::AddHexagonTargetArgs(

const

ArgList &Args,

2376

ArgStringList &CmdArgs)

const

{

2377

CmdArgs.push_back(

"-mqdsp6-compat"

);

2378

CmdArgs.push_back(

"-Wreturn-type"

);

2381

CmdArgs.push_back(

"-mllvm"

);

2383

Args.MakeArgString(

"-hexagon-small-data-threshold="

+ Twine(*G)));

2386 if

(!Args.hasArg(options::OPT_fno_short_enums))

2387

CmdArgs.push_back(

"-fshort-enums"

);

2388 if

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

2389

CmdArgs.push_back(

"-mllvm"

);

2390

CmdArgs.push_back(

"-enable-hexagon-ieee-rnd-near"

);

2392

CmdArgs.push_back(

"-mllvm"

);

2393

CmdArgs.push_back(

"-machine-sink-split=0"

);

2396void

Clang::AddLanaiTargetArgs(

const

ArgList &Args,

2397

ArgStringList &CmdArgs)

const

{

2398 if

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

2399

StringRef CPUName = A->getValue();

2401

CmdArgs.push_back(

"-target-cpu"

);

2402

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

2404 if

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

2405

StringRef

= A->getValue();

2409 if

(

.getAsInteger(10, Mregparm)) {

2410 if

(Mregparm != 4) {

2412

diag::err_drv_unsupported_option_argument)

2413

<< A->getSpelling() <<

;

2419void

Clang::AddWebAssemblyTargetArgs(

const

ArgList &Args,

2420

ArgStringList &CmdArgs)

const

{

2422 if

(!Args.hasArg(options::OPT_fvisibility_EQ,

2423

options::OPT_fvisibility_ms_compat))

2424

CmdArgs.push_back(

"-fvisibility=hidden"

);

2427void

Clang::AddVETargetArgs(

const

ArgList &Args, ArgStringList &CmdArgs)

const

{

2429

CmdArgs.push_back(

"-mfloat-abi"

);

2430

CmdArgs.push_back(

"hard"

);

2435 const InputInfo

&Input,

const

ArgList &Args)

const

{

2437 if

(

.getArgs().hasArg(options::OPT__HASH_HASH_HASH))

2440 using

llvm::yaml::escape;

2443 if

(!CompilationDatabase) {

2445 auto File

= std::make_unique<llvm::raw_fd_ostream>(

2447

llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append);

2449 D

.Diag(clang::diag::err_drv_compilationdatabase) <<

Filename 2453

CompilationDatabase = std::move(

File

);

2455 auto

&CDB = *CompilationDatabase;

2456 auto

CWD =

.getVFS().getCurrentWorkingDirectory();

2459

CDB <<

"{ \"directory\": \""

<< escape(*CWD) <<

"\""

;

2460

CDB <<

", \"file\": \""

<< escape(Input.

()) <<

"\""

;

2462

CDB <<

", \"output\": \""

<< escape(Output.

()) <<

"\""

;

2463

CDB <<

", \"arguments\": [\""

<< escape(

.ClangExecutable) <<

"\""

;

2467

CDB <<

", \""

<< escape(Buf) <<

"\""

;

2468 if

.SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {

2469

Buf =

"--sysroot="

;

2471

CDB <<

", \""

<< escape(Buf) <<

"\""

;

2473

CDB <<

", \""

<< escape(Input.

()) <<

"\""

;

2475

CDB <<

", \"-o\", \""

<< escape(Output.

()) <<

"\""

;

2476 for

(

auto

&A: Args) {

2477 auto

&O = A->getOption();

2479 if

(O.getID() == options::OPT_x)

2482 if

(O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)

2484 if

(O.getID() == options::OPT_gen_cdb_fragment_path)

2487 if

(O.getKind() == Option::InputClass)

2490 if

(O.getID() == options::OPT_o)

2494

A->render(Args, ASL);

2495 for

(

auto

&it: ASL)

2496

CDB <<

", \""

<< escape(it) <<

"\""

;

2500

CDB <<

", \""

<< escape(Buf) <<

"\"]},\n"

;

2503void

Clang::DumpCompilationDatabaseFragmentToDir(

2505 const InputInfo

&Input,

const

llvm::opt::ArgList &Args)

const

{

2507 if

(

.getArgs().hasArg(options::OPT__HASH_HASH_HASH))

2510 if

(CompilationDatabase)

2511

DumpCompilationDatabase(

""

Target

, Output, Input, Args);

2514 const auto

Driver

.getDriver();

2516 auto

Err = llvm::sys::fs::create_directory(

true

);

2518 Driver

Diag

(diag::err_drv_compilationdatabase) << Dir << Err.message();

2522

llvm::sys::path::append(

2524

Twine(llvm::sys::path::filename(Input.

())) +

".%%%%.json"

);

2527

Err = llvm::sys::fs::createUniqueFile(

, FD, TempPath,

2528

llvm::sys::fs::OF_Text);

2530 Driver

Diag

(diag::err_drv_compilationdatabase) <<

<< Err.message();

2533

CompilationDatabase =

2534

std::make_unique<llvm::raw_fd_ostream>(FD,

true

);

2535

DumpCompilationDatabase(

""

Target

, Output, Input, Args);

2545

CmdArgs.push_back(

"-mllvm"

);

2546

CmdArgs.push_back(Args.MakeArgString(

"-arm-implicit-it="

));

2550 const

ArgList &Args,

2551

ArgStringList &CmdArgs,

2561

Args.addOptInFlag(CmdArgs, options::OPT_mrelax_all,

2562

options::OPT_mno_relax_all);

2566 bool

DefaultIncrementalLinkerCompatible =

2567 C

.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();

2568 if

(Args.hasFlag(options::OPT_mincremental_linker_compatible,

2569

options::OPT_mno_incremental_linker_compatible,

2570

DefaultIncrementalLinkerCompatible))

2571

CmdArgs.push_back(

"-mincremental-linker-compatible"

);

2573

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

2575

Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,

2576

options::OPT_fno_emit_compact_unwind_non_canonical);

2586 bool

TakeNextArg =

false

;

2588 const

llvm::Triple &Triple =

.getDefaultToolChain().getTriple();

2589 bool

IsELF = Triple.isOSBinFormatELF();

2590 bool

Crel =

false

, ExperimentalCrel =

false

;

2591 bool

ImplicitMapSyms =

false

;

2592 bool

UseRelaxRelocations =

.getDefaultToolChain().useRelaxRelocations();

2593 bool

UseNoExecStack =

false

;

2595 const char

*MipsTargetFeature =

nullptr

;

2596

StringRef ImplicitIt;

2597 for

(

const

Arg *A :

2598

Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler,

2599

options::OPT_mimplicit_it_EQ)) {

2602 if

(A->getOption().getID() == options::OPT_mimplicit_it_EQ) {

2603 switch

(

.getDefaultToolChain().getArch()) {

2604 case

llvm::Triple::arm:

2605 case

llvm::Triple::armeb:

2606 case

llvm::Triple::thumb:

2607 case

llvm::Triple::thumbeb:

2609

ImplicitIt = A->getValue();

2611 D

.Diag(diag::err_drv_unsupported_option_argument)

2612

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

2619 for

(StringRef

: A->getValues()) {

2621

CmdArgs.push_back(

.data());

2622

TakeNextArg =

false

;

2626 if

(

.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&

2627 Value

"-mbig-obj"

)

2631 auto

checkArg = [&](

bool

ValidTarget,

2632

std::initializer_list<const char *>

Set

) {

2634 D

.Diag(diag::err_drv_unsupported_opt_for_target)

2635

<< (Twine(

"-Wa,"

) +

.first +

"="

).str()

2636

<< Triple.getTriple();

2637

}

else if

(!llvm::is_contained(

Set

.second)) {

2638 D

.Diag(diag::err_drv_unsupported_option_argument)

2639

<< (Twine(

"-Wa,"

) +

.first +

"="

).str() <<

.second;

2642 switch

(

.getDefaultToolChain().getArch()) {

2645 case

llvm::Triple::x86:

2646 case

llvm::Triple::x86_64:

2647 if

(

.first ==

"-mrelax-relocations"

2648 Equal

.first ==

"--mrelax-relocations"

) {

2649

UseRelaxRelocations =

.second ==

"yes"

;

2650

checkArg(IsELF, {

"yes"

"no"

});

2653 if

(

"-msse2avx"

) {

2654

CmdArgs.push_back(

"-msse2avx"

);

2658 case

llvm::Triple::wasm32:

2659 case

llvm::Triple::wasm64:

2660 if

(

"--no-type-check"

) {

2661

CmdArgs.push_back(

"-mno-type-check"

);

2665 case

llvm::Triple::thumb:

2666 case

llvm::Triple::thumbeb:

2667 case

llvm::Triple::arm:

2668 case

llvm::Triple::armeb:

2669 if

(

.first ==

"-mimplicit-it"

) {

2671

ImplicitIt =

.second;

2672

checkArg(

true

, {

"always"

"never"

"arm"

"thumb"

});

2675 if

(

"-mthumb"

)

2680 case

llvm::Triple::aarch64:

2681 case

llvm::Triple::aarch64_be:

2682 case

llvm::Triple::aarch64_32:

2683 if

(

.first ==

"-mmapsyms"

) {

2684

ImplicitMapSyms =

.second ==

"implicit"

;

2685

checkArg(IsELF, {

"default"

"implicit"

});

2689 case

llvm::Triple::mips:

2690 case

llvm::Triple::mipsel:

2691 case

llvm::Triple::mips64:

2692 case

llvm::Triple::mips64el:

2693 if

(

"--trap"

) {

2694

CmdArgs.push_back(

"-target-feature"

);

2695

CmdArgs.push_back(

"+use-tcc-in-div"

);

2698 if

(

"--break"

) {

2699

CmdArgs.push_back(

"-target-feature"

);

2700

CmdArgs.push_back(

"-use-tcc-in-div"

);

2703 if

(

.starts_with(

"-msoft-float"

)) {

2704

CmdArgs.push_back(

"-target-feature"

);

2705

CmdArgs.push_back(

"+soft-float"

);

2708 if

(

.starts_with(

"-mhard-float"

)) {

2709

CmdArgs.push_back(

"-target-feature"

);

2710

CmdArgs.push_back(

"-soft-float"

);

2713 if

(

"-mmsa"

) {

2717 if

(

"-mno-msa"

) {

2721

MipsTargetFeature = llvm::StringSwitch<const char *>(

)

2722

.Case(

"-mips1"

"+mips1"

)

2723

.Case(

"-mips2"

"+mips2"

)

2724

.Case(

"-mips3"

"+mips3"

)

2725

.Case(

"-mips4"

"+mips4"

)

2726

.Case(

"-mips5"

"+mips5"

)

2727

.Case(

"-mips32"

"+mips32"

)

2728

.Case(

"-mips32r2"

"+mips32r2"

)

2729

.Case(

"-mips32r3"

"+mips32r3"

)

2730

.Case(

"-mips32r5"

"+mips32r5"

)

2731

.Case(

"-mips32r6"

"+mips32r6"

)

2732

.Case(

"-mips64"

"+mips64"

)

2733

.Case(

"-mips64r2"

"+mips64r2"

)

2734

.Case(

"-mips64r3"

"+mips64r3"

)

2735

.Case(

"-mips64r5"

"+mips64r5"

)

2736

.Case(

"-mips64r6"

"+mips64r6"

)

2737

.Default(

nullptr

);

2738 if

(MipsTargetFeature)

2743 if

(

"-force_cpusubtype_ALL"

) {

2745

}

else if

(

"-L"

) {

2746

CmdArgs.push_back(

"-msave-temp-labels"

);

2747

}

else if

(

"--fatal-warnings"

) {

2748

CmdArgs.push_back(

"-massembler-fatal-warnings"

);

2749

}

else if

(

"--no-warn"

"-W"

) {

2750

CmdArgs.push_back(

"-massembler-no-warn"

);

2751

}

else if

(

"--noexecstack"

) {

2752

UseNoExecStack =

true

;

2753

}

else if

(

.starts_with(

"-compress-debug-sections"

) ||

2754 Value

.starts_with(

"--compress-debug-sections"

) ||

2755 Value

"-nocompress-debug-sections"

2756 Value

"--nocompress-debug-sections"

) {

2757

CmdArgs.push_back(

.data());

2758

}

else if

(

"--crel"

) {

2760

}

else if

(

"--no-crel"

) {

2762

}

else if

(

"--allow-experimental-crel"

) {

2763

ExperimentalCrel =

true

;

2764

}

else if

(

.starts_with(

"-I"

)) {

2765

CmdArgs.push_back(

.data());

2768 if

(

"-I"

)

2769

TakeNextArg =

true

;

2770

}

else if

(

.starts_with(

"-gdwarf-"

)) {

2773 if

(DwarfVersion == 0) {

2774

CmdArgs.push_back(

.data());

2777

llvm::codegenoptions::DebugInfoConstructor,

2778

DwarfVersion, llvm::DebuggerKind::Default);

2780

}

else if

(

.starts_with(

"-mcpu"

) ||

.starts_with(

"-mfpu"

) ||

2781 Value

.starts_with(

"-mhwdiv"

) ||

.starts_with(

"-march"

)) {

2783

}

else if

(

"-defsym"

"--defsym"

) {

2784 if

(A->getNumValues() != 2) {

2785 D

.Diag(diag::err_drv_defsym_invalid_format) <<

;

2788 const char

*S = A->getValue(1);

2789 auto

Pair = StringRef(S).split(

'='

);

2790 auto

Sym = Pair.first;

2791 auto

SVal = Pair.second;

2793 if

(Sym.empty() || SVal.empty()) {

2794 D

.Diag(diag::err_drv_defsym_invalid_format) << S;

2798 if

(SVal.getAsInteger(0, IVal)) {

2799 D

.Diag(diag::err_drv_defsym_invalid_symval) << SVal;

2802

CmdArgs.push_back(

"--defsym"

);

2803

TakeNextArg =

true

;

2804

}

else if

(

"-fdebug-compilation-dir"

) {

2805

CmdArgs.push_back(

"-fdebug-compilation-dir"

);

2806

TakeNextArg =

true

;

2807

}

else if

(

.consume_front(

"-fdebug-compilation-dir="

)) {

2811

CmdArgs.push_back(

"-fdebug-compilation-dir"

);

2812

CmdArgs.push_back(

.data());

2813

}

else if

(

"--version"

) {

2814 D

.PrintVersion(

, llvm::outs());

2816 D

.Diag(diag::err_drv_unsupported_option_argument)

2817

<< A->getSpelling() <<

;

2821 if

(ImplicitIt.size())

2824 if

(!ExperimentalCrel)

2825 D

.Diag(diag::err_drv_experimental_crel);

2826 if

(Triple.isOSBinFormatELF() && !Triple.isMIPS()) {

2827

CmdArgs.push_back(

"--crel"

);

2829 D

.Diag(diag::err_drv_unsupported_opt_for_target)

2830

"-Wa,--crel"

.getTargetTriple();

2833 if

(ImplicitMapSyms)

2834

CmdArgs.push_back(

"-mmapsyms=implicit"

);

2836

CmdArgs.push_back(

"-mmsa"

);

2837 if

(!UseRelaxRelocations)

2838

CmdArgs.push_back(

"-mrelax-relocations=no"

);

2840

CmdArgs.push_back(

"-mnoexecstack"

);

2841 if

(MipsTargetFeature !=

nullptr

) {

2842

CmdArgs.push_back(

"-target-feature"

);

2843

CmdArgs.push_back(MipsTargetFeature);

2847 if

(

.getDriver().embedBitcodeEnabled() ||

2848 C

.getDriver().embedBitcodeMarkerOnly())

2849

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

2851 if

(

const char

*AsSecureLogFile = getenv(

"AS_SECURE_LOG_FILE"

)) {

2852

CmdArgs.push_back(

"-as-secure-log-file"

);

2853

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

2884 if

(str1 != str2 && !str2.empty() && !str1.empty()) {

2885 D

.Diag(clang::diag::warn_drv_overriding_option) << str1 << str2;

2892 if

(!ComplexRangeStr.empty())

2893 return "-complex-range="

+ ComplexRangeStr;

2894 return

ComplexRangeStr;

2898 bool

OFastEnabled,

const

ArgList &Args,

2899

ArgStringList &CmdArgs,

2902 constexpr

std::array VecLibImpliesNoMathErrno{llvm::StringLiteral(

"ArmPL"

2903

llvm::StringLiteral(

"SLEEF"

)};

2904 bool

NoMathErrnoWasImpliedByVecLib =

false

;

2905 const

Arg *VecLibArg =

nullptr

;

2907 const

Arg *ArgThatEnabledMathErrnoAfterVecLib =

nullptr

;

2914 bool

HonorINFs =

true

;

2915 bool

HonorNaNs =

true

;

2916 bool

ApproxFunc =

false

;

2919 bool

AssociativeMath =

false

;

2920 bool

ReciprocalMath =

false

;

2921 bool

SignedZeros =

true

;

2922 bool

TrappingMath =

false

;

2923 bool

TrappingMathPresent =

false

;

2925 bool

RoundingFPMath =

false

;

2927

StringRef FPModel =

""

;

2929

StringRef FPExceptionBehavior =

""

;

2931

StringRef FPEvalMethod =

""

;

2932

llvm::DenormalMode DenormalFPMath =

2934

llvm::DenormalMode DenormalFP32Math =

2939

StringRef FPContract;

2940

StringRef LastSeenFfpContractOption;

2941

StringRef LastFpContractOverrideOption;

2942 bool

SeenUnsafeMathModeOption =

false

;

2946 bool

StrictFPModel =

false

;

2947

StringRef Float16ExcessPrecision =

""

;

2948

StringRef BFloat16ExcessPrecision =

""

;

2950

std::string ComplexRangeStr =

""

;

2951

std::string GccRangeComplexOption =

""

;

2956 if

(

Range

!= NewRange)

2958

!GccRangeComplexOption.empty()

2959

? GccRangeComplexOption

2966 auto

applyFastMath = [&](

bool

Aggressive) {

2977

AssociativeMath =

true

;

2978

ReciprocalMath =

true

;

2980

SignedZeros =

false

;

2981

TrappingMath =

false

;

2982

RoundingFPMath =

false

;

2983

FPExceptionBehavior =

""

;

2984

FPContract =

"fast"

;

2985

SeenUnsafeMathModeOption =

true

;

2989 auto

restoreFPContractState = [&]() {

2999 if

(LastSeenFfpContractOption !=

""

)

3000

FPContract = LastSeenFfpContractOption;

3001 else if

(SeenUnsafeMathModeOption)

3006

LastFpContractOverrideOption =

""

;

3009 if

(

const

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

3010

CmdArgs.push_back(

"-mlimit-float-precision"

);

3011

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

3014 for

(

const

Arg *A : Args) {

3015 auto

CheckMathErrnoForVecLib =

3016

llvm::make_scope_exit([&, MathErrnoBeforeArg = MathErrno] {

3017 if

(NoMathErrnoWasImpliedByVecLib && !MathErrnoBeforeArg && MathErrno)

3018

ArgThatEnabledMathErrnoAfterVecLib = A;

3021 switch

(A->getOption().getID()) {

3023 default

continue

;

3025 case

options::OPT_fcx_limited_range:

3026 if

(GccRangeComplexOption.empty()) {

3029 "-fcx-limited-range"

);

3031 if

(GccRangeComplexOption !=

"-fno-cx-limited-range"

)

3034

GccRangeComplexOption =

"-fcx-limited-range"

;

3037 case

options::OPT_fno_cx_limited_range:

3038 if

(GccRangeComplexOption.empty()) {

3040 "-fno-cx-limited-range"

);

3042 if

(GccRangeComplexOption !=

"-fcx-limited-range"

3043

GccRangeComplexOption !=

"-fno-cx-fortran-rules"

)

3045 "-fno-cx-limited-range"

);

3047

GccRangeComplexOption =

"-fno-cx-limited-range"

;

3050 case

options::OPT_fcx_fortran_rules:

3051 if

(GccRangeComplexOption.empty())

3053 "-fcx-fortran-rules"

);

3056

GccRangeComplexOption =

"-fcx-fortran-rules"

;

3059 case

options::OPT_fno_cx_fortran_rules:

3060 if

(GccRangeComplexOption.empty()) {

3062 "-fno-cx-fortran-rules"

);

3064 if

(GccRangeComplexOption !=

"-fno-cx-limited-range"

)

3066 "-fno-cx-fortran-rules"

);

3068

GccRangeComplexOption =

"-fno-cx-fortran-rules"

;

3071 case

options::OPT_fcomplex_arithmetic_EQ: {

3073

StringRef Val = A->getValue();

3076 else if

(Val ==

"improved"

)

3078 else if

(Val ==

"promoted"

)

3080 else if

(Val ==

"basic"

)

3083 D

.Diag(diag::err_drv_unsupported_option_argument)

3084

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

3087 if

(!GccRangeComplexOption.empty()) {

3088 if

(GccRangeComplexOption !=

"-fcx-limited-range"

) {

3089 if

(GccRangeComplexOption !=

"-fcx-fortran-rules"

) {

3106 case

options::OPT_ffp_model_EQ: {

3110

ApproxFunc =

false

;

3113

AssociativeMath =

false

;

3114

ReciprocalMath =

false

;

3115

SignedZeros =

true

;

3117

StringRef Val = A->getValue();

3118 if

(OFastEnabled && Val !=

"aggressive"

) {

3120 D

.Diag(clang::diag::warn_drv_overriding_option)

3121

<< Args.MakeArgString(

"-ffp-model="

+ Val) <<

"-Ofast"

;

3124

StrictFPModel =

false

;

3125 if

(!FPModel.empty() && FPModel != Val)

3126 D

.Diag(clang::diag::warn_drv_overriding_option)

3127

<< Args.MakeArgString(

"-ffp-model="

+ FPModel)

3128

<< Args.MakeArgString(

"-ffp-model="

+ Val);

3129 if

(Val ==

"fast"

) {

3131

applyFastMath(

false

);

3133

LastFpContractOverrideOption =

"-ffp-model=fast"

;

3134

}

else if

(Val ==

"aggressive"

) {

3136

applyFastMath(

true

);

3138

LastFpContractOverrideOption =

"-ffp-model=aggressive"

;

3139

}

else if

(Val ==

"precise"

) {

3142

LastFpContractOverrideOption =

"-ffp-model=precise"

;

3144

}

else if

(Val ==

"strict"

) {

3145

StrictFPModel =

true

;

3146

FPExceptionBehavior =

"strict"

;

3148

FPContract =

"off"

;

3149

LastFpContractOverrideOption =

"-ffp-model=strict"

;

3150

TrappingMath =

true

;

3151

RoundingFPMath =

true

;

3154 D

.Diag(diag::err_drv_unsupported_option_argument)

3155

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

3160 case

options::OPT_fhonor_infinities: HonorINFs =

true

;

break

;

3161 case

options::OPT_fno_honor_infinities: HonorINFs =

false

;

break

;

3162 case

options::OPT_fhonor_nans: HonorNaNs =

true

;

break

;

3163 case

options::OPT_fno_honor_nans: HonorNaNs =

false

;

break

;

3164 case

options::OPT_fapprox_func: ApproxFunc =

true

;

break

;

3165 case

options::OPT_fno_approx_func: ApproxFunc =

false

;

break

;

3166 case

options::OPT_fmath_errno: MathErrno =

true

;

break

;

3167 case

options::OPT_fno_math_errno: MathErrno =

false

;

break

;

3168 case

options::OPT_fassociative_math: AssociativeMath =

true

;

break

;

3169 case

options::OPT_fno_associative_math: AssociativeMath =

false

;

break

;

3170 case

options::OPT_freciprocal_math: ReciprocalMath =

true

;

break

;

3171 case

options::OPT_fno_reciprocal_math: ReciprocalMath =

false

;

break

;

3172 case

options::OPT_fsigned_zeros: SignedZeros =

true

;

break

;

3173 case

options::OPT_fno_signed_zeros: SignedZeros =

false

;

break

;

3174 case

options::OPT_ftrapping_math:

3175 if

(!TrappingMathPresent && !FPExceptionBehavior.empty() &&

3176

FPExceptionBehavior !=

"strict"

)

3178 D

.Diag(clang::diag::warn_drv_overriding_option)

3179

<< Args.MakeArgString(

"-ffp-exception-behavior="

3180

FPExceptionBehavior)

3181

"-ftrapping-math"

;

3182

TrappingMath =

true

;

3183

TrappingMathPresent =

true

;

3184

FPExceptionBehavior =

"strict"

;

3186 case

options::OPT_fveclib:

3188

NoMathErrnoWasImpliedByVecLib =

3189

llvm::is_contained(VecLibImpliesNoMathErrno, A->getValue());

3190 if

(NoMathErrnoWasImpliedByVecLib)

3193 case

options::OPT_fno_trapping_math:

3194 if

(!TrappingMathPresent && !FPExceptionBehavior.empty() &&

3195

FPExceptionBehavior !=

"ignore"

)

3197 D

.Diag(clang::diag::warn_drv_overriding_option)

3198

<< Args.MakeArgString(

"-ffp-exception-behavior="

3199

FPExceptionBehavior)

3200

"-fno-trapping-math"

;

3201

TrappingMath =

false

;

3202

TrappingMathPresent =

true

;

3203

FPExceptionBehavior =

"ignore"

;

3206 case

options::OPT_frounding_math:

3207

RoundingFPMath =

true

;

3210 case

options::OPT_fno_rounding_math:

3211

RoundingFPMath =

false

;

3214 case

options::OPT_fdenormal_fp_math_EQ:

3215

DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue());

3216

DenormalFP32Math = DenormalFPMath;

3217 if

(!DenormalFPMath.isValid()) {

3218 D

.Diag(diag::err_drv_invalid_value)

3219

<< A->getAsString(Args) << A->getValue();

3223 case

options::OPT_fdenormal_fp_math_f32_EQ:

3224

DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());

3225 if

(!DenormalFP32Math.isValid()) {

3226 D

.Diag(diag::err_drv_invalid_value)

3227

<< A->getAsString(Args) << A->getValue();

3232 case

options::OPT_ffp_contract: {

3233

StringRef Val = A->getValue();

3234 if

(Val ==

"fast"

|| Val ==

"on"

|| Val ==

"off"

3235

Val ==

"fast-honor-pragmas"

) {

3236 if

(Val != FPContract && LastFpContractOverrideOption !=

""

) {

3237 D

.Diag(clang::diag::warn_drv_overriding_option)

3238

<< LastFpContractOverrideOption

3239

<< Args.MakeArgString(

"-ffp-contract="

+ Val);

3243

LastSeenFfpContractOption = Val;

3244

LastFpContractOverrideOption =

""

;

3246 D

.Diag(diag::err_drv_unsupported_option_argument)

3247

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

3252 case

options::OPT_ffp_exception_behavior_EQ: {

3253

StringRef Val = A->getValue();

3254 if

(!TrappingMathPresent && !FPExceptionBehavior.empty() &&

3255

FPExceptionBehavior != Val)

3257 D

.Diag(clang::diag::warn_drv_overriding_option)

3258

<< Args.MakeArgString(

"-ffp-exception-behavior="

3259

FPExceptionBehavior)

3260

<< Args.MakeArgString(

"-ffp-exception-behavior="

+ Val);

3261

TrappingMath = TrappingMathPresent =

false

;

3262 if

(Val ==

"ignore"

|| Val ==

"maytrap"

)

3263

FPExceptionBehavior = Val;

3264 else if

(Val ==

"strict"

) {

3265

FPExceptionBehavior = Val;

3266

TrappingMath = TrappingMathPresent =

true

;

3268 D

.Diag(diag::err_drv_unsupported_option_argument)

3269

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

3274 case

options::OPT_ffp_eval_method_EQ: {

3275

StringRef Val = A->getValue();

3276 if

(Val ==

"double"

|| Val ==

"extended"

|| Val ==

"source"

)

3279 D

.Diag(diag::err_drv_unsupported_option_argument)

3280

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

3284 case

options::OPT_fexcess_precision_EQ: {

3285

StringRef Val = A->getValue();

3286 const

llvm::Triple::ArchType Arch = TC.

();

3287 if

(Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {

3288 if

(Val ==

"standard"

|| Val ==

"fast"

)

3289

Float16ExcessPrecision = Val;

3293 else if

(Val ==

"16"

)

3294

Float16ExcessPrecision =

"none"

;

3296 D

.Diag(diag::err_drv_unsupported_option_argument)

3297

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

3299 if

(!(Val ==

"standard"

|| Val ==

"fast"

))

3300 D

.Diag(diag::err_drv_unsupported_option_argument)

3301

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

3303

BFloat16ExcessPrecision = Float16ExcessPrecision;

3306 case

options::OPT_ffinite_math_only:

3310 case

options::OPT_fno_finite_math_only:

3315 case

options::OPT_funsafe_math_optimizations:

3316

AssociativeMath =

true

;

3317

ReciprocalMath =

true

;

3318

SignedZeros =

false

;

3320

TrappingMath =

false

;

3321

FPExceptionBehavior =

""

;

3322

FPContract =

"fast"

;

3323

LastFpContractOverrideOption =

"-funsafe-math-optimizations"

;

3324

SeenUnsafeMathModeOption =

true

;

3326 case

options::OPT_fno_unsafe_math_optimizations:

3327

AssociativeMath =

false

;

3328

ReciprocalMath =

false

;

3329

SignedZeros =

true

;

3330

ApproxFunc =

false

;

3331

restoreFPContractState();

3334 case

options::OPT_Ofast:

3339 case

options::OPT_ffast_math:

3340

applyFastMath(

true

);

3341 if

(A->getOption().getID() == options::OPT_Ofast)

3342

LastFpContractOverrideOption =

"-Ofast"

;

3344

LastFpContractOverrideOption =

"-ffast-math"

;

3346 case

options::OPT_fno_fast_math:

3353

AssociativeMath =

false

;

3354

ReciprocalMath =

false

;

3355

ApproxFunc =

false

;

3356

SignedZeros =

true

;

3357

restoreFPContractState();

3358

LastFpContractOverrideOption =

""

;

3368 if

(StrictFPModel) {

3371 if

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

3372

SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&

3373

FPContract ==

"off"

)

3377

StrictFPModel =

false

;

3382 auto

RHS = (A->getNumValues() == 0)

3384

: Args.MakeArgString(A->getSpelling() + A->getValue());

3385 if

(A->getSpelling() !=

"-ffp-contract="

) {

3386 if

(RHS !=

"-ffp-model=strict"

)

3387 D

.Diag(clang::diag::warn_drv_overriding_option)

3388

"-ffp-model=strict"

<< RHS;

3398

CmdArgs.push_back(

"-menable-no-infs"

);

3401

CmdArgs.push_back(

"-menable-no-nans"

);

3404

CmdArgs.push_back(

"-fapprox-func"

);

3407

CmdArgs.push_back(

"-fmath-errno"

);

3408 if

(NoMathErrnoWasImpliedByVecLib)

3409 D

.Diag(clang::diag::warn_drv_math_errno_enabled_after_veclib)

3410

<< ArgThatEnabledMathErrnoAfterVecLib->getAsString(Args)

3411

<< VecLibArg->getAsString(Args);

3414 if

(AssociativeMath && ReciprocalMath && !SignedZeros && ApproxFunc &&

3416

CmdArgs.push_back(

"-funsafe-math-optimizations"

);

3419

CmdArgs.push_back(

"-fno-signed-zeros"

);

3421 if

(AssociativeMath && !SignedZeros && !TrappingMath)

3422

CmdArgs.push_back(

"-mreassociate"

);

3425

CmdArgs.push_back(

"-freciprocal-math"

);

3429

assert(FPExceptionBehavior ==

"strict"

);

3433 if

(DenormalFPMath != llvm::DenormalMode::getIEEE()) {

3435

llvm::raw_svector_ostream ArgStr(DenormFlag);

3436

ArgStr <<

"-fdenormal-fp-math="

<< DenormalFPMath;

3437

CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));

3441 if

(DenormalFP32Math != DenormalFPMath) {

3443

llvm::raw_svector_ostream ArgStr(DenormFlag);

3444

ArgStr <<

"-fdenormal-fp-math-f32="

<< DenormalFP32Math;

3445

CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));

3448 if

(!FPContract.empty())

3449

CmdArgs.push_back(Args.MakeArgString(

"-ffp-contract="

+ FPContract));

3452

CmdArgs.push_back(Args.MakeArgString(

"-frounding-math"

));

3454

CmdArgs.push_back(Args.MakeArgString(

"-fno-rounding-math"

));

3456 if

(!FPExceptionBehavior.empty())

3457

CmdArgs.push_back(Args.MakeArgString(

"-ffp-exception-behavior="

3458

FPExceptionBehavior));

3460 if

(!FPEvalMethod.empty())

3461

CmdArgs.push_back(Args.MakeArgString(

"-ffp-eval-method="

+ FPEvalMethod));

3463 if

(!Float16ExcessPrecision.empty())

3464

CmdArgs.push_back(Args.MakeArgString(

"-ffloat16-excess-precision="

3465

Float16ExcessPrecision));

3466 if

(!BFloat16ExcessPrecision.empty())

3467

CmdArgs.push_back(Args.MakeArgString(

"-fbfloat16-excess-precision="

3468

BFloat16ExcessPrecision));

3475 if

(!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc &&

3476

ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath)

3477

CmdArgs.push_back(

"-ffast-math"

);

3483 bool

shouldAddFiniteMathOnly =

false

;

3484 if

(!HonorINFs && !HonorNaNs) {

3485

shouldAddFiniteMathOnly =

true

;

3487 bool

InfValues =

true

;

3488 bool

NanValues =

true

;

3489 for

(

const auto

*Arg : Args.filtered(options::OPT_Xclang)) {

3490

StringRef ArgValue = Arg->getValue();

3491 if

(ArgValue ==

"-menable-no-nans"

)

3493 else if

(ArgValue ==

"-menable-no-infs"

)

3496 if

(!NanValues && !InfValues)

3497

shouldAddFiniteMathOnly =

true

;

3499 if

(shouldAddFiniteMathOnly) {

3500

CmdArgs.push_back(

"-ffinite-math-only"

);

3502 if

(

const

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

3503

CmdArgs.push_back(

"-mfpmath"

);

3504

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

3508 if

(Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,

3509

options::OPT_fstrict_float_cast_overflow,

false

))

3510

CmdArgs.push_back(

"-fno-strict-float-cast-overflow"

);

3514 if

(!ComplexRangeStr.empty()) {

3515

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

3516 if

(Args.hasArg(options::OPT_fcomplex_arithmetic_EQ))

3517

CmdArgs.push_back(Args.MakeArgString(

"-fcomplex-arithmetic="

3520 if

(Args.hasArg(options::OPT_fcx_limited_range))

3521

CmdArgs.push_back(

"-fcx-limited-range"

);

3522 if

(Args.hasArg(options::OPT_fcx_fortran_rules))

3523

CmdArgs.push_back(

"-fcx-fortran-rules"

);

3524 if

(Args.hasArg(options::OPT_fno_cx_limited_range))

3525

CmdArgs.push_back(

"-fno-cx-limited-range"

);

3526 if

(Args.hasArg(options::OPT_fno_cx_fortran_rules))

3527

CmdArgs.push_back(

"-fno-cx-fortran-rules"

);

3531 const

llvm::Triple &Triple,

3534 if

(!Args.hasArg(options::OPT__analyzer_no_default_checks)) {

3535

CmdArgs.push_back(

"-analyzer-checker=core"

);

3536

CmdArgs.push_back(

"-analyzer-checker=apiModeling"

);

3538 if

(!Triple.isWindowsMSVCEnvironment()) {

3539

CmdArgs.push_back(

"-analyzer-checker=unix"

);

3542

CmdArgs.push_back(

"-analyzer-checker=unix.API"

);

3543

CmdArgs.push_back(

"-analyzer-checker=unix.Malloc"

);

3544

CmdArgs.push_back(

"-analyzer-checker=unix.MallocSizeof"

);

3545

CmdArgs.push_back(

"-analyzer-checker=unix.MismatchedDeallocator"

);

3546

CmdArgs.push_back(

"-analyzer-checker=unix.cstring.BadSizeArg"

);

3547

CmdArgs.push_back(

"-analyzer-checker=unix.cstring.NullArg"

);

3551 if

(Triple.isPS()) {

3552

CmdArgs.push_back(

"-analyzer-disable-checker=unix.API"

);

3553

CmdArgs.push_back(

"-analyzer-disable-checker=unix.Vfork"

);

3556 if

(Triple.isOSDarwin()) {

3557

CmdArgs.push_back(

"-analyzer-checker=osx"

);

3559 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType"

);

3561 else if

(Triple.isOSFuchsia())

3562

CmdArgs.push_back(

"-analyzer-checker=fuchsia"

);

3564

CmdArgs.push_back(

"-analyzer-checker=deadcode"

);

3567

CmdArgs.push_back(

"-analyzer-checker=cplusplus"

);

3569 if

(!Triple.isPS()) {

3570

CmdArgs.push_back(

"-analyzer-checker=security.insecureAPI.UncheckedReturn"

);

3571

CmdArgs.push_back(

"-analyzer-checker=security.insecureAPI.getpw"

);

3572

CmdArgs.push_back(

"-analyzer-checker=security.insecureAPI.gets"

);

3573

CmdArgs.push_back(

"-analyzer-checker=security.insecureAPI.mktemp"

);

3574

CmdArgs.push_back(

"-analyzer-checker=security.insecureAPI.mkstemp"

);

3575

CmdArgs.push_back(

"-analyzer-checker=security.insecureAPI.vfork"

);

3579

CmdArgs.push_back(

"-analyzer-checker=nullability.NullPassedToNonnull"

);

3580

CmdArgs.push_back(

"-analyzer-checker=nullability.NullReturnedFromNonnull"

);

3584

CmdArgs.push_back(

"-analyzer-output"

);

3585 if

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

3586

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

3588

CmdArgs.push_back(

"plist"

);

3593

CmdArgs.push_back(

"-w"

);

3596

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

3603 if

(std::isdigit(S[0]))

3606 return

llvm::all_of(S, [](

char C

) {

return

std::isalnum(

) ||

'_'

; });

3610 const

ArgList &Args, ArgStringList &CmdArgs,

3611 bool

KernelOrKext) {

3616 if

(EffectiveTriple.isNVPTX())

3624 if

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

3625

options::OPT_fstack_protector_all,

3626

options::OPT_fstack_protector_strong,

3627

options::OPT_fstack_protector)) {

3628 if

(A->getOption().matches(options::OPT_fstack_protector))

3629

StackProtectorLevel =

3631 else if

(A->getOption().matches(options::OPT_fstack_protector_strong))

3633 else if

(A->getOption().matches(options::OPT_fstack_protector_all))

3637 D

.Diag(diag::warn_drv_unsupported_option_for_target)

3638

<< A->getSpelling() << EffectiveTriple.getTriple();

3639

StackProtectorLevel = DefaultStackProtectorLevel;

3642

StackProtectorLevel = DefaultStackProtectorLevel;

3645 if

(StackProtectorLevel) {

3646

CmdArgs.push_back(

"-stack-protector"

);

3647

CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));

3651 for

(

const

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

3652

StringRef Str(A->getValue());

3653 if

(Str.starts_with(

"ssp-buffer-size="

)) {

3654 if

(StackProtectorLevel) {

3655

CmdArgs.push_back(

"-stack-protector-buffer-size"

);

3657

CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));

3663 const

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

3664 if

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

3665

StringRef

= A->getValue();

3666 if

(!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&

3667

!EffectiveTriple.isARM() && !EffectiveTriple.isThumb() &&

3668

!EffectiveTriple.isRISCV() && !EffectiveTriple.isPPC())

3669 D

.Diag(diag::err_drv_unsupported_opt_for_target)

3670

<< A->getAsString(Args) << TripleStr;

3671 if

((EffectiveTriple.isX86() || EffectiveTriple.isARM() ||

3672

EffectiveTriple.isThumb()) &&

3674 D

.Diag(diag::err_drv_invalid_value_with_suggestion)

3675

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

"tls global"

;

3678 if

((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&

3680 if

(!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {

3681 D

.Diag(diag::err_drv_ssp_missing_offset_argument)

3682

<< A->getAsString(Args);

3687 D

.Diag(diag::err_target_unsupported_tp_hard)

3688

<< EffectiveTriple.getArchName();

3692 if

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

3693

StringRef

= A->getValue();

3694 if

(

"cp15"

) {

3695 D

.Diag(diag::err_drv_argument_not_allowed_with)

3696

<< A->getAsString(Args) <<

"-mstack-protector-guard=tls"

;

3700

CmdArgs.push_back(

"-target-feature"

);

3701

CmdArgs.push_back(

"+read-tp-tpidruro"

);

3703 if

(EffectiveTriple.isAArch64() &&

"sysreg"

"global"

) {

3704 D

.Diag(diag::err_drv_invalid_value_with_suggestion)

3705

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

"sysreg global"

;

3708 if

(EffectiveTriple.isRISCV() || EffectiveTriple.isPPC()) {

3710 D

.Diag(diag::err_drv_invalid_value_with_suggestion)

3711

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

"tls global"

;

3714 if

(

"tls"

) {

3715 if

(!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) {

3716 D

.Diag(diag::err_drv_ssp_missing_offset_argument)

3717

<< A->getAsString(Args);

3722

A->render(Args, CmdArgs);

3725 if

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

3726

StringRef

= A->getValue();

3727 if

(!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&

3728

!EffectiveTriple.isARM() && !EffectiveTriple.isThumb() &&

3729

!EffectiveTriple.isRISCV() && !EffectiveTriple.isPPC())

3730 D

.Diag(diag::err_drv_unsupported_opt_for_target)

3731

<< A->getAsString(Args) << TripleStr;

3733 if

(

.getAsInteger(10, Offset)) {

3734 D

.Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<

;

3737 if

((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) &&

3738

(Offset < 0 || Offset > 0xfffff)) {

3739 D

.Diag(diag::err_drv_invalid_int_value)

3740

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

;

3743

A->render(Args, CmdArgs);

3746 if

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

3747

StringRef

= A->getValue();

3748 if

(!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() &&

3749

!EffectiveTriple.isRISCV() && !EffectiveTriple.isPPC())

3750 D

.Diag(diag::err_drv_unsupported_opt_for_target)

3751

<< A->getAsString(Args) << TripleStr;

3752 if

(EffectiveTriple.isX86() && (

"fs"

"gs"

)) {

3753 D

.Diag(diag::err_drv_invalid_value_with_suggestion)

3754

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

"fs gs"

;

3757 if

(EffectiveTriple.isAArch64() &&

"sp_el0"

) {

3758 D

.Diag(diag::err_drv_invalid_value) << A->getOption().getName() <<

;

3761 if

(EffectiveTriple.isRISCV() &&

"tp"

) {

3762 D

.Diag(diag::err_drv_invalid_value_with_suggestion)

3763

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

"tp"

;

3766 if

(EffectiveTriple.isPPC64() &&

"r13"

) {

3767 D

.Diag(diag::err_drv_invalid_value_with_suggestion)

3768

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

"r13"

;

3771 if

(EffectiveTriple.isPPC32() &&

"r2"

) {

3772 D

.Diag(diag::err_drv_invalid_value_with_suggestion)

3773

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

"r2"

;

3776

A->render(Args, CmdArgs);

3779 if

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

3780

StringRef

= A->getValue();

3782 D

.Diag(diag::err_drv_argument_only_allowed_with)

3783

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

"legal symbol name"

;

3786

A->render(Args, CmdArgs);

3791

ArgStringList &CmdArgs) {

3794 if

(!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux() &&

3795

!EffectiveTriple.isOSFuchsia())

3798 if

(!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() &&

3799

!EffectiveTriple.isPPC64() && !EffectiveTriple.isAArch64() &&

3800

!EffectiveTriple.isRISCV())

3803

Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection,

3804

options::OPT_fno_stack_clash_protection);

3809 const

ArgList &Args,

3810

ArgStringList &CmdArgs) {

3812

StringRef TrivialAutoVarInit =

""

;

3814 for

(

const

Arg *A : Args) {

3815 switch

(A->getOption().getID()) {

3818 case

options::OPT_ftrivial_auto_var_init: {

3820

StringRef Val = A->getValue();

3821 if

(Val ==

"uninitialized"

|| Val ==

"zero"

|| Val ==

"pattern"

)

3822

TrivialAutoVarInit = Val;

3824 D

.Diag(diag::err_drv_unsupported_option_argument)

3825

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

3831 if

(TrivialAutoVarInit.empty())

3832 switch

(DefaultTrivialAutoVarInit) {

3836

TrivialAutoVarInit =

"pattern"

;

3839

TrivialAutoVarInit =

"zero"

;

3843 if

(!TrivialAutoVarInit.empty()) {

3845

Args.MakeArgString(

"-ftrivial-auto-var-init="

+ TrivialAutoVarInit));

3849

Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) {

3850 if

(!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||

3852

Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==

3854 D

.Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency);

3856

StringRef Val = A->getValue();

3857 if

(std::stoi(Val.str()) <= 0)

3858 D

.Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value);

3860

Args.MakeArgString(

"-ftrivial-auto-var-init-stop-after="

+ Val));

3863 if

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

3864 if

(!Args.hasArg(options::OPT_ftrivial_auto_var_init) ||

3866

Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) ==

3868 D

.Diag(diag::err_drv_trivial_auto_var_init_max_size_missing_dependency);

3870

StringRef Val = A->getValue();

3871 if

(std::stoi(Val.str()) <= 0)

3872 D

.Diag(diag::err_drv_trivial_auto_var_init_max_size_invalid_value);

3874

Args.MakeArgString(

"-ftrivial-auto-var-init-max-size="

+ Val));

3882 const unsigned

ForwardedArguments[] = {

3883

options::OPT_cl_opt_disable,

3884

options::OPT_cl_strict_aliasing,

3885

options::OPT_cl_single_precision_constant,

3886

options::OPT_cl_finite_math_only,

3887

options::OPT_cl_kernel_arg_info,

3888

options::OPT_cl_unsafe_math_optimizations,

3889

options::OPT_cl_fast_relaxed_math,

3890

options::OPT_cl_mad_enable,

3891

options::OPT_cl_no_signed_zeros,

3892

options::OPT_cl_fp32_correctly_rounded_divide_sqrt,

3893

options::OPT_cl_uniform_work_group_size

3896 if

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

3897

std::string CLStdStr = std::string(

"-cl-std="

) + A->getValue();

3898

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

3899

}

else if

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

3900

std::string CLExtStr = std::string(

"-cl-ext="

) + A->getValue();

3901

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

3904 if

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

3905

CmdArgs.push_back(

"-menable-no-infs"

);

3906

CmdArgs.push_back(

"-menable-no-nans"

);

3909 for

(

const auto

&Arg : ForwardedArguments)

3910 if

(

const auto

*A = Args.getLastArg(Arg))

3911

CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));

3916

!Args.hasArg(options::OPT_cl_no_stdinc)) {

3917

CmdArgs.push_back(

"-finclude-default-header"

);

3918

CmdArgs.push_back(

"-fdeclare-opencl-builtins"

);

3924 const unsigned

ForwardedArguments[] = {options::OPT_dxil_validator_version,

3928

options::OPT_emit_llvm,

3929

options::OPT_emit_obj,

3930

options::OPT_disable_llvm_passes,

3931

options::OPT_fnative_half_type,

3932

options::OPT_hlsl_entrypoint};

3935 for

(

const auto

&Arg : ForwardedArguments)

3936 if

(

const auto

*A = Args.getLastArg(Arg))

3937

A->renderAsInput(Args, CmdArgs);

3939 if

(!Args.hasArg(options::OPT_dxc_no_stdinc) &&

3940

!Args.hasArg(options::OPT_nostdinc))

3941

CmdArgs.push_back(

"-finclude-default-header"

);

3945

ArgStringList &CmdArgs,

types::ID

InputType) {

3946 if

(!Args.hasArg(options::OPT_fopenacc))

3949

CmdArgs.push_back(

"-fopenacc"

);

3951 if

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

3952

StringRef

= A->getValue();

3954 if

.getAsInteger(10, Version))

3955

A->renderAsInput(Args, CmdArgs);

3957 D

.Diag(diag::err_drv_clang_unsupported) <<

;

3962 const

ArgList &Args, ArgStringList &CmdArgs) {

3965

Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,

3966

!Args.hasArg(options::OPT_mkernel));

3968

CmdArgs.push_back(

"-fno-builtin"

);

3971 if

(Args.hasArg(options::OPT_ffreestanding))

3972

UseBuiltins =

false

;

3975 for

(

const

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

3981

A->render(Args, CmdArgs);

3986 if

(

const char

*Str = std::getenv(

"CLANG_MODULE_CACHE_PATH"

)) {

3989 return Path

.getSingleStringRef() !=

""

;

3991 if

(llvm::sys::path::cache_directory(

Result

)) {

3992

llvm::sys::path::append(

Result

"clang"

);

3993

llvm::sys::path::append(

Result

"ModuleCache"

);

4001 const char

*BaseInput) {

4002 if

(Arg *ModuleOutputEQ = Args.getLastArg(options::OPT_fmodule_output_EQ))

4003 return

StringRef(ModuleOutputEQ->getValue());

4006 if

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

4007

FinalOutput && Args.hasArg(options::OPT_c))

4008

OutputPath = FinalOutput->getValue();

4010

OutputPath = BaseInput;

4013

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

4018 const

ArgList &Args,

const InputInfo

&Input,

4019 const InputInfo

&Output,

bool

HaveStd20,

4020

ArgStringList &CmdArgs) {

4022 bool

HaveStdCXXModules = IsCXX && HaveStd20;

4023 bool

HaveModules = HaveStdCXXModules;

4028 bool

HaveClangModules =

false

;

4029 if

(Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,

false

)) {

4030 bool

AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,

4031

options::OPT_fno_cxx_modules,

true

);

4032 if

(AllowedInCXX || !IsCXX) {

4033

CmdArgs.push_back(

"-fmodules"

);

4034

HaveClangModules =

true

;

4038

HaveModules |= HaveClangModules;

4042 if

(Args.hasFlag(options::OPT_fimplicit_module_maps,

4043

options::OPT_fno_implicit_module_maps, HaveClangModules))

4044

CmdArgs.push_back(

"-fimplicit-module-maps"

);

4047

Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse,

4048

options::OPT_fno_modules_decluse);

4052 if

(Args.hasFlag(options::OPT_fmodules_strict_decluse,

4053

options::OPT_fno_modules_strict_decluse,

false

))

4054

CmdArgs.push_back(

"-fmodules-strict-decluse"

);

4056

Args.addOptOutFlag(CmdArgs, options::OPT_fmodulemap_allow_subdirectory_search,

4057

options::OPT_fno_modulemap_allow_subdirectory_search);

4060 bool

ImplicitModules =

false

;

4061 if

(!Args.hasFlag(options::OPT_fimplicit_modules,

4062

options::OPT_fno_implicit_modules, HaveClangModules)) {

4064

CmdArgs.push_back(

"-fno-implicit-modules"

);

4065

}

else if

(HaveModules) {

4066

ImplicitModules =

true

;

4070 if

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

4071 Path

= A->getValue();

4073 bool

HasPath =

true

;

4074 if

(

.isForDiagnostics()) {

4078

llvm::sys::path::replace_extension(

".cache"

);

4079

llvm::sys::path::append(

"modules"

);

4080

}

else if

(

.empty()) {

4088 const char

Arg[] =

"-fmodules-cache-path="

;

4089 Path

.insert(

.begin(), Arg, Arg + strlen(Arg));

4090

CmdArgs.push_back(Args.MakeArgString(

));

4095 if

(Args.hasFlag(options::OPT_fprebuilt_implicit_modules,

4096

options::OPT_fno_prebuilt_implicit_modules,

false

))

4097

CmdArgs.push_back(

"-fprebuilt-implicit-modules"

);

4098 if

(Args.hasFlag(options::OPT_fmodules_validate_input_files_content,

4099

options::OPT_fno_modules_validate_input_files_content,

4101

CmdArgs.push_back(

"-fvalidate-ast-input-files-content"

);

4106

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

4110

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

4114 if

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

4116

llvm::sys::path::append(BuiltinModuleMap,

"include"

);

4117

llvm::sys::path::append(BuiltinModuleMap,

"module.modulemap"

);

4118 if

(llvm::sys::fs::exists(BuiltinModuleMap))

4120

Args.MakeArgString(

"-fmodule-map-file="

+ BuiltinModuleMap));

4127 if

(HaveModules || Input.

() == clang::driver::types::TY_ModuleFile) {

4128

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

4131 for

(

const

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

4132

CmdArgs.push_back(Args.MakeArgString(

4133

std::string(

"-fprebuilt-module-path="

) + A->getValue()));

4137

Args.ClaimAllArgs(options::OPT_fmodule_file);

4141 if

(HaveClangModules &&

.isForDiagnostics()) {

4143

llvm::sys::path::replace_extension(VFSDir,

".cache"

);

4145 C

.addTempFile(Args.MakeArgString(VFSDir));

4147

llvm::sys::path::append(VFSDir,

"vfs"

);

4148

CmdArgs.push_back(

"-module-dependency-dir"

);

4149

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

4152 if

(HaveClangModules)

4153

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

4156

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

4157

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

4158

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

4160 if

(HaveClangModules) {

4161

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

4163 if

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

4164 if

(Args.hasArg(options::OPT_fbuild_session_timestamp))

4165 D

.Diag(diag::err_drv_argument_not_allowed_with)

4166

<< A->getAsString(Args) <<

"-fbuild-session-timestamp"

;

4168

llvm::sys::fs::file_status Status;

4169 if

(llvm::sys::fs::status(A->getValue(), Status))

4170 D

.Diag(diag::err_drv_no_such_file) << A->getValue();

4171

CmdArgs.push_back(Args.MakeArgString(

4172 "-fbuild-session-timestamp="

4173

Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>(

4174

Status.getLastModificationTime().time_since_epoch())

4178 if

(Args.getLastArg(

4179

options::OPT_fmodules_validate_once_per_build_session)) {

4180 if

(!Args.getLastArg(options::OPT_fbuild_session_timestamp,

4181

options::OPT_fbuild_session_file))

4182 D

.Diag(diag::err_drv_modules_validate_once_requires_timestamp);

4184

Args.AddLastArg(CmdArgs,

4185

options::OPT_fmodules_validate_once_per_build_session);

4188 if

(Args.hasFlag(options::OPT_fmodules_validate_system_headers,

4189

options::OPT_fno_modules_validate_system_headers,

4191

CmdArgs.push_back(

"-fmodules-validate-system-headers"

);

4193

Args.AddLastArg(CmdArgs,

4194

options::OPT_fmodules_disable_diagnostic_validation);

4196

Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp);

4197

Args.ClaimAllArgs(options::OPT_fbuild_session_file);

4198

Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session);

4199

Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers);

4200

Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers);

4201

Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation);

4206

CmdArgs.push_back(

"-fskip-odr-check-in-gmf"

);

4208 if

(Args.hasArg(options::OPT_modules_reduced_bmi) &&

4209

(Input.

() == driver::types::TY_CXXModule ||

4210

Input.

() == driver::types::TY_PP_CXXModule)) {

4211

CmdArgs.push_back(

"-fmodules-reduced-bmi"

);

4213 if

(Args.hasArg(options::OPT_fmodule_output_EQ))

4214

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

4216

CmdArgs.push_back(Args.MakeArgString(

4217 "-fmodule-output="

4224

Args.ClaimAllArgs(options::OPT_modules_reduced_bmi);

4232 if

(Input.

() == driver::types::TY_CXXModule ||

4233

Input.

() == driver::types::TY_PP_CXXModule ||

4234

Input.

() == driver::types::TY_ModuleFile) {

4235

Args.ClaimAllArgs(options::OPT_fmodule_output);

4236

Args.ClaimAllArgs(options::OPT_fmodule_output_EQ);

4239 if

(Args.hasArg(options::OPT_fmodules_embed_all_files))

4240

CmdArgs.push_back(

"-fmodules-embed-all-files"

);

4246

ArgStringList &CmdArgs) {

4248 if

(

const

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

4249

options::OPT_fno_signed_char,

4250

options::OPT_funsigned_char,

4251

options::OPT_fno_unsigned_char)) {

4252 if

(A->getOption().matches(options::OPT_funsigned_char) ||

4253

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

4254

CmdArgs.push_back(

"-fno-signed-char"

);

4257

CmdArgs.push_back(

"-fno-signed-char"

);

4261

Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);

4263 if

(

const

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

4264

options::OPT_fno_short_wchar)) {

4265 if

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

4266

CmdArgs.push_back(

"-fwchar-type=short"

);

4267

CmdArgs.push_back(

"-fno-signed-wchar"

);

4269 bool

IsARM =

.isARM() ||

.isThumb() ||

.isAArch64();

4270

CmdArgs.push_back(

"-fwchar-type=int"

);

4271 if

(

.isOSzOS() ||

4272

(IsARM && !(

.isOSWindows() ||

.isOSNetBSD() ||

.isOSOpenBSD())))

4273

CmdArgs.push_back(

"-fno-signed-wchar"

);

4275

CmdArgs.push_back(

"-fsigned-wchar"

);

4277

}

else if

(

.isOSzOS())

4278

CmdArgs.push_back(

"-fno-signed-wchar"

);

4282 const

llvm::Triple &

const

ArgList &Args,

4284 const InputInfo

&Input, ArgStringList &CmdArgs) {

4285 const

llvm::Triple::ArchType Arch = TC.

();

4291 if

(!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,

4292

options::OPT_fno_objc_legacy_dispatch,

4295

CmdArgs.push_back(

"-fobjc-dispatch-method=mixed"

);

4297

CmdArgs.push_back(

"-fobjc-dispatch-method=non-legacy"

);

4303 if

(Arch == llvm::Triple::x86 &&

.isMacOSX() &&

4305

CmdArgs.push_back(

"-fobjc-subscripting-legacy-runtime"

);

4312

CmdArgs.push_back(

"-fobjc-arc"

);

4319

CmdArgs.push_back(

"-fobjc-arc-cxxlib=libc++"

);

4321

CmdArgs.push_back(

"-fobjc-arc-cxxlib=libstdc++"

);

4326 if

(Args.hasFlag(options::OPT_fobjc_arc_exceptions,

4327

options::OPT_fno_objc_arc_exceptions,

4329

CmdArgs.push_back(

"-fobjc-arc-exceptions"

);

4334 if

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

4335

Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);

4336

Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);

4342 auto

*Arg = Args.getLastArg(

4343

options::OPT_fobjc_convert_messages_to_runtime_calls,

4344

options::OPT_fno_objc_convert_messages_to_runtime_calls);

4346

Arg->getOption().matches(

4347

options::OPT_fno_objc_convert_messages_to_runtime_calls))

4348

CmdArgs.push_back(

"-fno-objc-convert-messages-to-runtime-calls"

);

4353 if

(InferCovariantReturns)

4354

CmdArgs.push_back(

"-fno-objc-infer-related-result-type"

);

4359

Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);

4363 if

(WeakArg->getOption().matches(options::OPT_fobjc_weak))

4364 D

.Diag(diag::err_objc_weak_unsupported);

4366

WeakArg->render(Args, CmdArgs);

4370 if

(Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing))

4371

CmdArgs.push_back(

"-fobjc-disable-direct-methods-for-testing"

);

4375

ArgStringList &CmdArgs) {

4376 bool

CaretDefault =

true

;

4377 bool

ColumnDefault =

true

;

4379 if

(

const

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

4380

options::OPT__SLASH_diagnostics_column,

4381

options::OPT__SLASH_diagnostics_caret)) {

4382 switch

(A->getOption().getID()) {

4383 case

options::OPT__SLASH_diagnostics_caret:

4384

CaretDefault =

true

;

4385

ColumnDefault =

true

;

4387 case

options::OPT__SLASH_diagnostics_column:

4388

CaretDefault =

false

;

4389

ColumnDefault =

true

;

4391 case

options::OPT__SLASH_diagnostics_classic:

4392

CaretDefault =

false

;

4393

ColumnDefault =

false

;

4399 if

(!Args.hasFlag(options::OPT_fcaret_diagnostics,

4400

options::OPT_fno_caret_diagnostics, CaretDefault))

4401

CmdArgs.push_back(

"-fno-caret-diagnostics"

);

4403

Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info,

4404

options::OPT_fno_diagnostics_fixit_info);

4405

Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option,

4406

options::OPT_fno_diagnostics_show_option);

4409

Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {

4410

CmdArgs.push_back(

"-fdiagnostics-show-category"

);

4411

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

4414

Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness,

4415

options::OPT_fno_diagnostics_show_hotness);

4418

Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {

4420

std::string(

"-fdiagnostics-hotness-threshold="

) + A->getValue();

4421

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

4425

Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {

4427

std::string(

"-fdiagnostics-misexpect-tolerance="

) + A->getValue();

4428

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

4431 if

(

const

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

4432

CmdArgs.push_back(

"-fdiagnostics-format"

);

4433

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

4434 if

(StringRef(A->getValue()) ==

"sarif"

4435

StringRef(A->getValue()) ==

"SARIF"

)

4436 D

.Diag(diag::warn_drv_sarif_format_unstable);

4439 if

(

const

Arg *A = Args.getLastArg(

4440

options::OPT_fdiagnostics_show_note_include_stack,

4441

options::OPT_fno_diagnostics_show_note_include_stack)) {

4442 const

Option &O = A->getOption();

4443 if

(O.matches(options::OPT_fdiagnostics_show_note_include_stack))

4444

CmdArgs.push_back(

"-fdiagnostics-show-note-include-stack"

);

4446

CmdArgs.push_back(

"-fno-diagnostics-show-note-include-stack"

);

4451 if

(Args.hasArg(options::OPT_fansi_escape_codes))

4452

CmdArgs.push_back(

"-fansi-escape-codes"

);

4454

Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,

4455

options::OPT_fno_show_source_location);

4457

Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,

4458

options::OPT_fno_diagnostics_show_line_numbers);

4460 if

(Args.hasArg(options::OPT_fdiagnostics_absolute_paths))

4461

CmdArgs.push_back(

"-fdiagnostics-absolute-paths"

);

4463 if

(!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,

4465

CmdArgs.push_back(

"-fno-show-column"

);

4467

Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,

4468

options::OPT_fno_spell_checking);

4470

Args.addLastArg(CmdArgs, options::OPT_warning_suppression_mappings_EQ);

4474 const

ArgList &Args, Arg *&Arg) {

4475

Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ,

4476

options::OPT_gno_split_dwarf);

4477 if

(!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf))

4480 if

(Arg->getOption().matches(options::OPT_gsplit_dwarf))

4483

StringRef

= Arg->getValue();

4484 if

(

"split"

)

4486 if

(

"single"

)

4489 D

.Diag(diag::err_drv_unsupported_option_argument)

4490

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

4495 const

ArgList &Args, ArgStringList &CmdArgs,

4496 unsigned

DwarfVersion) {

4497 auto

*DwarfFormatArg =

4498

Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32);

4499 if

(!DwarfFormatArg)

4502 if

(DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) {

4503 if

(DwarfVersion < 3)

4504 D

.Diag(diag::err_drv_argument_only_allowed_with)

4505

<< DwarfFormatArg->getAsString(Args) <<

"DWARFv3 or greater"

;

4506 else if

.isArch64Bit())

4507 D

.Diag(diag::err_drv_argument_only_allowed_with)

4508

<< DwarfFormatArg->getAsString(Args) <<

"64 bit architecture"

;

4509 else if

.isOSBinFormatELF())

4510 D

.Diag(diag::err_drv_argument_only_allowed_with)

4511

<< DwarfFormatArg->getAsString(Args) <<

"ELF platforms"

;

4514

DwarfFormatArg->render(Args, CmdArgs);

4519 const

ArgList &Args,

bool

IRInput, ArgStringList &CmdArgs,

4521

llvm::codegenoptions::DebugInfoKind &DebugInfoKind,

4523 if

(Args.hasFlag(options::OPT_fdebug_info_for_profiling,

4524

options::OPT_fno_debug_info_for_profiling,

false

) &&

4526

Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args,

, TC))

4527

CmdArgs.push_back(

"-fdebug-info-for-profiling"

);

4540 bool

SplitDWARFInlining =

4541

Args.hasFlag(options::OPT_fsplit_dwarf_inlining,

4542

options::OPT_fno_split_dwarf_inlining,

false

);

4547 if

(IRInput || Args.hasArg(options::OPT_g_Group)) {

4553

SplitDWARFInlining =

false

;

4556 if

(

const

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

4557

DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;

4561

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

4567 if

(DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||

4568

DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||

4569

(DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&

4570

SplitDWARFInlining))

4576 bool

HasDebuggerTuning =

false

;

4578

Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {

4579

HasDebuggerTuning =

true

;

4581 if

(A->getOption().matches(options::OPT_glldb))

4582

DebuggerTuning = llvm::DebuggerKind::LLDB;

4583 else if

(A->getOption().matches(options::OPT_gsce))

4584

DebuggerTuning = llvm::DebuggerKind::SCE;

4585 else if

(A->getOption().matches(options::OPT_gdbx))

4586

DebuggerTuning = llvm::DebuggerKind::DBX;

4588

DebuggerTuning = llvm::DebuggerKind::GDB;

4593 bool

EmitDwarf =

false

;

4597 bool

EmitCodeView =

false

;

4598 if

(

const

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

4603 if

(!EmitCodeView && !EmitDwarf &&

4604

DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {

4606 case

llvm::codegenoptions::DIF_CodeView:

4607

EmitCodeView =

true

;

4609 case

llvm::codegenoptions::DIF_DWARF:

4615 unsigned

RequestedDWARFVersion = 0;

4616 unsigned

EffectiveDWARFVersion = 0;

4621

EffectiveDWARFVersion =

4624

Args.ClaimAllArgs(options::OPT_fdebug_default_version);

4628 if

(RequestedDWARFVersion == 0 &&

4629

DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)

4630

DebugInfoKind = llvm::codegenoptions::NoDebugInfo;

4634 if

(

const

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

4636 if

(Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,

4637

DebuggerTuning == llvm::DebuggerKind::DBX))

4638

CmdArgs.push_back(

"-gstrict-dwarf"

);

4641

Args.ClaimAllArgs(options::OPT_g_flags_Group);

4649 if

(

const

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

4651 if

(!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,

4653

(DebuggerTuning != llvm::DebuggerKind::SCE &&

4654

DebuggerTuning != llvm::DebuggerKind::DBX)))

4655

CmdArgs.push_back(

"-gno-column-info"

);

4658 if

(Args.hasFlag(options::OPT_gmodules, options::OPT_gno_modules,

false

)) {

4663 if

(DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&

4664

DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {

4665

DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;

4666

CmdArgs.push_back(

"-dwarf-ext-refs"

);

4667

CmdArgs.push_back(

"-fmodule-format=obj"

);

4672 if

(

.isOSBinFormatELF() && SplitDWARFInlining)

4673

CmdArgs.push_back(

"-fsplit-dwarf-inlining"

);

4680 bool

NeedFullDebug = Args.hasFlag(

4681

options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,

4682

DebuggerTuning == llvm::DebuggerKind::LLDB ||

4684 if

(

const

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

4687 if

(DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||

4688

DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {

4689 if

(Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,

4690

options::OPT_feliminate_unused_debug_types,

false

))

4691

DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;

4692 else if

(NeedFullDebug)

4693

DebugInfoKind = llvm::codegenoptions::FullDebugInfo;

4696 if

(Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,

4702 const

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

4703 if

(RequestedDWARFVersion < 5)

4704 D

.Diag(diag::err_drv_argument_only_allowed_with)

4705

<< A->getAsString(Args) <<

"-gdwarf-5"

;

4706 else if

(EffectiveDWARFVersion < 5)

4709 D

.Diag(diag::warn_drv_dwarf_version_limited_by_target)

4711

<< EffectiveDWARFVersion;

4713

CmdArgs.push_back(

"-gembed-source"

);

4717

CmdArgs.push_back(

"-gcodeview"

);

4719

Args.addOptInFlag(CmdArgs, options::OPT_gcodeview_ghash,

4720

options::OPT_gno_codeview_ghash);

4722

Args.addOptOutFlag(CmdArgs, options::OPT_gcodeview_command_line,

4723

options::OPT_gno_codeview_command_line);

4726

Args.addOptOutFlag(CmdArgs, options::OPT_ginline_line_tables,

4727

options::OPT_gno_inline_line_tables);

4731

DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)

4732

DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;

4740 T

.isOSAIX() && !HasDebuggerTuning

4741

? llvm::DebuggerKind::Default

4745 if

(Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,

4749

CmdArgs.push_back(

"-debug-info-macro"

);

4752 const auto

*PubnamesArg =

4753

Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,

4754

options::OPT_gpubnames, options::OPT_gno_pubnames);

4757 const bool

OptionSet =

4759

(PubnamesArg->getOption().matches(options::OPT_gpubnames) ||

4760

PubnamesArg->getOption().matches(options::OPT_ggnu_pubnames)));

4761 if

((DebuggerTuning != llvm::DebuggerKind::LLDB || OptionSet) &&

4763

(!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&

4764

!PubnamesArg->getOption().matches(options::OPT_gno_pubnames))))

4765

CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(

4766

options::OPT_gpubnames)

4768

"-ggnu-pubnames"

);

4770 const auto

*SimpleTemplateNamesArg =

4771

Args.getLastArg(options::OPT_gsimple_template_names,

4772

options::OPT_gno_simple_template_names);

4773 bool

ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE;

4774 if

(SimpleTemplateNamesArg &&

4776 const auto

&Opt = SimpleTemplateNamesArg->getOption();

4777 if

(Opt.matches(options::OPT_gsimple_template_names)) {

4778

ForwardTemplateParams =

true

;

4779

CmdArgs.push_back(

"-gsimple-template-names=simple"

);

4784 bool

UseDebugTemplateAlias =

4785

DebuggerTuning == llvm::DebuggerKind::SCE && RequestedDWARFVersion >= 4;

4786 if

(

const auto

*DebugTemplateAlias = Args.getLastArg(

4787

options::OPT_gtemplate_alias, options::OPT_gno_template_alias)) {

4791 const auto

&Opt = DebugTemplateAlias->getOption();

4792

UseDebugTemplateAlias = Opt.matches(options::OPT_gtemplate_alias);

4795 if

(UseDebugTemplateAlias)

4796

CmdArgs.push_back(

"-gtemplate-alias"

);

4798 if

(

const

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

4799

StringRef

= A->getValue();

4800

CmdArgs.push_back(Args.MakeArgString(

"-gsrc-hash="

));

4803

Args.addOptInFlag(CmdArgs, options::OPT_fdebug_ranges_base_address,

4804

options::OPT_fno_debug_ranges_base_address);

4808 if

(

const

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

4810

CmdArgs.push_back(

"-mllvm"

);

4811

CmdArgs.push_back(

"-generate-arange-section"

);

4814

Args.addOptInFlag(CmdArgs, options::OPT_fforce_dwarf_frame,

4815

options::OPT_fno_force_dwarf_frame);

4817 bool

EnableTypeUnits =

false

;

4818 if

(Args.hasFlag(options::OPT_fdebug_types_section,

4819

options::OPT_fno_debug_types_section,

false

)) {

4820 if

(!(

.isOSBinFormatELF() ||

.isOSBinFormatWasm())) {

4821 D

.Diag(diag::err_drv_unsupported_opt_for_target)

4822

<< Args.getLastArg(options::OPT_fdebug_types_section)

4826

Args.getLastArg(options::OPT_fdebug_types_section), Args,

4828

EnableTypeUnits =

true

;

4829

CmdArgs.push_back(

"-mllvm"

);

4830

CmdArgs.push_back(

"-generate-type-units"

);

4835

Args.getLastArg(options::OPT_gomit_unreferenced_methods,

4836

options::OPT_gno_omit_unreferenced_methods))

4838 if

(Args.hasFlag(options::OPT_gomit_unreferenced_methods,

4839

options::OPT_gno_omit_unreferenced_methods,

false

) &&

4840

(DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor ||

4841

DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo) &&

4843

CmdArgs.push_back(

"-gomit-unreferenced-methods"

);

4849 if

(!Args.hasFlag(options::OPT_fdwarf_directory_asm,

4850

options::OPT_fno_dwarf_directory_asm,

4852

CmdArgs.push_back(

"-fno-dwarf-directory-asm"

);

4856 if

(ForwardTemplateParams)

4857

CmdArgs.push_back(

"-debug-forward-template-params"

);

4861 if

(DebuggerTuning == llvm::DebuggerKind::SCE)

4862

CmdArgs.push_back(

"-dwarf-explicit-import"

);

4868 if

(Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,

false

)) {

4869 if

(TC.

().isOSBinFormatELF() ||

4870

TC.

().isWindowsMSVCEnvironment()) {

4871 if

(DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)

4872

CmdArgs.push_back(

"-fjmc"

);

4873 else if

(

.IsCLMode())

4874 D

.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<

"/JMC" 4877 D

.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) <<

"-fjmc" 4880 D

.Diag(clang::diag::warn_drv_fjmc_for_elf_only);

4885 const char

*DebugCompilationDir =

4897

ArgStringList &CmdArgs) {

4898 unsigned

RTOptionID = options::OPT__SLASH_MT;

4900 if

(Args.hasArg(options::OPT__SLASH_LDd))

4903

RTOptionID = options::OPT__SLASH_MTd;

4905 if

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

4906

RTOptionID = A->getOption().getID();

4908 if

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

4909

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

4910

.Case(

"static"

, options::OPT__SLASH_MT)

4911

.Case(

"static_dbg"

, options::OPT__SLASH_MTd)

4912

.Case(

"dll"

, options::OPT__SLASH_MD)

4913

.Case(

"dll_dbg"

, options::OPT__SLASH_MDd)

4914

.Default(options::OPT__SLASH_MT);

4917

StringRef FlagForCRT;

4918 switch

(RTOptionID) {

4919 case

options::OPT__SLASH_MD:

4920 if

(Args.hasArg(options::OPT__SLASH_LDd))

4921

CmdArgs.push_back(

"-D_DEBUG"

);

4922

CmdArgs.push_back(

"-D_MT"

);

4923

CmdArgs.push_back(

"-D_DLL"

);

4924

FlagForCRT =

"--dependent-lib=msvcrt"

;

4926 case

options::OPT__SLASH_MDd:

4927

CmdArgs.push_back(

"-D_DEBUG"

);

4928

CmdArgs.push_back(

"-D_MT"

);

4929

CmdArgs.push_back(

"-D_DLL"

);

4930

FlagForCRT =

"--dependent-lib=msvcrtd"

;

4932 case

options::OPT__SLASH_MT:

4933 if

(Args.hasArg(options::OPT__SLASH_LDd))

4934

CmdArgs.push_back(

"-D_DEBUG"

);

4935

CmdArgs.push_back(

"-D_MT"

);

4936

CmdArgs.push_back(

"-flto-visibility-public-std"

);

4937

FlagForCRT =

"--dependent-lib=libcmt"

;

4939 case

options::OPT__SLASH_MTd:

4940

CmdArgs.push_back(

"-D_DEBUG"

);

4941

CmdArgs.push_back(

"-D_MT"

);

4942

CmdArgs.push_back(

"-flto-visibility-public-std"

);

4943

FlagForCRT =

"--dependent-lib=libcmtd"

;

4946

llvm_unreachable(

"Unexpected option ID."

);

4949 if

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

4950

CmdArgs.push_back(

"-D_VC_NODEFAULTLIB"

);

4952

CmdArgs.push_back(FlagForCRT.data());

4957

CmdArgs.push_back(

"--dependent-lib=oldnames"

);

4963 if

(TC.

().isWindowsArm64EC())

4964

CmdArgs.push_back(

"--dependent-lib=softintrin"

);

4969 const

ArgList &Args,

const char

*LinkingOutput)

const

{

4971 const

llvm::Triple &RawTriple = TC.

();

4973 const

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

4976

Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);

4978

ArgStringList CmdArgs;

4980

assert(Inputs.size() >= 1 &&

"Must have at least one input."

);

4995 bool

IsExtractAPI = isa<ExtractAPIJobAction>(JA);

4998 bool

IsHostOffloadingAction =

5002

Args.hasFlag(options::OPT_offload_new_driver,

5003

options::OPT_no_offload_new_driver,

5007

Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,

false

);

5009 auto

LTOMode = IsDeviceOffloadAction ?

.getOffloadLTOMode() :

.getLTOMode();

5010 bool

IsUsingLTO = LTOMode !=

LTOK_None

;

5014 InputInfo

ExtractAPIPlaceholderInput(Inputs[0].getType(),

"extract-api"

5018

IsExtractAPI ? ExtractAPIPlaceholderInput : Inputs[0];

5022 const InputInfo

*CudaDeviceInput =

nullptr

;

5023 const InputInfo

*OpenMPDeviceInput =

nullptr

;

5025 if

(&I == &Input || I.

() == types::TY_Nothing) {

5027

}

else if

(IsExtractAPI) {

5028 auto

ExpectedInputType = ExtractAPIPlaceholderInput.

();

5029 if

(I.getType() != ExpectedInputType) {

5030 D

.Diag(diag::err_drv_extract_api_wrong_kind)

5034

ExtractAPIInputs.push_back(I);

5035

}

else if

(IsHostOffloadingAction) {

5036

HostOffloadingInputs.push_back(I);

5037

}

else if

((IsCuda || IsHIP) && !CudaDeviceInput) {

5038

CudaDeviceInput = &I;

5039

}

else if

(IsOpenMPDevice && !OpenMPDeviceInput) {

5040

OpenMPDeviceInput = &I;

5042

llvm_unreachable(

"unexpectedly given multiple inputs"

);

5046 const

llvm::Triple *AuxTriple =

5048 bool

IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();

5049 bool

IsUEFI = RawTriple.isUEFI();

5050 bool

IsIAMCU = RawTriple.isOSIAMCU();

5055 if

(IsCuda || IsHIP || IsSYCL)

5056

IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();

5060 D

.Diag(diag::err_drv_clang_unsupported) <<

"C++ for IAMCU"

;

5065

CmdArgs.push_back(

"-cc1"

);

5068

CmdArgs.push_back(

"-triple"

);

5069

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

5071 if

(

const

Arg *MJ = Args.getLastArg(options::OPT_MJ)) {

5072

DumpCompilationDatabase(

, MJ->getValue(), TripleStr, Output, Input, Args);

5073

Args.ClaimAllArgs(options::OPT_MJ);

5074

}

else if

(

const

Arg *GenCDBFragment =

5075

Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {

5076

DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(),

5077

TripleStr, Output, Input, Args);

5078

Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);

5081 if

(IsCuda || IsHIP) {

5084

std::string NormalizedTriple;

5102

assert(CTC &&

"Expected valid CUDA Toolchain."

);

5104

CmdArgs.push_back(Args.MakeArgString(

5105

Twine(

"-target-sdk-version="

) +

5113

CmdArgs.push_back(

"-fcuda-allow-variadic-functions"

);

5116

CmdArgs.push_back(

"-aux-triple"

);

5117

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

5122 getToolChain

().getTriple().getVendor() == llvm::Triple::AMD))) {

5124 if

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

5125

CmdArgs.push_back(Args.MakeArgString(

5127

Args.getLastArgValue(options::OPT_mprintf_kind_EQ)));

5130

Args.MakeArgString(

"-Werror=format-invalid-specifier"

));

5136 if

(

const

Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))

5142

llvm::Triple AuxT =

.getDefaultToolChain().getTriple();

5143

std::string NormalizedTriple = AuxT.normalize();

5144

CmdArgs.push_back(

"-aux-triple"

);

5145

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

5148

CmdArgs.push_back(

"-fsycl-is-device"

);

5151 if

(!Args.getLastArg(options::OPT_O_Group))

5152

CmdArgs.push_back(

"-O2"

);

5159

CmdArgs.push_back(

"-fsycl-is-host"

);

5163

Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);

5165

SYCLStdArg->render(Args, CmdArgs);

5168

CmdArgs.push_back(

"-sycl-std=2020"

);

5172 if

(Args.hasArg(options::OPT_fclangir))

5173

CmdArgs.push_back(

"-fclangir"

);

5175 if

(IsOpenMPDevice) {

5177

std::string NormalizedTriple =

5181

CmdArgs.push_back(

"-aux-triple"

);

5182

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

5185 if

(Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||

5186

Triple.getArch() == llvm::Triple::thumb)) {

5187 unsigned

Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;

5188 unsigned

Version = 0;

5190

Triple.getArchName().substr(Offset).consumeInteger(10, Version);

5191 if

(Failure || Version < 7)

5192 D

.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()

5202 if

(Triple.isSPIR() || Triple.isSPIRV())

5203

CmdArgs.push_back(

"-Wspir-compat"

);

5206

RewriteKind rewriteKind = RK_None;

5208 bool

UnifiedLTO =

false

;

5210

UnifiedLTO = Args.hasFlag(options::OPT_funified_lto,

5211

options::OPT_fno_unified_lto, Triple.isPS());

5213

CmdArgs.push_back(

"-funified-lto"

);

5223 if

(!isa<AssembleJobAction>(JA)) {

5227

Args.ClaimAllArgs(options::OPT_mrelax_all);

5228

Args.ClaimAllArgs(options::OPT_mno_relax_all);

5229

Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);

5230

Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);

5231 switch

(

.getDefaultToolChain().getArch()) {

5232 case

llvm::Triple::arm:

5233 case

llvm::Triple::armeb:

5234 case

llvm::Triple::thumb:

5235 case

llvm::Triple::thumbeb:

5236

Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);

5242

Args.ClaimAllArgs(options::OPT_Wa_COMMA);

5243

Args.ClaimAllArgs(options::OPT_Xassembler);

5244

Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ);

5247 if

(isa<AnalyzeJobAction>(JA)) {

5248

assert(JA.

() == types::TY_Plist &&

"Invalid output type."

);

5249

CmdArgs.push_back(

"-analyze"

);

5250

}

else if

(isa<PreprocessJobAction>(JA)) {

5251 if

(Output.

() == types::TY_Dependencies)

5252

CmdArgs.push_back(

"-Eonly"

);

5254

CmdArgs.push_back(

"-E"

);

5255 if

(Args.hasArg(options::OPT_rewrite_objc) &&

5256

!Args.hasArg(options::OPT_g_Group))

5257

CmdArgs.push_back(

"-P"

);

5258 else if

(JA.

() == types::TY_PP_CXXHeaderUnit)

5259

CmdArgs.push_back(

"-fdirectives-only"

);

5261

}

else if

(isa<AssembleJobAction>(JA)) {

5262

CmdArgs.push_back(

"-emit-obj"

);

5267

(void)Args.hasArg(options::OPT_force__cpusubtype__ALL);

5268

}

else if

(isa<PrecompileJobAction>(JA)) {

5269 if

(JA.

() == types::TY_Nothing)

5270

CmdArgs.push_back(

"-fsyntax-only"

);

5271 else if

(JA.

() == types::TY_ModuleFile)

5272

CmdArgs.push_back(

"-emit-module-interface"

);

5273 else if

(JA.

() == types::TY_HeaderUnit)

5274

CmdArgs.push_back(

"-emit-header-unit"

);

5276

CmdArgs.push_back(

"-emit-pch"

);

5277

}

else if

(isa<VerifyPCHJobAction>(JA)) {

5278

CmdArgs.push_back(

"-verify-pch"

);

5279

}

else if

(isa<ExtractAPIJobAction>(JA)) {

5280

assert(JA.

() == types::TY_API_INFO &&

5281 "Extract API actions must generate a API information."

);

5282

CmdArgs.push_back(

"-extract-api"

);

5284 if

(Arg *PrettySGFArg = Args.getLastArg(options::OPT_emit_pretty_sgf))

5285

PrettySGFArg->render(Args, CmdArgs);

5287

Arg *SymbolGraphDirArg = Args.getLastArg(options::OPT_symbol_graph_dir_EQ);

5289 if

(Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ))

5290

ProductNameArg->render(Args, CmdArgs);

5291 if

(Arg *ExtractAPIIgnoresFileArg =

5292

Args.getLastArg(options::OPT_extract_api_ignores_EQ))

5293

ExtractAPIIgnoresFileArg->render(Args, CmdArgs);

5294 if

(Arg *EmitExtensionSymbolGraphs =

5295

Args.getLastArg(options::OPT_emit_extension_symbol_graphs)) {

5296 if

(!SymbolGraphDirArg)

5297 D

.Diag(diag::err_drv_missing_symbol_graph_dir);

5299

EmitExtensionSymbolGraphs->render(Args, CmdArgs);

5301 if

(SymbolGraphDirArg)

5302

SymbolGraphDirArg->render(Args, CmdArgs);

5304

assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&

5305 "Invalid action for clang tool."

);

5306 if

(JA.

() == types::TY_Nothing) {

5307

CmdArgs.push_back(

"-fsyntax-only"

);

5308

}

else if

(JA.

() == types::TY_LLVM_IR ||

5309

JA.

() == types::TY_LTO_IR) {

5310

CmdArgs.push_back(

"-emit-llvm"

);

5311

}

else if

(JA.

() == types::TY_LLVM_BC ||

5312

JA.

() == types::TY_LTO_BC) {

5314 if

(Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) &&

5315

Args.hasArg(options::OPT_emit_llvm)) {

5316

CmdArgs.push_back(

"-emit-llvm"

);

5318

CmdArgs.push_back(

"-emit-llvm-bc"

);

5320

}

else if

(JA.

() == types::TY_IFS ||

5321

JA.

() == types::TY_IFS_CPP) {

5323

Args.hasArg(options::OPT_interface_stub_version_EQ)

5324

? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)

5326

CmdArgs.push_back(

"-emit-interface-stubs"

);

5328

Args.MakeArgString(Twine(

"-interface-stub-version="

) + ArgStr.str()));

5329

}

else if

(JA.

() == types::TY_PP_Asm) {

5330

CmdArgs.push_back(

"-S"

);

5331

}

else if

(JA.

() == types::TY_AST) {

5332

CmdArgs.push_back(

"-emit-pch"

);

5333

}

else if

(JA.

() == types::TY_ModuleFile) {

5334

CmdArgs.push_back(

"-module-file-info"

);

5335

}

else if

(JA.

() == types::TY_RewrittenObjC) {

5336

CmdArgs.push_back(

"-rewrite-objc"

);

5337

rewriteKind = RK_NonFragile;

5338

}

else if

(JA.

() == types::TY_RewrittenLegacyObjC) {

5339

CmdArgs.push_back(

"-rewrite-objc"

);

5340

rewriteKind = RK_Fragile;

5341

}

else if

(JA.

() == types::TY_CIR) {

5342

CmdArgs.push_back(

"-emit-cir"

);

5344

assert(JA.

() == types::TY_PP_Asm &&

"Unexpected output type!"

);

5351 if

(JA.

() == types::TY_LLVM_BC)

5352

CmdArgs.push_back(

"-emit-llvm-uselists"

);

5356

!Args.hasFlag(options::OPT_offload_new_driver,

5357

options::OPT_no_offload_new_driver,

5359

!Triple.isAMDGPU()) {

5360 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5361

<< Args.getLastArg(options::OPT_foffload_lto,

5362

options::OPT_foffload_lto_EQ)

5364

<< Triple.getTriple();

5365

}

else if

(Triple.isNVPTX() && !IsRDCMode &&

5367 D

.Diag(diag::err_drv_unsupported_opt_for_language_mode)

5368

<< Args.getLastArg(options::OPT_foffload_lto,

5369

options::OPT_foffload_lto_EQ)

5374

CmdArgs.push_back(Args.MakeArgString(

5375

Twine(

"-flto="

) + (LTOMode ==

LTOK_Thin

"thin"

"full"

)));

5378 if

(!RawTriple.isPS4() ||

5379

(

.getLTOMode() ==

LTOK_Full

) || !UnifiedLTO)

5380

CmdArgs.push_back(

"-flto-unit"

);

5385

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

5387 if

(

const

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

5389 D

.Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);

5390

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

5394

Args.addOptInFlag(CmdArgs, options::OPT_mregnames,

5395

options::OPT_mno_regnames);

5397 if

(Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))

5398

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

5400 if

(Args.getLastArg(options::OPT_save_temps_EQ))

5401

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

5403 auto

*MemProfArg = Args.getLastArg(options::OPT_fmemory_profile,

5404

options::OPT_fmemory_profile_EQ,

5405

options::OPT_fno_memory_profile);

5407

!MemProfArg->getOption().matches(options::OPT_fno_memory_profile))

5408

MemProfArg->render(Args, CmdArgs);

5410 if

(

auto

*MemProfUseArg =

5411

Args.getLastArg(options::OPT_fmemory_profile_use_EQ)) {

5413 D

.Diag(diag::err_drv_argument_not_allowed_with)

5414

<< MemProfUseArg->getAsString(Args) << MemProfArg->getAsString(Args);

5415 if

(

auto

*PGOInstrArg = Args.getLastArg(options::OPT_fprofile_generate,

5416

options::OPT_fprofile_generate_EQ))

5417 D

.Diag(diag::err_drv_argument_not_allowed_with)

5418

<< MemProfUseArg->getAsString(Args) << PGOInstrArg->getAsString(Args);

5419

MemProfUseArg->render(Args, CmdArgs);

5424 if

(

.getDriver().embedBitcodeInObject() && !IsUsingLTO &&

5425

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

5427

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

5429

CmdArgs.push_back(

"-disable-llvm-passes"

);

5436 static const constexpr unsigned

kBitcodeOptionIgnorelist[] = {

5437

options::OPT_mkernel,

5438

options::OPT_fapple_kext,

5439

options::OPT_ffunction_sections,

5440

options::OPT_fno_function_sections,

5441

options::OPT_fdata_sections,

5442

options::OPT_fno_data_sections,

5443

options::OPT_fbasic_block_sections_EQ,

5444

options::OPT_funique_internal_linkage_names,

5445

options::OPT_fno_unique_internal_linkage_names,

5446

options::OPT_funique_section_names,

5447

options::OPT_fno_unique_section_names,

5448

options::OPT_funique_basic_block_section_names,

5449

options::OPT_fno_unique_basic_block_section_names,

5450

options::OPT_mrestrict_it,

5451

options::OPT_mno_restrict_it,

5452

options::OPT_mstackrealign,

5453

options::OPT_mno_stackrealign,

5454

options::OPT_mstack_alignment,

5455

options::OPT_mcmodel_EQ,

5456

options::OPT_mlong_calls,

5457

options::OPT_mno_long_calls,

5458

options::OPT_ggnu_pubnames,

5459

options::OPT_gdwarf_aranges,

5460

options::OPT_fdebug_types_section,

5461

options::OPT_fno_debug_types_section,

5462

options::OPT_fdwarf_directory_asm,

5463

options::OPT_fno_dwarf_directory_asm,

5464

options::OPT_mrelax_all,

5465

options::OPT_mno_relax_all,

5466

options::OPT_ftrap_function_EQ,

5467

options::OPT_ffixed_r9,

5468

options::OPT_mfix_cortex_a53_835769,

5469

options::OPT_mno_fix_cortex_a53_835769,

5470

options::OPT_ffixed_x18,

5471

options::OPT_mglobal_merge,

5472

options::OPT_mno_global_merge,

5473

options::OPT_mred_zone,

5474

options::OPT_mno_red_zone,

5475

options::OPT_Wa_COMMA,

5476

options::OPT_Xassembler,

5479 for

(

const auto

&A : Args)

5480 if

(llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID()))

5481 D

.Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();

5484

Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,

5485

options::OPT_fno_optimize_sibling_calls);

5493 case

llvm::Triple::arm:

5494 case

llvm::Triple::armeb:

5495 case

llvm::Triple::thumbeb:

5496

RenderARMABI(

, Triple, Args, CmdArgs);

5498 case

llvm::Triple::aarch64:

5499 case

llvm::Triple::aarch64_32:

5500 case

llvm::Triple::aarch64_be:

5501

RenderAArch64ABI(Triple, Args, CmdArgs);

5506 if

(

const

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

5507 if

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

5508

CmdArgs.push_back(

"-O3"

);

5509 D

.Diag(diag::warn_O4_is_O3);

5511

A->render(Args, CmdArgs);

5516 if

(Output.

() == types::TY_Dependencies) {

5519

CmdArgs.push_back(

"-o"

);

5522

assert(Output.

isNothing

() &&

"Input output."

);

5525 for

(

const auto

&II : Inputs) {

5527 if

(II.isFilename())

5528

CmdArgs.push_back(II.getFilename());

5530

II.getInputArg().renderAsInput(Args, CmdArgs);

5533 C

.addCommand(std::make_unique<Command>(

5535

CmdArgs, Inputs, Output,

.getPrependArg()));

5539 if

(

.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)

5540

CmdArgs.push_back(

"-fembed-bitcode=marker"

);

5545 if

.isForDiagnostics())

5546

CmdArgs.push_back(

"-disable-free"

);

5547

CmdArgs.push_back(

"-clear-ast-before-backend"

);

5550 const bool

IsAssertBuild =

false

;

5552 const bool

IsAssertBuild =

true

;

5556 if

(Args.hasFlag(options::OPT_fno_verify_intermediate_code,

5557

options::OPT_fverify_intermediate_code, !IsAssertBuild)) {

5558

CmdArgs.push_back(

"-disable-llvm-verifier"

);

5562 if

(Args.hasFlag(options::OPT_fdiscard_value_names,

5563

options::OPT_fno_discard_value_names, !IsAssertBuild)) {

5564 if

(Args.hasArg(options::OPT_fdiscard_value_names) &&

5566

return types::isLLVMIR(II.getType());

5568 D

.Diag(diag::warn_ignoring_fdiscard_for_bitcode);

5570

CmdArgs.push_back(

"-discard-value-names"

);

5575

CmdArgs.push_back(

"-main-file-name"

);

5580 if

(Args.hasArg(options::OPT_static))

5581

CmdArgs.push_back(

"-static-define"

);

5583 if

(Args.hasArg(options::OPT_municode))

5584

CmdArgs.push_back(

"-DUNICODE"

);

5586 if

(isa<AnalyzeJobAction>(JA))

5589 if

(isa<AnalyzeJobAction>(JA) ||

5590

(isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))

5591

CmdArgs.push_back(

"-setup-static-analyzer"

);

5596 bool

FoundAnalyzerConfig =

false

;

5597 for

(

auto

*Arg : Args.filtered(options::OPT_Xclang))

5598 if

(StringRef(Arg->getValue()) ==

"-analyzer-config"

) {

5599

FoundAnalyzerConfig =

true

;

5602 if

(!FoundAnalyzerConfig)

5603 for

(

auto

*Arg : Args.filtered(options::OPT_Xanalyzer))

5604 if

(StringRef(Arg->getValue()) ==

"-analyzer-config"

) {

5605

FoundAnalyzerConfig =

true

;

5608 if

(FoundAnalyzerConfig)

5609

CmdArgs.push_back(

"-analyzer-config-compatibility-mode=true"

);

5614

assert(FunctionAlignment <= 31 &&

"function alignment will be truncated!"

);

5615 if

(FunctionAlignment) {

5616

CmdArgs.push_back(

"-function-alignment"

);

5617

CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));

5622 if

(

const

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

5624 if

(StringRef(A->getValue()).getAsInteger(10,

) ||

> 65536)

5626

<< A->getAsString(Args) << A->getValue();

5628

TC.

getDriver

().

Diag

(diag::err_drv_alignment_not_power_of_two)

5629

<< A->getAsString(Args) << A->getValue();

5632

CmdArgs.push_back(Args.MakeArgString(

"-falign-loops="

5633

Twine(std::min(

, 65536u))));

5636 if

(Triple.isOSzOS()) {

5645 auto

findMacroDefinition = [&](

const

std::string &Macro) {

5646 auto

MacroDefs = Args.getAllArgValues(options::OPT_D);

5647 return

llvm::any_of(MacroDefs, [&](

const

std::string &M) {

5648 return

M == Macro || M.find(Macro +

'='

) != std::string::npos;

5653 if

(!findMacroDefinition(

"_UNIX03_WITHDRAWN"

))

5654

CmdArgs.push_back(

"-D_UNIX03_WITHDRAWN"

);

5656 if

(!findMacroDefinition(

"_OPEN_DEFAULT"

))

5657

CmdArgs.push_back(

"-D_OPEN_DEFAULT"

);

5660 if

(!findMacroDefinition(

"_XOPEN_SOURCE"

))

5661

CmdArgs.push_back(

"-D_XOPEN_SOURCE=600"

);

5665

llvm::Reloc::Model RelocationModel;

5668

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

ParsePICArgs

(TC, Args);

5669

Arg *LastPICDataRelArg =

5670

Args.getLastArg(options::OPT_mno_pic_data_is_text_relative,

5671

options::OPT_mpic_data_is_text_relative);

5672 bool

NoPICDataIsTextRelative =

false

;

5673 if

(LastPICDataRelArg) {

5674 if

(LastPICDataRelArg->getOption().matches(

5675

options::OPT_mno_pic_data_is_text_relative)) {

5676

NoPICDataIsTextRelative =

true

;

5678 D

.Diag(diag::err_drv_argument_only_allowed_with)

5679

"-mno-pic-data-is-text-relative" 5682 if

(!Triple.isSystemZ())

5683 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5684

<< (NoPICDataIsTextRelative ?

"-mno-pic-data-is-text-relative" 5685

"-mpic-data-is-text-relative"

)

5689 bool

IsROPI = RelocationModel == llvm::Reloc::ROPI ||

5690

RelocationModel == llvm::Reloc::ROPI_RWPI;

5691 bool

IsRWPI = RelocationModel == llvm::Reloc::RWPI ||

5692

RelocationModel == llvm::Reloc::ROPI_RWPI;

5694 if

(Args.hasArg(options::OPT_mcmse) &&

5695

!Args.hasArg(options::OPT_fallow_unsupported)) {

5697 D

.Diag(diag::err_cmse_pi_are_incompatible) << IsROPI;

5699 D

.Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI;

5703

!Args.hasArg(options::OPT_fallow_unsupported))

5704 D

.Diag(diag::err_drv_ropi_incompatible_with_cxx);

5708

CmdArgs.push_back(

"-mrelocation-model"

);

5709

CmdArgs.push_back(RMName);

5712

CmdArgs.push_back(

"-pic-level"

);

5713

CmdArgs.push_back(PICLevel == 1 ?

"1"

"2"

);

5715

CmdArgs.push_back(

"-pic-is-pie"

);

5716 if

(NoPICDataIsTextRelative)

5717

CmdArgs.push_back(

"-mcmodel=medium"

);

5720 if

(RelocationModel == llvm::Reloc::ROPI ||

5721

RelocationModel == llvm::Reloc::ROPI_RWPI)

5722

CmdArgs.push_back(

"-fropi"

);

5723 if

(RelocationModel == llvm::Reloc::RWPI ||

5724

RelocationModel == llvm::Reloc::ROPI_RWPI)

5725

CmdArgs.push_back(

"-frwpi"

);

5727 if

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

5728

CmdArgs.push_back(

"-meabi"

);

5729

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

5743 if

(Triple.isOSBinFormatELF()) {

5744

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

5745

options::OPT_fno_semantic_interposition);

5746 if

(RelocationModel != llvm::Reloc::Static && !IsPIE) {

5748 bool

SupportsLocalAlias =

5749

Triple.isAArch64() || Triple.isRISCV() || Triple.isX86();

5751

CmdArgs.push_back(

"-fhalf-no-semantic-interposition"

);

5752 else if

(A->getOption().matches(options::OPT_fsemantic_interposition))

5753

A->render(Args, CmdArgs);

5754 else if

(!SupportsLocalAlias)

5755

CmdArgs.push_back(

"-fhalf-no-semantic-interposition"

);

5761 if

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

5763 D

.Diag(diag::err_drv_invalid_thread_model_for_target)

5764

<< A->getValue() << A->getAsString(Args);

5765

Model = A->getValue();

5768 if

(Model !=

"posix"

) {

5769

CmdArgs.push_back(

"-mthread-model"

);

5770

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

5774 if

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

5775

StringRef Name = A->getValue();

5776 if

(Name ==

"SVML"

) {

5777 if

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

5778

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

5779 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5780

<< Name << Triple.getArchName();

5781

}

else if

(Name ==

"LIBMVEC-X86"

) {

5782 if

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

5783

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

5784 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5785

<< Name << Triple.getArchName();

5786

}

else if

(Name ==

"SLEEF"

|| Name ==

"ArmPL"

) {

5787 if

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

5788

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

5789

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

5790 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5791

<< Name << Triple.getArchName();

5793

A->render(Args, CmdArgs);

5796 if

(Args.hasFlag(options::OPT_fmerge_all_constants,

5797

options::OPT_fno_merge_all_constants,

false

))

5798

CmdArgs.push_back(

"-fmerge-all-constants"

);

5800

Args.addOptOutFlag(CmdArgs, options::OPT_fdelete_null_pointer_checks,

5801

options::OPT_fno_delete_null_pointer_checks);

5805 if

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

5806 if

(!Triple.isOSAIX() || Triple.isPPC32())

5807 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5808

<< A->getSpelling() << RawTriple.str();

5809

CmdArgs.push_back(

"-mabi=quadword-atomics"

);

5812 if

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

5815 if

(Triple.isOSAIX())

5816 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5817

<< A->getSpelling() << RawTriple.str();

5820 if

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

5821

StringRef

= A->getValue(), V1 =

;

5823 if

(V1.consumeInteger(10, Size) || !V1.empty())

5824 D

.Diag(diag::err_drv_invalid_argument_to_option)

5825

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

5827

CmdArgs.push_back(Args.MakeArgString(

"-fwarn-stack-size="

));

5830

Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables,

5831

options::OPT_fno_jump_tables);

5832

Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate,

5833

options::OPT_fno_profile_sample_accurate);

5834

Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments,

5835

options::OPT_fno_preserve_as_comments);

5837 if

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

5838

CmdArgs.push_back(

"-mregparm"

);

5839

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

5842 if

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

5843

options::OPT_msvr4_struct_return)) {

5845 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5846

<< A->getSpelling() << RawTriple.str();

5847

}

else if

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

5848

CmdArgs.push_back(

"-maix-struct-return"

);

5850

assert(A->getOption().matches(options::OPT_msvr4_struct_return));

5851

CmdArgs.push_back(

"-msvr4-struct-return"

);

5855 if

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

5856

options::OPT_freg_struct_return)) {

5857 if

(TC.

() != llvm::Triple::x86) {

5858 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5859

<< A->getSpelling() << RawTriple.str();

5860

}

else if

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

5861

CmdArgs.push_back(

"-fpcc-struct-return"

);

5863

assert(A->getOption().matches(options::OPT_freg_struct_return));

5864

CmdArgs.push_back(

"-freg-struct-return"

);

5868 if

(Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,

false

)) {

5869 if

(Triple.getArch() == llvm::Triple::m68k)

5870

CmdArgs.push_back(

"-fdefault-calling-conv=rtdcall"

);

5872

CmdArgs.push_back(

"-fdefault-calling-conv=stdcall"

);

5875 if

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

5877

CmdArgs.push_back(

"-fenable-matrix"

);

5878

CmdArgs.push_back(

"-mllvm"

);

5879

CmdArgs.push_back(

"-enable-matrix"

);

5884 const char

*FPKeepKindStr =

nullptr

;

5885 switch

(FPKeepKind) {

5887

FPKeepKindStr =

"-mframe-pointer=none"

;

5890

FPKeepKindStr =

"-mframe-pointer=reserved"

;

5893

FPKeepKindStr =

"-mframe-pointer=non-leaf"

;

5896

FPKeepKindStr =

"-mframe-pointer=all"

;

5899

assert(FPKeepKindStr &&

"unknown FramePointerKind"

);

5900

CmdArgs.push_back(FPKeepKindStr);

5902

Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,

5903

options::OPT_fno_zero_initialized_in_bss);

5907 D

.Diag(diag::warn_drv_deprecated_arg_ofast);

5910

OptSpecifier StrictAliasingAliasOption =

5911

OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;

5914 if

(!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,

5915

options::OPT_fno_strict_aliasing, !IsWindowsMSVC))

5916

CmdArgs.push_back(

"-relaxed-aliasing"

);

5917 if

(Args.hasFlag(options::OPT_fno_pointer_tbaa, options::OPT_fpointer_tbaa,

5919

CmdArgs.push_back(

"-no-pointer-tbaa"

);

5920 if

(!Args.hasFlag(options::OPT_fstruct_path_tbaa,

5921

options::OPT_fno_struct_path_tbaa,

true

))

5922

CmdArgs.push_back(

"-no-struct-path-tbaa"

);

5923

Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums,

5924

options::OPT_fno_strict_enums);

5925

Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return,

5926

options::OPT_fno_strict_return);

5927

Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders,

5928

options::OPT_fno_allow_editor_placeholders);

5929

Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers,

5930

options::OPT_fno_strict_vtable_pointers);

5931

Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables,

5932

options::OPT_fno_force_emit_vtables);

5933

Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls,

5934

options::OPT_fno_optimize_sibling_calls);

5935

Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,

5936

options::OPT_fno_escaping_block_tail_calls);

5938

Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,

5939

options::OPT_fno_fine_grained_bitfield_accesses);

5941

Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,

5942

options::OPT_fno_experimental_relative_cxx_abi_vtables);

5944

Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,

5945

options::OPT_fno_experimental_omit_vtable_rtti);

5947

Args.AddLastArg(CmdArgs, options::OPT_fdisable_block_signature_string,

5948

options::OPT_fno_disable_block_signature_string);

5951

Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,

5952

options::OPT_fno_split_stack);

5955 if

(Args.hasFlag(options::OPT_fprotect_parens,

5956

options::OPT_fno_protect_parens,

false

))

5957

CmdArgs.push_back(

"-fprotect-parens"

);

5961 if

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

5962 const

llvm::Triple::ArchType Arch = TC.

();

5963 if

(Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {

5964

StringRef

= A->getValue();

5966

CmdArgs.push_back(

"-fextend-arguments=64"

);

5967 else if

(

"32"

)

5968 D

.Diag(diag::err_drv_invalid_argument_to_option)

5969

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

5971 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5972

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

5975 if

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

5976 if

(TC.

() == llvm::Triple::avr)

5977

A->render(Args, CmdArgs);

5979 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5980

<< A->getAsString(Args) << TripleStr;

5983 if

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

5985

A->render(Args, CmdArgs);

5987

(A->getOption().getID() != options::OPT_mlong_double_80))

5988

A->render(Args, CmdArgs);

5990 D

.Diag(diag::err_drv_unsupported_opt_for_target)

5991

<< A->getAsString(Args) << TripleStr;

5997 if

(!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,

5998

IsIntegratedAssemblerDefault))

5999

CmdArgs.push_back(

"-fno-verbose-asm"

);

6003 if

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

6004

StringRef

= A->getValue();

6007

A->render(Args, CmdArgs);

6008 else if

.consumeInteger(10,

Num

) &&

Num

> 0 &&

6009

(

.empty() || (

.consume_front(

"."

) &&

6010

.consumeInteger(10,

Num

) &&

.empty())))

6011

A->render(Args, CmdArgs);

6013 D

.Diag(diag::err_drv_invalid_argument_to_option)

6014

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

6020

CmdArgs.push_back(

"-no-integrated-as"

);

6022 if

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

6023

CmdArgs.push_back(

"-mdebug-pass"

);

6024

CmdArgs.push_back(

"Structure"

);

6026 if

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

6027

CmdArgs.push_back(

"-mdebug-pass"

);

6028

CmdArgs.push_back(

"Arguments"

);

6034 if

(!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())

6035

CmdArgs.push_back(

"-mconstructor-aliases"

);

6039 if

(KernelOrKext && RawTriple.isOSDarwin())

6040

CmdArgs.push_back(

"-fforbid-guard-variables"

);

6042 if

(Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,

6043

Triple.isWindowsGNUEnvironment())) {

6044

CmdArgs.push_back(

"-mms-bitfields"

);

6047 if

(Triple.isWindowsGNUEnvironment()) {

6048

Args.addOptOutFlag(CmdArgs, options::OPT_fauto_import,

6049

options::OPT_fno_auto_import);

6052 if

(Args.hasFlag(options::OPT_fms_volatile, options::OPT_fno_ms_volatile,

6053

Triple.isX86() && IsWindowsMSVC))

6054

CmdArgs.push_back(

"-fms-volatile"

);

6059 if

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

6060

options::OPT_fno_direct_access_external_data)) {

6061 if

(A->getOption().matches(options::OPT_fdirect_access_external_data) !=

6063

A->render(Args, CmdArgs);

6064

}

else if

(PICLevel == 0 && Triple.isLoongArch()) {

6067

CmdArgs.push_back(

"-fno-direct-access-external-data"

);

6070 if

(Triple.isOSBinFormatELF() && (Triple.isAArch64() || Triple.isX86()))

6071

Args.addOptOutFlag(CmdArgs, options::OPT_fplt, options::OPT_fno_plt);

6077

Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,

false

) ||

6080

CmdArgs.push_back(

"-ffreestanding"

);

6082

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

6089 bool

IsAsyncUnwindTablesDefault =

6091 bool

IsSyncUnwindTablesDefault =

6094 bool

AsyncUnwindTables = Args.hasFlag(

6095

options::OPT_fasynchronous_unwind_tables,

6096

options::OPT_fno_asynchronous_unwind_tables,

6097

(IsAsyncUnwindTablesDefault || SanitizeArgs.needsUnwindTables()) &&

6100

Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,

6101

IsSyncUnwindTablesDefault && !Freestanding);

6102 if

(AsyncUnwindTables)

6103

CmdArgs.push_back(

"-funwind-tables=2"

);

6104 else if

(UnwindTables)

6105

CmdArgs.push_back(

"-funwind-tables=1"

);

6109 if

(!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&

6110

(IsCudaDevice || IsHIPDevice || IsSYCLDevice)) {

6111 const

ArgList &HostArgs =

6113

std::string HostCPU =

6115 if

(!HostCPU.empty()) {

6116

CmdArgs.push_back(

"-aux-target-cpu"

);

6117

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

6125 addMCModel

(

, Args, Triple, RelocationModel, CmdArgs);

6127 if

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

6128

StringRef

= A->getValue();

6129 unsigned

TLSSize = 0;

6130 Value

.getAsInteger(10, TLSSize);

6131 if

(!Triple.isAArch64() || !Triple.isOSBinFormatELF())

6132 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6133

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

6134 if

(TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)

6135 D

.Diag(diag::err_drv_invalid_int_value)

6136

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

;

6137

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

6141

CmdArgs.push_back(

"-enable-tlsdesc"

);

6144

std::string CPU =

getCPUName

(

, Args, Triple,

false

);

6146

CmdArgs.push_back(

"-target-cpu"

);

6147

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

6150

RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);

6155

AddClangCLArgs(Args, InputType, CmdArgs);

6157

llvm::codegenoptions::DebugInfoKind DebugInfoKind =

6158

llvm::codegenoptions::NoDebugInfo;

6161

CmdArgs, Output, DebugInfoKind, DwarfFission);

6168

TC.

().isOSBinFormatCOFF()) &&

6169

(isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||

6170

isa<BackendJobAction>(JA));

6172 const char

*SplitDWARFOut =

SplitDebugName

(JA, Args, Input, Output);

6173

CmdArgs.push_back(

"-split-dwarf-file"

);

6174

CmdArgs.push_back(SplitDWARFOut);

6176

CmdArgs.push_back(

"-split-dwarf-output"

);

6177

CmdArgs.push_back(SplitDWARFOut);

6182 if

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

6183

CmdArgs.push_back(

"-target-linker-version"

);

6184

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

6189 if

(!Args.hasArg(options::OPT_fallow_unsupported)) {

6191 if

(

types::isCXX

(InputType) && RawTriple.isOSDarwin() &&

6192

TC.

() == llvm::Triple::x86) {

6193 if

((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||

6194

(Unsupported = Args.getLastArg(options::OPT_mkernel)))

6195 D

.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)

6196

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

6199 if

((Unsupported = Args.getLastArg(options::OPT_faltivec)))

6200 D

.Diag(diag::err_drv_clang_unsupported_opt_faltivec)

6201

<< Unsupported->getOption().getName()

6202

"please use -maltivec and include altivec.h explicitly"

;

6203 if

((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))

6204 D

.Diag(diag::err_drv_clang_unsupported_opt_faltivec)

6205

<< Unsupported->getOption().getName() <<

"please use -mno-altivec"

;

6208

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

6210 if

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

6211

CmdArgs.push_back(

"-H"

);

6212

CmdArgs.push_back(

"-sys-header-deps"

);

6214

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

6216 if

(

.CCPrintHeadersFormat && !

.CCGenDiagnostics) {

6217

CmdArgs.push_back(

"-header-include-file"

);

6218

CmdArgs.push_back(!

.CCPrintHeadersFilename.empty()

6219

.CCPrintHeadersFilename.c_str()

6221

CmdArgs.push_back(

"-sys-header-deps"

);

6222

CmdArgs.push_back(Args.MakeArgString(

6223 "-header-include-format="

6226

Args.MakeArgString(

"-header-include-filtering="

6228 D

.CCPrintHeadersFiltering))));

6230

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

6231

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

6233 if

(

.CCLogDiagnostics && !

.CCGenDiagnostics) {

6234

CmdArgs.push_back(

"-diagnostic-log-file"

);

6235

CmdArgs.push_back(!

.CCLogDiagnosticsFilename.empty()

6236

.CCLogDiagnosticsFilename.c_str()

6242 if

(

.CCGenDiagnostics)

6243

CmdArgs.push_back(

"-disable-pragma-debug-crash"

);

6247 if

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

6248

StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir);

6249

CmdArgs.push_back(

"-mllvm"

);

6250

CmdArgs.push_back(Args.MakeArgString(

"-crash-diagnostics-dir="

+ Dir));

6255 if

(Args.hasFlag(options::OPT_ffunction_sections,

6256

options::OPT_fno_function_sections, UseSeparateSections)) {

6257

CmdArgs.push_back(

"-ffunction-sections"

);

6260 if

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

6261

options::OPT_fno_basic_block_address_map)) {

6262 if

((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF()) {

6263 if

(A->getOption().matches(options::OPT_fbasic_block_address_map))

6264

A->render(Args, CmdArgs);

6266 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6267

<< A->getAsString(Args) << TripleStr;

6271 if

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

6272

StringRef Val = A->getValue();

6273 if

(Val ==

"labels"

) {

6274 D

.Diag(diag::warn_drv_deprecated_arg)

6275

<< A->getAsString(Args) <<

true 6276

"-fbasic-block-address-map"

;

6277

CmdArgs.push_back(

"-fbasic-block-address-map"

);

6278

}

else if

(Triple.isX86() && Triple.isOSBinFormatELF()) {

6279 if

(Val !=

"all"

&& Val !=

"none"

&& !Val.starts_with(

"list="

))

6280 D

.Diag(diag::err_drv_invalid_value)

6281

<< A->getAsString(Args) << A->getValue();

6283

A->render(Args, CmdArgs);

6284

}

else if

(Triple.isAArch64() && Triple.isOSBinFormatELF()) {

6287 if

(Val !=

"labels"

&& Val !=

"none"

&& !Val.starts_with(

"list="

))

6288 D

.Diag(diag::err_drv_invalid_value)

6289

<< A->getAsString(Args) << A->getValue();

6291

A->render(Args, CmdArgs);

6292

}

else if

(Triple.isNVPTX()) {

6295

}

else if

(Val !=

"none"

) {

6298 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6299

<< A->getAsString(Args) << TripleStr;

6303 bool

HasDefaultDataSections = Triple.isOSBinFormatXCOFF();

6304 if

(Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,

6305

UseSeparateSections || HasDefaultDataSections)) {

6306

CmdArgs.push_back(

"-fdata-sections"

);

6309

Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names,

6310

options::OPT_fno_unique_section_names);

6311

Args.addOptInFlag(CmdArgs, options::OPT_fseparate_named_sections,

6312

options::OPT_fno_separate_named_sections);

6313

Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names,

6314

options::OPT_fno_unique_internal_linkage_names);

6315

Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names,

6316

options::OPT_fno_unique_basic_block_section_names);

6318 if

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

6319

options::OPT_fno_split_machine_functions)) {

6320 if

(!A->getOption().matches(options::OPT_fno_split_machine_functions)) {

6322 if

((Triple.isX86() || Triple.isAArch64()) && Triple.isOSBinFormatELF())

6323

A->render(Args, CmdArgs);

6325 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6326

<< A->getAsString(Args) << TripleStr;

6330

Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,

6331

options::OPT_finstrument_functions_after_inlining,

6332

options::OPT_finstrument_function_entry_bare);

6333

Args.AddLastArg(CmdArgs, options::OPT_fconvergent_functions,

6334

options::OPT_fno_convergent_functions);

6339 if

(!Triple.isNVPTX() && !Triple.isAMDGCN())

6342

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

6345

Args.hasArg(options::OPT_fsample_profile_use_profi)) {

6346

CmdArgs.push_back(

"-mllvm"

);

6347

CmdArgs.push_back(

"-sample-profile-use-profi"

);

6351 if

(RawTriple.isPS() &&

6352

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

6358 if

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

6359

CmdArgs.push_back(

"-nostdsysteminc"

);

6360

CmdArgs.push_back(

"-nobuiltininc"

);

6362 if

(Args.hasArg(options::OPT_nostdlibinc))

6363

CmdArgs.push_back(

"-nostdsysteminc"

);

6364

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

6365

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

6369

CmdArgs.push_back(

"-resource-dir"

);

6370

CmdArgs.push_back(

.ResourceDir.c_str());

6372

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

6379

AddPreprocessingOptions(

, JA,

, Args, CmdArgs, Output, Inputs);

6385

Args.ClaimAllArgs(options::OPT_D);

6388 if

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

6389 if

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

6390

CmdArgs.push_back(

"-O3"

);

6391 D

.Diag(diag::warn_O4_is_O3);

6393

A->render(Args, CmdArgs);

6398 for

(

const

Arg *A :

6399

Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {

6400 D

.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);

6404 for

(

const

Arg *A :

6405

Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {

6406 D

.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);

6412

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

6414 for

(

const

Arg *A :

6415

Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {

6417 if

(A->getOption().getID() == options::OPT__SLASH_wd) {

6418 unsigned

WarningNumber;

6419 if

(StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {

6420 D

.Diag(diag::err_drv_invalid_int_value)

6421

<< A->getAsString(Args) << A->getValue();

6426

CmdArgs.push_back(Args.MakeArgString(

6431

A->render(Args, CmdArgs);

6434

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

6436 if

(Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,

false

))

6437

CmdArgs.push_back(

"-pedantic"

);

6438

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

6439

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

6441

Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,

6442

options::OPT_fno_fixed_point);

6444 if

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

6445

A->render(Args, CmdArgs);

6447

Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,

6448

options::OPT_fno_experimental_relative_cxx_abi_vtables);

6450

Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,

6451

options::OPT_fno_experimental_omit_vtable_rtti);

6453 if

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

6454

A->render(Args, CmdArgs);

6461 bool

ImplyVCPPCVer =

false

;

6462 bool

ImplyVCPPCXXVer =

false

;

6463 const

Arg *

= Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);

6465 if

(

->getOption().matches(options::OPT_ansi))

6467

CmdArgs.push_back(

"-std=c++98"

);

6469

CmdArgs.push_back(

"-std=c89"

);

6471 Std

->render(Args, CmdArgs);

6474 if

(Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,

6475

options::OPT_ftrigraphs,

6476

options::OPT_fno_trigraphs))

6478

A->render(Args, CmdArgs);

6487 if

(!Args.hasArg(options::OPT__SLASH_std)) {

6488

Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,

"-std="

6491

ImplyVCPPCVer =

true

;

6493 else if

(IsWindowsMSVC)

6494

ImplyVCPPCXXVer =

true

;

6496

Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,

6497

options::OPT_fno_trigraphs);

6513

Args.getLastArg(options::OPT_Wwrite_strings,

6514

options::OPT_Wno_write_strings, options::OPT_w);

6516

WriteStrings->getOption().matches(options::OPT_Wwrite_strings))

6517

CmdArgs.push_back(

"-fconst-strings"

);

6524

Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,

6526

CmdArgs.push_back(

"-fdeprecated-macro"

);

6530 if

(Arg *

Asm

= Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {

6531 if

(

Asm

->getOption().matches(options::OPT_fasm))

6532

CmdArgs.push_back(

"-fgnu-keywords"

);

6534

CmdArgs.push_back(

"-fno-gnu-keywords"

);

6538

CmdArgs.push_back(

"-fno-autolink"

);

6540

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

6541

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

6542

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

6543

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

6545

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

6547 if

(Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))

6548

CmdArgs.push_back(

"-fexperimental-new-constant-interpreter"

);

6550 if

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

6551

CmdArgs.push_back(

"-fbracket-depth"

);

6552

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

6555 if

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

6556

options::OPT_Wlarge_by_value_copy_def)) {

6557 if

(A->getNumValues()) {

6558

StringRef

bytes

= A->getValue();

6559

CmdArgs.push_back(Args.MakeArgString(

"-Wlarge-by-value-copy="

bytes

));

6561

CmdArgs.push_back(

"-Wlarge-by-value-copy=64"

);

6564 if

(Args.hasArg(options::OPT_relocatable_pch))

6565

CmdArgs.push_back(

"-relocatable-pch"

);

6567 if

(

const

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

6568 static const char

*kCFABIs[] = {

6569 "standalone"

"objc"

"swift"

"swift-5.0"

"swift-4.2"

"swift-4.1"

6572 if

(!llvm::is_contained(kCFABIs, StringRef(A->getValue())))

6573 D

.Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();

6575

A->render(Args, CmdArgs);

6578 if

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

6579

CmdArgs.push_back(

"-fconstant-string-class"

);

6580

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

6583 if

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

6584

CmdArgs.push_back(

"-ftabstop"

);

6585

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

6588

Args.addOptInFlag(CmdArgs, options::OPT_fstack_size_section,

6589

options::OPT_fno_stack_size_section);

6591 if

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

6592

CmdArgs.push_back(

"-stack-usage-file"

);

6594 if

(Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {

6596

llvm::sys::path::replace_extension(OutputFilename,

"su"

);

6597

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

6603

CmdArgs.push_back(

"-ferror-limit"

);

6604 if

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

6605

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

6607

CmdArgs.push_back(

"19"

);

6609

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

6610

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

6611

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

6612

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

6613

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

6616 unsigned

MessageLength = 0;

6617 if

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

6618

StringRef

(A->getValue());

6619 if

(

.getAsInteger(0, MessageLength))

6620 D

.Diag(diag::err_drv_invalid_argument_to_option)

6621

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

6625

MessageLength = llvm::sys::Process::StandardErrColumns();

6627 if

(MessageLength != 0)

6629

Args.MakeArgString(

"-fmessage-length="

+ Twine(MessageLength)));

6631 if

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

6633

Args.MakeArgString(

"-frandomize-layout-seed="

+ Twine(A->getValue(0))));

6635 if

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

6636

CmdArgs.push_back(Args.MakeArgString(

"-frandomize-layout-seed-file="

6637

Twine(A->getValue(0))));

6640 if

(

const

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

6641

options::OPT_fvisibility_ms_compat)) {

6642 if

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

6643

A->render(Args, CmdArgs);

6645

assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));

6646

CmdArgs.push_back(

"-fvisibility=hidden"

);

6647

CmdArgs.push_back(

"-ftype-visibility=default"

);

6649

}

else if

(IsOpenMPDevice) {

6653

CmdArgs.push_back(

"-fvisibility=protected"

);

6657 if

(!RawTriple.isPS()) {

6659

Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,

6660

options::OPT_fno_visibility_from_dllstorageclass)) {

6661 if

(A->getOption().matches(

6662

options::OPT_fvisibility_from_dllstorageclass)) {

6663

CmdArgs.push_back(

"-fvisibility-from-dllstorageclass"

);

6664

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

6665

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

6666

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

6667

Args.AddLastArg(CmdArgs,

6668

options::OPT_fvisibility_externs_nodllstorageclass_EQ);

6673 if

(Args.hasFlag(options::OPT_fvisibility_inlines_hidden,

6674

options::OPT_fno_visibility_inlines_hidden,

false

))

6675

CmdArgs.push_back(

"-fvisibility-inlines-hidden"

);

6677

Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,

6678

options::OPT_fno_visibility_inlines_hidden_static_local_var);

6683

Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) {

6684 D

.Diag(diag::warn_drv_deprecated_arg)

6685

<< A->getAsString(Args) <<

true 6686

"-fvisibility-global-new-delete=force-hidden"

;

6690

Args.getLastArg(options::OPT_fvisibility_global_new_delete_EQ,

6691

options::OPT_fvisibility_global_new_delete_hidden)) {

6692 if

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

6693

A->render(Args, CmdArgs);

6695

assert(A->getOption().matches(

6696

options::OPT_fvisibility_global_new_delete_hidden));

6697

CmdArgs.push_back(

"-fvisibility-global-new-delete=force-hidden"

);

6701

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

6703 if

(Args.hasFlag(options::OPT_fnew_infallible,

6704

options::OPT_fno_new_infallible,

false

))

6705

CmdArgs.push_back(

"-fnew-infallible"

);

6707 if

(Args.hasFlag(options::OPT_fno_operator_names,

6708

options::OPT_foperator_names,

false

))

6709

CmdArgs.push_back(

"-fno-operator-names"

);

6712

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

6713

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

6714

Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);

6715

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

6716

Args.AddLastArg(CmdArgs, options::OPT_fraw_string_literals,

6717

options::OPT_fno_raw_string_literals);

6719 if

(Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,

6720

Triple.hasDefaultEmulatedTLS()))

6721

CmdArgs.push_back(

"-femulated-tls"

);

6723

Args.addOptInFlag(CmdArgs, options::OPT_fcheck_new,

6724

options::OPT_fno_check_new);

6726 if

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

6730 if

(!Triple.isX86() && !Triple.isAArch64())

6731 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6732

<< A->getAsString(Args) << TripleStr;

6736 if

(!isa<PreprocessJobAction>(JA) || Output.

() != types::TY_PP_Asm)

6737

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

6739

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

6740

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

6744 if

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

6745

options::OPT_fno_openmp,

false

) &&

6746

!Args.hasFlag(options::OPT_foffload_via_llvm,

6747

options::OPT_fno_offload_via_llvm,

false

) &&

6750 switch

(

.getOpenMPRuntime(Args)) {

6754

CmdArgs.push_back(

"-fopenmp"

);

6759 if

(!Args.hasFlag(options::OPT_fopenmp_use_tls,

6760

options::OPT_fnoopenmp_use_tls,

true

))

6761

CmdArgs.push_back(

"-fnoopenmp-use-tls"

);

6762

Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,

6763

options::OPT_fno_openmp_simd);

6764

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

6765

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

6766 if

(!Args.hasFlag(options::OPT_fopenmp_extensions,

6767

options::OPT_fno_openmp_extensions,

true

))

6768

CmdArgs.push_back(

"-fno-openmp-extensions"

);

6769

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

6770

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

6771

Args.AddAllArgs(CmdArgs,

6772

options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);

6773 if

(Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,

6774

options::OPT_fno_openmp_optimistic_collapse,

6776

CmdArgs.push_back(

"-fopenmp-optimistic-collapse"

);

6780 if

(Args.hasFlag(options::OPT_fopenmp_cuda_mode,

6781

options::OPT_fno_openmp_cuda_mode,

false

))

6782

CmdArgs.push_back(

"-fopenmp-cuda-mode"

);

6785

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

6786 if

(Args.hasFlag(options::OPT_fopenmp_target_debug,

6787

options::OPT_fno_openmp_target_debug,

false

))

6788

CmdArgs.push_back(

"-fopenmp-target-debug"

);

6792 if

(Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription,

6793

options::OPT_fno_openmp_assume_teams_oversubscription,

6795

CmdArgs.push_back(

"-fopenmp-assume-teams-oversubscription"

);

6796 if

(Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription,

6797

options::OPT_fno_openmp_assume_threads_oversubscription,

6799

CmdArgs.push_back(

"-fopenmp-assume-threads-oversubscription"

);

6800 if

(Args.hasArg(options::OPT_fopenmp_assume_no_thread_state))

6801

CmdArgs.push_back(

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

);

6802 if

(Args.hasArg(options::OPT_fopenmp_assume_no_nested_parallelism))

6803

CmdArgs.push_back(

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

);

6804 if

(Args.hasArg(options::OPT_fopenmp_offload_mandatory))

6805

CmdArgs.push_back(

"-fopenmp-offload-mandatory"

);

6806 if

(Args.hasArg(options::OPT_fopenmp_force_usm))

6807

CmdArgs.push_back(

"-fopenmp-force-usm"

);

6819

Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,

6820

options::OPT_fno_openmp_simd);

6821

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

6822

Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions,

6823

options::OPT_fno_openmp_extensions);

6828 if

(Args.hasFlag(options::OPT_foffload_via_llvm,

6829

options::OPT_fno_offload_via_llvm,

false

)) {

6830

CmdArgs.append({

"--offload-new-driver"

"-foffload-via-llvm"

});

6831

}

else if

(Args.hasFlag(options::OPT_offload_new_driver,

6832

options::OPT_no_offload_new_driver,

6834

CmdArgs.push_back(

"--offload-new-driver"

);

6838

XRay.

addArgs

(TC, Args, CmdArgs, InputType);

6841

Args.getAllArgValues(options::OPT_fprofile_list_EQ)) {

6843

CmdArgs.push_back(Args.MakeArgString(

"-fprofile-list="

Filename

));

6845 D

.Diag(clang::diag::err_drv_no_such_file) <<

Filename

;

6848 if

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

6849

StringRef S0 = A->getValue(), S = S0;

6850 unsigned

Size, Offset = 0;

6851 if

(!Triple.isAArch64() && !Triple.isLoongArch() && !Triple.isRISCV() &&

6853

!(!Triple.isOSAIX() && (Triple.getArch() == llvm::Triple::ppc ||

6854

Triple.getArch() == llvm::Triple::ppc64)))

6855 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6856

<< A->getAsString(Args) << TripleStr;

6857 else if

(S.consumeInteger(10, Size) ||

6858

(!S.empty() && (!S.consume_front(

","

) ||

6859

S.consumeInteger(10, Offset) || !S.empty())))

6860 D

.Diag(diag::err_drv_invalid_argument_to_option)

6861

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

6862 else if

(Size < Offset)

6863 D

.Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);

6865

CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));

6866

CmdArgs.push_back(Args.MakeArgString(

6867 "-fpatchable-function-entry-offset="

+ Twine(Offset)));

6871

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

6874

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

6876

llvm::Triple::ArchType Arch = TC.

();

6877 if

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

6878 if

(Arch == llvm::Triple::systemz || TC.

().isX86())

6879

A->render(Args, CmdArgs);

6881 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6882

<< A->getAsString(Args) << TripleStr;

6884 if

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

6885 if

(Arch == llvm::Triple::systemz)

6886

A->render(Args, CmdArgs);

6888 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6889

<< A->getAsString(Args) << TripleStr;

6891 if

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

6892 if

(Arch == llvm::Triple::systemz)

6893

A->render(Args, CmdArgs);

6895 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6896

<< A->getAsString(Args) << TripleStr;

6900 if

(Arg *A = Args.getLastArgNoClaim(options::OPT_pg)) {

6902 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6903

<< A->getAsString(Args) << TripleStr;

6906 if

(Arg *A = Args.getLastArgNoClaim(options::OPT_p)) {

6908 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6909

<< A->getAsString(Args) << TripleStr;

6912 if

(Arg *A = Args.getLastArgNoClaim(options::OPT_p, options::OPT_pg)) {

6913 if

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

6915 if

(TC.

().isOSAIX() && !Args.hasArgNoClaim(options::OPT_pg))

6916

CmdArgs.push_back(

"-pg"

);

6922 for

(

const

Arg *A : Args.filtered(options::OPT_b, options::OPT_K,

6923

options::OPT_mxcoff_build_id_EQ)) {

6924 D

.Diag(diag::err_drv_unsupported_opt_for_target)

6925

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

6929 if

(Args.getLastArg(options::OPT_fapple_kext) ||

6930

(Args.hasArg(options::OPT_mkernel) &&

types::isCXX

(InputType)))

6931

CmdArgs.push_back(

"-fapple-kext"

);

6933

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

6934

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

6935

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

6936

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

6937

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

6938

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

6939

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

6940

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

6941

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

6942

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

6944 if

(

const char

*Name =

.getTimeTraceFile(&JA)) {

6945

CmdArgs.push_back(Args.MakeArgString(

"-ftime-trace="

+ Twine(Name)));

6946

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

6947

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

6950 if

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

6951

CmdArgs.push_back(

"-ftrapv-handler"

);

6952

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

6955

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

6961

Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,

6962

options::OPT_fno_finite_loops);

6964

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

6965

Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,

6966

options::OPT_fno_unroll_loops);

6968

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

6970

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

6972

Args.addOptInFlag(CmdArgs, options::OPT_mspeculative_load_hardening,

6973

options::OPT_mno_speculative_load_hardening);

6979

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

6981

Args.addOptInFlag(CmdArgs, options::OPT_mstackrealign,

6982

options::OPT_mno_stackrealign);

6984 if

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

6985

StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);

6986

CmdArgs.push_back(Args.MakeArgString(

"-mstack-alignment="

+ alignment));

6989 if

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

6990

StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);

6993

CmdArgs.push_back(Args.MakeArgString(

"-mstack-probe-size="

+ Size));

6995

CmdArgs.push_back(

"-mstack-probe-size=0"

);

6998

Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,

6999

options::OPT_mno_stack_arg_probe);

7001 if

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

7002

options::OPT_mno_restrict_it)) {

7003 if

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

7004

CmdArgs.push_back(

"-mllvm"

);

7005

CmdArgs.push_back(

"-arm-restrict-it"

);

7007

CmdArgs.push_back(

"-mllvm"

);

7008

CmdArgs.push_back(

"-arm-default-it"

);

7022 if

(Args.hasFlag(options::OPT_fhip_new_launch_api,

7023

options::OPT_fno_hip_new_launch_api,

true

))

7024

CmdArgs.push_back(

"-fhip-new-launch-api"

);

7025

Args.addOptInFlag(CmdArgs, options::OPT_fgpu_allow_device_init,

7026

options::OPT_fno_gpu_allow_device_init);

7027

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

7028

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

7029

Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,

7030

options::OPT_fno_hip_kernel_arg_name);

7033 if

(IsCuda || IsHIP) {

7035

CmdArgs.push_back(

"-fgpu-rdc"

);

7036

Args.addOptInFlag(CmdArgs, options::OPT_fgpu_defer_diag,

7037

options::OPT_fno_gpu_defer_diag);

7038 if

(Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads,

7039

options::OPT_fno_gpu_exclude_wrong_side_overloads,

7041

CmdArgs.push_back(

"-fgpu-exclude-wrong-side-overloads"

);

7042

CmdArgs.push_back(

"-fgpu-defer-diag"

);

7047 if

(Args.hasArg(options::OPT_nogpulib))

7048

CmdArgs.push_back(

"-nogpulib"

);

7050 if

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

7052

Args.MakeArgString(Twine(

"-fcf-protection="

) + A->getValue()));

7054 if

(Arg *SA = Args.getLastArg(options::OPT_mcf_branch_label_scheme_EQ))

7055

CmdArgs.push_back(Args.MakeArgString(Twine(

"-mcf-branch-label-scheme="

) +

7059 if

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

7061

Args.MakeArgString(Twine(

"-mfunction-return="

) + A->getValue()));

7063

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

7068 if

(!(IsCudaDevice || IsHIPDevice)) {

7070 auto

*PGOArg = Args.getLastArg(

7071

options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,

7072

options::OPT_fcs_profile_generate,

7073

options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use,

7074

options::OPT_fprofile_use_EQ);

7076 D

.Diag(diag::err_drv_argument_not_allowed_with)

7077

"SampleUse with PGO options"

;

7079

StringRef fname = A->getValue();

7080 if

(!llvm::sys::fs::exists(fname))

7081 D

.Diag(diag::err_drv_no_such_file) << fname;

7083

A->render(Args, CmdArgs);

7085

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

7087 if

(Args.hasFlag(options::OPT_fpseudo_probe_for_profiling,

7088

options::OPT_fno_pseudo_probe_for_profiling,

false

)) {

7089

CmdArgs.push_back(

"-fpseudo-probe-for-profiling"

);

7092 if

(Args.hasFlag(options::OPT_funique_internal_linkage_names,

7093

options::OPT_fno_unique_internal_linkage_names,

true

))

7094

CmdArgs.push_back(

"-funique-internal-linkage-names"

);

7099

Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,

7100

options::OPT_fno_assume_sane_operator_new);

7102 if

(Args.hasFlag(options::OPT_fapinotes, options::OPT_fno_apinotes,

false

))

7103

CmdArgs.push_back(

"-fapinotes"

);

7104 if

(Args.hasFlag(options::OPT_fapinotes_modules,

7105

options::OPT_fno_apinotes_modules,

false

))

7106

CmdArgs.push_back(

"-fapinotes-modules"

);

7107

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

7110 if

(Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,

7112

(Args.hasArg(options::OPT_fgnu_runtime) &&

7113

Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&

7114

!Args.hasArg(options::OPT_fno_blocks))) {

7115

CmdArgs.push_back(

"-fblocks"

);

7118

CmdArgs.push_back(

"-fblocks-runtime-optional"

);

7123

CmdArgs.push_back(

"-fencode-extended-block-signature"

);

7125 if

(Args.hasFlag(options::OPT_fcoro_aligned_allocation,

7126

options::OPT_fno_coro_aligned_allocation,

false

) &&

7128

CmdArgs.push_back(

"-fcoro-aligned-allocation"

);

7130

Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,

7131

options::OPT_fno_double_square_bracket_attributes);

7133

Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control,

7134

options::OPT_fno_access_control);

7135

Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors,

7136

options::OPT_fno_elide_constructors);

7142

CmdArgs.push_back(

"-fno-rtti"

);

7145 if

(Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,

7146

TC.

() == llvm::Triple::hexagon || Triple.isOSzOS()))

7147

CmdArgs.push_back(

"-fshort-enums"

);

7153

options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,

7154

!RawTriple.isOSAIX() && !RawTriple.isOSWindows() &&

7155

((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||

7156

RawTriple.hasEnvironment())) ||

7158

CmdArgs.push_back(

"-fno-use-cxa-atexit"

);

7160 if

(Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,

7161

options::OPT_fno_register_global_dtors_with_atexit,

7162

RawTriple.isOSDarwin() && !KernelOrKext))

7163

CmdArgs.push_back(

"-fregister-global-dtors-with-atexit"

);

7165

Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives,

7166

options::OPT_fno_use_line_directives);

7169 if

(Args.hasFlag(options::OPT_fminimize_whitespace,

7170

options::OPT_fno_minimize_whitespace,

false

)) {

7171 types::ID

InputType = Inputs[0].getType();

7172 if

(!isDerivedFromC(InputType))

7173 D

.Diag(diag::err_drv_opt_unsupported_input_type)

7175

CmdArgs.push_back(

"-fminimize-whitespace"

);

7179 if

(Args.hasFlag(options::OPT_fkeep_system_includes,

7180

options::OPT_fno_keep_system_includes,

false

)) {

7181 types::ID

InputType = Inputs[0].getType();

7182 if

(!isDerivedFromC(InputType))

7183 D

.Diag(diag::err_drv_opt_unsupported_input_type)

7185

CmdArgs.push_back(

"-fkeep-system-includes"

);

7189 if

(Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,

7190

IsWindowsMSVC || IsUEFI))

7191

CmdArgs.push_back(

"-fms-extensions"

);

7194 bool

IsMSVCCompat = Args.hasFlag(

7195

options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,

7196

(IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,

7197

options::OPT_fno_ms_extensions,

true

)));

7199

CmdArgs.push_back(

"-fms-compatibility"

);

7201

Args.hasArg(options::OPT_fms_define_stdc))

7202

CmdArgs.push_back(

"-fms-define-stdc"

);

7205 if

(Triple.isWindowsMSVCEnvironment() && !

.IsCLMode() &&

7206

Args.hasArg(options::OPT_fms_runtime_lib_EQ))

7210

VersionTuple GNUCVer;

7211 if

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

7214

StringRef Val = A->getValue();

7215

Val = Val.empty() ?

"0"

: Val;

7216 bool Invalid

= GNUCVer.tryParse(Val);

7217 unsigned

Minor = GNUCVer.getMinor().value_or(0);

7218 unsigned

Patch = GNUCVer.getSubminor().value_or(0);

7219 if

(

Invalid

|| GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {

7220 D

.Diag(diag::err_drv_invalid_value)

7221

<< A->getAsString(Args) << A->getValue();

7223

}

else if

(!IsMSVCCompat) {

7225

GNUCVer = VersionTuple(4, 2, 1);

7227 if

(!GNUCVer.empty()) {

7229

Args.MakeArgString(

"-fgnuc-version="

+ GNUCVer.getAsString()));

7235

Args.MakeArgString(

"-fms-compatibility-version="

+ MSVT.getAsString()));

7237 bool

IsMSVC2015Compatible = MSVT.getMajor() >= 19;

7238 if

(ImplyVCPPCVer) {

7239

StringRef LanguageStandard;

7240 if

(

const

Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {

7242

LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())

7243

.Case(

"c11"

"-std=c11"

)

7244

.Case(

"c17"

"-std=c17"

)

7246 if

(LanguageStandard.empty())

7247 D

.Diag(clang::diag::warn_drv_unused_argument)

7248

<< StdArg->getAsString(Args);

7250

CmdArgs.push_back(LanguageStandard.data());

7252 if

(ImplyVCPPCXXVer) {

7253

StringRef LanguageStandard;

7254 if

(

const

Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {

7256

LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())

7257

.Case(

"c++14"

"-std=c++14"

)

7258

.Case(

"c++17"

"-std=c++17"

)

7259

.Case(

"c++20"

"-std=c++20"

)

7261

.Case(

"c++23preview"

"-std=c++23"

)

7262

.Case(

"c++latest"

"-std=c++26"

)

7264 if

(LanguageStandard.empty())

7265 D

.Diag(clang::diag::warn_drv_unused_argument)

7266

<< StdArg->getAsString(Args);

7269 if

(LanguageStandard.empty()) {

7270 if

(IsMSVC2015Compatible)

7271

LanguageStandard =

"-std=c++14"

;

7273

LanguageStandard =

"-std=c++11"

;

7276

CmdArgs.push_back(LanguageStandard.data());

7279

Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,

7280

options::OPT_fno_borland_extensions);

7283 if

(Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,

7285

CmdArgs.push_back(

"-fdeclspec"

);

7286 else if

(Args.hasArg(options::OPT_fno_declspec))

7287

CmdArgs.push_back(

"-fno-declspec"

);

7291 if

(!Args.hasFlag(options::OPT_fthreadsafe_statics,

7292

options::OPT_fno_threadsafe_statics,

7294

(!IsWindowsMSVC || IsMSVC2015Compatible)))

7295

CmdArgs.push_back(

"-fno-threadsafe-statics"

);

7297 if

(!Args.hasFlag(options::OPT_fms_tls_guards, options::OPT_fno_ms_tls_guards,

7299

CmdArgs.push_back(

"-fno-ms-tls-guards"

);

7302 if

(!Args.hasFlag(options::OPT_fassumptions, options::OPT_fno_assumptions,

7304

CmdArgs.push_back(

"-fno-assumptions"

);

7308

Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,

7309

options::OPT_fno_gnu_keywords);

7311

Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline,

7312

options::OPT_fno_gnu89_inline);

7314 const

Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions,

7315

options::OPT_finline_hint_functions,

7316

options::OPT_fno_inline_functions);

7317 if

(Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) {

7318 if

(A->getOption().matches(options::OPT_fno_inline))

7319

A->render(Args, CmdArgs);

7320

}

else if

(InlineArg) {

7321

InlineArg->render(Args, CmdArgs);

7324

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

7329

(

->containsValue(

"c++2a"

) ||

->containsValue(

"gnu++2a"

) ||

7330 Std

->containsValue(

"c++20"

) ||

->containsValue(

"gnu++20"

) ||

7331 Std

->containsValue(

"c++2b"

) ||

->containsValue(

"gnu++2b"

) ||

7332 Std

->containsValue(

"c++23"

) ||

->containsValue(

"gnu++23"

) ||

7333 Std

->containsValue(

"c++2c"

) ||

->containsValue(

"gnu++2c"

) ||

7334 Std

->containsValue(

"c++26"

) ||

->containsValue(

"gnu++26"

) ||

7335 Std

->containsValue(

"c++latest"

) ||

->containsValue(

"gnu++latest"

));

7350 if

(Args.hasFlag(options::OPT_fdelayed_template_parsing,

7351

options::OPT_fno_delayed_template_parsing,

7352

IsWindowsMSVC && !HaveCxx20)) {

7354 D

.Diag(clang::diag::warn_drv_delayed_template_parsing_after_cxx20);

7356

CmdArgs.push_back(

"-fdelayed-template-parsing"

);

7359 if

(Args.hasFlag(options::OPT_fpch_validate_input_files_content,

7360

options::OPT_fno_pch_validate_input_files_content,

false

))

7361

CmdArgs.push_back(

"-fvalidate-ast-input-files-content"

);

7362 if

(Args.hasFlag(options::OPT_fpch_instantiate_templates,

7363

options::OPT_fno_pch_instantiate_templates,

false

))

7364

CmdArgs.push_back(

"-fpch-instantiate-templates"

);

7365 if

(Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,

7367

CmdArgs.push_back(

"-fmodules-codegen"

);

7368 if

(Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo,

7370

CmdArgs.push_back(

"-fmodules-debuginfo"

);

7372 ObjCRuntime

Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);

7377

Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,

7378

options::OPT_fno_objc_encode_cxx_class_template_spec,

7380

CmdArgs.push_back(

"-fobjc-encode-cxx-class-template-spec"

);

7382 if

(Args.hasFlag(options::OPT_fapplication_extension,

7383

options::OPT_fno_application_extension,

false

))

7384

CmdArgs.push_back(

"-fapplication-extension"

);

7388 if

.getDriver().IsCLMode())

7389

EH =

addExceptionArgs

(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);

7392

Arg *A = Args.getLastArg(

7393

options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,

7394

options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);

7396 const

Option &Opt = A->getOption();

7397 if

(Opt.matches(options::OPT_fsjlj_exceptions))

7398

CmdArgs.push_back(

"-exception-model=sjlj"

);

7399 if

(Opt.matches(options::OPT_fseh_exceptions))

7400

CmdArgs.push_back(

"-exception-model=seh"

);

7401 if

(Opt.matches(options::OPT_fdwarf_exceptions))

7402

CmdArgs.push_back(

"-exception-model=dwarf"

);

7403 if

(Opt.matches(options::OPT_fwasm_exceptions))

7404

CmdArgs.push_back(

"-exception-model=wasm"

);

7409 case

llvm::ExceptionHandling::DwarfCFI:

7410

CmdArgs.push_back(

"-exception-model=dwarf"

);

7412 case

llvm::ExceptionHandling::SjLj:

7413

CmdArgs.push_back(

"-exception-model=sjlj"

);

7415 case

llvm::ExceptionHandling::WinEH:

7416

CmdArgs.push_back(

"-exception-model=seh"

);

7422

Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new,

7423

options::OPT_fno_assume_sane_operator_new);

7426

Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables,

7427

options::OPT_fno_assume_unique_vtables);

7431

Args.addLastArg(CmdArgs, options::OPT_fsized_deallocation,

7432

options::OPT_fno_sized_deallocation);

7436 if

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

7437

options::OPT_fno_aligned_allocation,

7438

options::OPT_faligned_new_EQ)) {

7439 if

(A->getOption().matches(options::OPT_fno_aligned_allocation))

7440

CmdArgs.push_back(

"-fno-aligned-allocation"

);

7442

CmdArgs.push_back(

"-faligned-allocation"

);

7447 if

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

7448

options::OPT_faligned_new_EQ))

7450

Args.MakeArgString(Twine(

"-fnew-alignment="

) + A->getValue()));

7454 if

(!Args.hasFlag(options::OPT_fconstant_cfstrings,

7455

options::OPT_fno_constant_cfstrings,

true

) ||

7456

!Args.hasFlag(options::OPT_mconstant_cfstrings,

7457

options::OPT_mno_constant_cfstrings,

true

))

7458

CmdArgs.push_back(

"-fno-constant-cfstrings"

);

7460

Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings,

7461

options::OPT_fno_pascal_strings);

7465 if

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

7466

std::string PackStructStr =

"-fpack-struct="

;

7467

PackStructStr += A->getValue();

7468

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

7469

}

else if

(Args.hasFlag(options::OPT_fpack_struct,

7470

options::OPT_fno_pack_struct,

false

)) {

7471

CmdArgs.push_back(

"-fpack-struct=1"

);

7475 bool

SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);

7476 if

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

7477 if

(!SkipMaxTypeAlign) {

7478

std::string MaxTypeAlignStr =

"-fmax-type-align="

;

7479

MaxTypeAlignStr += A->getValue();

7480

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

7482

}

else if

(RawTriple.isOSDarwin()) {

7483 if

(!SkipMaxTypeAlign) {

7484

std::string MaxTypeAlignStr =

"-fmax-type-align=16"

;

7485

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

7489 if

(!Args.hasFlag(options::OPT_Qy, options::OPT_Qn,

true

))

7490

CmdArgs.push_back(

"-Qn"

);

7493

Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);

7497 if

(!Args.hasFlag(options::OPT_fsigned_bitfields,

7498

options::OPT_funsigned_bitfields,

true

))

7499 D

.Diag(diag::warn_drv_clang_unsupported)

7500

<< Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);

7503 if

(!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope,

true

))

7504 D

.Diag(diag::err_drv_clang_unsupported)

7505

<< Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);

7508 if

(Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {

7509

StringRef value = inputCharset->getValue();

7510 if

(!value.equals_insensitive(

"utf-8"

))

7511 D

.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)

7516 if

(Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {

7517

StringRef value = execCharset->getValue();

7518 if

(!value.equals_insensitive(

"utf-8"

))

7519 D

.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)

7525

Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks,

7526

options::OPT_fno_asm_blocks);

7528

Args.addOptOutFlag(CmdArgs, options::OPT_fgnu_inline_asm,

7529

options::OPT_fno_gnu_inline_asm);

7535

OptSpecifier VectorizeAliasOption =

7536

EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;

7537 if

(Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,

7538

options::OPT_fno_vectorize, EnableVec))

7539

CmdArgs.push_back(

"-vectorize-loops"

);

7543

OptSpecifier SLPVectAliasOption =

7544

EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;

7545 if

(Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,

7546

options::OPT_fno_slp_vectorize, EnableSLPVec))

7547

CmdArgs.push_back(

"-vectorize-slp"

);

7551

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

7552

Args.AddLastArg(CmdArgs,

7553

options::OPT_fsanitize_undefined_strip_path_components_EQ);

7557 if

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

7558

options::OPT_fno_dollars_in_identifiers)) {

7559 if

(A->getOption().matches(options::OPT_fdollars_in_identifiers))

7560

CmdArgs.push_back(

"-fdollars-in-identifiers"

);

7562

CmdArgs.push_back(

"-fno-dollars-in-identifiers"

);

7565

Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack,

7566

options::OPT_fno_apple_pragma_pack);

7572 bool

RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,

7573

options::OPT_fno_rewrite_imports,

false

);

7575

CmdArgs.push_back(

"-frewrite-imports"

);

7577

Args.addOptInFlag(CmdArgs, options::OPT_fdirectives_only,

7578

options::OPT_fno_directives_only);

7584 if

(Args.hasFlag(options::OPT_frewrite_includes,

7585

options::OPT_fno_rewrite_includes,

false

) ||

7586

(

.isForDiagnostics() && !HaveModules))

7587

CmdArgs.push_back(

"-frewrite-includes"

);

7589 if

(Args.hasFlag(options::OPT_fzos_extensions,

7590

options::OPT_fno_zos_extensions,

false

))

7591

CmdArgs.push_back(

"-fzos-extensions"

);

7592 else if

(Args.hasArg(options::OPT_fno_zos_extensions))

7593

CmdArgs.push_back(

"-fno-zos-extensions"

);

7596 if

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

7597

options::OPT_traditional_cpp)) {

7598 if

(isa<PreprocessJobAction>(JA))

7599

CmdArgs.push_back(

"-traditional-cpp"

);

7601 D

.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);

7604

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

7605

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

7606

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

7608

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

7611 if

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

7612

CmdArgs.push_back(

"-serialize-diagnostic-file"

);

7613

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

7616 if

(Args.hasArg(options::OPT_fretain_comments_from_system_headers))

7617

CmdArgs.push_back(

"-fretain-comments-from-system-headers"

);

7619

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

7622

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

7624

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

7627 for

(

const

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

7628

CmdArgs.push_back(

"-load"

);

7629

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

7641 for

(

const

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

7642 auto

ArgValue = StringRef(A->getValue());

7643 auto

FirstDashIndex = ArgValue.find(

'-'

);

7644

StringRef PluginName = ArgValue.substr(0, FirstDashIndex);

7645

StringRef Arg = ArgValue.substr(FirstDashIndex + 1);

7648 if

(FirstDashIndex == StringRef::npos || Arg.empty()) {

7649 if

(PluginName.empty()) {

7650 D

.Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args);

7652 D

.Diag(diag::warn_drv_missing_plugin_arg)

7653

<< PluginName << A->getAsString(Args);

7658

CmdArgs.push_back(Args.MakeArgString(Twine(

"-plugin-arg-"

) + PluginName));

7659

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

7663 for

(

const

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

7665

Args.MakeArgString(Twine(

"-fpass-plugin="

) + A->getValue()));

7670 for

(

const

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

7671

CmdArgs.push_back(

"--vfsoverlay"

);

7672

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

7676

Args.addOptInFlag(CmdArgs, options::OPT_fsafe_buffer_usage_suggestions,

7677

options::OPT_fno_safe_buffer_usage_suggestions);

7679

Args.addOptInFlag(CmdArgs, options::OPT_fexperimental_late_parse_attributes,

7680

options::OPT_fno_experimental_late_parse_attributes);

7684 if

(!StatsFile.empty()) {

7685

CmdArgs.push_back(Args.MakeArgString(Twine(

"-stats-file="

) + StatsFile));

7686 if

(

.CCPrintInternalStats)

7687

CmdArgs.push_back(

"-stats-file-append"

);

7692 for

(

auto

Arg : Args.filtered(options::OPT_Xclang)) {

7696 if

(

.getDriver().isSaveTempsEnabled() &&

7697

!isa<PreprocessJobAction>(JA)) {

7698 if

(StringRef(Arg->getValue()) ==

"-finclude-default-header"

)

7701

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

7703 for

(

const

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

7709 if

(StringRef(A->getValue(0)) ==

"-disable-llvm-optzns"

) {

7710

CmdArgs.push_back(

"-disable-llvm-optzns"

);

7712

A->render(Args, CmdArgs);

7718

SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType);

7728 if

((

.getDriver().isSaveTempsEnabled() ||

7730

.getDriver().embedBitcodeInObject() && !IsUsingLTO) &&

7731

isa<CompileJobAction>(JA))

7732

CmdArgs.push_back(

"-disable-llvm-passes"

);

7734

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

7736 const char

*Exec =

.getClangProgramPath();

7743 auto

GRecordSwitches =

false

;

7744 auto

FRecordSwitches =

false

;

7748

CmdArgs.push_back(

"-dwarf-debug-flags"

);

7749

CmdArgs.push_back(FlagsArgString);

7751 if

(FRecordSwitches) {

7752

CmdArgs.push_back(

"-record-command-line"

);

7753

CmdArgs.push_back(FlagsArgString);

7760 if

((IsCuda || IsHIP) && CudaDeviceInput) {

7761

CmdArgs.push_back(

"-fcuda-include-gpubinary"

);

7762

CmdArgs.push_back(CudaDeviceInput->

());

7763

}

else if

(!HostOffloadingInputs.empty()) {

7764 if

((IsCuda || IsHIP) && !IsRDCMode) {

7765

assert(HostOffloadingInputs.size() == 1 &&

"Only one input expected"

);

7766

CmdArgs.push_back(

"-fcuda-include-gpubinary"

);

7767

CmdArgs.push_back(HostOffloadingInputs.front().getFilename());

7769 for

(

const InputInfo

Input : HostOffloadingInputs)

7770

CmdArgs.push_back(Args.MakeArgString(

"-fembed-offload-object="

7776 if

(Args.hasFlag(options::OPT_fcuda_short_ptr,

7777

options::OPT_fno_cuda_short_ptr,

false

))

7778

CmdArgs.push_back(

"-fcuda-short-ptr"

);

7781 if

(IsCuda || IsHIP) {

7783 const Action

*SourceAction = &JA;

7785

assert(!SourceAction->

().empty() &&

"unexpected root action!"

);

7786

SourceAction = SourceAction->

()[0];

7788 auto

CUID = cast<InputAction>(SourceAction)->getId();

7790

CmdArgs.push_back(Args.MakeArgString(Twine(

"-cuid="

) + Twine(CUID)));

7794 bool

UseApproxTranscendentals = Args.hasFlag(

7795

options::OPT_ffast_math, options::OPT_fno_fast_math,

false

);

7796 if

(Args.hasFlag(options::OPT_fgpu_approx_transcendentals,

7797

options::OPT_fno_gpu_approx_transcendentals,

7798

UseApproxTranscendentals))

7799

CmdArgs.push_back(

"-fgpu-approx-transcendentals"

);

7801

Args.claimAllArgs(options::OPT_fgpu_approx_transcendentals,

7802

options::OPT_fno_gpu_approx_transcendentals);

7806

CmdArgs.push_back(

"-fcuda-allow-variadic-functions"

);

7807

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

7810

Args.AddAllArgs(CmdArgs,

7811

options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ);

7813

Args.AddLastArg(CmdArgs, options::OPT_foffload_uniform_block,

7814

options::OPT_fno_offload_uniform_block);

7816

Args.AddLastArg(CmdArgs, options::OPT_foffload_implicit_host_device_templates,

7817

options::OPT_fno_offload_implicit_host_device_templates);

7819 if

(IsCudaDevice || IsHIPDevice) {

7820

StringRef InlineThresh =

7821

Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ);

7822 if

(!InlineThresh.empty()) {

7823

std::string ArgStr =

7824

std::string(

"-inline-threshold="

) + InlineThresh.str();

7825

CmdArgs.append({

"-mllvm"

, Args.MakeArgStringRef(ArgStr)});

7830

Args.addOptOutFlag(CmdArgs,

7831

options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,

7832

options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);

7839 if

(IsOpenMPDevice) {

7840

CmdArgs.push_back(

"-fopenmp-is-target-device"

);

7842 if

(Args.hasArg(options::OPT_foffload_via_llvm))

7843

CmdArgs.push_back(

"-fcuda-is-device"

);

7845 if

(OpenMPDeviceInput) {

7846

CmdArgs.push_back(

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

);

7847

CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->

()));

7851 if

(Triple.isAMDGPU()) {

7854

Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics,

7855

options::OPT_mno_unsafe_fp_atomics);

7856

Args.addOptOutFlag(CmdArgs, options::OPT_mamdgpu_ieee,

7857

options::OPT_mno_amdgpu_ieee);

7862 bool

VirtualFunctionElimination =

7863

Args.hasFlag(options::OPT_fvirtual_function_elimination,

7864

options::OPT_fno_virtual_function_elimination,

false

);

7865 if

(VirtualFunctionElimination) {

7869 D

.Diag(diag::err_drv_argument_only_allowed_with)

7870

"-fvirtual-function-elimination" 7873

CmdArgs.push_back(

"-fvirtual-function-elimination"

);

7877 bool

WholeProgramVTables = Args.hasFlag(

7878

options::OPT_fwhole_program_vtables,

7879

options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);

7880 if

(VirtualFunctionElimination && !WholeProgramVTables) {

7881 D

.Diag(diag::err_drv_argument_not_allowed_with)

7882

"-fno-whole-program-vtables" 7883

"-fvirtual-function-elimination"

;

7886 if

(WholeProgramVTables) {

7898

IsDeviceOffloadAction ?

.getLTOMode() :

.getOffloadLTOMode();

7899 auto

OtherIsUsingLTO = OtherLTOMode !=

LTOK_None

;

7901 if

((!IsUsingLTO && !OtherIsUsingLTO) ||

7902

(IsPS4 && !UnifiedLTO && (

.getLTOMode() !=

LTOK_Full

)))

7903 D

.Diag(diag::err_drv_argument_only_allowed_with)

7904

"-fwhole-program-vtables" 7905

<< ((IsPS4 && !UnifiedLTO) ?

"-flto=full"

"-flto"

);

7909

CmdArgs.push_back(

"-fwhole-program-vtables"

);

7912 bool

DefaultsSplitLTOUnit =

7913

((WholeProgramVTables || SanitizeArgs.needsLTO()) &&

7915

(!Triple.isPS4() && UnifiedLTO);

7917

Args.hasFlag(options::OPT_fsplit_lto_unit,

7918

options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);

7919 if

(SanitizeArgs.needsLTO() && !SplitLTOUnit)

7920 D

.Diag(diag::err_drv_argument_not_allowed_with) <<

"-fno-split-lto-unit" 7921

"-fsanitize=cfi"

;

7923

CmdArgs.push_back(

"-fsplit-lto-unit"

);

7925 if

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

7926

options::OPT_fno_fat_lto_objects)) {

7927 if

(IsUsingLTO && A->getOption().matches(options::OPT_ffat_lto_objects)) {

7929 if

(!Triple.isOSBinFormatELF()) {

7930 D

.Diag(diag::err_drv_unsupported_opt_for_target)

7933

CmdArgs.push_back(Args.MakeArgString(

7934

Twine(

"-flto="

) + (LTOMode ==

LTOK_Thin

"thin"

"full"

)));

7935

CmdArgs.push_back(

"-flto-unit"

);

7936

CmdArgs.push_back(

"-ffat-lto-objects"

);

7937

A->render(Args, CmdArgs);

7941 if

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

7942

options::OPT_fno_global_isel)) {

7943

CmdArgs.push_back(

"-mllvm"

);

7944 if

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

7945

CmdArgs.push_back(

"-global-isel=1"

);

7950 bool

IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;

7951 bool

IsOptLevelSupported =

false

;

7953

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

7954 if

(Triple.getArch() == llvm::Triple::aarch64) {

7955 if

(!A || A->getOption().matches(options::OPT_O0))

7956

IsOptLevelSupported =

true

;

7958 if

(!IsArchSupported || !IsOptLevelSupported) {

7959

CmdArgs.push_back(

"-mllvm"

);

7960

CmdArgs.push_back(

"-global-isel-abort=2"

);

7962 if

(!IsArchSupported)

7963 D

.Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName();

7965 D

.Diag(diag::warn_drv_global_isel_incomplete_opt);

7968

CmdArgs.push_back(

"-global-isel=0"

);

7973

Args.getLastArg(options::OPT_forder_file_instrumentation)) {

7974 D

.Diag(diag::warn_drv_deprecated_arg)

7975

<< A->getAsString(Args) <<

true 7976

"-ftemporal-profile"

;

7977

CmdArgs.push_back(

"-forder-file-instrumentation"

);

7982

CmdArgs.push_back(

"-mllvm"

);

7983

CmdArgs.push_back(

"-enable-order-file-instrumentation"

);

7987 if

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

7988

options::OPT_fno_force_enable_int128)) {

7989 if

(A->getOption().matches(options::OPT_fforce_enable_int128))

7990

CmdArgs.push_back(

"-fforce-enable-int128"

);

7993

Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts,

7994

options::OPT_fno_keep_static_consts);

7995

Args.addOptInFlag(CmdArgs, options::OPT_fkeep_persistent_storage_variables,

7996

options::OPT_fno_keep_persistent_storage_variables);

7997

Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers,

7998

options::OPT_fno_complete_member_pointers);

7999 if

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

8000

A->render(Args, CmdArgs);

8006 if

(Triple.isAArch64() &&

8007

(Args.hasArg(options::OPT_mno_fmv) ||

8008

(Triple.isAndroid() && Triple.isAndroidVersionLT(23)) ||

8011

CmdArgs.push_back(

"-target-feature"

);

8012

CmdArgs.push_back(

"-fmv"

);

8015 if

(Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,

8017

TC.

().isOSBinFormatCOFF()) &&

8022

CmdArgs.push_back(

"-faddrsig"

);

8024 if

((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&

8025

(EH || UnwindTables || AsyncUnwindTables ||

8026

DebugInfoKind != llvm::codegenoptions::NoDebugInfo))

8027

CmdArgs.push_back(

"-D__GCC_HAVE_DWARF2_CFI_ASM=1"

);

8029 if

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

8030

std::string Str = A->getAsString(Args);

8031 if

(!TC.

().isOSBinFormatELF())

8032 D

.Diag(diag::err_drv_unsupported_opt_for_target)

8034

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

8039 if

(Output.

() == types::TY_Dependencies) {

8042 if

(Output.

() == clang::driver::types::TY_IFS_CPP ||

8043

Output.

() == clang::driver::types::TY_IFS) {

8045

llvm::sys::path::replace_extension(OutputFilename,

"ifs"

);

8046

CmdArgs.push_back(

"-o"

);

8047

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

8049

CmdArgs.push_back(

"-o"

);

8053

assert(Output.

isNothing

() &&

"Invalid output."

);

8060

FrontendInputs = ExtractAPIInputs;

8062

FrontendInputs = {};

8064 for

(

const InputInfo

&Input : FrontendInputs) {

8068

Input.

getInputArg

().renderAsInput(Args, CmdArgs);

8071 if

(

.CC1Main && !

.CCGenDiagnostics) {

8073 C

.addCommand(std::make_unique<CC1Command>(

8075

Output,

.getPrependArg()));

8077 C

.addCommand(std::make_unique<Command>(

8079

Output,

.getPrependArg()));

8083 if

(Output.

() == types::TY_Object &&

8084

Args.hasFlag(options::OPT__SLASH_showFilenames,

8085

options::OPT__SLASH_showFilenames_,

false

)) {

8086 C

.getJobs().getJobs().back()->PrintInputFilenames =

true

;

8089 if

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

8091

!Args.hasArg(options::OPT_mfentry))

8092 D

.Diag(diag::err_drv_argument_not_allowed_with) <<

"-fomit-frame-pointer" 8093

<< A->getAsString(Args);

8099

Args.ClaimAllArgs(options::OPT_fpch_preprocess);

8103

Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);

8104

Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);

8107

Args.ClaimAllArgs(options::OPT_emit_llvm);

8114

Tool

(

"clang"

"clang frontend"

, TC), HasBackend(HasIntegratedBackend) {}

8121ObjCRuntime

Clang::AddObjCRuntimeArgs(

const

ArgList &args,

8123

ArgStringList &cmdArgs,

8124

RewriteKind rewriteKind)

const

{

8127

args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,

8128

options::OPT_fobjc_runtime_EQ);

8133

runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {

8135

StringRef value = runtimeArg->getValue();

8141

(runtime.

getVersion

() >= VersionTuple(2, 0)))

8142 if

().getTriple().isOSBinFormatELF() &&

8145

diag::err_drv_gnustep_objc_runtime_incompatible_binary)

8149

runtimeArg->render(args, cmdArgs);

8158 unsigned

objcABIVersion = 1;

8160 if

(Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {

8161

StringRef value = abiArg->getValue();

8164 else if

(value ==

"2"

)

8166 else if

(value ==

"3"

)

8172 bool

nonFragileABIIsDefault =

8173

(rewriteKind == RK_NonFragile ||

8174

(rewriteKind == RK_None &&

8176 if

(args.hasFlag(options::OPT_fobjc_nonfragile_abi,

8177

options::OPT_fno_objc_nonfragile_abi,

8178

nonFragileABIIsDefault)) {

8180#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 8181 unsigned

nonFragileABIVersion = 1;

8183 unsigned

nonFragileABIVersion = 2;

8187

args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {

8188

StringRef value = abiArg->getValue();

8190

nonFragileABIVersion = 1;

8191 else if

(value ==

"2"

)

8192

nonFragileABIVersion = 2;

8198

objcABIVersion = 1 + nonFragileABIVersion;

8206 bool

isNonFragile = objcABIVersion != 1;

8212 switch

(rewriteKind) {

8225

}

else if

(runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {

8237

assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));

8246 if

(llvm::any_of(inputs, [](

const InputInfo

&input) {

8250

args.MakeArgString(

"-fobjc-runtime="

+ runtime.

getAsString

()));

8255 bool

HaveDash = (I + 1 < EH.size() && EH[I + 1] ==

'-'

);

8262 bool

Synch =

false

;

8263 bool

Asynch =

false

;

8264 bool

NoUnwindC =

false

;

8276 bool

isWindowsMSVC) {

8279

std::vector<std::string> EHArgs =

8280

Args.getAllArgValues(options::OPT__SLASH_EH);

8281 for

(

const auto

&EHVal : EHArgs) {

8282 for

(

size_t

I = 0,

= EHVal.size(); I !=

; ++I) {

8288 if

(!isWindowsMSVC) {

8290 D

.Diag(clang::diag::warn_drv_unused_argument) <<

"/EHa"

<< EHVal;

8307 D

.Diag(clang::diag::err_drv_invalid_value) <<

"/EH"

<< EHVal;

8313 if

(EHArgs.empty() &&

8314

Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,

8317

EH.NoUnwindC =

true

;

8320 if

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

8322

EH.NoUnwindC =

false

;

8329void

Clang::AddClangCLArgs(

const

ArgList &Args,

types::ID

InputType,

8330

ArgStringList &CmdArgs)

const

{

8335 if

(Arg *ShowIncludes =

8336

Args.getLastArg(options::OPT__SLASH_showIncludes,

8337

options::OPT__SLASH_showIncludes_user)) {

8338

CmdArgs.push_back(

"--show-includes"

);

8339 if

(ShowIncludes->getOption().matches(options::OPT__SLASH_showIncludes))

8340

CmdArgs.push_back(

"-sys-header-deps"

);

8344 if

(Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,

8346

CmdArgs.push_back(

"-fno-rtti-data"

);

8350 if

(!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,

8352

CmdArgs.push_back(

"-stack-protector"

);

8360 if

(!isNVPTX && (EH.Synch || EH.Asynch)) {

8362

CmdArgs.push_back(

"-fcxx-exceptions"

);

8363

CmdArgs.push_back(

"-fexceptions"

);

8365

CmdArgs.push_back(

"-fasync-exceptions"

);

8367 if

(

types::isCXX

(InputType) && EH.Synch && EH.NoUnwindC)

8368

CmdArgs.push_back(

"-fexternc-nounwind"

);

8371 if

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

8372

CmdArgs.push_back(

"-E"

);

8373

CmdArgs.push_back(

"-P"

);

8376 if

(Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,

8377

options::OPT__SLASH_Zc_dllexportInlines,

8379

CmdArgs.push_back(

"-fno-dllexport-inlines"

);

8382 if

(Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,

8383

options::OPT__SLASH_Zc_wchar_t,

false

)) {

8384

CmdArgs.push_back(

"-fno-wchar"

);

8387 if

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

8389

std::vector<std::string> Values =

8390

Args.getAllArgValues(options::OPT__SLASH_arch);

8391 if

(!Values.empty()) {

8392

llvm::SmallSet<std::string, 4> SupportedArches;

8393 if

(Arch == llvm::Triple::x86)

8394

SupportedArches.insert(

"IA32"

);

8396 for

(

auto

: Values)

8397 if

(!SupportedArches.contains(

))

8398 D

.Diag(diag::err_drv_argument_not_allowed_with)

8399

<< std::string(

"/arch:"

).append(

) <<

"/kernel"

;

8402

CmdArgs.push_back(

"-fno-rtti"

);

8403 if

(Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_,

false

))

8404 D

.Diag(diag::err_drv_argument_not_allowed_with) <<

"/GR" 8408

Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);

8409

Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);

8410 if

(MostGeneralArg && BestCaseArg)

8411 D

.Diag(clang::diag::err_drv_argument_not_allowed_with)

8412

<< MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);

8414 if

(MostGeneralArg) {

8415

Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);

8416

Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);

8417

Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);

8419

Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;

8420

Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;

8421 if

(FirstConflict && SecondConflict && FirstConflict != SecondConflict)

8422 D

.Diag(clang::diag::err_drv_argument_not_allowed_with)

8423

<< FirstConflict->getAsString(Args)

8424

<< SecondConflict->getAsString(Args);

8427

CmdArgs.push_back(

"-fms-memptr-rep=single"

);

8428 else if

(MultipleArg)

8429

CmdArgs.push_back(

"-fms-memptr-rep=multiple"

);

8431

CmdArgs.push_back(

"-fms-memptr-rep=virtual"

);

8434 if

(Args.hasArg(options::OPT_regcall4))

8435

CmdArgs.push_back(

"-regcall4"

);

8439

Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,

8440

options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,

8441

options::OPT__SLASH_Gregcall)) {

8442 unsigned

DCCOptId = CCArg->getOption().

getID

();

8443 const char

*DCCFlag =

nullptr

;

8444 bool

ArchSupported = !isNVPTX;

8447 case

options::OPT__SLASH_Gd:

8448

DCCFlag =

"-fdefault-calling-conv=cdecl"

;

8450 case

options::OPT__SLASH_Gr:

8451

ArchSupported = Arch == llvm::Triple::x86;

8452

DCCFlag =

"-fdefault-calling-conv=fastcall"

;

8454 case

options::OPT__SLASH_Gz:

8455

ArchSupported = Arch == llvm::Triple::x86;

8456

DCCFlag =

"-fdefault-calling-conv=stdcall"

;

8458 case

options::OPT__SLASH_Gv:

8459

ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;

8460

DCCFlag =

"-fdefault-calling-conv=vectorcall"

;

8462 case

options::OPT__SLASH_Gregcall:

8463

ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;

8464

DCCFlag =

"-fdefault-calling-conv=regcall"

;

8469 if

(ArchSupported && DCCFlag)

8470

CmdArgs.push_back(DCCFlag);

8473 if

(Args.hasArg(options::OPT__SLASH_Gregcall4))

8474

CmdArgs.push_back(

"-regcall4"

);

8476

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

8478 if

(!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {

8479

CmdArgs.push_back(

"-fdiagnostics-format"

);

8480

CmdArgs.push_back(

"msvc"

);

8483 if

(Args.hasArg(options::OPT__SLASH_kernel))

8484

CmdArgs.push_back(

"-fms-kernel"

);

8486 for

(

const

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

8487

StringRef GuardArgs = A->getValue();

8490 if

(GuardArgs.equals_insensitive(

"cf"

)) {

8492

CmdArgs.push_back(

"-cfguard"

);

8493

}

else if

(GuardArgs.equals_insensitive(

"cf,nochecks"

)) {

8495

CmdArgs.push_back(

"-cfguard-no-checks"

);

8496

}

else if

(GuardArgs.equals_insensitive(

"ehcont"

)) {

8498

CmdArgs.push_back(

"-ehcontguard"

);

8499

}

else if

(GuardArgs.equals_insensitive(

"cf-"

) ||

8500

GuardArgs.equals_insensitive(

"ehcont-"

)) {

8503 D

.Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;

8511 return

Args.MakeArgString(llvm::sys::path::filename(Input.

getBaseInput

()));

8518 if

(

const char

*End = strrchr(Str,

'.'

))

8519 return

Args.MakeArgString(std::string(Str, End));

8528 if

(Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {

8530

llvm::sys::path::replace_extension(OutputFilename, llvm::Twine(

'd'

));

8531 return

Args.MakeArgString(OutputFilename);

8534 return

Args.MakeArgString(Twine(

getBaseInputStem

(Args, Inputs)) +

".d"

);

8540

ArgStringList &CmdArgs)

const

{

8546

CmdArgs.push_back(

"-target-abi"

);

8547

CmdArgs.push_back(ABIName.data());

8551

ArgStringList &CmdArgs)

const

{

8555 if

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

8556

StringRef

= A->getValue();

8558

CmdArgs.push_back(

"-mllvm"

);

8559

CmdArgs.push_back(Args.MakeArgString(

"-x86-asm-syntax="

));

8562

<< A->getSpelling() <<

;

8568

ArgStringList &CmdArgs)

const

{

8569

CmdArgs.push_back(

"-target-abi"

);

8576

ArgStringList &CmdArgs)

const

{

8580

CmdArgs.push_back(

"-target-abi"

);

8581

CmdArgs.push_back(ABIName.data());

8583 if

(Args.hasFlag(options::OPT_mdefault_build_attributes,

8584

options::OPT_mno_default_build_attributes,

true

)) {

8585

CmdArgs.push_back(

"-mllvm"

);

8586

CmdArgs.push_back(

"-riscv-add-build-attributes"

);

8592 const

ArgList &Args,

8593 const char

*LinkingOutput)

const

{

8594

ArgStringList CmdArgs;

8596

assert(Inputs.size() == 1 &&

"Unexpected number of inputs."

);

8600 const

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

8604

Args.ClaimAllArgs(options::OPT_w);

8606

Args.ClaimAllArgs(options::OPT_emit_llvm);

8613

CmdArgs.push_back(

"-cc1as"

);

8616

CmdArgs.push_back(

"-triple"

);

8617

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

8623

CmdArgs.push_back(

"-filetype"

);

8624

CmdArgs.push_back(

"obj"

);

8628

CmdArgs.push_back(

"-main-file-name"

);

8632

std::string CPU =

getCPUName

(

, Args, Triple,

true

);

8634

CmdArgs.push_back(

"-target-cpu"

);

8635

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

8642

(void)Args.hasArg(options::OPT_force__cpusubtype__ALL);

8645

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

8648

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

8651 auto

FindSource = [](

const Action

*S) ->

const Action

* {

8653

assert(!S->getInputs().empty() &&

"unexpected root action!"

);

8654

S = S->getInputs()[0];

8658 const Action

*SourceAction = FindSource(&JA);

8662 bool

WantDebug =

false

;

8663

Args.ClaimAllArgs(options::OPT_g_Group);

8664 if

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

8665

WantDebug = !A->getOption().matches(options::OPT_g0) &&

8666

!A->getOption().matches(options::OPT_ggdb0);

8669 bool

EmitDwarf =

false

;

8673 bool

EmitCodeView =

false

;

8674 if

(

const

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

8679 if

(!EmitCodeView && !EmitDwarf && WantDebug) {

8681 case

llvm::codegenoptions::DIF_CodeView:

8682

EmitCodeView =

true

;

8684 case

llvm::codegenoptions::DIF_DWARF:

8694

llvm::codegenoptions::DebugInfoKind DebugInfoKind =

8695

llvm::codegenoptions::NoDebugInfo;

8698 const char

*DebugCompilationDir =

8701 if

(SourceAction->

() == types::TY_Asm ||

8702

SourceAction->

() == types::TY_PP_Asm) {

8707

DebugInfoKind = (WantDebug ? llvm::codegenoptions::DebugInfoConstructor

8708

: llvm::codegenoptions::NoDebugInfo);

8715

CmdArgs.push_back(

"-dwarf-debug-producer"

);

8719

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

8723

llvm::DebuggerKind::Default);

8729

llvm::Reloc::Model RelocationModel;

8732

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

8737

CmdArgs.push_back(

"-mrelocation-model"

);

8738

CmdArgs.push_back(RMName);

8744

ArgStringList OriginalArgs;

8745 for

(

const auto

&Arg : Args)

8746

Arg->render(Args, OriginalArgs);

8751 for

(

const char

*OriginalArg : OriginalArgs) {

8755

Flags += EscapedArg;

8757

CmdArgs.push_back(

"-dwarf-debug-flags"

);

8758

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

8768 case

llvm::Triple::mips:

8769 case

llvm::Triple::mipsel:

8770 case

llvm::Triple::mips64:

8771 case

llvm::Triple::mips64el:

8775 case

llvm::Triple::x86:

8776 case

llvm::Triple::x86_64:

8780 case

llvm::Triple::arm:

8781 case

llvm::Triple::armeb:

8782 case

llvm::Triple::thumb:

8783 case

llvm::Triple::thumbeb:

8786 if

(Args.hasFlag(options::OPT_mdefault_build_attributes,

8787

options::OPT_mno_default_build_attributes,

true

)) {

8788

CmdArgs.push_back(

"-mllvm"

);

8789

CmdArgs.push_back(

"-arm-add-build-attributes"

);

8793 case

llvm::Triple::aarch64:

8794 case

llvm::Triple::aarch64_32:

8795 case

llvm::Triple::aarch64_be:

8796 if

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

8797

CmdArgs.push_back(

"-mllvm"

);

8798

CmdArgs.push_back(

"-aarch64-mark-bti-property"

);

8802 case

llvm::Triple::loongarch32:

8803 case

llvm::Triple::loongarch64:

8807 case

llvm::Triple::riscv32:

8808 case

llvm::Triple::riscv64:

8812 case

llvm::Triple::hexagon:

8813 if

(Args.hasFlag(options::OPT_mdefault_build_attributes,

8814

options::OPT_mno_default_build_attributes,

true

)) {

8815

CmdArgs.push_back(

"-mllvm"

);

8816

CmdArgs.push_back(

"-hexagon-add-build-attributes"

);

8826

Args.ClaimAllArgs(options::OPT_W_Group);

8831

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

8833 if

(DebugInfoKind > llvm::codegenoptions::NoDebugInfo && Output.

())

8840 if

(SourceAction != FindSource(&J.getSource()))

8842 auto

&JArgs = J.getArguments();

8843 for

(

unsigned

I = 0; I < JArgs.size(); ++I) {

8844 if

(StringRef(JArgs[I]).starts_with(

"-object-file-name="

) &&

8846

ArgStringList NewArgs(JArgs.begin(), JArgs.begin() + I);

8849

NewArgs.append(JArgs.begin() + I + 1, JArgs.end());

8850

J.replaceArguments(NewArgs);

8856

assert(Output.

() &&

"Unexpected lipo output."

);

8857

CmdArgs.push_back(

"-o"

);

8863 T

.isOSBinFormatELF()) {

8864

CmdArgs.push_back(

"-split-dwarf-output"

);

8868 if

(Triple.isAMDGPU())

8871

assert(Input.

() &&

"Invalid input."

);

8875 if

(

.CC1Main && !

.CCGenDiagnostics) {

8877 C

.addCommand(std::make_unique<CC1Command>(

8879

Output,

.getPrependArg()));

8881 C

.addCommand(std::make_unique<Command>(

8883

Output,

.getPrependArg()));

8891 const

llvm::opt::ArgList &TCArgs,

8892 const char

*LinkingOutput)

const

{

8894

assert(isa<OffloadBundlingJobAction>(JA) &&

"Expecting bundling job!"

);

8904

ArgStringList CmdArgs;

8907

CmdArgs.push_back(TCArgs.MakeArgString(

8910

assert(JA.

().size() == Inputs.size() &&

8911 "Not have inputs for all dependence actions??"

);

8915

Triples +=

"-targets="

;

8916 for

(

unsigned

I = 0; I < Inputs.size(); ++I) {

8925 if

(

const auto

*OA = dyn_cast<OffloadAction>(CurDep)) {

8927

OA->doOnEachDependence([&](

Action

*A,

const ToolChain

*TC,

const char

*) {

8928

assert(CurTC ==

nullptr

"Expected one dependence!"

);

8935

Triples += CurTC->

().normalize();

8944

StringRef GPUArchName;

8947 for

(

unsigned

ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {

8948 auto

ArchStr = StringRef(TCArgs.getArgString(ArgIndex));

8949 auto

Arch = ArchStr.starts_with_insensitive(

"-march="

);

8951

GPUArchName = ArchStr.substr(7);

8956

Triples += GPUArchName.str();

8959

CmdArgs.push_back(TCArgs.MakeArgString(Triples));

8963

TCArgs.MakeArgString(Twine(

"-output="

) + Output.

()));

8966 for

(

unsigned

I = 0; I < Inputs.size(); ++I) {

8972 if

(

const auto

*OA = dyn_cast<OffloadAction>(JA.

()[I])) {

8974

OA->doOnEachDependence([&](

Action

const ToolChain

*TC,

const char

*) {

8975

assert(CurTC ==

nullptr

"Expected one dependence!"

);

8978

UB +=

.addTempFile(

8983

CmdArgs.push_back(TCArgs.MakeArgString(UB));

8987 C

.addCommand(std::make_unique<Command>(

8990

CmdArgs, std::nullopt, Output));

8995 const InputInfoList

&Inputs,

const

llvm::opt::ArgList &TCArgs,

8996 const char

*LinkingOutput)

const

{

8998 auto

&UA = cast<OffloadUnbundlingJobAction>(JA);

9009

ArgStringList CmdArgs;

9011

assert(Inputs.size() == 1 &&

"Expecting to unbundle a single file!"

);

9015

CmdArgs.push_back(TCArgs.MakeArgString(

9020

Triples +=

"-targets="

;

9021 auto

DepInfo = UA.getDependentActionsInfo();

9022 for

(

unsigned

I = 0; I < DepInfo.size(); ++I) {

9026 auto

&Dep = DepInfo[I];

9029

Triples += Dep.DependentToolChain->getTriple().normalize();

9032

!Dep.DependentBoundArch.empty()) {

9034

Triples += Dep.DependentBoundArch;

9038

StringRef GPUArchName;

9041 for

(

unsigned

ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {

9042

StringRef ArchStr = StringRef(TCArgs.getArgString(ArgIndex));

9043 auto

Arch = ArchStr.starts_with_insensitive(

"-march="

);

9045

GPUArchName = ArchStr.substr(7);

9050

Triples += GPUArchName.str();

9054

CmdArgs.push_back(TCArgs.MakeArgString(Triples));

9058

TCArgs.MakeArgString(Twine(

"-input="

) + Input.

()));

9061 for

(

unsigned

I = 0; I < Outputs.size(); ++I) {

9064

UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);

9065

CmdArgs.push_back(TCArgs.MakeArgString(UB));

9067

CmdArgs.push_back(

"-unbundle"

);

9068

CmdArgs.push_back(

"-allow-missing-bundles"

);

9069 if

(TCArgs.hasArg(options::OPT_v))

9070

CmdArgs.push_back(

"-verbose"

);

9073 C

.addCommand(std::make_unique<Command>(

9076

CmdArgs, std::nullopt, Outputs));

9082 const

llvm::opt::ArgList &Args,

9083 const char

*LinkingOutput)

const

{

9084

ArgStringList CmdArgs;

9087

assert(Output.

() &&

"Invalid output."

);

9088

CmdArgs.push_back(

"-o"

);

9092 for

(

const InputInfo

&Input : Inputs) {

9095 const

ArgList &TCArgs =

9101

: TCArgs.getLastArgValue(options::OPT_march_EQ);

9105

ArgStringList Features;

9109

llvm::copy_if(Features, std::back_inserter(FeatureArgs),

9110

[](StringRef Arg) {

return

!Arg.starts_with(

"-target"

); });

9115 "file="

File

.str(),

9117 "arch="

+ Arch.str(),

9118 "kind="

+ Kind.str(),

9122 for

(StringRef Feature : FeatureArgs)

9123

Parts.emplace_back(

"feature="

+ Feature.str());

9125

CmdArgs.push_back(Args.MakeArgString(

"--image="

+ llvm::join(Parts,

","

)));

9128 C

.addCommand(std::make_unique<Command>(

9131

CmdArgs, Inputs, Output));

9137 const

ArgList &Args,

9138 const char

*LinkingOutput)

const

{

9141

ArgStringList CmdArgs;

9145 auto

TCRange =

.getOffloadToolChains(Kind);

9146 for

(

auto

&I : llvm::make_range(TCRange)) {

9150 if

(CudaInstallation.

isValid

())

9151

CmdArgs.push_back(Args.MakeArgString(

9159 if

(

const

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

9161 if

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

9162

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

9164 else if

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

9165

OOpt = A->getValue();

9168 else if

(OOpt ==

"s"

|| OOpt ==

"z"

)

9170

}

else if

(A->getOption().matches(options::OPT_O0))

9173

CmdArgs.push_back(Args.MakeArgString(Twine(

"--opt-level=O"

) + OOpt));

9177

Args.MakeArgString(

"--host-triple="

+ TheTriple.getTriple()));

9178 if

(Args.hasArg(options::OPT_v))

9179

CmdArgs.push_back(

"--wrapper-verbose"

);

9181 if

(

const

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

9182 if

(!A->getOption().matches(options::OPT_g0))

9183

CmdArgs.push_back(

"--device-debug"

);

9188 if

(

const

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

9189

CmdArgs.push_back(Args.MakeArgString(

"-mllvm"

));

9190

CmdArgs.push_back(Args.MakeArgString(

9191

Twine(

"--amdhsa-code-object-version="

) + A->getValue()));

9194 for

(

const auto

&A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))

9195

CmdArgs.push_back(Args.MakeArgString(

"--ptxas-arg="

+ A));

9198 if

(

const

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

9199

CmdArgs.push_back(Args.MakeArgString(Twine(

"--offload-opt=-pass-remarks="

) +

9201 if

(

const

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

9202

CmdArgs.push_back(Args.MakeArgString(

9203

Twine(

"--offload-opt=-pass-remarks-missed="

) + A->getValue()));

9204 if

(

const

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

9205

CmdArgs.push_back(Args.MakeArgString(

9206

Twine(

"--offload-opt=-pass-remarks-analysis="

) + A->getValue()));

9208 if

(Args.getLastArg(options::OPT_ftime_report))

9209

CmdArgs.push_back(

"--device-compiler=-ftime-report"

);

9211 if

(Args.getLastArg(options::OPT_save_temps_EQ))

9212

CmdArgs.push_back(

"--save-temps"

);

9215

Linker->

ConstructJob

(

, JA, Output, Inputs, Args, LinkingOutput);

9216 const auto

&LinkCommand =

.getJobs().getJobs().back();

9219 for

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

9220

StringRef Val = A->getValue(0);

9223

Args.MakeArgString(Twine(

"--device-linker="

) + A->getValue(1)));

9225

CmdArgs.push_back(Args.MakeArgString(

9226 "--device-linker="

9230

Args.ClaimAllArgs(options::OPT_Xoffload_linker);

9233 if

(Args.hasFlag(options::OPT_fopenmp_target_jit,

9234

options::OPT_fno_openmp_target_jit,

false

))

9235

CmdArgs.push_back(

"--embed-bitcode"

);

9238 for

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

9239

CmdArgs.push_back(

"-mllvm"

);

9240

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

9245 if

(!Args.hasArg(options::OPT_nostdlib, options::OPT_r, options::OPT_nogpulib,

9246

options::OPT_nodefaultlibs, options::OPT_nolibc,

9247

options::OPT_nogpulibc)) {

9255

CmdArgs.push_back(Args.MakeArgString(

9257

CmdArgs.push_back(Args.MakeArgString(

9264

Args.MakeArgString(

"--device-linker="

+ TC.

getTripleString

() +

"="

9265 "-lclang_rt.builtins"

));

9271 if

(!Args.hasFlag(options::OPT_gpulibc, options::OPT_nogpulibc,

true

))

9272

CmdArgs.push_back(

"--device-compiler=-nolibc"

);

9275

CmdArgs.push_back(Args.MakeArgString(Twine(

"--linker-path="

) +

9276

LinkCommand->getExecutable()));

9277 for

(

const char

*LinkArg : LinkCommand->getArguments())

9278

CmdArgs.push_back(LinkArg);

9283

Args.MakeArgString(