clang: lib/Frontend/CompilerInvocation.cpp Source File (original) (raw)

1

2

3

4

5

6

7

8

29#include "clang/Config/config.h"

43#include "llvm/ADT/APInt.h"

44#include "llvm/ADT/ArrayRef.h"

45#include "llvm/ADT/CachedHashString.h"

46#include "llvm/ADT/FloatingPointMode.h"

47#include "llvm/ADT/STLExtras.h"

48#include "llvm/ADT/SmallVector.h"

49#include "llvm/ADT/StringRef.h"

50#include "llvm/ADT/StringSwitch.h"

51#include "llvm/ADT/Twine.h"

52#include "llvm/Config/llvm-config.h"

53#include "llvm/Frontend/Debug/Options.h"

54#include "llvm/IR/DebugInfoMetadata.h"

55#include "llvm/Linker/Linker.h"

56#include "llvm/MC/MCTargetOptions.h"

57#include "llvm/Option/Arg.h"

58#include "llvm/Option/ArgList.h"

59#include "llvm/Option/OptSpecifier.h"

60#include "llvm/Option/OptTable.h"

61#include "llvm/Option/Option.h"

62#include "llvm/ProfileData/InstrProfReader.h"

63#include "llvm/Remarks/HotnessThresholdParser.h"

64#include "llvm/Support/CodeGen.h"

65#include "llvm/Support/Compiler.h"

66#include "llvm/Support/Error.h"

67#include "llvm/Support/ErrorHandling.h"

68#include "llvm/Support/ErrorOr.h"

69#include "llvm/Support/FileSystem.h"

70#include "llvm/Support/HashBuilder.h"

71#include "llvm/Support/MathExtras.h"

72#include "llvm/Support/MemoryBuffer.h"

73#include "llvm/Support/Path.h"

74#include "llvm/Support/Process.h"

75#include "llvm/Support/Regex.h"

76#include "llvm/Support/VersionTuple.h"

77#include "llvm/Support/VirtualFileSystem.h"

78#include "llvm/Support/raw_ostream.h"

79#include "llvm/Target/TargetOptions.h"

80#include "llvm/TargetParser/Host.h"

81#include "llvm/TargetParser/Triple.h"

82#include

83#include

84#include

85#include

86#include

87#include

88#include

89#include

90#include

91#include

92#include

93#include <type_traits>

94#include

95#include

96

97using namespace clang;

100

101

102

103

104

105

106

108 uint32_t Val;

109 if (Arg.getAsInteger(10, Val))

110 return llvm::createStringError(llvm::inconvertibleErrorCode(),

111 "Not an integer: %s", Arg.data());

112 return Val;

113}

114

115

116

117

118

120 return std::make_shared(X);

121}

122

137

140 if (this != &X) {

154 }

155 return *this;

156}

157

160 if (this != &X) {

174 }

175 return *this;

176}

177

182

188

189template

191 if (Storage.use_count() > 1)

192 Storage = std::make_shared(*Storage);

193 return *Storage;

194}

195

199

203

207

211

215

219

223

227

231

235

239

243

248

249

250

251

252

254

255#define OPTTABLE_STR_TABLE_CODE

256#include "clang/Options/Options.inc"

257#undef OPTTABLE_STR_TABLE_CODE

258

260 return OptionStrTable[Offset];

261}

262

263#define SIMPLE_ENUM_VALUE_TABLE

264#include "clang/Options/Options.inc"

265#undef SIMPLE_ENUM_VALUE_TABLE

266

268 unsigned TableIndex,

269 const ArgList &Args,

271 if (Args.hasArg(Opt))

272 return true;

273 return std::nullopt;

274}

275

277 unsigned,

278 const ArgList &Args,

280 if (Args.hasArg(Opt))

281 return false;

282 return std::nullopt;

283}

284

285

286

287

288

290 unsigned SpellingOffset, Option::OptionClass,

291 unsigned, ...) {

293}

295 const Twine &Spelling, Option::OptionClass,

296 unsigned, ...) {

297 Consumer(Spelling);

298}

299

301 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum::value;

302}

303

304template <typename T,

305 std::enable_if_t<!is_uint64_t_convertible(), bool> = false>

307 return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,

309 if (Args.hasArg(Opt))

311 return std::nullopt;

312 };

313}

314

315template <typename T,

316 std::enable_if_t<is_uint64_t_convertible(), bool> = false>

320

322 OptSpecifier OtherOpt) {

323 return [Value, OtherValue,

324 OtherOpt](OptSpecifier Opt, unsigned, const ArgList &Args,

326 if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {

327 return A->getOption().matches(Opt) ? Value : OtherValue;

328 }

329 return std::nullopt;

330 };

331}

332

335 Option::OptionClass, unsigned, bool KeyPath) {

336 if (KeyPath == Value)

338 };

339}

340

342 const Twine &Spelling,

343 Option::OptionClass OptClass, unsigned,

344 const Twine &Value) {

345 switch (OptClass) {

346 case Option::SeparateClass:

347 case Option::JoinedOrSeparateClass:

348 case Option::JoinedAndSeparateClass:

349 Consumer(Spelling);

351 break;

352 case Option::JoinedClass:

353 case Option::CommaJoinedClass:

354 Consumer(Spelling + Value);

355 break;

356 default:

357 llvm_unreachable("Cannot denormalize an option with option class "

358 "incompatible with string denormalization.");

359 }

360}

361

362template

363static void

365 Option::OptionClass OptClass, unsigned TableIndex, T Value) {

367 TableIndex, Twine(Value));

368}

369

370template

372 Option::OptionClass OptClass, unsigned TableIndex,

375}

376

377static std::optional

379 for (int I = 0, E = Table.Size; I != E; ++I)

380 if (Name == Table.Table[I].Name)

381 return Table.Table[I];

382

383 return std::nullopt;

384}

385

386static std::optional

388 for (int I = 0, E = Table.Size; I != E; ++I)

390 return Table.Table[I];

391

392 return std::nullopt;

393}

394

396 unsigned TableIndex,

397 const ArgList &Args,

399 assert(TableIndex < SimpleEnumValueTablesSize);

400 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];

401

402 auto *Arg = Args.getLastArg(Opt);

403 if (!Arg)

404 return std::nullopt;

405

406 StringRef ArgValue = Arg->getValue();

408 return MaybeEnumVal->Value;

409

410 Diags.Report(diag::err_drv_invalid_value)

411 << Arg->getAsString(Args) << ArgValue;

412 return std::nullopt;

413}

414

416 unsigned SpellingOffset,

417 Option::OptionClass OptClass,

418 unsigned TableIndex, unsigned Value) {

419 assert(TableIndex < SimpleEnumValueTablesSize);

420 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];

423 TableIndex, MaybeEnumVal->Name);

424 } else {

425 llvm_unreachable("The simple enum value was not correctly defined in "

426 "the tablegen option description");

427 }

428}

429

430template

432 unsigned SpellingOffset,

433 Option::OptionClass OptClass,

434 unsigned TableIndex, T Value) {

436 TableIndex, static_cast<unsigned>(Value));

437}

438

440 int TableIndex,

441 const ArgList &Args,

443 auto *Arg = Args.getLastArg(Opt);

444 if (!Arg)

445 return std::nullopt;

446 return std::string(Arg->getValue());

447}

448

449template

451 const ArgList &Args,

453 auto *Arg = Args.getLastArg(Opt);

454 if (!Arg)

455 return std::nullopt;

456 IntTy Res;

457 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {

458 Diags.Report(diag::err_drv_invalid_int_value)

459 << Arg->getAsString(Args) << Arg->getValue();

460 return std::nullopt;

461 }

462 return Res;

463}

464

465static std::optional<std::vectorstd::string>

468 return Args.getAllArgValues(Opt);

469}

470

472 unsigned SpellingOffset,

473 Option::OptionClass OptClass,

474 unsigned TableIndex,

475 const std::vectorstd::string &Values) {

476 switch (OptClass) {

477 case Option::CommaJoinedClass: {

478 std::string CommaJoinedValue;

479 if (!Values.empty()) {

480 CommaJoinedValue.append(Values.front());

481 for (const std::string &Value : llvm::drop_begin(Values, 1)) {

482 CommaJoinedValue.append(",");

483 CommaJoinedValue.append(Value);

484 }

485 }

487 Option::OptionClass::JoinedClass, TableIndex,

488 CommaJoinedValue);

489 break;

490 }

491 case Option::JoinedClass:

492 case Option::SeparateClass:

493 case Option::JoinedOrSeparateClass:

494 for (const std::string &Value : Values)

496 break;

497 default:

498 llvm_unreachable("Cannot denormalize an option with option class "

499 "incompatible with string vector denormalization.");

500 }

501}

502

504 int TableIndex,

505 const ArgList &Args,

507 auto *Arg = Args.getLastArg(Opt);

508 if (!Arg)

509 return std::nullopt;

510 return llvm::Triple::normalize(Arg->getValue());

511}

512

513template <typename T, typename U>

515 return static_cast<T>(Value);

516}

517

519 return KeyPath | Value;

520}

521

525

526template <typename T, typename U, U Value>

530

531#define PARSE_OPTION_WITH_MARSHALLING( \

532 ARGS, DIAGS, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, \

533 ALIASARGS, FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, \

534 METAVAR, VALUES, SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \

535 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \

536 MERGER, EXTRACTOR, TABLE_INDEX) \

537 if ((VISIBILITY) & options::CC1Option) { \

538 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \

539 if (IMPLIED_CHECK) \

540 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \

541 if (SHOULD_PARSE) \

542 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \

543 KEYPATH = \

544 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \

545 }

546

547

548

549#define GENERATE_OPTION_WITH_MARSHALLING( \

550 CONSUMER, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, ALIASARGS, \

551 FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \

552 SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \

553 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \

554 TABLE_INDEX) \

555 if ((VISIBILITY) & options::CC1Option) { \

556 [&](const auto &Extracted) { \

557 if (ALWAYS_EMIT || \

558 (Extracted != \

559 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \

560 : (DEFAULT_VALUE)))) \

561 DENORMALIZER(CONSUMER, SPELLING_OFFSET, Option::KIND##Class, \

562 TABLE_INDEX, Extracted); \

563 }(EXTRACTOR(KEYPATH)); \

564 }

565

567

571 unsigned NumErrorsBefore = Diags.getNumErrors();

572

577 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;

578 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;

579 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;

580 CodeGenOpts.DisableFree = FrontendOpts.DisableFree;

583 CodeGenOpts.ClearASTBeforeBackend = false;

585 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;

586 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;

588

589 llvm::Triple T(TargetOpts.Triple);

590 llvm::Triple::ArchType Arch = T.getArch();

591

594

595 if (CodeGenOpts.getExceptionHandling() !=

597 T.isWindowsMSVCEnvironment())

598 Diags.Report(diag::err_fe_invalid_exception_model)

599 << static_cast<unsigned>(CodeGenOpts.getExceptionHandling()) << T.str();

600

601 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)

602 Diags.Report(diag::warn_c_kext);

603

604 if (LangOpts.NewAlignOverride &&

605 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {

606 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);

607 Diags.Report(diag::err_fe_invalid_alignment)

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

609 LangOpts.NewAlignOverride = 0;

610 }

611

612

613

614 if (LangOpts.CPlusPlus11) {

615 if (Args.hasArg(OPT_fraw_string_literals, OPT_fno_raw_string_literals)) {

616 Args.claimAllArgs(OPT_fraw_string_literals, OPT_fno_raw_string_literals);

617 Diags.Report(diag::warn_drv_fraw_string_literals_in_cxx11)

618 << bool(LangOpts.RawStringLiterals);

619 }

620

621

622 LangOpts.RawStringLiterals = true;

623 }

624

625 LangOpts.NamedLoops =

626 Args.hasFlag(OPT_fnamed_loops, OPT_fno_named_loops, LangOpts.C2y);

627

628

629 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)

630 Diags.Report(diag::err_drv_argument_not_allowed_with) << "-fsycl-is-device"

631 << "-fsycl-is-host";

632

633 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)

634 Diags.Report(diag::err_drv_argument_not_allowed_with)

636

637 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)

638 Diags.Report(diag::err_drv_argument_not_allowed_with)

640

641 if (Args.hasArg(OPT_fdx_rootsignature_version) && !LangOpts.HLSL)

642 Diags.Report(diag::err_drv_argument_not_allowed_with)

644

645 if (Args.hasArg(OPT_fdx_rootsignature_define) && !LangOpts.HLSL)

646 Diags.Report(diag::err_drv_argument_not_allowed_with)

648

649 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)

650 Diags.Report(diag::warn_ignored_hip_only_option)

651 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);

652

653 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)

654 Diags.Report(diag::warn_ignored_hip_only_option)

655 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);

656

657

658

659

660

661

662

663

664 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {

665 if (LangOpts.ApproxFunc)

666 Diags.Report(diag::err_incompatible_fp_eval_method_options) << 0;

667 if (LangOpts.AllowFPReassoc)

668 Diags.Report(diag::err_incompatible_fp_eval_method_options) << 1;

669 if (LangOpts.AllowRecip)

670 Diags.Report(diag::err_incompatible_fp_eval_method_options) << 2;

671 }

672

673

674

675

676 if (Args.getLastArg(OPT_cl_strict_aliasing) &&

678 Diags.Report(diag::warn_option_invalid_ocl_version)

680 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);

681

682 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {

683 auto DefaultCC = LangOpts.getDefaultCallingConv();

684

687 Arch != llvm::Triple::x86;

690 .isX86();

692 if (emitError)

693 Diags.Report(diag::err_drv_argument_not_allowed_with)

694 << A->getSpelling() << T.getTriple();

695 }

696

697 return Diags.getNumErrors() == NumErrorsBefore;

698}

699

700

701

702

703

705 llvm::opt::OptSpecifier OptSpecifier) {

708 Option::OptionClass::FlagClass, 0);

709}

710

712 llvm::opt::OptSpecifier OptSpecifier,

713 const Twine &Value) {

716}

717

718

722

723

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

751 bool CheckAgainstOriginalInvocation = false,

752 bool ForceRoundTrip = false) {

753#ifndef NDEBUG

754 bool DoRoundTripDefault = true;

755#else

756 bool DoRoundTripDefault = false;

757#endif

758

759 bool DoRoundTrip = DoRoundTripDefault;

760 if (ForceRoundTrip) {

761 DoRoundTrip = true;

762 } else {

763 for (const auto *Arg : CommandLineArgs) {

764 if (Arg == StringRef("-round-trip-args"))

765 DoRoundTrip = true;

766 if (Arg == StringRef("-no-round-trip-args"))

767 DoRoundTrip = false;

768 }

769 }

770

771

772

773 if (!DoRoundTrip)

774 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);

775

776

778 std::string Buffer;

779 llvm::raw_string_ostream OS(Buffer);

780 for (const char *Arg : Args) {

781 llvm::sys::printArg(OS, Arg, true);

782 OS << ' ';

783 }

784 return Buffer;

785 };

786

787

791

792

793

794 if ((DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||

796

797

798

799

801 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);

804

805

806

807 Diags.Report(diag::err_cc1_round_trip_fail_then_ok);

808 Diags.Report(diag::note_cc1_round_trip_original)

809 << SerializeArgs(CommandLineArgs);

810 return false;

811 }

812

813

814 llvm::BumpPtrAllocator Alloc;

815 llvm::StringSaver StringPool(Alloc);

816 auto SA = [&StringPool](const Twine &Arg) {

817 return StringPool.save(Arg).data();

818 };

819

820

821

822

824 Generate(DummyInvocation, GeneratedArgs, SA);

825

826

827

828

829

830 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);

831

832

833

834 if (!Success2) {

835 Diags.Report(diag::err_cc1_round_trip_ok_then_fail);

836 Diags.Report(diag::note_cc1_round_trip_generated)

837 << 1 << SerializeArgs(GeneratedArgs);

838 return false;

839 }

840

842 if (CheckAgainstOriginalInvocation)

843

844 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());

845 else

846

847

848 Generate(RealInvocation, ComparisonArgs, SA);

849

850

853 return llvm::equal(A, B, [](const char *AElem, const char *BElem) {

854 return StringRef(AElem) == StringRef(BElem);

855 });

856 };

857

858

859

860

861 if ((GeneratedArgs, ComparisonArgs)) {

862 Diags.Report(diag::err_cc1_round_trip_mismatch);

863 Diags.Report(diag::note_cc1_round_trip_generated)

864 << 1 << SerializeArgs(GeneratedArgs);

865 Diags.Report(diag::note_cc1_round_trip_generated)

866 << 2 << SerializeArgs(ComparisonArgs);

867 return false;

868 }

869

870 Diags.Report(diag::remark_cc1_round_trip_generated)

871 << 1 << SerializeArgs(GeneratedArgs);

872 Diags.Report(diag::remark_cc1_round_trip_generated)

873 << 2 << SerializeArgs(ComparisonArgs);

874

875 return Success2;

876}

877

880 const char *Argv0) {

885 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);

886 },

889 Args.push_back("-cc1");

891 },

892 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,

893 true, true);

894}

895

897 OptSpecifier GroupWithValue,

898 std::vectorstd::string &Diagnostics) {

899 for (auto *A : Args.filtered(Group)) {

900 if (A->getOption().getKind() == Option::FlagClass) {

901

902

903 Diagnostics.push_back(

904 std::string(A->getOption().getName().drop_front(1)));

905 } else if (A->getOption().matches(GroupWithValue)) {

906

907

908 Diagnostics.push_back(

909 std::string(A->getOption().getName().drop_front(1).rtrim("=-")));

910 } else {

911

912 Diagnostics.push_back(A->getValue());

913 }

914 }

915}

916

917

918

921

923 std::vectorstd::string &Funcs) {

924 std::vectorstd::string Values = Args.getAllArgValues(OPT_fno_builtin_);

926 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);

927}

928

932

933#define ANALYZER_OPTION_WITH_MARSHALLING(...) \

934 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

935#include "clang/Options/Options.inc"

936#undef ANALYZER_OPTION_WITH_MARSHALLING

937

940#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \

941 case NAME##Model: \

942 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \

943 break;

944#include "clang/StaticAnalyzer/Core/Analyses.def"

945 default:

946 llvm_unreachable("Tried to generate unknown analysis constraint.");

947 }

948 }

949

952#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \

953 case PD_##NAME: \

954 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \

955 break;

956#include "clang/StaticAnalyzer/Core/Analyses.def"

957 default:

958 llvm_unreachable("Tried to generate unknown analysis diagnostic client.");

959 }

960 }

961

964#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \

965 case NAME: \

966 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \

967 break;

968#include "clang/StaticAnalyzer/Core/Analyses.def"

969 default:

970 llvm_unreachable("Tried to generate unknown analysis purge mode.");

971 }

972 }

973

976#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \

977 case NAME: \

978 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \

979 break;

980#include "clang/StaticAnalyzer/Core/Analyses.def"

981 default:

982 llvm_unreachable("Tried to generate unknown analysis inlining mode.");

983 }

984 }

985

987 OptSpecifier Opt =

988 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;

990 }

991

994

995

997 for (const auto &C : Opts.Config)

998 SortedConfigOpts.emplace_back(C.getKey(), C.getValue());

999 llvm::sort(SortedConfigOpts, llvm::less_first());

1000

1001 for (const auto &[Key, Value] : SortedConfigOpts) {

1002

1003

1004 auto Entry = ConfigOpts.Config.find(Key);

1005 if (Entry != ConfigOpts.Config.end() && Entry->getValue() == Value)

1006 continue;

1007

1008 GenerateArg(Consumer, OPT_analyzer_config, Key + "=" + Value);

1009 }

1010

1011

1012}

1013

1016 unsigned NumErrorsBefore = Diags.getNumErrors();

1017

1019

1020#define ANALYZER_OPTION_WITH_MARSHALLING(...) \

1021 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

1022#include "clang/Options/Options.inc"

1023#undef ANALYZER_OPTION_WITH_MARSHALLING

1024

1025 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {

1026 StringRef Name = A->getValue();

1028#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \

1029 .Case(CMDFLAG, NAME##Model)

1030#include "clang/StaticAnalyzer/Core/Analyses.def"

1033 Diags.Report(diag::err_drv_invalid_value)

1034 << A->getAsString(Args) << Name;

1035 } else {

1036#ifndef LLVM_WITH_Z3

1037 if (Value == AnalysisConstraints::Z3ConstraintsModel) {

1038 Diags.Report(diag::err_analyzer_not_built_with_z3);

1039 }

1040#endif

1042 }

1043 }

1044

1045 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {

1046 StringRef Name = A->getValue();

1048#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \

1049 .Case(CMDFLAG, PD_##NAME)

1050#include "clang/StaticAnalyzer/Core/Analyses.def"

1053 Diags.Report(diag::err_drv_invalid_value)

1054 << A->getAsString(Args) << Name;

1055 } else {

1057 }

1058 }

1059

1060 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {

1061 StringRef Name = A->getValue();

1063#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \

1064 .Case(CMDFLAG, NAME)

1065#include "clang/StaticAnalyzer/Core/Analyses.def"

1068 Diags.Report(diag::err_drv_invalid_value)

1069 << A->getAsString(Args) << Name;

1070 } else {

1072 }

1073 }

1074

1075 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {

1076 StringRef Name = A->getValue();

1078#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \

1079 .Case(CMDFLAG, NAME)

1080#include "clang/StaticAnalyzer/Core/Analyses.def"

1083 Diags.Report(diag::err_drv_invalid_value)

1084 << A->getAsString(Args) << Name;

1085 } else {

1087 }

1088 }

1089

