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);