399                             const llvm::opt::ArgList &Args,
 
  400                             bool DiagnoseErrors) {
 
  414  CfiCrossDso = Args.hasFlag(options::OPT_fsanitize_cfi_cross_dso,
 
  415                             options::OPT_fno_sanitize_cfi_cross_dso, 
false);
 
  424      Args.hasFlag(options::OPT_fsanitize_minimal_runtime,
 
  425                   options::OPT_fno_sanitize_minimal_runtime, MinimalRuntime);
 
  428  Arg *OptLevel = Args.getLastArg(options::OPT_O_Group);
 
  429  bool RemoveObjectSizeAtO0 =
 
  430      !OptLevel || OptLevel->getOption().matches(options::OPT_O0);
 
  432  for (
const llvm::opt::Arg *Arg : llvm::reverse(Args)) {
 
  433    if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
 
  437      if (RemoveObjectSizeAtO0) {
 
  438        AllRemove |= SanitizerKind::ObjectSize;
 
  442        if ((Add & SanitizerKind::ObjectSize) && DiagnoseErrors)
 
  443          D.
Diag(diag::warn_drv_object_size_disabled_O0)
 
  444              << Arg->getAsString(Args);
 
  455              Add & InvalidTrappingKinds & ~DiagnosedKinds) {
 
  456        if (DiagnoseErrors) {
 
  458          D.
Diag(diag::err_drv_argument_not_allowed_with)
 
  459              << Desc << 
"-fsanitize-trap=undefined";
 
  461        DiagnosedKinds |= KindsToDiagnose;
 
  463      Add &= ~InvalidTrappingKinds;
 
  465      if (MinimalRuntime) {
 
  468          if (DiagnoseErrors) {
 
  470            D.
Diag(diag::err_drv_argument_not_allowed_with)
 
  471                << Desc << 
"-fsanitize-minimal-runtime";
 
  473          DiagnosedKinds |= KindsToDiagnose;
 
  478      if (llvm::opt::Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
 
  479        StringRef CM = A->getValue();
 
  481            (Add & SanitizerKind::Function & ~DiagnosedKinds)) {
 
  483            D.
Diag(diag::err_drv_argument_only_allowed_with)
 
  484                << 
"-fsanitize=function" 
  487          DiagnosedKinds |= SanitizerKind::Function;
 
  493      const llvm::Triple &Triple = TC.
getTriple();
 
  497          if (DiagnoseErrors) {
 
  499            llvm::opt::Arg *A = Args.getLastArgNoClaim(
 
  500                options::OPT_mexecute_only, options::OPT_mno_execute_only);
 
  501            if (A && A->getOption().matches(options::OPT_mexecute_only))
 
  502              D.
Diag(diag::err_drv_argument_not_allowed_with)
 
  503                  << Desc << A->getAsString(Args);
 
  505              D.
Diag(diag::err_drv_unsupported_opt_for_target)
 
  506                  << Desc << Triple.str();
 
  508          DiagnosedKinds |= KindsToDiagnose;
 
  523      if (CfiCrossDso && (Add & SanitizerKind::CFIMFCall & ~DiagnosedKinds)) {
 
  525          D.
Diag(diag::err_drv_argument_not_allowed_with)
 
  526              << 
"-fsanitize=cfi-mfcall" 
  527              << 
"-fsanitize-cfi-cross-dso";
 
  529        DiagnosedKinds |= SanitizerKind::CFIMFCall;
 
  532      if (
SanitizerMask KindsToDiagnose = Add & ~Supported & ~DiagnosedKinds) {
 
  533        if (DiagnoseErrors) {
 
  535          D.
Diag(diag::err_drv_unsupported_opt_for_target)
 
  538        DiagnosedKinds |= KindsToDiagnose;
 
  546        if (
const llvm::opt::Arg *NoRTTIArg = TC.
getRTTIArg()) {
 
  547          assert(NoRTTIArg->getOption().matches(options::OPT_fno_rtti) &&
 
  548                 "RTTI disabled without -fno-rtti option?");
 
  552            D.
Diag(diag::err_drv_argument_not_allowed_with)
 
  553                << 
"-fsanitize=vptr" << NoRTTIArg->getAsString(Args);
 
  558            D.
Diag(diag::warn_drv_disabling_vptr_no_rtti_default);
 
  562        AllRemove |= SanitizerKind::Vptr;
 
  570      Add &= ~InvalidTrappingKinds;
 
  571      if (MinimalRuntime) {
 
  582      if (Add & SanitizerKind::UndefinedGroup) {
 
  583        bool S = Args.hasFlagNoClaim(options::OPT_fno_strict_overflow,
 
  584                                     options::OPT_fstrict_overflow, 
false);
 
  585        if (Args.hasFlagNoClaim(options::OPT_fwrapv, options::OPT_fno_wrapv, S))
 
  587        if (Args.hasFlagNoClaim(options::OPT_fwrapv_pointer,
 
  588                                options::OPT_fno_wrapv_pointer, S))
 
  593      if (Add & SanitizerKind::Fuzzer)
 
  594        Add |= SanitizerKind::FuzzerNoLink;
 
  597      if (Add & SanitizerKind::FuzzerNoLink) {
 
  606    } 
else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 
  613  std::pair<SanitizerMask, SanitizerMask> IncompatibleGroups[] = {
 
  614      std::make_pair(SanitizerKind::Address,
 
  615                     SanitizerKind::Thread | SanitizerKind::Memory),
 
  616      std::make_pair(SanitizerKind::Type,
 
  617                     SanitizerKind::Address | SanitizerKind::KernelAddress |
 
  618                         SanitizerKind::Memory | SanitizerKind::Leak |
 
  619                         SanitizerKind::Thread | SanitizerKind::KernelAddress),
 
  620      std::make_pair(SanitizerKind::Thread, SanitizerKind::Memory),
 
  621      std::make_pair(SanitizerKind::Leak,
 
  622                     SanitizerKind::Thread | SanitizerKind::Memory),
 
  623      std::make_pair(SanitizerKind::KernelAddress,
 
  624                     SanitizerKind::Address | SanitizerKind::Leak |
 
  625                         SanitizerKind::Thread | SanitizerKind::Memory),
 
  626      std::make_pair(SanitizerKind::HWAddress,
 
  627                     SanitizerKind::Address | SanitizerKind::Thread |
 
  628                         SanitizerKind::Memory | SanitizerKind::KernelAddress),
 
  629      std::make_pair(SanitizerKind::Scudo,
 
  630                     SanitizerKind::Address | SanitizerKind::HWAddress |
 
  631                         SanitizerKind::Leak | SanitizerKind::Thread |
 
  632                         SanitizerKind::Memory | SanitizerKind::KernelAddress),
 
  633      std::make_pair(SanitizerKind::SafeStack,
 
  635                                                   : SanitizerKind::Leak) |
 
  636                         SanitizerKind::Address | SanitizerKind::HWAddress |
 
  637                         SanitizerKind::Thread | SanitizerKind::Memory |
 
  638                         SanitizerKind::KernelAddress),
 
  639      std::make_pair(SanitizerKind::KernelHWAddress,
 
  640                     SanitizerKind::Address | SanitizerKind::HWAddress |
 
  641                         SanitizerKind::Leak | SanitizerKind::Thread |
 
  642                         SanitizerKind::Memory | SanitizerKind::KernelAddress |
 
  643                         SanitizerKind::SafeStack),
 
  644      std::make_pair(SanitizerKind::KernelMemory,
 
  645                     SanitizerKind::Address | SanitizerKind::HWAddress |
 
  646                         SanitizerKind::Leak | SanitizerKind::Thread |
 
  647                         SanitizerKind::Memory | SanitizerKind::KernelAddress |
 
  648                         SanitizerKind::Scudo | SanitizerKind::SafeStack),
 
  649      std::make_pair(SanitizerKind::MemTag, SanitizerKind::Address |
 
  650                                                SanitizerKind::KernelAddress |
 
  651                                                SanitizerKind::HWAddress |
 
  652                                                SanitizerKind::KernelHWAddress),
 
  653      std::make_pair(SanitizerKind::KCFI, SanitizerKind::Function),
 
  654      std::make_pair(SanitizerKind::Realtime,
 
  655                     SanitizerKind::Address | SanitizerKind::Thread |
 
  656                         SanitizerKind::Undefined | SanitizerKind::Memory),
 
  657      std::make_pair(SanitizerKind::AllocToken,
 
  658                     SanitizerKind::Address | SanitizerKind::HWAddress |
 
  659                         SanitizerKind::KernelAddress |
 
  660                         SanitizerKind::KernelHWAddress |
 
  661                         SanitizerKind::Memory)};
 
  668  for (
auto G : IncompatibleGroups) {
 
  670    if ((
Default & Group) && (Kinds & G.second))
 
  684    D.
Diag(diag::err_drv_argument_only_allowed_with)
 
  688  if ((Kinds & SanitizerKind::ShadowCallStack) && TC.
getTriple().isAArch64() &&
 
  689      !llvm::AArch64::isX18ReservedByDefault(TC.
getTriple()) &&
 
  690      !Args.hasArg(options::OPT_ffixed_x18) && DiagnoseErrors) {
 
  691    D.
Diag(diag::err_drv_argument_only_allowed_with)
 
  700  if (~Supported & SanitizerKind::Vptr) {
 
  706    if (KindsToDiagnose) {
 
  708      S.
Mask = KindsToDiagnose;
 
  710        D.
Diag(diag::err_drv_unsupported_opt_for_target)
 
  712      Kinds &= ~KindsToDiagnose;
 
  717  for (
auto G : IncompatibleGroups) {
 
  722          D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
 
  738      options::OPT_fno_sanitize_recover_EQ);
 
  739  RecoverableKinds &= Kinds;
 
  741  TrappingKinds &= Kinds;
 
  742  RecoverableKinds &= ~TrappingKinds;
 
  747                        options::OPT_fsanitize_merge_handlers_EQ,
 
  748                        options::OPT_fno_sanitize_merge_handlers_EQ);
 
  757                        {}, options::OPT_fsanitize_annotate_debug_info_EQ,
 
  758                        options::OPT_fno_sanitize_annotate_debug_info_EQ);
 
  759  AnnotateDebugInfoKinds &= Kinds;
 
  764  if (!Args.hasArgNoClaim(options::OPT_fno_sanitize_ignorelist))
 
  770      D, Args, UserIgnorelistFiles, options::OPT_fsanitize_ignorelist_EQ,
 
  771      options::OPT_fno_sanitize_ignorelist,
 
  772      clang::diag::err_drv_malformed_sanitizer_ignorelist, DiagnoseErrors);
 
  775  if (Arg *A = Args.getLastArg(
 
  776          options::OPT_fsanitize_coverage_stack_depth_callback_min_EQ)) {
 
  777    StringRef S = A->getValue();
 
  778    if (S.getAsInteger(0, CoverageStackDepthCallbackMin) ||
 
  779        CoverageStackDepthCallbackMin < 0) {
 
  781        D.
Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 
  786  if (AllAddedKinds & SanitizerKind::Memory) {
 
  788            Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,
 
  789                            options::OPT_fno_sanitize_memory_track_origins)) {
 
  790      if (!A->getOption().matches(
 
  791              options::OPT_fno_sanitize_memory_track_origins)) {
 
  792        StringRef S = A->getValue();
 
  793        if (S.getAsInteger(0, MsanTrackOrigins) || MsanTrackOrigins < 0 ||
 
  794            MsanTrackOrigins > 2) {
 
  796            D.
Diag(clang::diag::err_drv_invalid_value)
 
  797                << A->getAsString(Args) << S;
 
  801    MsanUseAfterDtor = Args.hasFlag(
 
  802        options::OPT_fsanitize_memory_use_after_dtor,
 
  803        options::OPT_fno_sanitize_memory_use_after_dtor, MsanUseAfterDtor);
 
  804    MsanParamRetval = Args.hasFlag(
 
  805        options::OPT_fsanitize_memory_param_retval,
 
  806        options::OPT_fno_sanitize_memory_param_retval, MsanParamRetval);
 
  807  } 
else if (AllAddedKinds & SanitizerKind::KernelMemory) {
 
  808    MsanUseAfterDtor = 
false;
 
  809    MsanParamRetval = Args.hasFlag(
 
  810        options::OPT_fsanitize_memory_param_retval,
 
  811        options::OPT_fno_sanitize_memory_param_retval, MsanParamRetval);
 
  813    MsanUseAfterDtor = 
false;
 
  814    MsanParamRetval = 
false;
 
  817  if (AllAddedKinds & SanitizerKind::MemTag) {
 
  819        Args.getLastArgValue(options::OPT_fsanitize_memtag_mode_EQ, 
"sync");
 
  820    if (S == 
"async" || S == 
"sync") {
 
  821      MemtagMode = S.str();
 
  823      D.
Diag(clang::diag::err_drv_invalid_value_with_suggestion)
 
  824          << 
"-fsanitize-memtag-mode=" << S << 
"{async, sync}";
 
  829  if (AllAddedKinds & SanitizerKind::Thread) {
 
  830    TsanMemoryAccess = Args.hasFlag(
 
  831        options::OPT_fsanitize_thread_memory_access,
 
  832        options::OPT_fno_sanitize_thread_memory_access, TsanMemoryAccess);
 
  833    TsanFuncEntryExit = Args.hasFlag(
 
  834        options::OPT_fsanitize_thread_func_entry_exit,
 
  835        options::OPT_fno_sanitize_thread_func_entry_exit, TsanFuncEntryExit);
 
  837        Args.hasFlag(options::OPT_fsanitize_thread_atomics,
 
  838                     options::OPT_fno_sanitize_thread_atomics, TsanAtomics);
 
  841  if (AllAddedKinds & SanitizerKind::CFI) {
 
  844    NeedPIE |= CfiCrossDso;
 
  845    CfiICallGeneralizePointers =
 
  846        Args.hasArg(options::OPT_fsanitize_cfi_icall_generalize_pointers);
 
  848    CfiICallNormalizeIntegers =
 
  849        Args.hasArg(options::OPT_fsanitize_cfi_icall_normalize_integers);
 
  851    if (CfiCrossDso && CfiICallGeneralizePointers && DiagnoseErrors)
 
  852      D.
Diag(diag::err_drv_argument_not_allowed_with)
 
  853          << 
"-fsanitize-cfi-cross-dso" 
  854          << 
"-fsanitize-cfi-icall-generalize-pointers";
 
  856    CfiCanonicalJumpTables =
 
  857        Args.hasFlag(options::OPT_fsanitize_cfi_canonical_jump_tables,
 
  858                     options::OPT_fno_sanitize_cfi_canonical_jump_tables, 
true);
 
  861  if (AllAddedKinds & SanitizerKind::KCFI) {
 
  862    CfiICallGeneralizePointers =
 
  863        Args.hasArg(options::OPT_fsanitize_cfi_icall_generalize_pointers);
 
  864    CfiICallNormalizeIntegers =
 
  865        Args.hasArg(options::OPT_fsanitize_cfi_icall_normalize_integers);
 
  867    KcfiArity = Args.hasArg(options::OPT_fsanitize_kcfi_arity);
 
  869    if (AllAddedKinds & SanitizerKind::CFI && DiagnoseErrors)
 
  870      D.
Diag(diag::err_drv_argument_not_allowed_with)
 
  875  Stats = Args.hasFlag(options::OPT_fsanitize_stats,
 
  876                       options::OPT_fno_sanitize_stats, 
false);
 
  878  if (MinimalRuntime) {
 
  881    if (IncompatibleMask && DiagnoseErrors)
 
  882      D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
 
  883          << 
"-fsanitize-minimal-runtime" 
  887  for (
const auto *Arg : Args.filtered(
 
  888           options::OPT_fsanitize_undefined_ignore_overflow_pattern_EQ)) {
 
  890    OverflowPatternExclusions |=
 
  896  for (
const auto *Arg : Args) {
 
  897    if (Arg->getOption().matches(options::OPT_fsanitize_coverage)) {
 
  898      int LegacySanitizeCoverage;
 
  899      if (Arg->getNumValues() == 1 &&
 
  900          !StringRef(Arg->getValue(0))
 
  901               .getAsInteger(0, LegacySanitizeCoverage)) {
 
  902        CoverageFeatures = 0;
 
  904        if (LegacySanitizeCoverage != 0 && DiagnoseErrors) {
 
  905          D.
Diag(diag::warn_drv_deprecated_arg)
 
  906              << Arg->getAsString(Args) << 
true 
  907              << 
"-fsanitize-coverage=trace-pc-guard";
 
  918        CoverageFeatures = 0;
 
  920    } 
else if (Arg->getOption().matches(options::OPT_fno_sanitize_coverage)) {
 
  926  if (DiagnoseErrors) {
 
  928      D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
 
  929          << 
"-fsanitize-coverage=func" 
  930          << 
"-fsanitize-coverage=bb";
 
  932      D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
 
  933          << 
"-fsanitize-coverage=func" 
  934          << 
"-fsanitize-coverage=edge";
 
  936      D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
 
  937          << 
"-fsanitize-coverage=bb" 
  938          << 
"-fsanitize-coverage=edge";
 
  942      D.
Diag(clang::diag::warn_drv_deprecated_arg)
 
  943          << 
"-fsanitize-coverage=trace-bb" << 
true 
  944          << 
"-fsanitize-coverage=trace-pc-guard";
 
  946      D.
Diag(clang::diag::warn_drv_deprecated_arg)
 
  947          << 
"-fsanitize-coverage=8bit-counters" << 
true 
  948          << 
"-fsanitize-coverage=trace-pc-guard";
 
  956  if ((CoverageFeatures & InsertionPointTypes) &&
 
  957      !(CoverageFeatures & InstrumentationTypes) && DiagnoseErrors) {
 
  958    D.
Diag(clang::diag::warn_drv_deprecated_arg)
 
  959        << 
"-fsanitize-coverage=[func|bb|edge]" << 
true 
  960        << 
"-fsanitize-coverage=[func|bb|edge],[trace-pc-guard|trace-pc],[" 
  965  if (!(CoverageFeatures & InsertionPointTypes)) {
 
  966    if (CoverageFeatures &
 
  979  if (CoverageFeatures) {
 
  981        D, Args, CoverageAllowlistFiles,
 
  982        options::OPT_fsanitize_coverage_allowlist, OptSpecifier(),
 
  983        clang::diag::err_drv_malformed_sanitizer_coverage_allowlist,
 
  986        D, Args, CoverageIgnorelistFiles,
 
  987        options::OPT_fsanitize_coverage_ignorelist, OptSpecifier(),
 
  988        clang::diag::err_drv_malformed_sanitizer_coverage_ignorelist,
 
  993  for (
const auto *Arg :
 
  994       Args.filtered(options::OPT_fexperimental_sanitize_metadata_EQ,
 
  995                     options::OPT_fno_experimental_sanitize_metadata_EQ)) {
 
  996    if (Arg->getOption().matches(
 
  997            options::OPT_fexperimental_sanitize_metadata_EQ)) {
 
  999      BinaryMetadataFeatures |=
 
 1003      BinaryMetadataFeatures &=
 
 1009  if (BinaryMetadataFeatures) {
 
 1011        D, Args, BinaryMetadataIgnorelistFiles,
 
 1012        options::OPT_fexperimental_sanitize_metadata_ignorelist_EQ,
 
 1014        clang::diag::err_drv_malformed_sanitizer_metadata_ignorelist,
 
 1018  SharedRuntime = Args.hasFlag(
 
 1019      options::OPT_shared_libsan, options::OPT_static_libsan,
 
 1022  if (!SharedRuntime && TC.
getTriple().isOSWindows()) {
 
 1024        Args.getLastArg(options::OPT_shared_libsan, options::OPT_static_libsan);
 
 1025    D.
Diag(clang::diag::err_drv_unsupported_opt_for_target)
 
 1026        << A->getSpelling() << TC.
getTriple().str();
 
 1029  ImplicitCfiRuntime = TC.
getTriple().isAndroid();
 
 1031  if (AllAddedKinds & SanitizerKind::Address) {
 
 1032    NeedPIE |= TC.
getTriple().isOSFuchsia();
 
 1034            Args.getLastArg(options::OPT_fsanitize_address_field_padding)) {
 
 1035      StringRef S = A->getValue();
 
 1037      if ((S.getAsInteger(0, AsanFieldPadding) || AsanFieldPadding < 0 ||
 
 1038           AsanFieldPadding > 2) &&
 
 1040        D.
Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 
 1044    if (Arg *WindowsDebugRTArg =
 
 1045            Args.getLastArg(options::OPT__SLASH_MTd, options::OPT__SLASH_MT,
 
 1046                            options::OPT__SLASH_MDd, options::OPT__SLASH_MD,
 
 1047                            options::OPT__SLASH_LDd, options::OPT__SLASH_LD)) {
 
 1048      switch (WindowsDebugRTArg->getOption().getID()) {
 
 1049      case options::OPT__SLASH_MTd:
 
 1050      case options::OPT__SLASH_MDd:
 
 1051      case options::OPT__SLASH_LDd:
 
 1052        if (DiagnoseErrors) {
 
 1053          D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
 
 1054              << WindowsDebugRTArg->getAsString(Args)
 
 1056          D.
Diag(clang::diag::note_drv_address_sanitizer_debug_runtime);
 
 1061    StableABI = Args.hasFlag(options::OPT_fsanitize_stable_abi,
 
 1062                             options::OPT_fno_sanitize_stable_abi, 
false);
 
 1064    AsanPoisonCustomArrayCookie = Args.hasFlag(
 
 1065        options::OPT_fsanitize_address_poison_custom_array_cookie,
 
 1066        options::OPT_fno_sanitize_address_poison_custom_array_cookie,
 
 1067        AsanPoisonCustomArrayCookie);
 
 1069    AsanOutlineInstrumentation =
 
 1070        Args.hasFlag(options::OPT_fsanitize_address_outline_instrumentation,
 
 1071                     options::OPT_fno_sanitize_address_outline_instrumentation,
 
 1072                     AsanOutlineInstrumentation);
 
 1074    AsanGlobalsDeadStripping = Args.hasFlag(
 
 1075        options::OPT_fsanitize_address_globals_dead_stripping,
 
 1076        options::OPT_fno_sanitize_address_globals_dead_stripping, 
true);
 
 1082    AsanUseOdrIndicator =
 
 1083        Args.hasFlag(options::OPT_fsanitize_address_use_odr_indicator,
 
 1084                     options::OPT_fno_sanitize_address_use_odr_indicator,
 
 1087    if (AllAddedKinds & SanitizerKind::PointerCompare & ~AllRemove) {
 
 1088      AsanInvalidPointerCmp = 
true;
 
 1091    if (AllAddedKinds & SanitizerKind::PointerSubtract & ~AllRemove) {
 
 1092      AsanInvalidPointerSub = 
true;
 
 1096        (Args.hasArg(options::OPT_mkernel) ||
 
 1097         Args.hasArg(options::OPT_fapple_kext))) {
 
 1098      AsanDtorKind = llvm::AsanDtorKind::None;
 
 1101    if (
const auto *Arg =
 
 1102            Args.getLastArg(options::OPT_sanitize_address_destructor_EQ)) {
 
 1104      if (parsedAsanDtorKind == llvm::AsanDtorKind::Invalid && DiagnoseErrors) {
 
 1105        TC.
getDriver().
Diag(clang::diag::err_drv_unsupported_option_argument)
 
 1106            << Arg->getSpelling() << Arg->getValue();
 
 1108      AsanDtorKind = parsedAsanDtorKind;
 
 1111    if (
const auto *Arg = Args.getLastArg(
 
 1112            options::OPT_sanitize_address_use_after_return_EQ)) {
 
 1113      auto parsedAsanUseAfterReturn =
 
 1115      if (parsedAsanUseAfterReturn ==
 
 1116              llvm::AsanDetectStackUseAfterReturnMode::Invalid &&
 
 1118        TC.
getDriver().
Diag(clang::diag::err_drv_unsupported_option_argument)
 
 1119            << Arg->getSpelling() << Arg->getValue();
 
 1121      AsanUseAfterReturn = parsedAsanUseAfterReturn;
 
 1127        SanitizerKind::PointerCompare | SanitizerKind::PointerSubtract;
 
 1128    if ((AllAddedKinds & DetectInvalidPointerPairs & ~AllRemove) &&
 
 1130      TC.
getDriver().
Diag(clang::diag::err_drv_argument_only_allowed_with)
 
 1132                                 SanitizerKind::PointerCompare |
 
 1133                                     SanitizerKind::PointerSubtract)
 
 1134          << 
"-fsanitize=address";
 
 1138  if (AllAddedKinds & (SanitizerKind::Address | SanitizerKind::KernelAddress)) {
 
 1139    AsanUseAfterScope = Args.hasFlag(
 
 1140        options::OPT_fsanitize_address_use_after_scope,
 
 1141        options::OPT_fno_sanitize_address_use_after_scope, AsanUseAfterScope);
 
 1143    AsanUseAfterScope = 
false;
 
 1146  if (AllAddedKinds & SanitizerKind::HWAddress) {
 
 1147    if (Arg *HwasanAbiArg =
 
 1148            Args.getLastArg(options::OPT_fsanitize_hwaddress_abi_EQ)) {
 
 1149      HwasanAbi = HwasanAbiArg->getValue();
 
 1150      if (HwasanAbi != 
"platform" && HwasanAbi != 
"interceptor" &&
 
 1152        D.
Diag(clang::diag::err_drv_invalid_value)
 
 1153            << HwasanAbiArg->getAsString(Args) << HwasanAbi;
 
 1155      HwasanAbi = 
"interceptor";
 
 1157    if (TC.
getTriple().getArch() == llvm::Triple::x86_64)
 
 1158      HwasanUseAliases = Args.hasFlag(
 
 1159          options::OPT_fsanitize_hwaddress_experimental_aliasing,
 
 1160          options::OPT_fno_sanitize_hwaddress_experimental_aliasing,
 
 1164  if (AllAddedKinds & SanitizerKind::SafeStack) {
 
 1170  if (AllAddedKinds & SanitizerKind::AllocToken) {
 
 1171    AllocTokenFastABI = Args.hasFlag(
 
 1172        options::OPT_fsanitize_alloc_token_fast_abi,
 
 1173        options::OPT_fno_sanitize_alloc_token_fast_abi, AllocTokenFastABI);
 
 1174    AllocTokenExtended = Args.hasFlag(
 
 1175        options::OPT_fsanitize_alloc_token_extended,
 
 1176        options::OPT_fno_sanitize_alloc_token_extended, AllocTokenExtended);
 
 1179  LinkRuntimes = Args.hasFlag(options::OPT_fsanitize_link_runtime,
 
 1180                              options::OPT_fno_sanitize_link_runtime,
 
 1181                              !Args.hasArg(options::OPT_r));
 
 1186      Args.hasFlag(options::OPT_fsanitize_link_cxx_runtime,
 
 1187                   options::OPT_fno_sanitize_link_cxx_runtime, LinkCXXRuntimes);
 
 1189  NeedsMemProfRt = Args.hasFlag(options::OPT_fmemory_profile,
 
 1190                                options::OPT_fmemory_profile_EQ,
 
 1191                                options::OPT_fno_memory_profile, 
false);
 
 1194  Sanitizers.Mask |= Kinds;
 
 1195  RecoverableSanitizers.Mask |= RecoverableKinds;
 
 1196  TrapSanitizers.Mask |= TrappingKinds;
 
 1197  assert(!(RecoverableKinds & TrappingKinds) &&
 
 1198         "Overlap between recoverable and trapping sanitizers");
 
 1200  MergeHandlers.Mask |= MergeKinds;
 
 1202  AnnotateDebugInfo.Mask |= AnnotateDebugInfoKinds;
 
 1205  SkipHotCutoffs.clear(~Sanitizers.Mask);