1091 for (const Arg *A :

1092 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {

1093 A->claim();

1094 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;

1095

1096

1097 StringRef CheckerAndPackageList = A->getValue();

1099 CheckerAndPackageList.split(CheckersAndPackages, ",");

1100 for (const StringRef &CheckerOrPackage : CheckersAndPackages)

1102 IsEnabled);

1103 }

1104

1105

1106 for (const auto *A : Args.filtered(OPT_analyzer_config)) {

1107

1108

1109

1110 StringRef configList = A->getValue();

1112 configList.split(configVals, ",");

1113 for (const auto &configVal : configVals) {

1114 StringRef key, val;

1115 std::tie(key, val) = configVal.split("=");

1116 if (val.empty()) {

1118 diag::err_analyzer_config_no_value) << configVal;

1119 break;

1120 }

1121 if (val.contains('=')) {

1123 diag::err_analyzer_config_multiple_values)

1124 << configVal;

1125 break;

1126 }

1127

1128

1129

1132 Diags.Report(diag::err_analyzer_config_unknown) << key;

1133 continue;

1134 }

1135

1136 A->claim();

1137 Opts.Config[key] = std::string(val);

1138 }

1139 }

1140

1143 else

1145

1147 for (unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {

1148 if (i != 0)

1149 os << " ";

1150 os << Args.getArgString(i);

1151 }

1152

1153 return Diags.getNumErrors() == NumErrorsBefore;

1154}

1155

1157 StringRef OptionName, StringRef DefaultVal) {

1158 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;

1159}

1160

1163 StringRef &OptionField, StringRef Name,

1164 StringRef DefaultVal) {

1165

1166

1167

1168 OptionField = getStringOption(Config, Name, DefaultVal);

1169}

1170

1173 bool &OptionField, StringRef Name, bool DefaultVal) {

1174 auto PossiblyInvalidVal =

1175 llvm::StringSwitch<std::optional>(

1176 getStringOption(Config, Name, (DefaultVal ? "true" : "false")))

1177 .Case("true", true)

1178 .Case("false", false)

1179 .Default(std::nullopt);

1180

1181 if (!PossiblyInvalidVal) {

1182 if (Diags)

1183 Diags->Report(diag::err_analyzer_config_invalid_input)

1184 << Name << "a boolean";

1185 else

1186 OptionField = DefaultVal;

1187 } else

1188 OptionField = *PossiblyInvalidVal;

1189}

1190

1193 unsigned &OptionField, StringRef Name,

1194 unsigned DefaultVal) {

1195

1196 OptionField = DefaultVal;

1197 bool HasFailed = getStringOption(Config, Name, std::to_string(DefaultVal))

1198 .getAsInteger(0, OptionField);

1199 if (Diags && HasFailed)

1200 Diags->Report(diag::err_analyzer_config_invalid_input)

1201 << Name << "an unsigned";

1202}

1203

1207 unsigned DefaultVal) {

1209 getStringOption(Config, Name, std::to_string(DefaultVal)));

1210 if (Parsed.has_value()) {

1211 OptionField = Parsed.value();

1212 return;

1213 }

1214 if (Diags && !Parsed.has_value())

1215 Diags->Report(diag::err_analyzer_config_invalid_input)

1216 << Name << "a positive";

1217

1218 OptionField = DefaultVal;

1219}

1220

1223

1224

1225

1226#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \

1227 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);

1228#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)

1229#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"

1230

1231 assert(AnOpts.UserMode == "shallow" || AnOpts.UserMode == "deep");

1232 const bool InShallowMode = AnOpts.UserMode == "shallow";

1233

1234#define ANALYZER_OPTION(...)

1235#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \

1236 SHALLOW_VAL, DEEP_VAL) \

1237 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \

1238 InShallowMode ? SHALLOW_VAL : DEEP_VAL);

1239#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"

1240

1241

1242

1243

1244

1245

1246 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {

1247 std::vector Checkers =

1249 std::vector Packages =

1251

1253 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages, ";");

1254

1255 for (const StringRef &CheckerOrPackage : CheckersAndPackages) {

1256 if (Diags) {

1257 bool IsChecker = CheckerOrPackage.contains('.');

1258 bool IsValidName = IsChecker

1259 ? llvm::is_contained(Checkers, CheckerOrPackage)

1260 : llvm::is_contained(Packages, CheckerOrPackage);

1261

1262 if (!IsValidName)

1263 Diags->Report(diag::err_unknown_analyzer_checker_or_package)

1264 << CheckerOrPackage;

1265 }

1266

1268 }

1269 }

1270

1271 if (!Diags)

1272 return;

1273

1274 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)

1275 Diags->Report(diag::err_analyzer_config_invalid_input)

1276 << "track-conditions-debug" << "'track-conditions' to also be enabled";

1277}

1278

1279

1280static void

1282 StringRef Name,

1284 if (Remark.hasValidPattern()) {

1287 GenerateArg(Consumer, OPT_R_Joined, Name);

1289 GenerateArg(Consumer, OPT_R_Joined, StringRef("no-") + Name);

1290 }

1291}

1292

1293

1294

1295

1298 OptSpecifier OptEQ, StringRef Name) {

1300

1301 auto InitializeResultPattern = [&Diags, &Args, &Result](const Arg *A,

1302 StringRef Pattern) {

1303 Result.Pattern = Pattern.str();

1304

1305 std::string RegexError;

1306 Result.Regex = std::make_sharedllvm::Regex(Result.Pattern);

1307 if (!Result.Regex->isValid(RegexError)) {

1308 Diags.Report(diag::err_drv_optimization_remark_pattern)

1309 << RegexError << A->getAsString(Args);

1310 return false;

1311 }

1312

1313 return true;

1314 };

1315

1316 for (Arg *A : Args) {

1317 if (A->getOption().matches(OPT_R_Joined)) {

1318 StringRef Value = A->getValue();

1319

1320 if (Value == Name)

1322 else if (Value == "everything")

1324 else if (Value.split('-') == std::make_pair(StringRef("no"), Name))

1326 else if (Value == "no-everything")

1328 else

1329 continue;

1330

1333 Result.Pattern = "";

1334 Result.Regex = nullptr;

1335 } else {

1336 InitializeResultPattern(A, ".*");

1337 }

1338 } else if (A->getOption().matches(OptEQ)) {

1340 if (!InitializeResultPattern(A, A->getValue()))

1342 }

1343 }

1344

1345 return Result;

1346}

1347

1349 const std::vectorstd::string &Levels,

1353 for (const auto &Level : Levels) {

1355 llvm::StringSwitch(Level)

1363 Diags.Report(diag::err_drv_invalid_value) << FlagName << Level;

1364 }

1365 M = M | PM;

1366 }

1368}

1369

1371 const std::vectorstd::string &Sanitizers,

1373 for (const auto &Sanitizer : Sanitizers) {

1376 Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;

1377 else

1378 S.set(K, true);

1379 }

1380}

1381

1385 return Values;

1386}

1387

1390 const std::vectorstd::string &Sanitizers,

1393 for (const auto &Sanitizer : Sanitizers) {

1395 Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;

1396 }

1397 return Cutoffs;

1398}

1399

1404 llvm::SplitString(Bundle, BundleParts, ",");

1405 for (const auto &B : BundleParts) {

1408 if (B != "none")

1409 D.Report(diag::err_drv_invalid_value) << FlagName << Bundle;

1410 else

1411 S.Mask = Mask;

1413 S.Mask = Mask;

1414 else

1415 S.set(Mask, true);

1416 }

1417}

1418

1422 std::string Buffer;

1423 llvm::raw_string_ostream OS(Buffer);

1424 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; }, ",");

1425 return Buffer;

1426}

1427

1430 const llvm::Triple &Triple) {

1431 assert(Triple.getArch() == llvm::Triple::aarch64);

1432 if (LangOpts.PointerAuthCalls) {

1435

1437 Key::ASIA, false,

1438 LangOpts.PointerAuthFunctionTypeDiscrimination ? Discrimination::Type

1439 : Discrimination::None);

1440

1442 Key::ASDA, LangOpts.PointerAuthVTPtrAddressDiscrimination,

1443 LangOpts.PointerAuthVTPtrTypeDiscrimination ? Discrimination::Type

1444 : Discrimination::None);

1445

1446 if (LangOpts.PointerAuthTypeInfoVTPtrDiscrimination)

1450 else

1453

1460

1461 if (LangOpts.PointerAuthInitFini) {

1463 Key::ASIA, LangOpts.PointerAuthInitFiniAddressDiscrimination,

1465 }

1466

1473 if (LangOpts.PointerAuthBlockDescriptorPointers)

1477

1483 if (LangOpts.PointerAuthObjcIsa) {

1490 }

1491

1492 if (LangOpts.PointerAuthObjcClassROPointers)

1496 }

1501}

1502

1505 const llvm::Triple &Triple,

1507 if (!LangOpts.PointerAuthCalls && !LangOpts.PointerAuthReturns &&

1508 !LangOpts.PointerAuthAuthTraps && !LangOpts.PointerAuthIndirectGotos &&

1509 !LangOpts.AArch64JumpTableHardening)

1510 return;

1511

1513}

1514

1515void CompilerInvocationBase::GenerateCodeGenArgs(const CodeGenOptions &Opts,

1517 const llvm::Triple &T,

1518 const std::string &OutputFile,

1520 const CodeGenOptions &CodeGenOpts = Opts;

1521

1522 if (Opts.OptimizationLevel == 0)

1524 else

1525 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));

1526

1527#define CODEGEN_OPTION_WITH_MARSHALLING(...) \

1528 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

1529#include "clang/Options/Options.inc"

1530#undef CODEGEN_OPTION_WITH_MARSHALLING

1531

1532 if (Opts.OptimizationLevel > 0) {

1534 GenerateArg(Consumer, OPT_finline_functions);

1536 GenerateArg(Consumer, OPT_finline_hint_functions);

1539 }

1540

1541 if (Opts.DirectAccessExternalData && LangOpts->PICLevel != 0)

1542 GenerateArg(Consumer, OPT_fdirect_access_external_data);

1543 else if (!Opts.DirectAccessExternalData && LangOpts->PICLevel == 0)

1544 GenerateArg(Consumer, OPT_fno_direct_access_external_data);

1545

1546 std::optional DebugInfoVal;

1547 switch (Opts.DebugInfo) {

1548 case llvm::codegenoptions::DebugLineTablesOnly:

1549 DebugInfoVal = "line-tables-only";

1550 break;

1551 case llvm::codegenoptions::DebugDirectivesOnly:

1552 DebugInfoVal = "line-directives-only";

1553 break;

1554 case llvm::codegenoptions::DebugInfoConstructor:

1555 DebugInfoVal = "constructor";

1556 break;

1557 case llvm::codegenoptions::LimitedDebugInfo:

1558 DebugInfoVal = "limited";

1559 break;

1560 case llvm::codegenoptions::FullDebugInfo:

1561 DebugInfoVal = "standalone";

1562 break;

1563 case llvm::codegenoptions::UnusedTypeInfo:

1564 DebugInfoVal = "unused-types";

1565 break;

1566 case llvm::codegenoptions::NoDebugInfo:

1567 DebugInfoVal = std::nullopt;

1568 break;

1569 case llvm::codegenoptions::LocTrackingOnly:

1570 DebugInfoVal = std::nullopt;

1571 break;

1572 }

1573 if (DebugInfoVal)

1574 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);

1575

1577 GenerateArg(Consumer, OPT_fdebug_prefix_map_EQ,

1578 Prefix.first + "=" + Prefix.second);

1579

1581 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,

1582 Prefix.first + "=" + Prefix.second);

1583

1584 if (Opts.NewStructPathTBAA)

1585 GenerateArg(Consumer, OPT_new_struct_path_tbaa);

1586

1587 if (Opts.OptimizeSize == 1)

1589 else if (Opts.OptimizeSize == 2)

1591

1592

1593

1594

1595

1596

1597 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)

1598 GenerateArg(Consumer, OPT_funroll_loops);

1599 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)

1600 GenerateArg(Consumer, OPT_fno_unroll_loops);

1601

1602 if (Opts.InterchangeLoops)

1603 GenerateArg(Consumer, OPT_floop_interchange);

1604 else

1605 GenerateArg(Consumer, OPT_fno_loop_interchange);

1606

1607 if (Opts.FuseLoops)

1608 GenerateArg(Consumer, OPT_fexperimental_loop_fusion);

1609

1612

1613 if (Opts.DebugNameTable ==

1614 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))

1615 GenerateArg(Consumer, OPT_ggnu_pubnames);

1616 else if (Opts.DebugNameTable ==

1617 static_cast<unsigned>(

1618 llvm::DICompileUnit::DebugNameTableKind::Default))

1620

1621 if (Opts.DebugTemplateAlias)

1622 GenerateArg(Consumer, OPT_gtemplate_alias);

1623

1624 auto TNK = Opts.getDebugSimpleTemplateNames();

1625 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {

1626 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)

1627 GenerateArg(Consumer, OPT_gsimple_template_names_EQ, "simple");

1628 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)

1629 GenerateArg(Consumer, OPT_gsimple_template_names_EQ, "mangled");

1630 }

1631

1632

1633

1634 if (Opts.TimePasses) {

1635 if (Opts.TimePassesPerRun)

1636 GenerateArg(Consumer, OPT_ftime_report_EQ, "per-pass-run");

1637 else

1638 GenerateArg(Consumer, OPT_ftime_report);

1639

1640 if (Opts.TimePassesJson)

1641 GenerateArg(Consumer, OPT_ftime_report_json);

1642 }

1643

1644 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)

1645 GenerateArg(Consumer, OPT_flto_EQ, "full");

1646

1647 if (Opts.PrepareForThinLTO)

1648 GenerateArg(Consumer, OPT_flto_EQ, "thin");

1649

1652

1654 GenerateArg(Consumer, OPT_save_temps_EQ, "obj");

1655

1656 StringRef MemProfileBasename("memprof.profraw");

1659 GenerateArg(Consumer, OPT_fmemory_profile);

1660 } else {

1661 size_t ArgLength =

1663 GenerateArg(Consumer, OPT_fmemory_profile_EQ,

1665 }

1666 }

1667

1669 GenerateArg(Consumer, OPT_coverage_version_EQ,

1671

1672

1673

1674

1675

1677 std::string InstrBundle =

1679 if (!InstrBundle.empty())

1680 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);

1681 }

1682

1683 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)

1684 GenerateArg(Consumer, OPT_fcf_protection_EQ, "full");

1685 else if (Opts.CFProtectionReturn)

1686 GenerateArg(Consumer, OPT_fcf_protection_EQ, "return");

1687 else if (Opts.CFProtectionBranch)

1688 GenerateArg(Consumer, OPT_fcf_protection_EQ, "branch");

1689

1690 if (Opts.CFProtectionBranch) {

1691 switch (Opts.getCFBranchLabelScheme()) {

1693 break;

1694#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \

1695 case CFBranchLabelSchemeKind::Kind: \

1696 GenerateArg(Consumer, OPT_mcf_branch_label_scheme_EQ, #FlagVal); \

1697 break;

1698#include "clang/Basic/CFProtectionOptions.def"

1699 }

1700 }

1701

1702 if (Opts.FunctionReturnThunks)

1703 GenerateArg(Consumer, OPT_mfunction_return_EQ, "thunk-extern");

1704

1706 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&

1707 F.PropagateAttrs && F.Internalize;

1709 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,

1710 F.Filename);

1711 }

1712

1713 if (Opts.EmulatedTLS)

1714 GenerateArg(Consumer, OPT_femulated_tls);

1715

1716 if (Opts.FPDenormalMode != llvm::DenormalMode::getIEEE())

1718

1721 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,

1723

1725 OptSpecifier Opt =

1726 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;

1729 OptSpecifier Opt =

1730 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;

1732 }

1733

1734 if (Opts.EnableAIXExtendedAltivecABI)

1735 GenerateArg(Consumer, OPT_mabi_EQ_vec_extabi);

1736

1737 if (Opts.XCOFFReadOnlyPointers)

1738 GenerateArg(Consumer, OPT_mxcoff_roptr);

1739

1742

1745

1748

1751

1754

1755 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,

1758 : "auto");

1759

1760 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,

1762

1764 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);

1765

1767 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);

1768

1769 for (StringRef Sanitizer :

1771 GenerateArg(Consumer, OPT_fsanitize_merge_handlers_EQ, Sanitizer);

1772

1773 SmallVector<std::string, 4> Values;

1775 for (std::string Sanitizer : Values)

1776 GenerateArg(Consumer, OPT_fsanitize_skip_hot_cutoff_EQ, Sanitizer);

1777

1779 GenerateArg(Consumer, OPT_fallow_runtime_check_skip_hot_cutoff_EQ,

1781 }

1782

1783 for (StringRef Sanitizer :

1785 GenerateArg(Consumer, OPT_fsanitize_annotate_debug_info_EQ, Sanitizer);

1786

1787 if (!Opts.EmitVersionIdentMetadata)

1789

1790 switch (Opts.FiniteLoops) {

1792 break;

1794 GenerateArg(Consumer, OPT_ffinite_loops);

1795 break;

1797 GenerateArg(Consumer, OPT_fno_finite_loops);

1798 break;

1799 }

1800

1801 if (Opts.StaticClosure)

1802 GenerateArg(Consumer, OPT_static_libclosure);

1803}

1804

1805bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,

1808 const llvm::Triple &T,

1809 const std::string &OutputFile,

1811 unsigned NumErrorsBefore = Diags.getNumErrors();

1812

1814

1815

1816

1818

1819

1820 const LangOptions *LangOpts = &LangOptsRef;

1821

1822#define CODEGEN_OPTION_WITH_MARSHALLING(...) \

1823 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

1824#include "clang/Options/Options.inc"

1825#undef CODEGEN_OPTION_WITH_MARSHALLING

1826

1827

1828

1829 if (Opts.OptimizationLevel == 0) {

1831 } else if (const Arg *A = Args.getLastArg(options::OPT_finline_functions,

1832 options::OPT_finline_hint_functions,

1833 options::OPT_fno_inline_functions,

1834 options::OPT_fno_inline)) {

1835

1836

1837 if (A->getOption().matches(options::OPT_finline_functions))

1839 else if (A->getOption().matches(options::OPT_finline_hint_functions))

1841 else

1843 } else {

1845 }

1846

1847

1848

1849 Opts.DirectAccessExternalData =

1850 Args.hasArg(OPT_fdirect_access_external_data) ||

1851 (!Args.hasArg(OPT_fno_direct_access_external_data) &&

1853

1854 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {

1855 unsigned Val =

1856 llvm::StringSwitch(A->getValue())

1857 .Case("line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)

1858 .Case("line-directives-only",

1859 llvm::codegenoptions::DebugDirectivesOnly)

1860 .Case("constructor", llvm::codegenoptions::DebugInfoConstructor)

1861 .Case("limited", llvm::codegenoptions::LimitedDebugInfo)

1862 .Case("standalone", llvm::codegenoptions::FullDebugInfo)

1863 .Case("unused-types", llvm::codegenoptions::UnusedTypeInfo)

1864 .Default(~0U);

1865 if (Val == ~0U)

1866 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)

1867 << A->getValue();

1868 else

1869 Opts.setDebugInfo(static_castllvm::codegenoptions::DebugInfoKind\(Val));

1870 }

1871

1872

1873

1874 if (const Arg *A =

1875 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {

1876 if (A->getOption().matches(OPT_fuse_ctor_homing) &&

1877 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)

1878 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);

1879 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&

1880 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)

1881 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);

1882 }

1883

1884 for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {

1885 auto Split = StringRef(Arg).split('=');

1887 }

1888

1889 for (const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {

1890 auto Split = StringRef(Arg).split('=');

1892 }

1893

1894 const llvm::Triple::ArchType DebugEntryValueArchs[] = {

1895 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,

1896 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,

1897 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el,

1898 llvm::Triple::riscv32, llvm::Triple::riscv64};

1899

1901 llvm::is_contained(DebugEntryValueArchs, T.getArch()))

1902 Opts.EmitCallSiteInfo = true;

1903

1905 Diags.Report(diag::warn_ignoring_verify_debuginfo_preserve_export)

1908 }

1909

1910 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&

1911 Args.hasArg(OPT_new_struct_path_tbaa);

1913 Opts.SimplifyLibCalls = ->NoBuiltin;

1914 if (Opts.SimplifyLibCalls)

1916 Opts.UnrollLoops =

1917 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,

1918 (Opts.OptimizationLevel > 1));

1919 Opts.InterchangeLoops =

1920 Args.hasFlag(OPT_floop_interchange, OPT_fno_loop_interchange, false);

1921 Opts.FuseLoops = Args.hasFlag(OPT_fexperimental_loop_fusion,

1922 OPT_fno_experimental_loop_fusion, false);

1924 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));

1925

1926 Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);

1927

1928 Opts.DebugNameTable = static_cast<unsigned>(

1929 Args.hasArg(OPT_ggnu_pubnames)

1930 ? llvm::DICompileUnit::DebugNameTableKind::GNU

1931 : Args.hasArg(OPT_gpubnames)

1932 ? llvm::DICompileUnit::DebugNameTableKind::Default

1933 : llvm::DICompileUnit::DebugNameTableKind::None);

1934 if (const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {

1935 StringRef Value = A->getValue();

1936 if (Value != "simple" && Value != "mangled")

1937 Diags.Report(diag::err_drv_unsupported_option_argument)

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

1939 Opts.setDebugSimpleTemplateNames(

1940 StringRef(A->getValue()) == "simple"

1941 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple

1942 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);

1943 }

1944

1945 if (Args.hasArg(OPT_ftime_report, OPT_ftime_report_EQ, OPT_ftime_report_json,

1946 OPT_stats_file_timers)) {

1947 Opts.TimePasses = true;

1948

1949

1950 if (const Arg *EQ = Args.getLastArg(OPT_ftime_report_EQ)) {

1951 StringRef Val = EQ->getValue();

1952 if (Val == "per-pass")

1953 Opts.TimePassesPerRun = false;

1954 else if (Val == "per-pass-run")

1955 Opts.TimePassesPerRun = true;

1956 else

1957 Diags.Report(diag::err_drv_invalid_value)

1958 << EQ->getAsString(Args) << EQ->getValue();

1959 }

1960

1961 if (Args.getLastArg(OPT_ftime_report_json))

1962 Opts.TimePassesJson = true;

1963 }

1964

1965 Opts.PrepareForLTO = false;

1966 Opts.PrepareForThinLTO = false;

1967 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {

1968 Opts.PrepareForLTO = true;

1969 StringRef S = A->getValue();

1970 if (S == "thin")

1971 Opts.PrepareForThinLTO = true;

1972 else if (S != "full")

1973 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;

1974 if (Args.hasArg(OPT_funified_lto))

1975 Opts.PrepareForThinLTO = true;

1976 }

1977 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {

1979 Diags.Report(diag::err_drv_argument_only_allowed_with)

1980 << A->getAsString(Args) << "-x ir";

1982 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));

1983 }

1984 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))

1986 llvm::StringSwitchstd::string(A->getValue())

1987 .Case("obj", OutputFile)

1988 .Default(llvm::sys::path::filename(OutputFile).str());

1989

1990

1991 const char *MemProfileBasename = "memprof.profraw";

1992 if (Args.hasArg(OPT_fmemory_profile_EQ)) {

1993 SmallString<128> Path(Args.getLastArgValue(OPT_fmemory_profile_EQ));

1994 llvm::sys::path::append(Path, MemProfileBasename);

1996 } else if (Args.hasArg(OPT_fmemory_profile))

1998

2000 if (Args.hasArg(OPT_coverage_version_EQ)) {

2001 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);

2002 if (CoverageVersion.size() != 4) {

2003 Diags.Report(diag::err_drv_invalid_value)

2004 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)

2005 << CoverageVersion;

2006 } else {

2008 }

2009 }

2010 }

2011

2012

2013

2014 for (const auto &A : Args) {

2015

2016 if (A->getOption().getID() == options::OPT_o ||

2017 A->getOption().getID() == options::OPT_INPUT ||

2018 A->getOption().getID() == options::OPT_x ||

2019 A->getOption().getID() == options::OPT_fembed_bitcode ||

2020 A->getOption().matches(options::OPT_W_Group))

2021 continue;

2022 ArgStringList ASL;

2023 A->render(Args, ASL);

2024 for (const auto &arg : ASL) {

2025 StringRef ArgStr(arg);

2026 llvm::append_range(Opts.CmdArgs, ArgStr);

2027

2028 Opts.CmdArgs.push_back('\0');

2029 }

2030 }

2031

2032 auto XRayInstrBundles =

2033 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);

2034 if (XRayInstrBundles.empty())

2036 else

2037 for (const auto &A : XRayInstrBundles)

2040

2041 if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {

2042 StringRef Name = A->getValue();

2043 if (Name == "full") {

2044 Opts.CFProtectionReturn = 1;

2045 Opts.CFProtectionBranch = 1;

2046 } else if (Name == "return")

2047 Opts.CFProtectionReturn = 1;

2048 else if (Name == "branch")

2049 Opts.CFProtectionBranch = 1;

2050 else if (Name != "none")

2051 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;

2052 }

2053

2054 if (Opts.CFProtectionBranch && T.isRISCV()) {

2055 if (const Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {

2056 const auto Scheme =

2057 llvm::StringSwitch(A->getValue())

2058#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \

2059 .Case(#FlagVal, CFBranchLabelSchemeKind::Kind)

2060#include "clang/Basic/CFProtectionOptions.def"

2063 Opts.setCFBranchLabelScheme(Scheme);

2064 else

2065 Diags.Report(diag::err_drv_invalid_value)

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

2067 }

2068 }

2069

2070 if (const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {

2071 auto Val = llvm::StringSwitchllvm::FunctionReturnThunksKind(A->getValue())

2072 .Case("keep", llvm::FunctionReturnThunksKind::Keep)

2073 .Case("thunk-extern", llvm::FunctionReturnThunksKind::Extern)

2074 .Default(llvm::FunctionReturnThunksKind::Invalid);

2075

2076 if (.isX86())

2077 Diags.Report(diag::err_drv_argument_not_allowed_with)

2078 << A->getSpelling() << T.getTriple();

2079 else if (Val == llvm::FunctionReturnThunksKind::Invalid)

2080 Diags.Report(diag::err_drv_invalid_value)

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

2082 else if (Val == llvm::FunctionReturnThunksKind::Extern &&

2083 Args.getLastArgValue(OPT_mcmodel_EQ) == "large")

2084 Diags.Report(diag::err_drv_argument_not_allowed_with)

2085 << A->getAsString(Args)

2086 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);

2087 else

2088 Opts.FunctionReturnThunks = static_cast<unsigned>(Val);

2089 }

2090

2091 for (auto *A :

2092 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {

2093 CodeGenOptions::BitcodeFileToLink F;

2095 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {

2096 F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;

2097

2098

2101 }

2103 }

2104

2105 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {

2106 StringRef Val = A->getValue();

2107 Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val);

2110 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;

2111 }

2112

2113 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {

2114 StringRef Val = A->getValue();

2115 Opts.FP32DenormalMode = llvm::parseDenormalFPAttribute(Val);

2117 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;

2118 }

2119

2120

2121

2122 if (Arg *A =

2123 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,

2124 OPT_maix_struct_return, OPT_msvr4_struct_return)) {

2125

2126

2127 if (T.isOSAIX())

2128 Diags.Report(diag::err_drv_unsupported_opt_for_target)

2129 << A->getSpelling() << T.str();

2130

2131 const Option &O = A->getOption();

2132 if (O.matches(OPT_fpcc_struct_return) ||

2133 O.matches(OPT_maix_struct_return)) {

2135 } else {

2136 assert(O.matches(OPT_freg_struct_return) ||

2137 O.matches(OPT_msvr4_struct_return));

2139 }

2140 }

2141

2142 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {

2143 if (.isOSAIX())

2144 Diags.Report(diag::err_drv_unsupported_opt_for_target)

2145 << A->getSpelling() << T.str();

2146

2147

2148

2149

2150

2151

2152

2153

2154

2155 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections, false))

2156 Diags.Report(diag::err_roptr_requires_data_sections);

2157

2158 Opts.XCOFFReadOnlyPointers = true;

2159 }

2160

2161 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {

2162 if (.isOSAIX() || T.isPPC32())

2163 Diags.Report(diag::err_drv_unsupported_opt_for_target)

2164 << A->getSpelling() << T.str();

2165 }

2166

2167 bool NeedLocTracking = false;

2168

2170 NeedLocTracking = true;

2171

2172 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {

2174 NeedLocTracking = true;

2175 }

2176

2177 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {

2179 NeedLocTracking = true;

2180 }

2181

2184

2187

2189 Diags, Args, OPT_Rpass_analysis_EQ, "pass-analysis");

2190

2194

2196 bool UsingProfile =

2198

2199 if (Opts.DiagnosticsWithHotness && !UsingProfile &&

2200

2202 Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)

2203 << "-fdiagnostics-show-hotness";

2204

2205

2206 if (auto *arg =

2207 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {

2208 auto ResultOrErr =

2209 llvm::remarks::parseHotnessThresholdOption(arg->getValue());

2210

2211 if (!ResultOrErr) {

2212 Diags.Report(diag::err_drv_invalid_diagnotics_hotness_threshold)

2213 << "-fdiagnostics-hotness-threshold=";

2214 } else {

2218 !UsingProfile)

2219 Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)

2220 << "-fdiagnostics-hotness-threshold=";

2221 }

2222 }

2223

2224 if (auto *arg =

2225 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {

2227

2228 if (!ResultOrErr) {

2229 Diags.Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)

2230 << "-fdiagnostics-misexpect-tolerance=";

2231 } else {

2235 !UsingProfile)

2236 Diags.Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)

2237 << "-fdiagnostics-misexpect-tolerance=";

2238 }

2239 }

2240

2241

2242

2243

2244 if (UsingSampleProfile)

2245 NeedLocTracking = true;

2246

2248 NeedLocTracking = true;

2249

2250

2251

2252 if (NeedLocTracking &&

2253 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)

2254 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);

2255

2256

2257

2259 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,

2262 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,

2265 Args.getAllArgValues(OPT_fsanitize_merge_handlers_EQ),

2267

2268

2270 "-fsanitize-skip-hot-cutoff=",

2271 Args.getAllArgValues(OPT_fsanitize_skip_hot_cutoff_EQ), Diags);

2272

2274 "-fsanitize-annotate-debug-info=",

2275 Args.getAllArgValues(OPT_fsanitize_annotate_debug_info_EQ), Diags,

2277

2278 if (StringRef V =

2279 Args.getLastArgValue(OPT_fallow_runtime_check_skip_hot_cutoff_EQ);

2280 .empty()) {

2281 double A;

2282 if (V.getAsDouble(A) || A < 0.0 || A > 1.0) {

2283 Diags.Report(diag::err_drv_invalid_value)

2284 << "-fallow-runtime-check-skip-hot-cutoff=" << V;

2285 } else {

2287 }

2288 }

2289

2290 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);

2291

2292 if (->CUDAIsDevice)

2294

2295 if (Args.hasArg(options::OPT_ffinite_loops))

2297 else if (Args.hasArg(options::OPT_fno_finite_loops))

2299

2300 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(

2301 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee, true);

2302 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)

2303 Diags.Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);

2304

2305 Opts.StaticClosure = Args.hasArg(options::OPT_static_libclosure);

2306

2307 return Diags.getNumErrors() == NumErrorsBefore;

2308}

2309

2313#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \

2314 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

2315#include "clang/Options/Options.inc"

2316#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING

2317

2319 GenerateArg(Consumer, OPT_show_includes);

2320

2321 for (const auto &Dep : Opts.ExtraDeps) {

2322 switch (Dep.second) {

2324

2325 continue;

2327

2328

2329 continue;

2331

2332

2333 continue;

2335 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);

2336 break;

2337 }

2338 }

2339}

2340

2344 bool ShowLineMarkers) {

2345 unsigned NumErrorsBefore = Diags.getNumErrors();

2346

2348#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \

2349 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

2350#include "clang/Options/Options.inc"

2351#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING

2352

2353 if (Args.hasArg(OPT_show_includes)) {

2354

2355

2356

2359 else

2361 } else {

2363 }

2364

2365

2366

2367

2368 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {

2369 for (const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {

2370 StringRef Val = A->getValue();

2371 if (!Val.contains('='))

2373 }

2375 for (const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {

2376 StringRef Val = A->getValue();

2377 if (!Val.contains('='))

2379 }

2380 }

2381 }

2382

2383

2384 for (const auto &Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))

2386

2387

2388 for (const auto *A : Args.filtered(OPT_fdepfile_entry))

2390

2391

2392 for (const auto *A : Args.filtered(OPT_fmodule_file)) {

2393 StringRef Val = A->getValue();

2394 if (!Val.contains('='))

2396 }

2397

2398

2399

2402 if (Args.hasArg(OPT_header_include_format_EQ))

2403 Diags.Report(diag::err_drv_print_header_cc1_invalid_combination)

2406 else

2407 Diags.Report(diag::err_drv_print_header_cc1_invalid_filtering)

2411 if (Args.hasArg(OPT_header_include_filtering_EQ))

2412 Diags.Report(diag::err_drv_print_header_cc1_invalid_combination)

2415 else

2416 Diags.Report(diag::err_drv_print_header_cc1_invalid_format)

2418 }

2419

2420 return Diags.getNumErrors() == NumErrorsBefore;

2421}

2422

2424

2425

2426

2427

2428 enum {

2429 Colors_On,

2430 Colors_Off,

2431 Colors_Auto

2432 } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;

2433 for (auto *A : Args) {

2434 const Option &O = A->getOption();

2435 if (O.matches(options::OPT_fcolor_diagnostics)) {

2436 ShowColors = Colors_On;

2437 } else if (O.matches(options::OPT_fno_color_diagnostics)) {

2438 ShowColors = Colors_Off;

2439 } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {

2440 StringRef Value(A->getValue());

2441 if (Value == "always")

2442 ShowColors = Colors_On;

2443 else if (Value == "never")

2444 ShowColors = Colors_Off;

2445 else if (Value == "auto")

2446 ShowColors = Colors_Auto;

2447 }

2448 }

2449 return ShowColors == Colors_On ||

2450 (ShowColors == Colors_Auto &&

2451 llvm::sys::Process::StandardErrHasColors());

2452}

2453

2457 for (const auto &Prefix : VerifyPrefixes) {

2458

2459

2460 auto BadChar = llvm::find_if(Prefix, [](char C) {

2462 });

2463 if (BadChar != Prefix.end() || (Prefix[0])) {

2465 Diags.Report(diag::err_drv_invalid_value) << "-verify=" << Prefix;

2466 Diags.Report(diag::note_drv_verify_prefix_spelling);

2467 }

2468 }

2470}

2471

2475

2476#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \

2477 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

2478#include "clang/Options/Options.inc"

2479#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING

2480}

2481

2484 unsigned NumErrorsBefore = Diags.getNumErrors();

2485

2487

2488#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \

2489 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

2490#include "clang/Options/Options.inc"

2491#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING

2492

2493 return Diags.getNumErrors() == NumErrorsBefore;

2494}

2495

2499#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \

2500 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

2501#include "clang/Options/Options.inc"

2502#undef MIGRATOR_OPTION_WITH_MARSHALLING

2503}

2504

2507 unsigned NumErrorsBefore = Diags.getNumErrors();

2508

2510

2511#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \

2512 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

2513#include "clang/Options/Options.inc"

2514#undef MIGRATOR_OPTION_WITH_MARSHALLING

2515

2516 return Diags.getNumErrors() == NumErrorsBefore;

2517}

2518

2519void CompilerInvocationBase::GenerateDiagnosticArgs(

2521 bool DefaultDiagColor) {

2523#define DIAG_OPTION_WITH_MARSHALLING(...) \

2524 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

2525#include "clang/Options/Options.inc"

2526#undef DIAG_OPTION_WITH_MARSHALLING

2527

2529 GenerateArg(Consumer, OPT_diagnostic_serialized_file,

2531

2532 if (Opts.ShowColors)

2533 GenerateArg(Consumer, OPT_fcolor_diagnostics);

2534

2535 if (Opts.VerifyDiagnostics &&

2536 llvm::is_contained(Opts.VerifyPrefixes, "expected"))

2538

2540 if (Prefix != "expected")

2541 GenerateArg(Consumer, OPT_verify_EQ, Prefix);

2542

2545

2547 GenerateArg(Consumer, OPT_verify_ignore_unexpected);

2548 } else {

2550 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ, "note");

2552 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ, "remark");

2554 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ, "warning");

2556 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ, "error");

2557 }

2558

2560

2561 if (Warning == "undef-prefix")

2562 continue;

2563

2564 if (Warning == "invalid-constexpr" || Warning == "no-invalid-constexpr")

2565 continue;

2566 Consumer(StringRef("-W") + Warning);

2567 }

2568

2570

2571

2572 StringRef IgnoredRemarks[] = {"pass", "no-pass",

2573 "pass-analysis", "no-pass-analysis",

2574 "pass-missed", "no-pass-missed"};

2575 if (llvm::is_contained(IgnoredRemarks, Remark))

2576 continue;

2577

2578 Consumer(StringRef("-R") + Remark);

2579 }

2580

2582 GenerateArg(Consumer, OPT_warning_suppression_mappings_EQ,

2584 }

2585}

2586

2587std::unique_ptr

2589 auto DiagOpts = std::make_unique();

2590 unsigned MissingArgIndex, MissingArgCount;

2592 Argv.slice(1), MissingArgIndex, MissingArgCount);

2593

2594 bool ShowColors = true;

2595 if (std::optionalstd::string NoColor =

2596 llvm::sys::Process::GetEnv("NO_COLOR");

2597 NoColor && !NoColor->empty()) {

2598

2599

2600 ShowColors = false;

2601 }

2602

2603

2604

2605

2606 (void)ParseDiagnosticArgs(*DiagOpts, Args, nullptr, ShowColors);

2607 return DiagOpts;

2608}

2609

2612 bool DefaultDiagColor) {

2613 std::optional IgnoringDiagOpts;

2614 std::optional IgnoringDiags;

2615 if (!Diags) {

2616 IgnoringDiagOpts.emplace();

2619 Diags = &*IgnoringDiags;

2620 }

2621

2622 unsigned NumErrorsBefore = Diags->getNumErrors();

2623

2624

2625

2627

2628#define DIAG_OPTION_WITH_MARSHALLING(...) \

2629 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)

2630#include "clang/Options/Options.inc"

2631#undef DIAG_OPTION_WITH_MARSHALLING

2632

2633 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);

2634

2635 if (Arg *A =

2636 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))

2639

2640 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);

2641 Opts.VerifyPrefixes = Args.getAllArgValues(OPT_verify_EQ);

2642 if (Args.hasArg(OPT_verify))

2644

2645

2647 Opts.VerifyDiagnostics = false;

2648 else

2652 "-verify-ignore-unexpected=",

2653 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);

2654 if (Args.hasArg(OPT_verify_ignore_unexpected))

2656 Opts.setVerifyIgnoreUnexpected(DiagMask);

2658 Diags->Report(diag::warn_ignoring_ftabstop_value)

2661 }

2662

2663 if (const Arg *A = Args.getLastArg(OPT_warning_suppression_mappings_EQ))

2665

2668

2669 return Diags->getNumErrors() == NumErrorsBefore;

2670}

2671

2674 unsigned DefaultOpt = 0;

2677 !Args.hasArg(OPT_cl_opt_disable))

2678 DefaultOpt = 2;

2679

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

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

2682 return 0;

2683

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

2685 return 3;

2686

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

2688

2689 StringRef S(A->getValue());

2690 if (S == "s" || S == "z")

2691 return 2;

2692

2693 if (S == "g")

2694 return 1;

2695

2697 }

2698

2699 unsigned MaxOptLevel = 3;

2700 if (DefaultOpt > MaxOptLevel) {

2701

2702

2703 Diags.Report(diag::warn_drv_optimization_value)

2704 << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel;

2705 DefaultOpt = MaxOptLevel;

2706 }

2707

2708 return DefaultOpt;

2709}

2710

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

2713 if (A->getOption().matches(options::OPT_O)) {

2714 switch (A->getValue()[0]) {

2715 default:

2716 return 0;

2717 case 's':

2718 return 1;

2719 case 'z':

2720 return 2;

2721 }

2722 }

2723 }

2724 return 0;

2725}

2726

2727

2728

2729

2730

2732 std::string &BlockName,

2733 unsigned &MajorVersion,

2734 unsigned &MinorVersion,

2735 bool &Hashed,

2736 std::string &UserInfo) {

2738 Arg.split(Args, ':', 5);

2739 if (Args.size() < 5)

2740 return true;

2741

2742 BlockName = std::string(Args[0]);

2743 if (Args[1].getAsInteger(10, MajorVersion)) return true;

2744 if (Args[2].getAsInteger(10, MinorVersion)) return true;

2745 if (Args[3].getAsInteger(2, Hashed)) return true;

2746 if (Args.size() > 4)

2747 UserInfo = std::string(Args[4]);

2748 return false;

2749}

2750

2751

2752

2753

2754

2756 static const std::pair<frontend::ActionKind, unsigned> Table[] = {

2758

2765

2780

2783

2787 OPT_emit_reduced_module_interface},

2804 OPT_print_dependency_directives_minimized_source},

2805 };

2806

2807 return Table;

2808}

2809

2810

2811static std::optionalfrontend::ActionKind

2814 if (ActionOpt.second == Opt.getID())

2815 return ActionOpt.first;

2816

2817 return std::nullopt;

2818}

2819

2820

2821static std::optional

2824 if (ActionOpt.first == ProgramAction)

2825 return OptSpecifier(ActionOpt.second);

2826

2827 return std::nullopt;

2828}

2829

2833#define FRONTEND_OPTION_WITH_MARSHALLING(...) \

2834 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

2835#include "clang/Options/Options.inc"

2836#undef FRONTEND_OPTION_WITH_MARSHALLING

2837

2838 std::optional ProgramActionOpt =

2840

2841

2842 std::function<void()> GenerateProgramAction = [&]() {

2843 GenerateArg(Consumer, *ProgramActionOpt);

2844 };

2845

2846 if (!ProgramActionOpt) {

2847

2849 "Frontend action without option.");

2850 GenerateProgramAction = [&]() {

2852 };

2853 }

2854

2855

2857 GenerateProgramAction = [&]() {

2858

2859

2860

2862 StringRef Format;

2865 llvm_unreachable("Default AST dump format.");

2867 Format = "json";

2868 break;

2869 }

2870

2872 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);

2874 GenerateArg(Consumer, OPT_ast_dump_EQ, Format);

2875 } else {

2877 GenerateArg(Consumer, OPT_ast_dump_all);

2880 }

2881 };

2882 }

2883

2885 GenerateProgramAction = [&]() {

2887 };

2888 }

2889

2890 GenerateProgramAction();

2891

2892 for (const auto &PluginArgs : Opts.PluginArgs) {

2894 for (const auto &PluginArg : PluginArgs.second)

2896 Opt.getPrefix() + Opt.getName() + PluginArgs.first,

2897 Opt.getKind(), 0, PluginArg);

2898 }

2899

2901 if (auto *TestExt = dyn_cast_or_null(Ext.get()))

2902 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());

2903

2905 GenerateArg(Consumer, OPT_code_completion_at,

2907

2908 for (const auto &Plugin : Opts.Plugins)

2909 GenerateArg(Consumer, OPT_load, Plugin);

2910

2911

2912

2913 for (const auto &ModuleFile : Opts.ModuleFiles)

2914 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);

2915

2918

2922

2923 {

2924 StringRef Preprocessed = Opts.DashX.isPreprocessed() ? "-cpp-output" : "";

2927 StringRef HeaderUnit = "";

2930 break;

2932 HeaderUnit = "-user";

2933 break;

2935 HeaderUnit = "-system";

2936 break;

2938 HeaderUnit = "-header-unit";

2939 break;

2940 }

2941 StringRef Header = IsHeader ? "-header" : "";

2942

2943 StringRef Lang;

2946 Lang = "c";

2947 break;

2949 Lang = "cl";

2950 break;

2952 Lang = "clcpp";

2953 break;

2955 Lang = "cuda";

2956 break;

2958 Lang = "hip";

2959 break;

2961 Lang = "c++";

2962 break;

2964 Lang = "objective-c";

2965 break;

2967 Lang = "objective-c++";

2968 break;

2970 Lang = "assembler-with-cpp";

2971 break;

2974 "Generating -x argument for unknown language (not precompiled).");

2975 Lang = "ast";

2976 break;

2978 Lang = "ir";

2979 break;

2981 Lang = "hlsl";

2982 break;

2984 Lang = "cir";

2985 break;

2986 }

2987

2989 Lang + HeaderUnit + Header + ModuleMap + Preprocessed);

2990 }

2991

2992

2993 for (const auto &Input : Opts.Inputs)

2994 Consumer(Input.getFile());

2995}

2996

2999 unsigned NumErrorsBefore = Diags.getNumErrors();

3000

3002

3003#define FRONTEND_OPTION_WITH_MARSHALLING(...) \

3004 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

3005#include "clang/Options/Options.inc"

3006#undef FRONTEND_OPTION_WITH_MARSHALLING

3007

3009 if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {

3010 OptSpecifier Opt = OptSpecifier(A->getOption().getID());

3011 std::optionalfrontend::ActionKind ProgramAction = getFrontendAction(Opt);

3012 assert(ProgramAction && "Option specifier not in Action_Group.");

3013

3015 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {

3016 unsigned Val = llvm::StringSwitch(A->getValue())

3019 .Default(std::numeric_limits::max());

3020

3021 if (Val != std::numeric_limits::max())

3023 else {

3024 Diags.Report(diag::err_drv_invalid_value)

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

3027 }

3028 }

3029

3030 if (ProgramAction == frontend::FixIt && Opt == OPT_fixit_EQ)

3032

3034 StringRef ArgStr =

3035 Args.hasArg(OPT_interface_stub_version_EQ)

3036 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)

3037 : "ifs-v1";

3038 if (ArgStr == "experimental-yaml-elf-v1" ||

3039 ArgStr == "experimental-ifs-v1" || ArgStr == "experimental-ifs-v2" ||

3040 ArgStr == "experimental-tapi-elf-v1") {

3041 std::string ErrorMessage =

3042 "Invalid interface stub format: " + ArgStr.str() +

3043 " is deprecated.";

3044 Diags.Report(diag::err_drv_invalid_value)

3045 << "Must specify a valid interface stub format type, ie: "

3046 "-interface-stub-version=ifs-v1"

3047 << ErrorMessage;

3049 } else if (!ArgStr.starts_with("ifs-")) {

3050 std::string ErrorMessage =

3051 "Invalid interface stub format: " + ArgStr.str() + ".";

3052 Diags.Report(diag::err_drv_invalid_value)

3053 << "Must specify a valid interface stub format type, ie: "

3054 "-interface-stub-version=ifs-v1"

3055 << ErrorMessage;

3057 }

3058 }

3059

3061

3062

3063

3064

3065

3066

3067

3068

3069 if (!A->getSpelling().starts_with("-ast-dump")) {

3070 const Arg *SavedAction = nullptr;

3071 for (const Arg *AA :

3072 Args.filtered(OPT_Action_Group, OPT_main_file_name)) {

3073 if (AA->getOption().matches(OPT_main_file_name)) {

3074 SavedAction = nullptr;

3075 } else if (!SavedAction) {

3076 SavedAction = AA;

3077 } else {

3078 if (!A->getOption().matches(OPT_ast_dump_EQ))

3079 Diags.Report(diag::err_fe_invalid_multiple_actions)

3080 << SavedAction->getSpelling() << A->getSpelling();

3081 break;

3082 }

3083 }

3084 }

3085 }

3086

3087 if (const Arg* A = Args.getLastArg(OPT_plugin)) {

3088 Opts.Plugins.emplace_back(A->getValue(0));

3091 }

3092 for (const auto *AA : Args.filtered(OPT_plugin_arg))

3093 Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));

3094

3095 for (const std::string &Arg :

3096 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {

3097 std::string BlockName;

3098 unsigned MajorVersion;

3099 unsigned MinorVersion;

3100 bool Hashed;

3101 std::string UserInfo;

3103 MinorVersion, Hashed, UserInfo)) {

3104 Diags.Report(diag::err_test_module_file_extension_format) << Arg;

3105

3106 continue;

3107 }

3108

3109

3111 std::make_shared(

3112 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));

3113 }

3114

3115 if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {

3119 Diags.Report(diag::err_drv_invalid_value)

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

3121 Diags.Report(diag::note_command_line_code_loc_requirement);

3122 }

3123 }

3124

3125 Opts.Plugins = Args.getAllArgValues(OPT_load);

3126 Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);

3127 Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);

3128

3129 for (const auto *A : Args.filtered(OPT_fmodule_file)) {

3130 StringRef Val = A->getValue();

3131 if (!Val.contains('='))

3132 Opts.ModuleFiles.push_back(std::string(Val));

3133 }

3134

3136 Diags.Report(diag::err_drv_argument_only_allowed_with) << "-fsystem-module"

3137 << "-emit-module";

3138 if (Args.hasArg(OPT_fclangir) || Args.hasArg(OPT_emit_cir))

3140

3141#if CLANG_ENABLE_CIR

3142 if (Args.hasArg(OPT_clangir_disable_passes))

3144

3145 if (Args.hasArg(OPT_clangir_disable_verifier))

3147#endif

3148

3149 if (Args.hasArg(OPT_aux_target_cpu))

3150 Opts.AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));

3151 if (Args.hasArg(OPT_aux_target_feature))

3152 Opts.AuxTargetFeatures = Args.getAllArgValues(OPT_aux_target_feature);

3153

3155 if (const Arg *A = Args.getLastArg(OPT_x)) {

3156 StringRef XValue = A->getValue();

3157

3158

3159

3160

3161 bool Preprocessed = XValue.consume_back("-cpp-output");

3162 bool ModuleMap = XValue.consume_back("-module-map");

3163

3164 bool IsHeader =

3165 XValue != "precompiled-header" && XValue.consume_back("-header");

3166

3167

3168

3169

3171 if (IsHeader || Preprocessed) {

3172 if (XValue.consume_back("-header-unit"))

3174 else if (XValue.consume_back("-system"))

3176 else if (XValue.consume_back("-user"))

3178 }

3179

3180

3181

3182 IsHeaderFile = IsHeader && !Preprocessed && &&

3184

3185

3186 DashX = llvm::StringSwitch(XValue)

3197

3198

3199

3200 if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && &&

3202 DashX = llvm::StringSwitch(XValue)

3206

3207

3208 if (DashX.isUnknown() && !Preprocessed && !IsHeaderFile && &&

3210 DashX = llvm::StringSwitch(XValue)

3213 .Cases({"ast", "pcm", "precompiled-header"},

3218

3220 Diags.Report(diag::err_drv_invalid_value)

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

3222

3223 if (Preprocessed)

3225

3228 IsHeaderFile = true;

3229 } else if (IsHeaderFile)

3233 }

3234

3235

3236 std::vectorstd::string Inputs = Args.getAllArgValues(OPT_INPUT);

3237 Opts.Inputs.clear();

3238 if (Inputs.empty())

3239 Inputs.push_back("-");

3240

3242 Inputs.size() > 1)

3243 Diags.Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];

3244

3245 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {

3249 StringRef(Inputs[i]).rsplit('.').second);

3250

3253

3254 if (i == 0)

3255 DashX = IK;

3256 }

3257

3258 bool IsSystem = false;

3259

3260

3265 }

3266

3267 Opts.Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);

3268 }

3269

3270 Opts.DashX = DashX;

3271

3272 return Diags.getNumErrors() == NumErrorsBefore;

3273}

3274

3278#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \

3279 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

3280#include "clang/Options/Options.inc"

3281#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING

3282

3284 GenerateArg(Consumer, OPT_stdlib_EQ, "libc++");

3285

3287 GenerateArg(Consumer, OPT_fmodule_file, File.first + "=" + File.second);

3288

3290 GenerateArg(Consumer, OPT_fprebuilt_module_path, Path);

3291

3293 GenerateArg(Consumer, OPT_fmodules_ignore_macro, Macro.val());

3294

3297 std::optional IsFramework,

3298 std::optional IgnoreSysRoot) {

3299 return llvm::is_contained(Groups, Entry.Group) &&

3300 (!IsFramework || (Entry.IsFramework == *IsFramework)) &&

3301 (!IgnoreSysRoot || (Entry.IgnoreSysRoot == *IgnoreSysRoot));

3302 };

3303

3306

3307

3308 for (; It < End && Matches(*It, {frontend::Angled}, std::nullopt, true);

3309 ++It) {

3310 OptSpecifier Opt = [It, Matches]() {

3312 return OPT_F;

3314 return OPT_I;

3315 llvm_unreachable("Unexpected HeaderSearchOptions::Entry.");

3316 }();

3317

3319 }

3320

3321

3322

3323

3324

3325 for (; It < End &&

3327 ++It) {

3328 OptSpecifier Opt =

3329 It->Group == frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;

3331 }

3332

3333

3334

3335

3336 for (; It < End && Matches(*It, {frontend::After}, false, true); ++It)

3337 GenerateArg(Consumer, OPT_idirafter, It->Path);

3338 for (; It < End && Matches(*It, {frontend::Quoted}, false, true); ++It)

3339 GenerateArg(Consumer, OPT_iquote, It->Path);

3340 for (; It < End && Matches(*It, {frontend::System}, false, std::nullopt);

3341 ++It)

3342 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,

3343 It->Path);

3344 for (; It < End && Matches(*It, {frontend::System}, true, true); ++It)

3345 GenerateArg(Consumer, OPT_iframework, It->Path);

3346 for (; It < End && Matches(*It, {frontend::System}, true, false); ++It)

3347 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);

3348

3349

3350 for (; It < End && Matches(*It, {frontend::CSystem}, false, true); ++It)

3351 GenerateArg(Consumer, OPT_c_isystem, It->Path);

3352 for (; It < End && Matches(*It, {frontend::CXXSystem}, false, true); ++It)

3353 GenerateArg(Consumer, OPT_cxx_isystem, It->Path);

3355 GenerateArg(Consumer, OPT_objc_isystem, It->Path);

3357 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);

3358

3359

3360

3361

3362

3363 for (; It < End &&

3365 ++It) {

3367 ? OPT_internal_isystem

3368 : OPT_internal_externc_isystem;

3370 }

3371 for (; It < End && Matches(*It, {frontend::System}, true, true); ++It)

3372 GenerateArg(Consumer, OPT_internal_iframework, It->Path);

3373

3374 assert(It == End && "Unhandled HeaderSearchOption::Entry.");

3375

3376

3378 OptSpecifier Opt = P.IsSystemHeader ? OPT_system_header_prefix

3379 : OPT_no_system_header_prefix;

3381 }

3382

3384 GenerateArg(Consumer, OPT_ivfsoverlay, F);

3385}

3386

3389 unsigned NumErrorsBefore = Diags.getNumErrors();

3390

3392

3393#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \

3394 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

3395#include "clang/Options/Options.inc"

3396#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING

3397

3398 if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))

3399 Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);

3400

3401

3402 for (const auto *A : Args.filtered(OPT_fmodule_file)) {

3403 StringRef Val = A->getValue();

3404 if (Val.contains('=')) {

3405 auto Split = Val.split('=');

3407 std::string(Split.first), std::string(Split.second));

3408 }

3409 }

3410 for (const auto *A : Args.filtered(OPT_fprebuilt_module_path))

3412

3413 for (const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {

3414 StringRef MacroDef = A->getValue();

3416 llvm::CachedHashString(MacroDef.split('=').first));

3417 }

3418

3419

3420 bool IsSysrootSpecified =

3421 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);

3422

3423

3424

3425 auto PrefixHeaderPath = [IsSysrootSpecified,

3426 &Opts](const llvm::opt::Arg *A,

3427 bool IsFramework = false) -> std::string {

3428 assert(A->getNumValues() && "Unexpected empty search path flag!");

3429 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {

3431 llvm::sys::path::append(Buffer, Opts.Sysroot,

3432 llvm::StringRef(A->getValue()).substr(1));

3433 return std::string(Buffer);

3434 }

3435 return A->getValue();

3436 };

3437

3438 for (const auto *A : Args.filtered(OPT_I, OPT_F)) {

3439 bool IsFramework = A->getOption().matches(OPT_F);

3441 IsFramework, true);

3442 }

3443

3444

3445 StringRef Prefix = "";

3446 for (const auto *A :

3447 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {

3448 if (A->getOption().matches(OPT_iprefix))

3449 Prefix = A->getValue();

3450 else if (A->getOption().matches(OPT_iwithprefix))

3452 else

3454 }

3455

3456 for (const auto *A : Args.filtered(OPT_idirafter))

3458 for (const auto *A : Args.filtered(OPT_iquote))

3460

3461 for (const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {

3462 if (A->getOption().matches(OPT_iwithsysroot)) {

3464 false);

3465 continue;

3466 }

3468 }

3469 for (const auto *A : Args.filtered(OPT_iframework))

3471 for (const auto *A : Args.filtered(OPT_iframeworkwithsysroot))

3473 false);

3474

3475

3476 for (const auto *A : Args.filtered(OPT_c_isystem))

3478 for (const auto *A : Args.filtered(OPT_cxx_isystem))

3480 for (const auto *A : Args.filtered(OPT_objc_isystem))

3482 for (const auto *A : Args.filtered(OPT_objcxx_isystem))

3484

3485

3486 for (const auto *A :

3487 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {

3489 if (A->getOption().matches(OPT_internal_externc_isystem))

3491 Opts.AddPath(A->getValue(), Group, false, true);

3492 }

3493 for (const auto *A : Args.filtered(OPT_internal_iframework))

3495

3496

3497 for (const auto *A :

3498 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))

3500 A->getValue(), A->getOption().matches(OPT_system_header_prefix));

3501

3502 for (const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))

3504

3505 return Diags.getNumErrors() == NumErrorsBefore;

3506}

3507

3511 GenerateArg(Consumer, OPT_fapinotes_swift_version,

3513

3515 GenerateArg(Consumer, OPT_iapinotes_modules, Path);

3516}

3517

3520 if (const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {

3521 if (Opts.SwiftVersion.tryParse(A->getValue()))

3522 diags.Report(diag::err_drv_invalid_value)

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

3524 }

3525 for (const Arg *A : Args.filtered(OPT_iapinotes_modules))

3527}

3528

3531 if (Opts.PointerAuthIntrinsics)

3532 GenerateArg(Consumer, OPT_fptrauth_intrinsics);

3533 if (Opts.PointerAuthCalls)

3534 GenerateArg(Consumer, OPT_fptrauth_calls);

3535 if (Opts.PointerAuthReturns)

3536 GenerateArg(Consumer, OPT_fptrauth_returns);

3537 if (Opts.PointerAuthIndirectGotos)

3538 GenerateArg(Consumer, OPT_fptrauth_indirect_gotos);

3539 if (Opts.PointerAuthAuthTraps)

3540 GenerateArg(Consumer, OPT_fptrauth_auth_traps);

3541 if (Opts.PointerAuthVTPtrAddressDiscrimination)

3542 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_address_discrimination);

3543 if (Opts.PointerAuthVTPtrTypeDiscrimination)

3544 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_type_discrimination);

3545 if (Opts.PointerAuthTypeInfoVTPtrDiscrimination)

3546 GenerateArg(Consumer, OPT_fptrauth_type_info_vtable_pointer_discrimination);

3547 if (Opts.PointerAuthFunctionTypeDiscrimination)

3548 GenerateArg(Consumer, OPT_fptrauth_function_pointer_type_discrimination);

3549 if (Opts.PointerAuthInitFini)

3550 GenerateArg(Consumer, OPT_fptrauth_init_fini);

3551 if (Opts.PointerAuthInitFiniAddressDiscrimination)

3552 GenerateArg(Consumer, OPT_fptrauth_init_fini_address_discrimination);

3553 if (Opts.PointerAuthELFGOT)

3554 GenerateArg(Consumer, OPT_fptrauth_elf_got);

3555 if (Opts.AArch64JumpTableHardening)

3556 GenerateArg(Consumer, OPT_faarch64_jump_table_hardening);

3557 if (Opts.PointerAuthObjcIsa)

3558 GenerateArg(Consumer, OPT_fptrauth_objc_isa);

3559 if (Opts.PointerAuthObjcInterfaceSel)

3560 GenerateArg(Consumer, OPT_fptrauth_objc_interface_sel);

3561 if (Opts.PointerAuthObjcClassROPointers)

3562 GenerateArg(Consumer, OPT_fptrauth_objc_class_ro);

3563 if (Opts.PointerAuthBlockDescriptorPointers)

3564 GenerateArg(Consumer, OPT_fptrauth_block_descriptor_pointers);

3565}

3566

3569 Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);

3570 Opts.PointerAuthCalls = Args.hasArg(OPT_fptrauth_calls);

3571 Opts.PointerAuthReturns = Args.hasArg(OPT_fptrauth_returns);

3572 Opts.PointerAuthIndirectGotos = Args.hasArg(OPT_fptrauth_indirect_gotos);

3573 Opts.PointerAuthAuthTraps = Args.hasArg(OPT_fptrauth_auth_traps);

3574 Opts.PointerAuthVTPtrAddressDiscrimination =

3575 Args.hasArg(OPT_fptrauth_vtable_pointer_address_discrimination);

3576 Opts.PointerAuthVTPtrTypeDiscrimination =

3577 Args.hasArg(OPT_fptrauth_vtable_pointer_type_discrimination);

3578 Opts.PointerAuthTypeInfoVTPtrDiscrimination =

3579 Args.hasArg(OPT_fptrauth_type_info_vtable_pointer_discrimination);

3580 Opts.PointerAuthFunctionTypeDiscrimination =

3581 Args.hasArg(OPT_fptrauth_function_pointer_type_discrimination);

3582 Opts.PointerAuthInitFini = Args.hasArg(OPT_fptrauth_init_fini);

3583 Opts.PointerAuthInitFiniAddressDiscrimination =

3584 Args.hasArg(OPT_fptrauth_init_fini_address_discrimination);

3585 Opts.PointerAuthELFGOT = Args.hasArg(OPT_fptrauth_elf_got);

3586 Opts.AArch64JumpTableHardening =

3587 Args.hasArg(OPT_faarch64_jump_table_hardening);

3588 Opts.PointerAuthBlockDescriptorPointers =

3589 Args.hasArg(OPT_fptrauth_block_descriptor_pointers);

3590 Opts.PointerAuthObjcIsa = Args.hasArg(OPT_fptrauth_objc_isa);

3591 Opts.PointerAuthObjcClassROPointers = Args.hasArg(OPT_fptrauth_objc_class_ro);

3592 Opts.PointerAuthObjcInterfaceSel =

3593 Args.hasArg(OPT_fptrauth_objc_interface_sel);

3594

3595 if (Opts.PointerAuthObjcInterfaceSel)

3596 Opts.PointerAuthObjcInterfaceSelKey =

3598}

3599

3600

3607 llvm_unreachable("should not parse language flags for this input");

3608

3612

3616

3619

3623

3625

3628

3631

3633

3634

3635

3636 return true;

3637

3640 }

3641

3642 llvm_unreachable("unexpected input language");

3643}

3644

3645

3649 return "C";

3651 return "Objective-C";

3653 return "C++";

3655 return "Objective-C++";

3657 return "OpenCL";

3659 return "C++ for OpenCL";

3661 return "CUDA";

3663 return "HIP";

3664

3666 return "Asm";

3668 return "LLVM IR";

3670 return "Clang IR";

3671

3673 return "HLSL";

3674

3676 break;

3677 }

3678 llvm_unreachable("unknown input language");

3679}

3680

3681void CompilerInvocationBase::GenerateLangArgs(const LangOptions &Opts,

3683 const llvm::Triple &T,

3688 if (Opts.ObjCAutoRefCount)

3690 if (Opts.PICLevel != 0)

3691 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));

3692 if (Opts.PIE)

3695 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);

3696

3697 return;

3698 }

3699

3700 OptSpecifier StdOpt;

3702 case LangStandard::lang_opencl10:

3703 case LangStandard::lang_opencl11:

3704 case LangStandard::lang_opencl12:

3705 case LangStandard::lang_opencl20:

3706 case LangStandard::lang_opencl30:

3707 case LangStandard::lang_openclcpp10:

3708 case LangStandard::lang_openclcpp2021:

3709 StdOpt = OPT_cl_std_EQ;

3710 break;

3711 default:

3712 StdOpt = OPT_std_EQ;

3713 break;

3714 }

3715

3717 GenerateArg(Consumer, StdOpt, LangStandard.getName());

3718

3719 if (Opts.IncludeDefaultHeader)

3720 GenerateArg(Consumer, OPT_finclude_default_header);

3721 if (Opts.DeclareOpenCLBuiltins)

3722 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);

3723

3724 const LangOptions *LangOpts = &Opts;

3725

3726#define LANG_OPTION_WITH_MARSHALLING(...) \

3727 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

3728#include "clang/Options/Options.inc"

3729#undef LANG_OPTION_WITH_MARSHALLING

3730

3731

3732

3733 if (Opts.ObjC) {

3735

3737 GenerateArg(Consumer, OPT_fobjc_gc_only);

3740 else if (Opts.ObjCAutoRefCount == 1)

3742

3743 if (Opts.ObjCWeakRuntime)

3744 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);

3745

3746 if (Opts.ObjCWeak)

3748

3749 if (Opts.ObjCSubscriptingLegacyRuntime)

3750 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);

3751 }

3752

3753 if (Opts.GNUCVersion != 0) {

3754 unsigned Major = Opts.GNUCVersion / 100 / 100;

3755 unsigned Minor = (Opts.GNUCVersion / 100) % 100;

3756 unsigned Patch = Opts.GNUCVersion % 100;

3757 GenerateArg(Consumer, OPT_fgnuc_version_EQ,

3758 Twine(Major) + "." + Twine(Minor) + "." + Twine(Patch));

3759 }

3760

3761 if (Opts.IgnoreXCOFFVisibility)

3762 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);

3763

3769 }

3770 if (Opts.PointerOverflowDefined)

3771 GenerateArg(Consumer, OPT_fwrapv_pointer);

3772

3773 if (Opts.MSCompatibilityVersion != 0) {

3774 unsigned Major = Opts.MSCompatibilityVersion / 10000000;

3775 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;

3776 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;

3777 GenerateArg(Consumer, OPT_fms_compatibility_version,

3778 Twine(Major) + "." + Twine(Minor) + "." + Twine(Subminor));

3779 }

3780

3781 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||

3782 T.isOSzOS()) {

3783 if (!Opts.Trigraphs)

3784 GenerateArg(Consumer, OPT_fno_trigraphs);

3785 } else {

3786 if (Opts.Trigraphs)

3788 }

3789

3790 if (T.isOSzOS() && !Opts.ZOSExt)

3791 GenerateArg(Consumer, OPT_fno_zos_extensions);

3792 else if (Opts.ZOSExt)

3793 GenerateArg(Consumer, OPT_fzos_extensions);

3794

3795 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))

3797

3798 if (Opts.ConvergentFunctions)

3799 GenerateArg(Consumer, OPT_fconvergent_functions);

3800 else

3801 GenerateArg(Consumer, OPT_fno_convergent_functions);

3802

3803 if (Opts.NoBuiltin && !Opts.Freestanding)

3805

3806 if (!Opts.NoBuiltin)

3809

3810 if (Opts.LongDoubleSize == 128)

3811 GenerateArg(Consumer, OPT_mlong_double_128);

3812 else if (Opts.LongDoubleSize == 64)

3813 GenerateArg(Consumer, OPT_mlong_double_64);

3814 else if (Opts.LongDoubleSize == 80)

3815 GenerateArg(Consumer, OPT_mlong_double_80);

3816

3817

3818

3819

3820

3821 if (Opts.OpenMP && !Opts.OpenMPSimd) {

3823

3824 if (Opts.OpenMP != 51)

3825 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));

3826

3827 if (!Opts.OpenMPUseTLS)

3828 GenerateArg(Consumer, OPT_fnoopenmp_use_tls);

3829

3830 if (Opts.OpenMPIsTargetDevice)

3831 GenerateArg(Consumer, OPT_fopenmp_is_target_device);

3832

3833 if (Opts.OpenMPIRBuilder)

3834 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);

3835 }

3836

3837 if (Opts.OpenMPSimd) {

3838 GenerateArg(Consumer, OPT_fopenmp_simd);

3839

3840 if (Opts.OpenMP != 51)

3841 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));

3842 }

3843

3844 if (Opts.OpenMPThreadSubscription)

3845 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);

3846

3847 if (Opts.OpenMPTeamSubscription)

3848 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);

3849

3850 if (Opts.OpenMPTargetDebug != 0)

3851 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,

3852 Twine(Opts.OpenMPTargetDebug));

3853

3854 if (Opts.OpenMPCUDANumSMs != 0)

3855 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,

3856 Twine(Opts.OpenMPCUDANumSMs));

3857

3858 if (Opts.OpenMPCUDABlocksPerSM != 0)

3859 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,

3860 Twine(Opts.OpenMPCUDABlocksPerSM));

3861

3862 if (Opts.OpenMPCUDAReductionBufNum != 1024)

3863 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,

3864 Twine(Opts.OpenMPCUDAReductionBufNum));

3865

3867 std::string Targets;

3868 llvm::raw_string_ostream OS(Targets);

3869 llvm::interleave(

3871 [&OS](const llvm::Triple &T) { OS << T.str(); }, ",");

3872 GenerateArg(Consumer, OPT_offload_targets_EQ, Targets);

3873 }

3874

3875 if (Opts.OpenMPCUDAMode)

3876 GenerateArg(Consumer, OPT_fopenmp_cuda_mode);

3877

3878 if (Opts.OpenACC)

3880

3881

3882

3883

3885 GenerateArg(Consumer, OPT_ffp_contract, "fast");

3887 GenerateArg(Consumer, OPT_ffp_contract, "on");

3889 GenerateArg(Consumer, OPT_ffp_contract, "off");

3891 GenerateArg(Consumer, OPT_ffp_contract, "fast-honor-pragmas");

3892

3894 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);

3895

3896

3898 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);

3899

3900 switch (Opts.getClangABICompat()) {

3901#define ABI_VER_MAJOR_MINOR(Major, Minor) \

3902 case LangOptions::ClangABI::Ver##Major##_##Minor: \

3903 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, #Major "." #Minor); \

3904 break;

3905#define ABI_VER_MAJOR(Major) \

3906 case LangOptions::ClangABI::Ver##Major: \

3907 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, #Major ".0"); \

3908 break;

3909#define ABI_VER_LATEST(Latest) \

3910 case LangOptions::ClangABI::Latest: \

3911 break;

3912#include "clang/Basic/ABIVersions.def"

3913 }

3914

3915 if (Opts.getSignReturnAddressScope() ==

3917 GenerateArg(Consumer, OPT_msign_return_address_EQ, "all");

3918 else if (Opts.getSignReturnAddressScope() ==

3920 GenerateArg(Consumer, OPT_msign_return_address_EQ, "non-leaf");

3921

3922 if (Opts.getSignReturnAddressKey() ==

3924 GenerateArg(Consumer, OPT_msign_return_address_key_EQ, "b_key");

3925

3929

3930 if (Opts.RelativeCXXABIVTables)

3931 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);

3932 else

3933 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);

3934

3936 GenerateArg(Consumer, OPT_ffile_reproducible);

3937 else

3938 GenerateArg(Consumer, OPT_fno_file_reproducible);

3939

3941 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first + "=" + MP.second);

3942

3945

3947 GenerateArg(Consumer, OPT_falloc_token_max_EQ,

3949

3951 StringRef S = llvm::getAllocTokenModeAsString(*Opts.AllocTokenMode);

3952 GenerateArg(Consumer, OPT_falloc_token_mode_EQ, S);

3953 }

3954

3955 if (Opts.MatrixTypes) {

3956 if (Opts.getDefaultMatrixMemoryLayout() ==

3958 GenerateArg(Consumer, OPT_fmatrix_memory_layout_EQ, "column-major");

3959 if (Opts.getDefaultMatrixMemoryLayout() ==

3961 GenerateArg(Consumer, OPT_fmatrix_memory_layout_EQ, "row-major");

3962 }

3963}

3964

3965bool CompilerInvocation::ParseLangArgs(LangOptions &Opts, ArgList &Args,

3966 InputKind IK, const llvm::Triple &T,

3967 std::vectorstd::string &Includes,

3969 unsigned NumErrorsBefore = Diags.getNumErrors();

3970

3974

3975

3976

3977 if (Args.hasArg(OPT_fobjc_arc))

3978 Opts.ObjCAutoRefCount = 1;

3979

3980

3982 Opts.PIE = Args.hasArg(OPT_pic_is_pie);

3983 parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),

3985

3986 return Diags.getNumErrors() == NumErrorsBefore;

3987 }

3988

3989

3990

3991

3992

3994 if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {

3997 Diags.Report(diag::err_drv_invalid_value)

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

3999

4000 for (unsigned KindValue = 0;

4002 ++KindValue) {

4006 auto Diag = Diags.Report(diag::note_drv_use_standard);

4008 unsigned NumAliases = 0;

4009#define LANGSTANDARD(id, name, lang, desc, features, version)

4010#define LANGSTANDARD_ALIAS(id, alias) \

4011 if (KindValue == LangStandard::lang_##id) ++NumAliases;

4012#define LANGSTANDARD_ALIAS_DEPR(id, alias)

4013#include "clang/Basic/LangStandards.def"

4014 Diag << NumAliases;

4015#define LANGSTANDARD(id, name, lang, desc, features, version)

4016#define LANGSTANDARD_ALIAS(id, alias) \

4017 if (KindValue == LangStandard::lang_##id) Diag << alias;

4018#define LANGSTANDARD_ALIAS_DEPR(id, alias)

4019#include "clang/Basic/LangStandards.def"

4020 }

4021 }

4022 } else {

4023

4024

4027 Diags.Report(diag::err_drv_argument_not_allowed_with)

4029 }

4030 }

4031 }

4032

4033

4034

4035 if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {

4037 llvm::StringSwitchLangStandard::Kind(A->getValue())

4038 .Cases({"cl", "CL"}, LangStandard::lang_opencl10)

4039 .Cases({"cl1.0", "CL1.0"}, LangStandard::lang_opencl10)

4040 .Cases({"cl1.1", "CL1.1"}, LangStandard::lang_opencl11)

4041 .Cases({"cl1.2", "CL1.2"}, LangStandard::lang_opencl12)

4042 .Cases({"cl2.0", "CL2.0"}, LangStandard::lang_opencl20)

4043 .Cases({"cl3.0", "CL3.0"}, LangStandard::lang_opencl30)

4044 .Cases({"clc++", "CLC++"}, LangStandard::lang_openclcpp10)

4045 .Cases({"clc++1.0", "CLC++1.0"}, LangStandard::lang_openclcpp10)

4046 .Cases({"clc++2021", "CLC++2021"}, LangStandard::lang_openclcpp2021)

4048

4050 Diags.Report(diag::err_drv_invalid_value)

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

4052 }

4053 else

4054 LangStd = OpenCLLangStd;

4055 }

4056

4057

4058 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);

4059 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);

4060

4062

4063

4064

4065 LangOptions *LangOpts = &Opts;

4066

4067#define LANG_OPTION_WITH_MARSHALLING(...) \

4068 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

4069#include "clang/Options/Options.inc"

4070#undef LANG_OPTION_WITH_MARSHALLING

4071

4072 if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {

4073 StringRef Name = A->getValue();

4074 if (Name == "full") {

4075 Opts.CFProtectionBranch = 1;

4076 Opts.CFProtectionReturn = 1;

4077 } else if (Name == "branch") {

4078 Opts.CFProtectionBranch = 1;

4079 } else if (Name == "return") {

4080 Opts.CFProtectionReturn = 1;

4081 }

4082 }

4083

4084 if (Opts.CFProtectionBranch) {

4085 if (const Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {

4086 const auto Scheme =

4087 llvm::StringSwitch(A->getValue())

4088#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \

4089 .Case(#FlagVal, CFBranchLabelSchemeKind::Kind)

4090#include "clang/Basic/CFProtectionOptions.def"

4092 Opts.setCFBranchLabelScheme(Scheme);

4093 }

4094 }

4095

4096 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&

4097 !Args.hasArg(OPT_sycl_std_EQ)) {

4098

4099

4100

4101

4102

4104 }

4105

4106 if (Opts.ObjC) {

4107 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {

4108 StringRef value = arg->getValue();

4110 Diags.Report(diag::err_drv_unknown_objc_runtime) << value;

4111 }

4112

4113 if (Args.hasArg(OPT_fobjc_gc_only))

4115 else if (Args.hasArg(OPT_fobjc_gc))

4117 else if (Args.hasArg(OPT_fobjc_arc)) {

4118 Opts.ObjCAutoRefCount = 1;

4120 Diags.Report(diag::err_arc_unsupported_on_runtime);

4121 }

4122

4123

4124

4125

4126

4127 if (Args.hasArg(OPT_fobjc_runtime_has_weak))

4128 Opts.ObjCWeakRuntime = 1;

4129 else

4131

4132

4133

4134 if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {

4135 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {

4136 assert(!Opts.ObjCWeak);

4138 Diags.Report(diag::err_objc_weak_with_gc);

4139 } else if (!Opts.ObjCWeakRuntime) {

4140 Diags.Report(diag::err_objc_weak_unsupported);

4141 } else {

4142 Opts.ObjCWeak = 1;

4143 }

4144 } else if (Opts.ObjCAutoRefCount) {

4145 Opts.ObjCWeak = Opts.ObjCWeakRuntime;

4146 }

4147

4148 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))

4149 Opts.ObjCSubscriptingLegacyRuntime =

4151 }

4152

4153 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {

4154

4155

4156 VersionTuple GNUCVer;

4157 bool Invalid = GNUCVer.tryParse(A->getValue());

4158 unsigned Major = GNUCVer.getMajor();

4159 unsigned Minor = GNUCVer.getMinor().value_or(0);

4160 unsigned Patch = GNUCVer.getSubminor().value_or(0);

4161 if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {

4162 Diags.Report(diag::err_drv_invalid_value)

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

4164 }

4165 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;

4166 }

4167

4168 if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))

4169 Opts.IgnoreXCOFFVisibility = 1;

4170

4171 if (Args.hasArg(OPT_ftrapv)) {

4173

4175 std::string(Args.getLastArgValue(OPT_ftrapv_handler));

4176 }

4177 else if (Args.hasArg(OPT_fwrapv))

4179 if (Args.hasArg(OPT_fwrapv_pointer))

4180 Opts.PointerOverflowDefined = true;

4181

4182 Opts.MSCompatibilityVersion = 0;

4183 if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {

4184 VersionTuple VT;

4185 if (VT.tryParse(A->getValue()))

4186 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)

4187 << A->getValue();

4188 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +

4189 VT.getMinor().value_or(0) * 100000 +

4190 VT.getSubminor().value_or(0);

4191 }

4192

4193

4194

4195

4196

4197 Opts.Trigraphs =

4198 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||

4199 T.isOSzOS();

4200 Opts.Trigraphs =

4201 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);

4202

4203 Opts.ZOSExt =

4204 Args.hasFlag(OPT_fzos_extensions, OPT_fno_zos_extensions, T.isOSzOS());

4205

4206 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL

4207 && Opts.OpenCLVersion == 200);

4208

4209 bool HasConvergentOperations = Opts.isTargetDevice() || Opts.OpenCL ||

4210 Opts.HLSL || T.isAMDGPU() || T.isNVPTX();

4211 Opts.ConvergentFunctions =

4212 Args.hasFlag(OPT_fconvergent_functions, OPT_fno_convergent_functions,

4213 HasConvergentOperations);

4214

4215 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;

4216 if (!Opts.NoBuiltin)

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

4219 if (A->getOption().matches(options::OPT_mlong_double_64))

4220 Opts.LongDoubleSize = 64;

4221 else if (A->getOption().matches(options::OPT_mlong_double_80))

4222 Opts.LongDoubleSize = 80;

4223 else if (A->getOption().matches(options::OPT_mlong_double_128))

4224 Opts.LongDoubleSize = 128;

4225 else

4226 Opts.LongDoubleSize = 0;

4227 }

4228 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)

4230

4232

4233

4234 if (Arg *A = Args.getLastArg(OPT_mrtd)) {

4236 Diags.Report(diag::err_drv_argument_not_allowed_with)

4237 << A->getSpelling() << "-fdefault-calling-conv";

4238 else {

4239 switch (T.getArch()) {

4240 case llvm::Triple::x86:

4242 break;

4243 case llvm::Triple::m68k:

4245 break;

4246 default:

4247 Diags.Report(diag::err_drv_argument_not_allowed_with)

4248 << A->getSpelling() << T.getTriple();

4249 }

4250 }

4251 }

4252

4253

4254 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;

4255

4256 bool IsSimdSpecified =

4257 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,

4258 false);

4259 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;

4260 Opts.OpenMPUseTLS =

4261 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);

4262 Opts.OpenMPIsTargetDevice =

4263 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);

4264 Opts.OpenMPIRBuilder =

4265 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);

4266 bool IsTargetSpecified =

4267 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_offload_targets_EQ);

4268

4269 if (Opts.OpenMP || Opts.OpenMPSimd) {

4271 Args, OPT_fopenmp_version_EQ,

4272 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))

4273 Opts.OpenMP = Version;

4274

4275

4276 if (!Opts.OpenMPIsTargetDevice) {

4277 switch (T.getArch()) {

4278 default:

4279 break;

4280

4281 case llvm::Triple::nvptx:

4282 case llvm::Triple::nvptx64:

4283 Diags.Report(diag::err_drv_omp_host_target_not_supported) << T.str();

4284 break;

4285 }

4286 }

4287 }

4288

4289

4290

4291 if ((Opts.OpenMPIsTargetDevice && T.isGPU()) || Opts.OpenCLCPlusPlus) {

4292

4293 Opts.Exceptions = 0;

4294 Opts.CXXExceptions = 0;

4295 }

4296 if (Opts.OpenMPIsTargetDevice && T.isNVPTX()) {

4297 Opts.OpenMPCUDANumSMs =

4299 Opts.OpenMPCUDANumSMs, Diags);

4300 Opts.OpenMPCUDABlocksPerSM =

4301 getLastArgIntValue(Args, options::OPT_fopenmp_cuda_blocks_per_sm_EQ,

4302 Opts.OpenMPCUDABlocksPerSM, Diags);

4304 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,

4305 Opts.OpenMPCUDAReductionBufNum, Diags);

4306 }

4307

4308

4309

4310 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||

4311 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {

4313 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);

4314 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))

4315 Opts.OpenMPTargetDebug = 1;

4316 }

4317

4318 if (Opts.OpenMPIsTargetDevice) {

4319 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))

4320 Opts.OpenMPTeamSubscription = true;

4321 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))

4322 Opts.OpenMPThreadSubscription = true;

4323 }

4324

4325

4326 if (Arg *A = Args.getLastArg(options::OPT_offload_targets_EQ)) {

4327 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };

4328 auto getArchPtrSize = [](const llvm::Triple &T) {

4329 if (T.isArch16Bit())

4330 return Arch16Bit;

4331 if (T.isArch32Bit())

4332 return Arch32Bit;

4333 assert(T.isArch64Bit() && "Expected 64-bit architecture");

4334 return Arch64Bit;

4335 };

4336

4337 for (unsigned i = 0; i < A->getNumValues(); ++i) {

4338 llvm::Triple TT(A->getValue(i));

4339

4340 if (TT.getArch() == llvm::Triple::UnknownArch ||

4341 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||

4342 TT.getArch() == llvm::Triple::spirv64 ||

4343 TT.getArch() == llvm::Triple::systemz ||

4344 TT.getArch() == llvm::Triple::loongarch64 ||

4345 TT.getArch() == llvm::Triple::nvptx ||

4346 TT.getArch() == llvm::Triple::nvptx64 || TT.isAMDGCN() ||

4347 TT.getArch() == llvm::Triple::x86 ||

4348 TT.getArch() == llvm::Triple::x86_64))

4349 Diags.Report(diag::err_drv_invalid_omp_target) << A->getValue(i);

4350 else if (getArchPtrSize(T) != getArchPtrSize(TT))

4351 Diags.Report(diag::err_drv_incompatible_omp_arch)

4352 << A->getValue(i) << T.str();

4353 else

4355 }

4356 }

4357

4358

4359 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&

4360 (T.isNVPTX() || T.isAMDGCN()) &&

4361 Args.hasArg(options::OPT_fopenmp_cuda_mode);

4362

4363

4364 if (Args.hasArg(options::OPT_fopenacc))

4365 Opts.OpenACC = true;

4366

4367 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {

4368 StringRef Val = A->getValue();

4369 if (Val == "fast")

4371 else if (Val == "on")

4373 else if (Val == "off")

4375 else if (Val == "fast-honor-pragmas")

4377 else

4378 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;

4379 }

4380

4381 if (auto *A =

4382 Args.getLastArg(OPT_fsanitize_undefined_ignore_overflow_pattern_EQ)) {

4383 for (int i = 0, n = A->getNumValues(); i != n; ++i) {

4385 llvm::StringSwitch(A->getValue(i))

4388 .Case("add-unsigned-overflow-test",

4390 .Case("add-signed-overflow-test",

4393 .Case("unsigned-post-decr-while",

4395 .Default(0);

4396 }

4397 }

4398

4399

4400 parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),

4402 Opts.NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);

4403 std::vectorstd::string systemIgnorelists =

4404 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);

4406 systemIgnorelists.begin(),

4407 systemIgnorelists.end());

4408

4409 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {

4410 Opts.setClangABICompat(LangOptions::ClangABI::Latest);

4411

4412 StringRef Ver = A->getValue();

4413 std::pair<StringRef, StringRef> VerParts = Ver.split('.');

4414 int Major, Minor = 0;

4415

4416

4417

4418 if (!VerParts.first.starts_with("0") &&

4419 !VerParts.first.getAsInteger(10, Major) && 3 <= Major &&

4420 Major <= MAX_CLANG_ABI_COMPAT_VERSION &&

4421 (Major == 3

4422 ? VerParts.second.size() == 1 &&

4423 !VerParts.second.getAsInteger(10, Minor)

4424 : VerParts.first.size() == Ver.size() || VerParts.second == "0")) {

4425

4426#define ABI_VER_MAJOR_MINOR(Major_, Minor_) \

4427 if (std::tuple(Major, Minor) <= std::tuple(Major_, Minor_)) \

4428 Opts.setClangABICompat(LangOptions::ClangABI::Ver##Major_##_##Minor_); \

4429 else

4430#define ABI_VER_MAJOR(Major_) \

4431 if (Major <= Major_) \

4432 Opts.setClangABICompat(LangOptions::ClangABI::Ver##Major_); \

4433 else

4434#define ABI_VER_LATEST(Latest) \

4435 { \

4436 }

4437#include "clang/Basic/ABIVersions.def"

4438 } else if (Ver != "latest") {

4439 Diags.Report(diag::err_drv_invalid_value)

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

4441 }

4442 }

4443

4444 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {

4445 StringRef SignScope = A->getValue();

4446

4447 if (SignScope.equals_insensitive("none"))

4448 Opts.setSignReturnAddressScope(

4450 else if (SignScope.equals_insensitive("all"))

4451 Opts.setSignReturnAddressScope(

4453 else if (SignScope.equals_insensitive("non-leaf"))

4454 Opts.setSignReturnAddressScope(

4456 else

4457 Diags.Report(diag::err_drv_invalid_value)

4458 << A->getAsString(Args) << SignScope;

4459

4460 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {

4461 StringRef SignKey = A->getValue();

4462 if (!SignScope.empty() && !SignKey.empty()) {

4463 if (SignKey == "a_key")

4464 Opts.setSignReturnAddressKey(

4466 else if (SignKey == "b_key")

4467 Opts.setSignReturnAddressKey(

4469 else

4470 Diags.Report(diag::err_drv_invalid_value)

4471 << A->getAsString(Args) << SignKey;

4472 }

4473 }

4474 }

4475

4476

4477 StringRef CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);

4478 if (.empty()) {

4480 Diags.Report(diag::err_invalid_cxx_abi) << CXXABI;

4481 } else {

4484 Diags.Report(diag::err_unsupported_cxx_abi) << CXXABI << T.str();

4485 else

4487 }

4488 }

4489

4490 Opts.RelativeCXXABIVTables =

4491 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,

4492 options::OPT_fno_experimental_relative_cxx_abi_vtables,

4494

4495

4496 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);

4497 Opts.OmitVTableRTTI =

4498 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,

4499 options::OPT_fno_experimental_omit_vtable_rtti, false);

4500 if (Opts.OmitVTableRTTI && HasRTTI)

4501 Diags.Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);

4502

4503 for (const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {

4504 auto Split = StringRef(A).split('=');

4506 {std::string(Split.first), std::string(Split.second)});

4507 }

4508

4510 !Args.getLastArg(OPT_fno_file_reproducible) &&

4511 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||

4512 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||

4513 Args.getLastArg(OPT_ffile_reproducible));

4514

4515

4516 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {

4517 unsigned VScaleMin;

4518 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)

4519 Diags.Report(diag::err_cc1_unbounded_vscale_min);

4520 }

4521 if (Arg *A = Args.getLastArg(options::OPT_mvscale_streaming_min_EQ)) {

4522 unsigned VScaleMin;

4523 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)

4524 Diags.Report(diag::err_cc1_unbounded_vscale_min);

4525 }

4526

4527 if (const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {

4528 std::ifstream SeedFile(A->getValue(0));

4529

4530 if (!SeedFile.is_open())

4531 Diags.Report(diag::err_drv_cannot_open_randomize_layout_seed_file)

4532 << A->getValue(0);

4533

4535 }

4536

4537 if (const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))

4539

4540 if (const auto *Arg = Args.getLastArg(options::OPT_falloc_token_max_EQ)) {

4541 StringRef S = Arg->getValue();

4543 if (S.getAsInteger(0, Value))

4544 Diags.Report(diag::err_drv_invalid_value) << Arg->getAsString(Args) << S;

4545 else

4547 }

4548

4549 if (const auto *Arg = Args.getLastArg(options::OPT_falloc_token_mode_EQ)) {

4550 StringRef S = Arg->getValue();

4551 if (auto Mode = getAllocTokenModeFromString(S))

4553 else

4554 Diags.Report(diag::err_drv_invalid_value) << Arg->getAsString(Args) << S;

4555 }

4556

4557

4558 if (Opts.MatrixTypes) {

4559 if (const Arg *A = Args.getLastArg(OPT_fmatrix_memory_layout_EQ)) {

4560 StringRef ClangValue = A->getValue();

4561 if (ClangValue == "row-major")

4562 Opts.setDefaultMatrixMemoryLayout(

4564 else

4565 Opts.setDefaultMatrixMemoryLayout(

4567

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

4569 StringRef OptValue = A->getValue();

4570 if (OptValue.consume_front("-matrix-default-layout=") &&

4571 ClangValue != OptValue)

4572 Diags.Report(diag::err_conflicting_matrix_layout_flags)

4573 << ClangValue << OptValue;

4574 }

4575 }

4576 }

4577

4578

4579 if (Opts.HLSL) {

4580

4581

4582 if (T.isDXIL() || T.isSPIRVLogical()) {

4583 enum { ShaderModel, VulkanEnv, ShaderStage };

4584 enum { OS, Environment };

4585

4586 int ExpectedOS = T.isSPIRVLogical() ? VulkanEnv : ShaderModel;

4587

4588 if (T.getOSName().empty()) {

4589 Diags.Report(diag::err_drv_hlsl_bad_shader_required_in_target)

4590 << ExpectedOS << OS << T.str();

4591 } else if (T.getEnvironmentName().empty()) {

4592 Diags.Report(diag::err_drv_hlsl_bad_shader_required_in_target)

4594 } else if (.isShaderStageEnvironment()) {

4595 Diags.Report(diag::err_drv_hlsl_bad_shader_unsupported)

4596 << ShaderStage << T.getEnvironmentName() << T.str();

4597 }

4598

4599 if (T.isDXIL()) {

4600 if (.isShaderModelOS() || T.getOSVersion() == VersionTuple(0)) {

4601 Diags.Report(diag::err_drv_hlsl_bad_shader_unsupported)

4602 << ShaderModel << T.getOSName() << T.str();

4603 }

4604

4605

4606

4607 if (Args.getLastArg(OPT_fnative_half_type) ||

4608 Args.getLastArg(OPT_fnative_int16_type)) {

4609 const LangStandard &Std =

4611 if (!(Opts.LangStd >= LangStandard::lang_hlsl2018 &&

4612 T.getOSVersion() >= VersionTuple(6, 2)))

4613 Diags.Report(diag::err_drv_hlsl_16bit_types_unsupported)

4614 << "-enable-16bit-types" << true << Std.getName()

4615 << T.getOSVersion().getAsString();

4616 }

4617 } else if (T.isSPIRVLogical()) {

4618 if (.isVulkanOS() || T.getVulkanVersion() == VersionTuple(0)) {

4619 Diags.Report(diag::err_drv_hlsl_bad_shader_unsupported)

4620 << VulkanEnv << T.getOSName() << T.str();

4621 }

4622 if (Args.getLastArg(OPT_fnative_half_type) ||

4623 Args.getLastArg(OPT_fnative_int16_type)) {

4624 const char *Str = Args.getLastArg(OPT_fnative_half_type)

4625 ? "-fnative-half-type"

4626 : "-fnative-int16-type";

4627 const LangStandard &Std =

4629 if (!(Opts.LangStd >= LangStandard::lang_hlsl2018))

4630 Diags.Report(diag::err_drv_hlsl_16bit_types_unsupported)

4631 << Str << false << Std.getName();

4632 }

4633 } else {

4634 llvm_unreachable("expected DXIL or SPIR-V target");

4635 }

4636 } else

4637 Diags.Report(diag::err_drv_hlsl_unsupported_target) << T.str();

4638

4639 if (Opts.LangStd < LangStandard::lang_hlsl202x) {

4640 const LangStandard &Requested =

4642 const LangStandard &Recommended =

4644 Diags.Report(diag::warn_hlsl_langstd_minimal)

4646 }

4647 }

4648

4649 return Diags.getNumErrors() == NumErrorsBefore;

4650}

4651

4653 switch (Action) {

4682 return false;

4683

4693 return true;

4694 }

4695 llvm_unreachable("invalid frontend action");

4696}

4697

4699 switch (Action) {

4714 return true;

4738 return false;

4739 }

4740 llvm_unreachable("invalid frontend action");

4741}

4742

4749

4750#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \

4751 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

4752#include "clang/Options/Options.inc"

4753#undef PREPROCESSOR_OPTION_WITH_MARSHALLING

4754

4756 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);

4757

4759 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl, D);

4760

4762 GenerateArg(Consumer, OPT_preamble_bytes_EQ,

4765

4766 for (const auto &M : Opts.Macros) {

4767

4768

4769 if (M.first == "__CET__=1" && !M.second &&

4770 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)

4771 continue;

4772 if (M.first == "__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&

4773 !CodeGenOpts.CFProtectionBranch)

4774 continue;

4775 if (M.first == "__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&

4776 CodeGenOpts.CFProtectionBranch)

4777 continue;

4778

4779 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);

4780 }

4781

4782 for (const auto &I : Opts.Includes) {

4783

4784

4785 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&

4786 ((LangOpts.DeclareOpenCLBuiltins && I == "opencl-c-base.h") ||

4787 I == "opencl-c.h"))

4788 continue;

4789

4790

4791 if (LangOpts.HLSL && I == "hlsl.h")

4792 continue;

4793

4795 }

4796

4798 GenerateArg(Consumer, OPT_chain_include, CI);

4799

4801 GenerateArg(Consumer, OPT_remap_file, RF.first + ";" + RF.second);

4802

4805

4807 GenerateArg(Consumer, OPT_fdefine_target_os_macros);

4808

4809 for (const auto &EmbedEntry : Opts.EmbedEntries)

4810 GenerateArg(Consumer, OPT_embed_dir_EQ, EmbedEntry);

4811

4812

4813

4814}

4815

4820 unsigned NumErrorsBefore = Diags.getNumErrors();

4821

4823

4824#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \

4825 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

4826#include "clang/Options/Options.inc"

4827#undef PREPROCESSOR_OPTION_WITH_MARSHALLING

4828

4829 Opts.PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||

4830 Args.hasArg(OPT_pch_through_hdrstop_use);

4831

4832 for (const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))

4834

4835 if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {

4836 StringRef Value(A->getValue());

4837 size_t Comma = Value.find(',');

4838 unsigned Bytes = 0;

4839 unsigned EndOfLine = 0;

4840

4841 if (Comma == StringRef::npos ||

4842 Value.substr(0, Comma).getAsInteger(10, Bytes) ||

4843 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))

4844 Diags.Report(diag::err_drv_preamble_format);

4845 else {

4848 }

4849 }

4850

4851

4852 for (const auto *A : Args.filtered(OPT_D, OPT_U)) {

4853 if (A->getOption().matches(OPT_D))

4855 else

4857 }

4858

4859

4860 for (const auto *A : Args.filtered(OPT_include))

4861 Opts.Includes.emplace_back(A->getValue());

4862

4863 for (const auto *A : Args.filtered(OPT_chain_include))

4865

4866 for (const auto *A : Args.filtered(OPT_remap_file)) {

4867 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');

4868

4869 if (Split.second.empty()) {

4870 Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);

4871 continue;

4872 }

4873

4875 }

4876

4877 if (const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {

4878 StringRef Epoch = A->getValue();

4879

4880

4881

4882 const uint64_t MaxTimestamp =

4883 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);

4884 uint64_t V;

4885 if (Epoch.getAsInteger(10, V) || V > MaxTimestamp) {

4886 Diags.Report(diag::err_fe_invalid_source_date_epoch)

4887 << Epoch << MaxTimestamp;

4888 } else {

4890 }

4891 }

4892

4893 for (const auto *A : Args.filtered(OPT_embed_dir_EQ)) {

4894 StringRef Val = A->getValue();

4895 Opts.EmbedEntries.push_back(std::string(Val));

4896 }

4897

4898

4899

4900

4903

4905 Args.hasFlag(OPT_fdefine_target_os_macros,

4907

4908 return Diags.getNumErrors() == NumErrorsBefore;

4909}

4910

4911static void

4916

4917#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \

4918 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

4919#include "clang/Options/Options.inc"

4920#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING

4921

4923 if (Generate_dM)

4925 if (!Generate_dM && Opts.ShowMacros)

4928 GenerateArg(Consumer, OPT_fdirectives_only);

4929}

4930

4934 unsigned NumErrorsBefore = Diags.getNumErrors();

4935

4937

4938#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \

4939 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

4940#include "clang/Options/Options.inc"

4941#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING

4942

4944 Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);

4945 Opts.DirectivesOnly = Args.hasArg(OPT_fdirectives_only);

4946

4947 return Diags.getNumErrors() == NumErrorsBefore;

4948}

4949

4953#define TARGET_OPTION_WITH_MARSHALLING(...) \

4954 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

4955#include "clang/Options/Options.inc"

4956#undef TARGET_OPTION_WITH_MARSHALLING

4957

4959 GenerateArg(Consumer, OPT_target_sdk_version_EQ,

4962 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,

4964}

4965

4968 unsigned NumErrorsBefore = Diags.getNumErrors();

4969

4971

4972#define TARGET_OPTION_WITH_MARSHALLING(...) \

4973 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)

4974#include "clang/Options/Options.inc"

4975#undef TARGET_OPTION_WITH_MARSHALLING

4976

4977 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {

4978 llvm::VersionTuple Version;

4979 if (Version.tryParse(A->getValue()))

4980 Diags.Report(diag::err_drv_invalid_value)

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

4982 else

4984 }

4985 if (Arg *A =

4986 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {

4987 llvm::VersionTuple Version;

4988 if (Version.tryParse(A->getValue()))

4989 Diags.Report(diag::err_drv_invalid_value)

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

4991 else

4993 }

4994

4995 return Diags.getNumErrors() == NumErrorsBefore;

4996}

4997

4998bool CompilerInvocation::CreateFromArgsImpl(

5001 unsigned NumErrorsBefore = Diags.getNumErrors();

5002

5003

5006 unsigned MissingArgIndex, MissingArgCount;

5007 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,

5008 MissingArgCount, VisibilityMask);

5010

5011

5012 if (MissingArgCount)

5013 Diags.Report(diag::err_drv_missing_argument)

5014 << Args.getArgString(MissingArgIndex) << MissingArgCount;

5015

5016

5017 for (const auto *A : Args.filtered(OPT_UNKNOWN)) {

5018 auto ArgString = A->getAsString(Args);

5019 std::string Nearest;

5020 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)

5021 Diags.Report(diag::err_drv_unknown_argument) << ArgString;

5022 else

5023 Diags.Report(diag::err_drv_unknown_argument_with_suggestion)

5024 << ArgString << Nearest;

5025 }

5026

5031 false);

5033

5045 }

5047

5049

5051 Diags);

5053 LangOpts.ObjCExceptions = 1;

5054

5056 if (Warning == "misexpect" &&

5057 !Diags.isIgnored(diag::warn_profile_data_misexpect, SourceLocation())) {

5059 }

5060 }

5061

5063

5064

5067 }

5068

5071 Diags.Report(diag::warn_drv_openacc_without_cir);

5072

5073

5074 if (LangOpts.OpenMPIsTargetDevice)

5076

5077 ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags, T,

5079

5080

5081

5082

5084 .Sanitize.has(SanitizerKind::Address) &&

5085 .Sanitize.has(SanitizerKind::KernelAddress) &&

5086 .Sanitize.has(SanitizerKind::Memory) &&

5087 .Sanitize.has(SanitizerKind::KernelMemory);

5088

5094

5100 Diags.Report(diag::err_fe_dependency_file_requires_MT);

5101

5102

5103 if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&

5105 Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;

5106 Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);

5107 }

5108

5109

5113 }

5114

5117 llvm::driver::ProfileInstrKind::ProfileNone)

5118 Diags.Report(diag::err_drv_profile_instrument_use_path_with_no_kind);

5119

5121

5122 return Diags.getNumErrors() == NumErrorsBefore;

5123}

5124

5128 const char *Argv0) {

5130

5134 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);

5135 },

5138 Args.push_back("-cc1");

5140 },

5141 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);

5142}

5143

5145

5146 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;

5147

5148

5149

5150

5151

5153

5154

5155

5157

5158

5159

5161#define LANGOPT(Name, Bits, Default, Compatibility, Description) \

5162 if constexpr (CK::Compatibility != CK::Benign) \

5163 HBuilder.add(LangOpts->Name);

5164#define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \

5165 if constexpr (CK::Compatibility != CK::Benign) \

5166 HBuilder.add(static_cast(LangOpts->get##Name()));

5167#include "clang/Basic/LangOptions.def"

5168

5169 HBuilder.addRange(getLangOpts().ModuleFeatures);

5170

5172 HBuilder.addRange(getLangOpts().CommentOpts.BlockCommandNames);

5173

5174

5177 HBuilder.addRange(getTargetOpts().FeaturesAsWritten);

5178

5179

5182

5185

5186

5188

5189 StringRef MacroDef = Macro.first;

5191 llvm::CachedHashString(MacroDef.split('=').first)))

5192 continue;

5193 }

5194

5195 HBuilder.add(Macro);

5196 }

5197

5198

5204

5209

5211#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);

5212#define ENUM_DIAGOPT(Name, Type, Bits, Default) \

5213 HBuilder.add(diagOpts.get##Name());

5214#include "clang/Basic/DiagnosticOptions.def"

5215#undef DIAGOPT

5216#undef ENUM_DIAGOPT

5217 }

5218

5219

5221

5222

5223 for (const auto &ext : getFrontendOpts().ModuleFileExtensions)

5224 ext->hashExtension(HBuilder);

5225

5226

5229 HBuilder.add(APINotesOpts.SwiftVersion.getMajor());

5230 if (auto Minor = APINotesOpts.SwiftVersion.getMinor())

5231 HBuilder.add(*Minor);

5232 if (auto Subminor = APINotesOpts.SwiftVersion.getSubminor())

5233 HBuilder.add(*Subminor);

5234 if (auto Build = APINotesOpts.SwiftVersion.getBuild())

5235 HBuilder.add(*Build);

5236 }

5237

5238

5239 {

5241#define CODEGENOPT(Name, Bits, Default, Compatibility) \

5242 if constexpr (CK::Compatibility != CK::Benign) \

5243 HBuilder.add(CodeGenOpts->Name);

5244#define ENUM_CODEGENOPT(Name, Type, Bits, Default, Compatibility) \

5245 if constexpr (CK::Compatibility != CK::Benign) \

5246 HBuilder.add(static_cast(CodeGenOpts->get##Name()));

5247#define DEBUGOPT(Name, Bits, Default, Compatibility)

5248#define VALUE_DEBUGOPT(Name, Bits, Default, Compatibility)

5249#define ENUM_DEBUGOPT(Name, Type, Bits, Default, Compatibility)

5250#include "clang/Basic/CodeGenOptions.def"

5251 }

5252

5253

5254

5257

5258

5260

5262#define DEBUGOPT(Name, Bits, Default, Compatibility) \

5263 if constexpr (CK::Compatibility != CK::Benign) \

5264 HBuilder.add(CodeGenOpts->Name);

5265#define VALUE_DEBUGOPT(Name, Bits, Default, Compatibility) \

5266 if constexpr (CK::Compatibility != CK::Benign) \

5267 HBuilder.add(CodeGenOpts->Name);

5268#define ENUM_DEBUGOPT(Name, Type, Bits, Default, Compatibility) \

5269 if constexpr (CK::Compatibility != CK::Benign) \

5270 HBuilder.add(static_cast(CodeGenOpts->get##Name()));

5271#include "clang/Basic/DebugOptions.def"

5272 }

5273

5274

5275

5278 if (!SanHash.empty())

5279 HBuilder.add(SanHash.Mask);

5280

5281 llvm::MD5::MD5Result Result;

5282 HBuilder.getHasher().final(Result);

5283 uint64_t Hash = Result.high() ^ Result.low();

5284 return toString(llvm::APInt(64, Hash), 36, false);

5285}

5286

5288 llvm::function_ref<bool(std::string &)> Predicate) {

5289#define RETURN_IF(PATH) \

5290 do { \

5291 if (Predicate(PATH)) \

5292 return; \

5293 } while (0)

5294

5295#define RETURN_IF_MANY(PATHS) \

5296 do { \

5297 if (llvm::any_of(PATHS, Predicate)) \

5298 return; \

5299 } while (0)

5300

5301 auto &HeaderSearchOpts = *this->HSOpts;

5302

5303 RETURN_IF(HeaderSearchOpts.Sysroot);

5304 for (auto &Entry : HeaderSearchOpts.UserEntries)

5305 if (Entry.IgnoreSysRoot)

5307 RETURN_IF(HeaderSearchOpts.ResourceDir);

5308 RETURN_IF(HeaderSearchOpts.ModuleCachePath);

5309 RETURN_IF(HeaderSearchOpts.ModuleUserBuildPath);

5310 for (auto &[Name, File] : HeaderSearchOpts.PrebuiltModuleFiles)

5312 RETURN_IF_MANY(HeaderSearchOpts.PrebuiltModulePaths);

5314

5315

5320

5321

5324 if (Input.isBuffer())

5325 continue;

5326

5328 }

5329

5337

5338

5339 auto &FileSystemOpts = *this->FSOpts;

5340 RETURN_IF(FileSystemOpts.WorkingDir);

5341

5342

5346

5347

5349

5350

5354

5355

5358}

5359

5361 llvm::function_ref<bool(StringRef)> Callback) const {

5362

5363

5365 [&Callback](std::string &Path) { return Callback(StringRef(Path)); });

5366}

5367

5391

5393 std::vectorstd::string Args{"-cc1"};

5395 [&Args](const Twine &Arg) { Args.push_back(Arg.str()); });

5396 return Args;

5397}

5398

5404

5416

5421 llvm::vfs::getRealFileSystem());

5422}

5423

5429 Diags, std::move(BaseFS));

5430}

5431

5435 if (VFSOverlayFiles.empty())

5436 return BaseFS;

5437

5439

5440 for (const auto &File : VFSOverlayFiles) {

5441 llvm::ErrorOr<std::unique_ptrllvm::MemoryBuffer> Buffer =

5443 if (!Buffer) {

5444 Diags.Report(diag::err_missing_vfs_overlay_file) << File;

5445 continue;

5446 }

5447

5449 std::move(Buffer.get()), nullptr, File,

5450 nullptr, Result);

5451 if (!FS) {

5452 Diags.Report(diag::err_invalid_vfs_overlay) << File;

5453 continue;

5454 }

5455

5457 }

5459}

Defines the Diagnostic-related interfaces.

Defines enum values for all the target-independent builtin functions.

static void getAllNoBuiltinFuncValues(ArgList &Args, std::vector< std::string > &Funcs)

Definition CompilerInvocation.cpp:922

static T extractMaskValue(T KeyPath)

Definition CompilerInvocation.cpp:527

static std::optional< IntTy > normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:450

static T mergeMaskValue(T KeyPath, U Value)

Definition CompilerInvocation.cpp:518

static std::optional< std::string > normalizeString(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:439

static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, OptSpecifier OtherOpt)

Definition CompilerInvocation.cpp:321

static void parsePointerAuthOptions(PointerAuthOptions &Opts, const LangOptions &LangOpts, const llvm::Triple &Triple, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:1503

static void denormalizeString(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, T Value)

Definition CompilerInvocation.cpp:364

static SmallVector< StringRef, 4 > serializeSanitizerKinds(SanitizerSet S)

Definition CompilerInvocation.cpp:1382

static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, ArgList &Args, DiagnosticsEngine &D, XRayInstrSet &S)

Definition CompilerInvocation.cpp:1400

static void GenerateFrontendArgs(const FrontendOptions &Opts, ArgumentConsumer Consumer, bool IsHeader)

Definition CompilerInvocation.cpp:2830

static std::optional< SimpleEnumValue > findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value)

Definition CompilerInvocation.cpp:387

static bool ParseTargetArgs(TargetOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:4966

static auto makeFlagToValueNormalizer(T Value)

Definition CompilerInvocation.cpp:306

static CodeGenOptions::OptRemark ParseOptimizationRemark(DiagnosticsEngine &Diags, ArgList &Args, OptSpecifier OptEQ, StringRef Name)

Parse a remark command line argument.

Definition CompilerInvocation.cpp:1297

static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:2482

static constexpr bool is_uint64_t_convertible()

Definition CompilerInvocation.cpp:300

static void GeneratePointerAuthArgs(const LangOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:3529

static std::optional< SimpleEnumValue > findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name)

Definition CompilerInvocation.cpp:378

static std::optional< OptSpecifier > getProgramActionOpt(frontend::ActionKind ProgramAction)

Maps frontend action to command line option.

Definition CompilerInvocation.cpp:2822

static bool parseDiagnosticLevelMask(StringRef FlagName, const std::vector< std::string > &Levels, DiagnosticsEngine &Diags, DiagnosticLevelMask &M)

Definition CompilerInvocation.cpp:1348

static std::optional< bool > normalizeSimpleFlag(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:267

CompilerInvocation::ArgumentConsumer ArgumentConsumer

Definition CompilerInvocation.cpp:253

static void denormalizeSimpleEnumImpl(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, unsigned Value)

Definition CompilerInvocation.cpp:415

static void GenerateArg(ArgumentConsumer Consumer, llvm::opt::OptSpecifier OptSpecifier)

Definition CompilerInvocation.cpp:704

static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, OptSpecifier GroupWithValue, std::vector< std::string > &Diagnostics)

Definition CompilerInvocation.cpp:896

static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:1014

static void ParsePointerAuthArgs(LangOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:3567

static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, DiagnosticsEngine *Diags)

Definition CompilerInvocation.cpp:1221

static void denormalizeSimpleFlag(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass, unsigned,...)

The tblgen-erated code passes in a fifth parameter of an arbitrary type, but denormalizeSimpleFlags n...

Definition CompilerInvocation.cpp:289

static bool ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, const FrontendOptions &FrontendOpts)

Definition CompilerInvocation.cpp:4816

static std::optional< unsigned > normalizeSimpleEnum(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:395

static StringRef GetInputKindName(InputKind IK)

Get language name for given input kind.

Definition CompilerInvocation.cpp:3646

static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, StringRef &OptionField, StringRef Name, StringRef DefaultVal)

Definition CompilerInvocation.cpp:1161

static std::optional< std::string > normalizeTriple(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:503

T & ensureOwned(std::shared_ptr< T > &Storage)

Definition CompilerInvocation.cpp:190

static void GenerateMigratorArgs(const MigratorOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:2496

static const auto & getFrontendActionTable()

Return a table that associates command line option specifiers with the frontend action.

Definition CompilerInvocation.cpp:2755

static void GenerateTargetArgs(const TargetOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:4950

static std::optional< frontend::ActionKind > getFrontendAction(OptSpecifier &Opt)

Maps command line option to frontend action.

Definition CompilerInvocation.cpp:2812

static bool checkVerifyPrefixes(const std::vector< std::string > &VerifyPrefixes, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:2454

static SanitizerMaskCutoffs parseSanitizerWeightedKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:1389

static void GenerateAPINotesArgs(const APINotesOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:3508

static bool isCodeGenAction(frontend::ActionKind Action)

Definition CompilerInvocation.cpp:4698

static std::optional< bool > normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, const ArgList &Args, DiagnosticsEngine &)

Definition CompilerInvocation.cpp:276

static void GenerateFileSystemArgs(const FileSystemOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:2472

static bool IsInputCompatibleWithStandard(InputKind IK, const LangStandard &S)

Check if input file kind and language standard are compatible.

Definition CompilerInvocation.cpp:3601

static void denormalizeStringImpl(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned, const Twine &Value)

Definition CompilerInvocation.cpp:341

static llvm::StringRef lookupStrInTable(unsigned Offset)

Definition CompilerInvocation.cpp:259

static void GeneratePreprocessorArgs(const PreprocessorOptions &Opts, ArgumentConsumer Consumer, const LangOptions &LangOpts, const FrontendOptions &FrontendOpts, const CodeGenOptions &CodeGenOpts)

Definition CompilerInvocation.cpp:4743

static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, bool &IsHeaderFile)

Definition CompilerInvocation.cpp:2997

static auto makeBooleanOptionDenormalizer(bool Value)

Definition CompilerInvocation.cpp:333

static void GeneratePreprocessorOutputArgs(const PreprocessorOutputOptions &Opts, ArgumentConsumer Consumer, frontend::ActionKind Action)

Definition CompilerInvocation.cpp:4912

static bool isStrictlyPreprocessorAction(frontend::ActionKind Action)

Definition CompilerInvocation.cpp:4652

#define RETURN_IF_MANY(PATHS)

static std::string serializeXRayInstrumentationBundle(const XRayInstrSet &S)

Definition CompilerInvocation.cpp:1419

static bool ParseMigratorArgs(MigratorOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:2505

static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor)

Definition CompilerInvocation.cpp:2423

static T mergeForwardValue(T KeyPath, U Value)

Definition CompilerInvocation.cpp:514

static void ParseAPINotesArgs(APINotesOptions &Opts, ArgList &Args, DiagnosticsEngine &diags)

Definition CompilerInvocation.cpp:3518

static void denormalizeStringVector(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, const std::vector< std::string > &Values)

Definition CompilerInvocation.cpp:471

static bool ParseDependencyOutputArgs(DependencyOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, bool ShowLineMarkers)

Definition CompilerInvocation.cpp:2341

static Expected< std::optional< uint32_t > > parseToleranceOption(StringRef Arg)

Definition CompilerInvocation.cpp:107

static std::optional< std::vector< std::string > > normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &)

Definition CompilerInvocation.cpp:466

static void GenerateAnalyzerArgs(const AnalyzerOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:929

static void GenerateOptimizationRemark(ArgumentConsumer Consumer, OptSpecifier OptEQ, StringRef Name, const CodeGenOptions::OptRemark &Remark)

Generate a remark argument. This is an inverse of ParseOptimizationRemark.

Definition CompilerInvocation.cpp:1281

static bool ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action)

Definition CompilerInvocation.cpp:4931

llvm::function_ref< void( CompilerInvocation &, SmallVectorImpl< const char * > &, CompilerInvocation::StringAllocator)> GenerateFn

Definition CompilerInvocation.cpp:724

static bool RoundTrip(ParseFn Parse, GenerateFn Generate, CompilerInvocation &RealInvocation, CompilerInvocation &DummyInvocation, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0, bool CheckAgainstOriginalInvocation=false, bool ForceRoundTrip=false)

May perform round-trip of command line arguments.

Definition CompilerInvocation.cpp:746

static T extractForwardValue(T KeyPath)

Definition CompilerInvocation.cpp:522

static void denormalizeSimpleEnum(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, T Value)

Definition CompilerInvocation.cpp:431

std::shared_ptr< T > make_shared_copy(const T &X)

Definition CompilerInvocation.cpp:119

llvm::function_ref< bool(CompilerInvocation &, ArrayRef< const char * >, DiagnosticsEngine &, const char *)> ParseFn

Definition CompilerInvocation.cpp:719

static bool parseTestModuleFileExtensionArg(StringRef Arg, std::string &BlockName, unsigned &MajorVersion, unsigned &MinorVersion, bool &Hashed, std::string &UserInfo)

Parse the argument to the -ftest-module-file-extension command-line argument.

Definition CompilerInvocation.cpp:2731

static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:3387

static void GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:2310

static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config, StringRef OptionName, StringRef DefaultVal)

Definition CompilerInvocation.cpp:1156

static bool FixupInvocation(CompilerInvocation &Invocation, DiagnosticsEngine &Diags, const ArgList &Args, InputKind IK)

Definition CompilerInvocation.cpp:568

static void parseSanitizerKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S)

Definition CompilerInvocation.cpp:1370

static void GenerateHeaderSearchArgs(const HeaderSearchOptions &Opts, ArgumentConsumer Consumer)

Definition CompilerInvocation.cpp:3275

Defines the clang::FileSystemOptions interface.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::LangOptions interface.

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

Defines types useful for describing an Objective-C runtime.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

Defines the clang::SanitizerKind enum.

Defines the clang::SourceLocation class and associated facilities.

#define CXXABI(Name, Str)

Defines the clang::TargetOptions class.

Defines version macros and version-related utility functions for Clang.

Defines the clang::XRayInstrKind enum.

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

Tracks various options which control how API notes are found and handled.

llvm::VersionTuple SwiftVersion

The Swift version which should be used for API notes.

std::vector< std::string > ModuleSearchPaths

The set of search paths where we API notes can be found for particular modules.

Stores options for the analyzer from the command line.

static std::vector< StringRef > getRegisteredPackages(bool IncludeExperimental=false)

Retrieves the list of packages generated from Checkers.td.

std::vector< std::pair< std::string, bool > > CheckersAndPackages

Pairs of checker/package name and enable/disable.

std::vector< std::string > SilencedCheckersAndPackages

Vector of checker/package names which will not emit warnings.

AnalysisDiagClients AnalysisDiagOpt

AnalysisConstraints AnalysisConstraintsOpt

ConfigTable Config

A key-value table of use-specified configuration values.

unsigned ShouldEmitErrorsOnInvalidConfigValue

AnalysisPurgeMode AnalysisPurgeOpt

bool isUnknownAnalyzerConfig(llvm::StringRef Name)

static std::vector< StringRef > getRegisteredCheckers(bool IncludeExperimental=false)

Retrieves the list of checkers generated from Checkers.td.

llvm::StringMap< std::string > ConfigTable

std::string FullCompilerInvocation

Store full compiler invocation for reproducible instructions in the generated report.

AnalysisInliningMode InliningMode

The mode of function selection used during inlining.

static bool isBuiltinFunc(llvm::StringRef Name)

Returns true if this is a libc/libm function without the '__builtin_' prefix.

CompatibilityKind

For ASTs produced with different option value, signifies their level of compatibility.

CodeGenOptions - Track various options which control how the code is optimized and passed to the back...

llvm::SmallVector< std::pair< std::string, std::string >, 0 > CoveragePrefixMap

Prefix replacement map for source-based code coverage to remap source file paths in coverage mapping.

SanitizerSet SanitizeMergeHandlers

Set of sanitizer checks that can merge handlers (smaller code size at the expense of debuggability).

llvm::SmallVector< std::pair< std::string, std::string >, 0 > DebugPrefixMap

std::string OptRecordFile

The name of the file to which the backend should save YAML optimization records.

std::string BinutilsVersion

std::vector< BitcodeFileToLink > LinkBitcodeFiles

The files specified here are linked in to the module before optimizations.

std::optional< uint64_t > DiagnosticsHotnessThreshold

The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.

char CoverageVersion[4]

The version string to put into coverage files.

llvm::DenormalMode FPDenormalMode

The floating-point denormal mode to use.

std::string CoverageNotesFile

The filename with path we use for coverage notes files.

std::string ProfileInstrumentUsePath

Name of the profile file to use as input for -fprofile-instr-use.

std::string SampleProfileFile

Name of the profile file to use with -fprofile-sample-use.

uint64_t LargeDataThreshold

The code model-specific large data threshold to use (-mlarge-data-threshold).

std::string MemoryProfileOutput

Name of the profile file to use as output for with -fmemory-profile.

std::string CodeModel

The code model to use (-mcmodel).

std::string CoverageDataFile

The filename with path we use for coverage data files.

std::optional< uint32_t > DiagnosticsMisExpectTolerance

The maximum percentage profiling weights can deviate from the expected values in order to be included...

std::string StackUsageOutput

Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.

std::string OptRecordPasses

The regex that filters the passes that should be saved to the optimization records.

std::string SaveTempsFilePrefix

Prefix to use for -save-temps output.

XRayInstrSet XRayInstrumentationBundle

Set of XRay instrumentation kinds to emit.

bool hasSanitizeCoverage() const

SanitizerSet SanitizeAnnotateDebugInfo

Set of sanitizer checks, for which the instrumentation will be annotated with extra debug info.

PointerAuthOptions PointerAuth

Configuration for pointer-signing.

llvm::DenormalMode FP32DenormalMode

The floating-point denormal mode to use, for float.

SanitizerSet SanitizeTrap

Set of sanitizer checks that trap rather than diagnose.

SanitizerSet SanitizeRecover

Set of sanitizer checks that are non-fatal (i.e.

bool hasReducedDebugInfo() const

Check if type and variable info should be emitted.

OptRemark OptimizationRemark

Selected optimizations for which we should enable optimization remarks.

std::string ThinLTOIndexFile

Name of the function summary index file to use for ThinLTO function importing.

const char * Argv0

Executable and command-line used to create a given CompilerInvocation.

SanitizerMaskCutoffs SanitizeSkipHotCutoffs

Set of thresholds in a range [0.0, 1.0]: the top hottest code responsible for the given fraction of P...

std::vector< std::string > NoBuiltinFuncs

A list of all -fno-builtin-* function names (e.g., memset).

std::vector< uint8_t > CmdArgs

List of backend command-line options for -fembed-bitcode.

OptRemark OptimizationRemarkAnalysis

Selected optimizations for which we should enable optimization analyses.

std::optional< double > AllowRuntimeCheckSkipHotCutoff

std::vector< std::string > CommandLineArgs

void resetNonModularOptions(StringRef ModuleFormat)

Reset all of the options that are not considered when building a module.

std::string OptRecordFormat

The format used for serializing remarks (default: YAML)

std::string DIBugsReportFilePath

The file to use for dumping bug report by Debugify for original debug info.

OptRemark OptimizationRemarkMissed

Selected optimizations for which we should enable missed optimization remarks.

The base class of CompilerInvocation.

std::shared_ptr< DiagnosticOptions > DiagnosticOpts

Options controlling the diagnostic engine.

std::shared_ptr< AnalyzerOptions > AnalyzerOpts

Options controlling the static analyzer.

CompilerInvocationBase()

Definition CompilerInvocation.cpp:123

std::shared_ptr< MigratorOptions > MigratorOpts

std::shared_ptr< PreprocessorOutputOptions > PreprocessorOutputOpts

Options controlling preprocessed output.

std::shared_ptr< APINotesOptions > APINotesOpts

Options controlling API notes.

std::shared_ptr< TargetOptions > TargetOpts

Options controlling the target.

const FrontendOptions & getFrontendOpts() const

const CodeGenOptions & getCodeGenOpts() const

void visitPathsImpl(llvm::function_ref< bool(std::string &)> Predicate)

Visits paths stored in the invocation.

Definition CompilerInvocation.cpp:5287

llvm::function_ref< const char *(const Twine &)> StringAllocator

Command line generation.

const FileSystemOptions & getFileSystemOpts() const

std::shared_ptr< PreprocessorOptions > PPOpts

Options controlling the preprocessor (aside from #include handling).

const PreprocessorOutputOptions & getPreprocessorOutputOpts() const

void visitPaths(llvm::function_ref< bool(StringRef)> Callback) const

Visitation.

Definition CompilerInvocation.cpp:5360

std::vector< std::string > getCC1CommandLine() const

Generate cc1-compatible command line arguments from this instance, wrapping the result as a std::vect...

Definition CompilerInvocation.cpp:5392

std::shared_ptr< FileSystemOptions > FSOpts

Options controlling file system operations.

const AnalyzerOptions & getAnalyzerOpts() const

const MigratorOptions & getMigratorOpts() const

void generateCC1CommandLine(llvm::SmallVectorImpl< const char * > &Args, StringAllocator SA) const

Generate cc1-compatible command line arguments from this instance.

CompilerInvocationBase & deep_copy_assign(const CompilerInvocationBase &X)

Definition CompilerInvocation.cpp:139

const DependencyOutputOptions & getDependencyOutputOpts() const

CompilerInvocationBase & shallow_copy_assign(const CompilerInvocationBase &X)

Definition CompilerInvocation.cpp:159

const TargetOptions & getTargetOpts() const

std::shared_ptr< CodeGenOptions > CodeGenOpts

Options controlling IRgen and the backend.

std::shared_ptr< LangOptions > LangOpts

Options controlling the language variant.

const APINotesOptions & getAPINotesOpts() const

const HeaderSearchOptions & getHeaderSearchOpts() const

std::shared_ptr< HeaderSearchOptions > HSOpts

Options controlling the #include directive.

const PreprocessorOptions & getPreprocessorOpts() const

const DiagnosticOptions & getDiagnosticOpts() const

const LangOptions & getLangOpts() const

Const getters.

std::shared_ptr< FrontendOptions > FrontendOpts

Options controlling the frontend itself.

llvm::function_ref< void(const Twine &)> ArgumentConsumer

std::shared_ptr< DependencyOutputOptions > DependencyOutputOpts

Options controlling dependency output.

Helper class for holding the data necessary to invoke the compiler.

PreprocessorOptions & getPreprocessorOpts()

void clearImplicitModuleBuildOptions()

Disable implicit modules and canonicalize options that are only used by implicit modules.

Definition CompilerInvocation.cpp:5405

MigratorOptions & getMigratorOpts()

AnalyzerOptions & getAnalyzerOpts()

APINotesOptions & getAPINotesOpts()

static bool CreateFromArgs(CompilerInvocation &Res, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0=nullptr)

Create a compiler invocation from a list of input options.

Definition CompilerInvocation.cpp:5125

LangOptions & getLangOpts()

Mutable getters.

static bool checkCC1RoundTrip(ArrayRef< const char * > Args, DiagnosticsEngine &Diags, const char *Argv0=nullptr)

Check that Args can be parsed and re-serialized without change, emiting diagnostics for any differenc...

Definition CompilerInvocation.cpp:878

DependencyOutputOptions & getDependencyOutputOpts()

CompilerInvocation()=default

void resetNonModularOptions()

Reset all of the options that are not considered when building a module.

Definition CompilerInvocation.cpp:5399

FrontendOptions & getFrontendOpts()

std::string getModuleHash() const

Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...

Definition CompilerInvocation.cpp:5144

FileSystemOptions & getFileSystemOpts()

CompilerInvocation & operator=(const CompilerInvocation &X)

static void setDefaultPointerAuthOptions(PointerAuthOptions &Opts, const LangOptions &LangOpts, const llvm::Triple &Triple)

Populate Opts with the default set of pointer authentication-related options given LangOpts and Tripl...

Definition CompilerInvocation.cpp:1428

CodeGenOptions & getCodeGenOpts()

TargetOptions & getTargetOpts()

HeaderSearchOptions & getHeaderSearchOpts()

DiagnosticOptions & getDiagnosticOpts()

PreprocessorOutputOptions & getPreprocessorOutputOpts()

Same as CompilerInvocation, but with copy-on-write optimization.

FrontendOptions & getMutFrontendOpts()

Definition CompilerInvocation.cpp:236

LangOptions & getMutLangOpts()

Mutable getters.

Definition CompilerInvocation.cpp:196

HeaderSearchOptions & getMutHeaderSearchOpts()

Definition CompilerInvocation.cpp:208

MigratorOptions & getMutMigratorOpts()

Definition CompilerInvocation.cpp:220

PreprocessorOptions & getMutPreprocessorOpts()

Definition CompilerInvocation.cpp:212

APINotesOptions & getMutAPINotesOpts()

Definition CompilerInvocation.cpp:224

PreprocessorOutputOptions & getMutPreprocessorOutputOpts()

Definition CompilerInvocation.cpp:245

CodeGenOptions & getMutCodeGenOpts()

Definition CompilerInvocation.cpp:228

TargetOptions & getMutTargetOpts()

Definition CompilerInvocation.cpp:200

FileSystemOptions & getMutFileSystemOpts()

Definition CompilerInvocation.cpp:232

AnalyzerOptions & getMutAnalyzerOpts()

Definition CompilerInvocation.cpp:216

DiagnosticOptions & getMutDiagnosticOpts()

Definition CompilerInvocation.cpp:204

DependencyOutputOptions & getMutDependencyOutputOpts()

Definition CompilerInvocation.cpp:240

DependencyOutputOptions - Options for controlling the compiler dependency file generation.

ShowIncludesDestination ShowIncludesDest

Destination of cl.exe style /showIncludes info.

HeaderIncludeFormatKind HeaderIncludeFormat

The format of header information.

std::string OutputFile

The file to write dependency output to.

HeaderIncludeFilteringKind HeaderIncludeFiltering

Determine whether header information should be filtered.

std::vector< std::string > Targets

A list of names to use as the targets in the dependency file; this list must contain at least one ent...

std::vector< std::pair< std::string, ExtraDepKind > > ExtraDeps

A list of extra dependencies (filename and kind) to be used for every target.

unsigned IncludeSystemHeaders

Include system header dependencies.

static llvm::IntrusiveRefCntPtr< DiagnosticIDs > create()

Options for controlling the compiler diagnostics engine.

std::string DiagnosticSuppressionMappingsFile

Path for the file that defines diagnostic suppression mappings.

std::vector< std::string > Remarks

The list of -R... options used to alter the diagnostic mappings, with the prefixes removed.

std::vector< std::string > Warnings

The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.

std::vector< std::string > VerifyPrefixes

The prefixes for comment directives sought by -verify ("expected" by default).

std::string DiagnosticSerializationFile

The file to serialize diagnostics to (non-appending).

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

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)

Set the diagnostic client associated with this diagnostic object.

unsigned getNumErrors() const

bool isIgnored(unsigned DiagID, SourceLocation Loc) const

Determine whether the diagnostic is known to be ignored.

unsigned getNumWarnings() const

Keeps track of options that affect how file operations are performed.

FrontendOptions - Options for controlling the behavior of the frontend.

InputKind DashX

The input kind, either specified via -x argument or deduced from the input file name.

std::vector< std::string > ModuleFiles

The list of additional prebuilt module files to load before processing the input.

unsigned ClangIRDisablePasses

Disable Clang IR specific (CIR) passes.

std::map< std::string, std::vector< std::string > > PluginArgs

Args to pass to the plugins.

unsigned ClangIRDisableCIRVerifier

Disable Clang IR (CIR) verifier.

unsigned IsSystemModule

When using -emit-module, treat the modulemap as a system module.

unsigned UseClangIRPipeline

Use Clang IR pipeline to emit code.

ASTDumpOutputFormat ASTDumpFormat

Specifies the output format of the AST.

std::optional< std::string > AuxTargetCPU

Auxiliary target CPU for CUDA/HIP compilation.

std::string OutputFile

The output file, if any.

unsigned ShowStats

Show frontend performance metrics and statistics.

unsigned GenReducedBMI

Whether to generate reduced BMI for C++20 named modules.

std::string ActionName

The name of the action to run when using a plugin action.

std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions

The list of module file extensions.

ParsedSourceLocation CodeCompletionAt

If given, enable code completion at the provided location.

std::string FixItSuffix

If given, the new suffix for fix-it rewritten files.

static InputKind getInputKindForExtension(StringRef Extension)

getInputKindForExtension - Return the appropriate input kind for a file extension.

std::vector< std::string > Plugins

The list of plugins to load.

unsigned ASTDumpAll

Whether we deserialize all decls when forming AST dumps.

unsigned GenerateGlobalModuleIndex

Whether we can generate the global module index if needed.

unsigned DisableFree

Disable memory freeing on exit.

SmallVector< FrontendInputFile, 0 > Inputs

The input files and their types.

frontend::ActionKind ProgramAction

The frontend action to perform.

std::optional< std::vector< std::string > > AuxTargetFeatures

Auxiliary target features for CUDA/HIP compilation.

std::string AuxTriple

Auxiliary triple for CUDA/HIP compilation.

unsigned UseGlobalModuleIndex

Whether we can use the global module index if available.

unsigned ASTDumpDecls

Whether we include declaration dumps in AST dumps.

A diagnostic client that ignores all diagnostics.

The kind of a file that we've been handed as an input.

bool isPreprocessed() const

InputKind withHeaderUnit(HeaderUnitKind HU) const

bool isUnknown() const

Is the input kind fully-unknown?

InputKind getPreprocessed() const

HeaderUnitKind getHeaderUnitKind() const

InputKind getHeader() const

InputKind withFormat(Format F) const

Language getLanguage() const

@ None

No signing for any function.

@ NonLeaf

Sign the return address of functions that spill LR.

@ All

Sign the return address of all functions,.

@ BKey

Return address signing uses APIB key.

@ AKey

Return address signing uses APIA key.

@ None

Don't exclude any overflow patterns from sanitizers.

@ AddUnsignedOverflowTest

if (a + b < a)

@ All

Exclude all overflow patterns (below)

@ AddSignedOverflowTest

if (a + b < a)

@ PostDecrInWhile

while (count–)

CompatibilityKind

For ASTs produced with different option value, signifies their level of compatibility.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

void resetNonModularOptions()

Reset all of the options that are not considered when building a module.

std::optional< TargetCXXABI::Kind > CXXABI

C++ ABI to compile with, if specified by the frontend through -fc++-abi=.

std::vector< std::string > NoBuiltinFuncs

A list of all -fno-builtin-* function names (e.g., memset).

std::string ModuleName

The module currently being compiled as specified by -fmodule-name.

clang::ObjCRuntime ObjCRuntime

std::string getOpenCLVersionString() const

Return the OpenCL C or C++ for OpenCL language name and version as a string.

unsigned OverflowPatternExclusionMask

Which overflow patterns should be excluded from sanitizer instrumentation.

SanitizerSet Sanitize

Set of enabled sanitizers.

std::optional< llvm::AllocTokenMode > AllocTokenMode

The allocation token mode.

bool UseTargetPathSeparator

Indicates whether to use target's platform-specific file separator when FILE macro is used and when c...

static void setLangDefaults(LangOptions &Opts, Language Lang, const llvm::Triple &T, std::vector< std::string > &Includes, LangStandard::Kind LangStd=LangStandard::lang_unspecified)

Set language defaults for the given input language and language standard in the given LangOptions obj...

std::string OverflowHandler

The name of the handler function to be called when -ftrapv is specified.

std::string RandstructSeed

The seed used by the randomize structure layout feature.

std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap

A prefix map for FILE, BASE_FILE and __builtin_FILE().

bool isTargetDevice() const

True when compiling for an offloading target device.

std::optional< uint64_t > AllocTokenMax

Maximum number of allocation tokens (0 = target SIZE_MAX), nullopt if none set (use target SIZE_MAX).

LangStandard::Kind LangStd

The used language standard.

unsigned getOpenCLCompatibleVersion() const

Return the OpenCL version that kernel language is compatible with.

bool SanitizeCoverage

Is at least one coverage instrumentation type enabled.

std::vector< llvm::Triple > OMPTargetTriples

Triples of the OpenMP targets that the host code codegen should take into account in order to generat...

std::vector< std::string > NoSanitizeFiles

Paths to files specifying which objects (files, functions, variables) should not be instrumented.

std::string CurrentModule

The name of the current module, of which the main source file is a part.

std::vector< std::string > ModuleFeatures

The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...

The basic abstraction for the target Objective-C runtime.

bool allowsWeak() const

Does this runtime allow the use of __weak?

bool tryParse(StringRef input)

Try to parse an Objective-C runtime specification from the given string.

std::string getAsString() const

bool allowsARC() const

Does this runtime allow ARC at all?

@ FragileMacOSX

'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...

Discrimination

Forms of extra discrimination.

ARM8_3Key

Hardware pointer-signing keys in ARM8.3.

static constexpr std::optional< PositiveAnalyzerOption > create(unsigned Val)

PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...

std::vector< std::pair< std::string, std::string > > RemappedFiles

The set of file remappings, which take existing files on the system (the first part of each pair) and...

bool PCHWithHdrStopCreate

When true, we are creating a PCH or creating the PCH object while expecting a pragma hdrstop to separ...

std::vector< std::string > Includes

std::pair< unsigned, bool > PrecompiledPreambleBytes

If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...

bool LexEditorPlaceholders

When enabled, the preprocessor will construct editor placeholder tokens.

void resetNonModularOptions()

Reset any options that are not considered when building a module.

void addMacroUndef(StringRef Name)

std::set< std::string > DeserializedPCHDeclsToErrorOn

This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...

std::vector< std::string > EmbedEntries

User specified embed entries.

void addMacroDef(StringRef Name)

bool DefineTargetOSMacros

Indicates whether to predefine target OS macros.

bool DetailedRecord

Whether we should maintain a detailed record of all macro definitions and expansions.

std::vector< std::string > ChainedIncludes

Headers that will be converted to chained PCHs in memory.

bool PCHWithHdrStop

When true, we are creating or using a PCH where a pragma hdrstop is expected to indicate the beginnin...

std::optional< uint64_t > SourceDateEpoch

If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.

bool UsePredefines

Initialize the preprocessor with the compiler and target specific predefines.

void addRemappedFile(StringRef From, StringRef To)

std::vector< std::pair< std::string, bool > > Macros

PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g....

unsigned ShowMacros

Print macro definitions.

unsigned ShowCPP

Print normal preprocessed output.

unsigned ShowLineMarkers

Show #line markers.

unsigned DirectivesOnly

Process directives but do not expand macros.

Encodes a location in the source.

static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind)

static const auto & getSpelling(Kind ABIKind)

static bool usesRelativeVTables(const llvm::Triple &T)

static bool isABI(StringRef Name)

Options for controlling the target.

std::string Triple

The name of the target triple to compile for.

llvm::VersionTuple SDKVersion

The version of the SDK which was used during the compilation.

uint64_t LargeDataThreshold

llvm::VersionTuple DarwinTargetVariantSDKVersion

The version of the darwin target variant SDK which was used during the compilation.

std::string HostTriple

When compiling for the device side, contains the triple used to compile for the host.

constexpr XRayInstrMask None

constexpr XRayInstrMask All

@ OS

Indicates that the tracking object is a descendant of a referenced-counted OSObject,...

IncludeDirGroup

IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...

@ CXXSystem

Like System, but only used for C++.

@ Angled

Paths for '#include <>' added by '-I'.

@ CSystem

Like System, but only used for C.

@ System

Like Angled, but marks system directories.

@ Quoted

'#include ""' paths, added by 'gcc -iquote'.

@ ExternCSystem

Like System, but headers are implicitly wrapped in extern "C".

@ ObjCSystem

Like System, but only used for ObjC.

@ ObjCXXSystem

Like System, but only used for ObjC++.

@ After

Like System, but searched after the system directories.

@ GenerateHeaderUnit

Generate a C++20 header unit module from a header file.

@ VerifyPCH

Load and verify that a PCH file is usable.

@ PrintPreprocessedInput

-E mode.

@ RewriteTest

Rewriter playground.

@ ParseSyntaxOnly

Parse and perform semantic analysis.

@ TemplightDump

Dump template instantiations.

@ GenerateModuleInterface

Generate pre-compiled module from a standard C++ module interface unit.

@ EmitLLVM

Emit a .ll file.

@ PrintPreamble

Print the "preamble" of the input file.

@ InitOnly

Only execute frontend initialization.

@ ASTView

Parse ASTs and view them in Graphviz.

@ PluginAction

Run a plugin action,.

@ DumpRawTokens

Dump out raw tokens.

@ PrintDependencyDirectivesSourceMinimizerOutput

Print the output of the dependency directives source minimizer.

@ RewriteObjC

ObjC->C Rewriter.

@ RunPreprocessorOnly

Just lex, no output.

@ ModuleFileInfo

Dump information about a module file.

@ EmitCIR

Emit a .cir file.

@ DumpCompilerOptions

Dump the compiler configuration.

@ RunAnalysis

Run one or more source code analyses.

@ ASTPrint

Parse ASTs and print them.

@ GenerateReducedModuleInterface

Generate reduced module interface for a standard C++ module interface unit.

@ GenerateInterfaceStubs

Generate Interface Stub Files.

@ ASTDump

Parse ASTs and dump them.

@ DumpTokens

Dump out preprocessed tokens.

@ FixIt

Parse and apply any fixits to the source.

@ EmitAssembly

Emit a .s file.

@ EmitCodeGenOnly

Generate machine code, but don't emit anything.

@ RewriteMacros

Expand macros but not #includes.

@ EmitHTML

Translate input source into HTML.

@ GeneratePCH

Generate pre-compiled header.

@ EmitLLVMOnly

Generate LLVM IR, but do not emit anything.

@ GenerateModule

Generate pre-compiled module from a module map.

@ ASTDeclList

Parse ASTs and list Decl nodes.

bool EQ(InterpState &S, CodePtr OpPC)

const unsigned VERSION_MINOR

AST file minor version number supported by this version of Clang.

const unsigned VERSION_MAJOR

AST file major version number supported by this version of Clang.

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

ASTDumpOutputFormat

Used to specify the format for printing AST dump information.

bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args, DiagnosticsEngine *Diags=nullptr, bool DefaultDiagColor=true)

Fill out Opts based on the options given in Args.

SanitizerMask getPPTransparentSanitizers()

Return the sanitizers which do not affect preprocessing.

IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromOverlayFiles(ArrayRef< std::string > VFSOverlayFiles, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS)

Definition CompilerInvocation.cpp:5432

DiagnosticLevelMask

A bitmask representing the diagnostic levels used by VerifyDiagnosticConsumer.

const char * headerIncludeFormatKindToString(HeaderIncludeFormatKind K)

std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)

Definition CompilerInvocation.cpp:2588

constexpr uint16_t BlockDescriptorConstantDiscriminator

Constant discriminator to be used with block descriptor pointers.

constexpr uint16_t IsaPointerConstantDiscriminator

Constant discriminator to be used with objective-c isa pointers.

const char * headerIncludeFilteringKindToString(HeaderIncludeFilteringKind K)

std::vector< std::string > Macros

A list of macros of the form = .

AnalysisConstraints

AnalysisConstraints - Set of available constraint models.

@ Success

Annotation was successful.

@ Parse

Parse the block; this code is always used.

constexpr uint16_t SuperPointerConstantDiscriminator

Constant discriminator to be used with objective-c superclass pointers.

void serializeSanitizerSet(SanitizerSet Set, SmallVectorImpl< StringRef > &Values)

Serialize a SanitizerSet into values for -fsanitize= or -fno-sanitize=.

LLVM_READONLY bool isLetter(unsigned char c)

Return true if this character is an ASCII letter: [a-zA-Z].

LLVM_READONLY bool isAlphanumeric(unsigned char c)

Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].

constexpr uint16_t MethodListPointerConstantDiscriminator

Constant discriminator to be used with method list pointers.

constexpr uint16_t ClassROConstantDiscriminator

Constant discriminator to be used with objective-c class_ro_t pointers.

constexpr uint16_t InitFiniPointerConstantDiscriminator

Constant discriminator to be used with function pointers in .init_array and .fini_array.

@ C

Languages that the frontend can parse and compile.

@ CIR

LLVM IR & CIR: we accept these so that we can run the optimizer on them, and compile them to assembly...

@ Asm

Assembly: we accept this only so that we can preprocess it.

bool parseSanitizerWeightedValue(StringRef Value, bool AllowGroups, SanitizerMaskCutoffs &Cutoffs)

Parse a single weighted value (e.g., 'undefined=0.05') from a -fsanitize= or -fno-sanitize= value lis...

@ Result

The result type of a method or function.

unsigned getOptimizationLevel(const llvm::opt::ArgList &Args, InputKind IK, DiagnosticsEngine &Diags)

XRayInstrMask parseXRayInstrValue(StringRef Value)

Parses a command line argument into a mask.

const FunctionProtoType * T

IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)

Definition CompilerInvocation.cpp:5418

void serializeXRayInstrValue(XRayInstrSet Set, SmallVectorImpl< StringRef > &Values)

Serializes a set into a list of command line arguments.

unsigned getOptimizationLevelSize(const llvm::opt::ArgList &Args)

AnalysisPurgeMode

AnalysisPurgeModes - Set of available strategies for dead symbol removal.

void serializeSanitizerMaskCutoffs(const SanitizerMaskCutoffs &Cutoffs, SmallVectorImpl< std::string > &Values)

Serialize a SanitizerMaskCutoffs into command line arguments.

ShaderStage

Shader programs run in specific pipeline stages.

constexpr uint16_t StdTypeInfoVTablePointerConstantDiscrimination

Constant discriminator for std::type_info vtable pointers: 0xB1EA/45546 The value is ptrauth_string_d...

SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups)

Parse a single value from a -fsanitize= or -fno-sanitize= value list.

const llvm::opt::OptTable & getDriverOptTable()

AnalysisDiagClients

AnalysisDiagClients - Set of available diagnostic clients for rendering analysis results.

@ NUM_ANALYSIS_DIAG_CLIENTS

std::string getClangFullRepositoryVersion()

Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...

int getLastArgIntValue(const llvm::opt::ArgList &Args, llvm::opt::OptSpecifier Id, int Default, DiagnosticsEngine *Diags=nullptr, unsigned Base=0)

Return the value of the last argument as an integer, or a default.

AnalysisInliningMode

AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.

int const char * function

__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)

bool Internalize

If true, we use LLVM module internalizer.

bool PropagateAttrs

If true, we set attributes functions in the bitcode library according to our CodeGenOptions,...

std::string Filename

The filename of the bitcode file to link in.

unsigned LinkFlags

Bitwise combination of llvm::Linker::Flags, passed to the LLVM linker.

Dummy tag type whose instance can be passed into the constructor to prevent creation of the reference...

LangStandard - Information about the properties of a particular language standard.

clang::Language getLanguage() const

Get the language that this standard describes.

const char * getDescription() const

getDescription - Get the description of this standard.

static const LangStandard & getLangStandardForKind(Kind K)

const char * getName() const

getName - Get the name of this standard.

static Kind getLangKind(StringRef Name)

static ParsedSourceLocation FromString(StringRef Str)

Construct a parsed source location from a string; the Filename is empty on error.

std::string ToString() const

Serialize ParsedSourceLocation back to a string.

PointerAuthSchema BlockDescriptorPointers

The ABI for pointers to block descriptors.

PointerAuthSchema BlockHelperFunctionPointers

The ABI for block object copy/destroy function pointers.

PointerAuthSchema CXXVTablePointers

The ABI for C++ virtual table pointers (the pointer to the table itself) as installed in an actual cl...

PointerAuthSchema InitFiniPointers

The ABI for function addresses in .init_array and .fini_array.

PointerAuthSchema BlockInvocationFunctionPointers

The ABI for block invocation function pointers.

PointerAuthSchema BlockByrefHelperFunctionPointers

The ABI for __block variable copy/destroy function pointers.

PointerAuthSchema CXXVTTVTablePointers

The ABI for C++ virtual table pointers as installed in a VTT.

bool ReturnAddresses

Should return addresses be authenticated?

PointerAuthSchema CXXTypeInfoVTablePointer

TypeInfo has external ABI requirements and is emitted without actually having parsed the libcxx defin...

bool AArch64JumpTableHardening

Use hardened lowering for jump-table dispatch?

PointerAuthSchema ObjCMethodListPointer

The ABI for a reference to an Objective-C method list in _class_ro_t.

PointerAuthSchema FunctionPointers

The ABI for C function pointers.

PointerAuthSchema ObjCSuperPointers

The ABI for Objective-C superclass pointers.

bool AuthTraps

Do authentication failures cause a trap?

PointerAuthSchema CXXMemberFunctionPointers

The ABI for C++ member function pointers.

PointerAuthSchema CXXVirtualVariadicFunctionPointers

The ABI for variadic C++ virtual function pointers.

PointerAuthSchema ObjCMethodListFunctionPointers

The ABI for Objective-C method lists.

PointerAuthSchema ObjCClassROPointers

The ABI for Objective-C class_ro_t pointers.

PointerAuthSchema CXXVirtualFunctionPointers

The ABI for most C++ virtual function pointers, i.e. v-table entries.

PointerAuthSchema ObjCIsaPointers

The ABI for Objective-C isa pointers.

bool IndirectGotos

Do indirect goto label addresses need to be authenticated?

void clear(SanitizerMask K=SanitizerKind::All)

Disable the sanitizers specified in K.

void set(SanitizerMask K, bool Value)

Enable or disable a certain (single) sanitizer.

bool empty() const

Returns true if no sanitizers are enabled.

SanitizerMask Mask

Bitmask of enabled sanitizers.

void set(XRayInstrMask K, bool Value)