reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

tools/clang/include/clang/Basic/Sanitizers.h
  167   void clear(SanitizerMask K = SanitizerKind::All) { Mask &= ~K; }
  186   return SanitizerKind::CFI | SanitizerKind::Integer |
  186   return SanitizerKind::CFI | SanitizerKind::Integer |
  187          SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
  187          SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
  188          SanitizerKind::Undefined | SanitizerKind::FloatDivideByZero;
  188          SanitizerKind::Undefined | SanitizerKind::FloatDivideByZero;
tools/clang/include/clang/Driver/SanitizerArgs.h
   63   bool needsAsanRt() const { return Sanitizers.has(SanitizerKind::Address); }
   65     return Sanitizers.has(SanitizerKind::HWAddress);
   67   bool needsTsanRt() const { return Sanitizers.has(SanitizerKind::Thread); }
   68   bool needsMsanRt() const { return Sanitizers.has(SanitizerKind::Memory); }
   69   bool needsFuzzer() const { return Sanitizers.has(SanitizerKind::Fuzzer); }
   71     return Sanitizers.has(SanitizerKind::Leak) &&
   72            !Sanitizers.has(SanitizerKind::Address) &&
   73            !Sanitizers.has(SanitizerKind::HWAddress);
   77   bool needsDfsanRt() const { return Sanitizers.has(SanitizerKind::DataFlow); }
   82   bool needsScudoRt() const { return Sanitizers.has(SanitizerKind::Scudo); }
tools/clang/lib/AST/Decl.cpp
 4396       (SanitizerKind::Address | SanitizerKind::KernelAddress);
 4396       (SanitizerKind::Address | SanitizerKind::KernelAddress);
tools/clang/lib/Basic/Targets/OSTargets.cpp
   31   if (Opts.Sanitize.has(SanitizerKind::Address))
tools/clang/lib/CodeGen/BackendUtil.cpp
  257   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Address);
  281   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::HWAddress);
  299   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Memory);
  541   Options.Atomic = LangOpts.Sanitize.has(SanitizerKind::Thread);
  615   if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
  631   if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
  638   if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
  645   if (LangOpts.Sanitize.has(SanitizerKind::HWAddress)) {
  652   if (LangOpts.Sanitize.has(SanitizerKind::KernelHWAddress)) {
  659   if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
  666   if (LangOpts.Sanitize.has(SanitizerKind::KernelMemory)) {
  673   if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
  680   if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
  968   if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
  969     ASanPass(SanitizerKind::Address, /*CompileKernel=*/false);
  972   if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
  973     ASanPass(SanitizerKind::KernelAddress, /*CompileKernel=*/true);
  976   if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
  981   if (LangOpts.Sanitize.has(SanitizerKind::KernelMemory)) {
  986   if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
 1141       if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
 1162       if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
 1167       if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
 1176       if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
 1184       if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
 1189         bool Recover = CodeGenOpts.SanitizeRecover.has(SanitizerKind::Address);
 1240     if (LangOpts.Sanitize.has(SanitizerKind::HWAddress)) {
 1241       bool Recover = CodeGenOpts.SanitizeRecover.has(SanitizerKind::HWAddress);
 1245     if (LangOpts.Sanitize.has(SanitizerKind::KernelHWAddress)) {
tools/clang/lib/CodeGen/CGBuiltin.cpp
 1098   if (!SanOpts.has(SanitizerKind::Builtin) || !getTarget().isCLZForZeroUndef())
 1104   EmitCheck(std::make_pair(Cond, SanitizerKind::Builtin),
tools/clang/lib/CodeGen/CGCall.cpp
 2401           if (AVAttr && !SanOpts.has(SanitizerKind::Alignment)) {
 2975   if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute))
 2989     CheckKind = SanitizerKind::ReturnsNonnullAttribute;
 2996     CheckKind = SanitizerKind::NullabilityReturn;
 3354   if (!AC.getDecl() || !(SanOpts.has(SanitizerKind::NonnullAttribute) ||
 3355                          SanOpts.has(SanitizerKind::NullabilityArg)))
 3364   if (SanOpts.has(SanitizerKind::NonnullAttribute))
 3368   if (SanOpts.has(SanitizerKind::NullabilityArg) && !NNAttr && PVD) {
 3383     CheckKind = SanitizerKind::NonnullAttribute;
 3387     CheckKind = SanitizerKind::NullabilityArg;
 4417     if (SanOpts.has(SanitizerKind::Unreachable)) {
 4427       if (SanOpts.hasOneOf(SanitizerKind::Address |
 4428                            SanitizerKind::KernelAddress)) {
tools/clang/lib/CodeGen/CGClass.cpp
  317       SkippedChecks.set(SanitizerKind::Null, !NullCheckValue);
  341     SkippedChecks.set(SanitizerKind::Null, true);
  884       CGF.SanOpts.set(SanitizerKind::Bool, false);
  885       CGF.SanOpts.set(SanitizerKind::Enum, false);
 1813         SanOpts.has(SanitizerKind::Memory) && ClassDecl->getNumVBases() &&
 1839       SanOpts.has(SanitizerKind::Memory) && !ClassDecl->getNumVBases() &&
 1863       SanOpts.has(SanitizerKind::Memory))
 2641   if (SanOpts.has(SanitizerKind::CFIVCall))
 2662   if (!SanOpts.has(SanitizerKind::CFICastStrict))
 2685   if (!SanOpts.has(SanitizerKind::CFICastStrict))
 2726     M = SanitizerKind::CFIVCall;
 2730     M = SanitizerKind::CFINVCall;
 2734     M = SanitizerKind::CFIDerivedCast;
 2738     M = SanitizerKind::CFIUnrelatedCast;
 2796   if (!SanOpts.has(SanitizerKind::CFIVCall) ||
 2797       !CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIVCall))
 2802       SanitizerKind::CFIVCall, TypeName);
 2823   if (SanOpts.has(SanitizerKind::CFIVCall) &&
 2825           SanitizerKind::CFIVCall, TypeName)) {
 2826     EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIVCall),
tools/clang/lib/CodeGen/CGDecl.cpp
  721   if (!SanOpts.has(SanitizerKind::NullabilityAssign))
  736   EmitCheck({{IsNotNull, SanitizerKind::NullabilityAssign}},
tools/clang/lib/CodeGen/CGDeclCXX.cpp
  353   if (getLangOpts().Sanitize.has(SanitizerKind::Address) &&
  354       !isInSanitizerBlacklist(SanitizerKind::Address, Fn, Loc))
  357   if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) &&
  358       !isInSanitizerBlacklist(SanitizerKind::KernelAddress, Fn, Loc))
  361   if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) &&
  362       !isInSanitizerBlacklist(SanitizerKind::HWAddress, Fn, Loc))
  365   if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) &&
  366       !isInSanitizerBlacklist(SanitizerKind::KernelHWAddress, Fn, Loc))
  369   if (getLangOpts().Sanitize.has(SanitizerKind::MemTag) &&
  370       !isInSanitizerBlacklist(SanitizerKind::MemTag, Fn, Loc))
  373   if (getLangOpts().Sanitize.has(SanitizerKind::Thread) &&
  374       !isInSanitizerBlacklist(SanitizerKind::Thread, Fn, Loc))
  377   if (getLangOpts().Sanitize.has(SanitizerKind::Memory) &&
  378       !isInSanitizerBlacklist(SanitizerKind::Memory, Fn, Loc))
  381   if (getLangOpts().Sanitize.has(SanitizerKind::KernelMemory) &&
  382       !isInSanitizerBlacklist(SanitizerKind::KernelMemory, Fn, Loc))
  385   if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) &&
  386       !isInSanitizerBlacklist(SanitizerKind::SafeStack, Fn, Loc))
  389   if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) &&
  390       !isInSanitizerBlacklist(SanitizerKind::ShadowCallStack, Fn, Loc))
tools/clang/lib/CodeGen/CGExpr.cpp
  524           !SanOpts.has(SanitizerKind::HWAddress) &&
  525           !SanOpts.has(SanitizerKind::Memory) &&
  647   return SanOpts.has(SanitizerKind::Null) |
  648          SanOpts.has(SanitizerKind::Alignment) |
  649          SanOpts.has(SanitizerKind::ObjectSize) |
  650          SanOpts.has(SanitizerKind::Vptr);
  685       SkippedChecks.has(SanitizerKind::Null) || PtrToAlloca;
  687   if ((SanOpts.has(SanitizerKind::Null) || AllowNullPointers) &&
  706         Checks.push_back(std::make_pair(IsNonNull, SanitizerKind::Null));
  711   if (SanOpts.has(SanitizerKind::ObjectSize) &&
  712       !SkippedChecks.has(SanitizerKind::ObjectSize) &&
  734       Checks.push_back(std::make_pair(LargeEnough, SanitizerKind::ObjectSize));
  741   if (SanOpts.has(SanitizerKind::Alignment) &&
  742       !SkippedChecks.has(SanitizerKind::Alignment)) {
  756         Checks.push_back(std::make_pair(Aligned, SanitizerKind::Alignment));
  780   if (SanOpts.has(SanitizerKind::Vptr) &&
  781       !SkippedChecks.has(SanitizerKind::Vptr) && isVptrCheckRequired(TCK, Ty)) {
  806             SanitizerKind::Vptr, Out.str())) {
  844       EmitCheck(std::make_pair(EqualHash, SanitizerKind::Vptr),
  982   EmitCheck(std::make_pair(Check, SanitizerKind::ArrayBounds),
 1084         if (SanOpts.has(SanitizerKind::CFIUnrelatedCast) &&
 1209   if (SanOpts.has(SanitizerKind::ArrayBounds) && isa<ArraySubscriptExpr>(E))
 1218         SkippedChecks.set(SanitizerKind::Alignment, true);
 1220         SkippedChecks.set(SanitizerKind::Null, true);
 1589   bool HasBoolCheck = SanOpts.has(SanitizerKind::Bool);
 1590   bool HasEnumCheck = SanOpts.has(SanitizerKind::Enum);
 1628       NeedsEnumCheck ? SanitizerKind::Enum : SanitizerKind::Bool;
 1628       NeedsEnumCheck ? SanitizerKind::Enum : SanitizerKind::Bool;
 2936   if (Kind == SanitizerKind::Function || Kind == SanitizerKind::Vptr)
 2936   if (Kind == SanitizerKind::Function || Kind == SanitizerKind::Vptr)
 2938   else if (Kind == SanitizerKind::Return || Kind == SanitizerKind::Unreachable)
 2938   else if (Kind == SanitizerKind::Return || Kind == SanitizerKind::Unreachable)
 3246       {CFITCK_VCall, SanitizerKind::CFIVCall},
 3247       {CFITCK_NVCall, SanitizerKind::CFINVCall},
 3248       {CFITCK_DerivedCast, SanitizerKind::CFIDerivedCast},
 3249       {CFITCK_UnrelatedCast, SanitizerKind::CFIUnrelatedCast},
 3250       {CFITCK_ICall, SanitizerKind::CFIICall}};
 3272   if (SanOpts.has(SanitizerKind::Unreachable)) {
 3275                              SanitizerKind::Unreachable),
 3467     if (SanOpts.has(SanitizerKind::ArrayBounds))
 3874       SkippedChecks.set(SanitizerKind::Alignment, true);
 3876       SkippedChecks.set(SanitizerKind::Null, true);
 4403     if (SanOpts.has(SanitizerKind::CFIDerivedCast))
 4420     if (SanOpts.has(SanitizerKind::CFIUnrelatedCast))
 4789   if (getLangOpts().CPlusPlus && SanOpts.has(SanitizerKind::Function) &&
 4829       EmitCheck(std::make_pair(CalleeRTTIMatch, SanitizerKind::Function),
 4842   if (SanOpts.has(SanitizerKind::CFIICall) &&
 4867       EmitCfiSlowPathCheck(SanitizerKind::CFIICall, TypeTest, CrossDsoTypeId,
 4870       EmitCheck(std::make_pair(TypeTest, SanitizerKind::CFIICall),
tools/clang/lib/CodeGen/CGExprCXX.cpp
  327       SkippedChecks.set(SanitizerKind::Alignment, true);
  329       SkippedChecks.set(SanitizerKind::Null, true);
  379     if (SanOpts.has(SanitizerKind::CFINVCall) &&
 1709   SkippedChecks.set(SanitizerKind::Null, nullCheck);
tools/clang/lib/CodeGen/CGExprScalar.cpp
  280         if (isa<ParmVarDecl>(VD) && !CGF.SanOpts.has(SanitizerKind::Alignment))
  357               SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation)),
  359               SanOpts.has(SanitizerKind::ImplicitIntegerSignChange)) {}
  718         if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
  729         CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
  935   CGF.EmitCheck(std::make_pair(Check, SanitizerKind::FloatCastOverflow),
  964     Mask = SanitizerKind::ImplicitUnsignedIntegerTruncation;
  967     Mask = SanitizerKind::ImplicitSignedIntegerTruncation;
  982   if (!CGF.SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation))
 1003   if (CGF.SanOpts.has(SanitizerKind::ImplicitIntegerSignChange) &&
 1084       std::make_pair(Check, SanitizerKind::ImplicitIntegerSignChange));
 1090   if (!CGF.SanOpts.has(SanitizerKind::ImplicitIntegerSignChange))
 1122   if (CGF.SanOpts.has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
 1147   if (CGF.SanOpts.has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
 1340   if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) &&
 1751   if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
 2003     if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
 2077     if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast))
 2338     if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
 2381           CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
 2427                CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) {
 2849           CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
 2966   if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
 2968                                     SanitizerKind::IntegerDivideByZero));
 2972   if (CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow) &&
 2986         std::make_pair(NotOverflow, SanitizerKind::SignedIntegerOverflow));
 2996     if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
 2997          CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
 3002     } else if (CGF.SanOpts.has(SanitizerKind::FloatDivideByZero) &&
 3007       EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
 3037   if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
 3038        CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
 3098     if (!isSigned || CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) {
 3100       SanitizerMask Kind = isSigned ? SanitizerKind::SignedIntegerOverflow
 3101                               : SanitizerKind::UnsignedIntegerOverflow;
 3215   if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
 3350       if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
 3361       CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
 3495         if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
 3506         CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
 3597   bool SanitizeBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) &&
 3601   bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent);
 3615           std::make_pair(ValidExponent, SanitizerKind::ShiftExponent));
 3648       Checks.push_back(std::make_pair(BaseCheck, SanitizerKind::ShiftBase));
 3669   else if (CGF.SanOpts.has(SanitizerKind::ShiftExponent) &&
 3674     EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops);
 4658   if (!SanOpts.has(SanitizerKind::PointerOverflow))
 4719     Checks.emplace_back(Valid, SanitizerKind::PointerOverflow);
 4755     Checks.emplace_back(ValidGEP, SanitizerKind::PointerOverflow);
tools/clang/lib/CodeGen/CodeGenFunction.cpp
   52       LangOpts.Sanitize.has(SanitizerKind::HWAddress) ||
   53       LangOpts.Sanitize.has(SanitizerKind::Memory))
  603   if (SanOpts.has(SanitizerKind::Thread)) {
  680       if (mask & SanitizerKind::Address)
  681         SanOpts.set(SanitizerKind::KernelAddress, false);
  682       if (mask & SanitizerKind::KernelAddress)
  683         SanOpts.set(SanitizerKind::Address, false);
  684       if (mask & SanitizerKind::HWAddress)
  685         SanOpts.set(SanitizerKind::KernelHWAddress, false);
  686       if (mask & SanitizerKind::KernelHWAddress)
  687         SanOpts.set(SanitizerKind::HWAddress, false);
  692   if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
  692   if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
  694   if (SanOpts.hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress))
  694   if (SanOpts.hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress))
  696   if (SanOpts.has(SanitizerKind::MemTag))
  698   if (SanOpts.has(SanitizerKind::Thread))
  700   if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
  700   if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
  702   if (SanOpts.has(SanitizerKind::SafeStack))
  704   if (SanOpts.has(SanitizerKind::ShadowCallStack))
  708   if (SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
  708   if (SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
  713   if (SanOpts.has(SanitizerKind::Thread)) {
  727   if (D && SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
  729       SanOpts.Mask &= ~SanitizerKind::CFIUnrelatedCast;
  735   if (D && SanOpts.has(SanitizerKind::Null))
  739         SanOpts.Mask &= ~SanitizerKind::Null;
  782   if (getLangOpts().CPlusPlus && SanOpts.has(SanitizerKind::Function)) {
  805   if (SanOpts.has(SanitizerKind::NullabilityReturn)) {
  808       if (!(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
  992       SkippedChecks.set(SanitizerKind::ObjectSize, true);
 1000         SkippedChecks.set(SanitizerKind::Null, true);
 1222     if (SanOpts.has(SanitizerKind::Return)) {
 1225       EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
 1232     if (SanOpts.has(SanitizerKind::Return) || ShouldEmitUnreachable) {
 1940           if (SanOpts.has(SanitizerKind::VLABound) &&
 1948                                      SanitizerKind::VLABound),
 2053   if (SanOpts.has(SanitizerKind::Alignment)) {
 2353   if (!SanOpts.has(SanitizerKind::Alignment))
 2377     EmitCheck({std::make_pair(TheCheck, SanitizerKind::Alignment)},
tools/clang/lib/CodeGen/CodeGenFunction.h
 1589            (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
tools/clang/lib/CodeGen/CodeGenModule.cpp
  140   if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
  536   if (LangOpts.Sanitize.has(SanitizerKind::CFIICall)) {
 1773   if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
 2256       (SanitizerKind::Address | SanitizerKind::KernelAddress |
 2256       (SanitizerKind::Address | SanitizerKind::KernelAddress |
 2257        SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
 2257        SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
 2258        SanitizerKind::MemTag);
 5835   return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
 5836            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) ||
 5837           (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
 5838            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) ||
 5839           (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
 5840            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) ||
 5841           (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) &&
 5842            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast)));
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
  652   bool ShouldEmitCFICheck = CGF.SanOpts.has(SanitizerKind::CFIMFCall) &&
  712       if (CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIMFCall)) {
  720         CGF.EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIMFCall),
  766       CGF.EmitCheck(std::make_pair(Bit, SanitizerKind::CFIMFCall),
 2022   if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&
 2051   if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)
tools/clang/lib/CodeGen/SanitizerMetadata.cpp
   24   return SS.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress |
   24   return SS.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress |
   25                      SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
   25                      SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
   26                      SanitizerKind::MemTag);
   72     if (Attr->getMask() & SanitizerKind::Address)
tools/clang/lib/Driver/SanitizerArgs.cpp
   28     SanitizerKind::Undefined | SanitizerKind::Integer |
   28     SanitizerKind::Undefined | SanitizerKind::Integer |
   29     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
   29     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
   30     SanitizerKind::CFI | SanitizerKind::FloatDivideByZero;
   30     SanitizerKind::CFI | SanitizerKind::FloatDivideByZero;
   32     SanitizerKind::Vptr | SanitizerKind::CFI;
   32     SanitizerKind::Vptr | SanitizerKind::CFI;
   33 static const SanitizerMask NotAllowedWithTrap = SanitizerKind::Vptr;
   35     SanitizerKind::Function | SanitizerKind::Vptr;
   35     SanitizerKind::Function | SanitizerKind::Vptr;
   37     SanitizerKind::DataFlow | SanitizerKind::HWAddress | SanitizerKind::Scudo;
   37     SanitizerKind::DataFlow | SanitizerKind::HWAddress | SanitizerKind::Scudo;
   37     SanitizerKind::DataFlow | SanitizerKind::HWAddress | SanitizerKind::Scudo;
   39     SanitizerKind::Address | SanitizerKind::HWAddress | SanitizerKind::Thread |
   39     SanitizerKind::Address | SanitizerKind::HWAddress | SanitizerKind::Thread |
   39     SanitizerKind::Address | SanitizerKind::HWAddress | SanitizerKind::Thread |
   40     SanitizerKind::Memory | SanitizerKind::DataFlow;
   40     SanitizerKind::Memory | SanitizerKind::DataFlow;
   42     SanitizerKind::Address | SanitizerKind::HWAddress |
   42     SanitizerKind::Address | SanitizerKind::HWAddress |
   43     SanitizerKind::KernelAddress | SanitizerKind::KernelHWAddress |
   43     SanitizerKind::KernelAddress | SanitizerKind::KernelHWAddress |
   44     SanitizerKind::MemTag | SanitizerKind::Memory |
   44     SanitizerKind::MemTag | SanitizerKind::Memory |
   45     SanitizerKind::KernelMemory | SanitizerKind::Leak |
   45     SanitizerKind::KernelMemory | SanitizerKind::Leak |
   46     SanitizerKind::Undefined | SanitizerKind::Integer |
   46     SanitizerKind::Undefined | SanitizerKind::Integer |
   47     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
   47     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
   48     SanitizerKind::DataFlow | SanitizerKind::Fuzzer |
   48     SanitizerKind::DataFlow | SanitizerKind::Fuzzer |
   49     SanitizerKind::FuzzerNoLink | SanitizerKind::FloatDivideByZero |
   49     SanitizerKind::FuzzerNoLink | SanitizerKind::FloatDivideByZero |
   50     SanitizerKind::SafeStack | SanitizerKind::ShadowCallStack;
   50     SanitizerKind::SafeStack | SanitizerKind::ShadowCallStack;
   52     SanitizerKind::Undefined | SanitizerKind::Integer |
   52     SanitizerKind::Undefined | SanitizerKind::Integer |
   53     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
   53     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
   54     SanitizerKind::FloatDivideByZero;
   56     SanitizerKind::Unreachable | SanitizerKind::Return;
   56     SanitizerKind::Unreachable | SanitizerKind::Return;
   58     SanitizerKind::KernelAddress | SanitizerKind::KernelHWAddress;
   58     SanitizerKind::KernelAddress | SanitizerKind::KernelHWAddress;
   60     SanitizerKind::Undefined | SanitizerKind::Integer;
   60     SanitizerKind::Undefined | SanitizerKind::Integer;
   61 static const SanitizerMask NeedsLTO = SanitizerKind::CFI;
   63     (SanitizerKind::Undefined & ~SanitizerKind::Vptr) |
   63     (SanitizerKind::Undefined & ~SanitizerKind::Vptr) |
   64     SanitizerKind::UnsignedIntegerOverflow | SanitizerKind::ImplicitConversion |
   64     SanitizerKind::UnsignedIntegerOverflow | SanitizerKind::ImplicitConversion |
   65     SanitizerKind::Nullability | SanitizerKind::LocalBounds |
   65     SanitizerKind::Nullability | SanitizerKind::LocalBounds |
   66     SanitizerKind::CFI | SanitizerKind::FloatDivideByZero;
   66     SanitizerKind::CFI | SanitizerKind::FloatDivideByZero;
   67 static const SanitizerMask TrappingDefault = SanitizerKind::CFI;
   69     SanitizerKind::CFIVCall | SanitizerKind::CFINVCall |
   69     SanitizerKind::CFIVCall | SanitizerKind::CFINVCall |
   70     SanitizerKind::CFIMFCall | SanitizerKind::CFIDerivedCast |
   70     SanitizerKind::CFIMFCall | SanitizerKind::CFIDerivedCast |
   71     SanitizerKind::CFIUnrelatedCast;
   73     TrappingSupported | SanitizerKind::Scudo | SanitizerKind::ShadowCallStack;
   73     TrappingSupported | SanitizerKind::Scudo | SanitizerKind::ShadowCallStack;
  126   } Blacklists[] = {{"asan_blacklist.txt", SanitizerKind::Address},
  127                     {"hwasan_blacklist.txt", SanitizerKind::HWAddress},
  128                     {"memtag_blacklist.txt", SanitizerKind::MemTag},
  129                     {"msan_blacklist.txt", SanitizerKind::Memory},
  130                     {"tsan_blacklist.txt", SanitizerKind::Thread},
  131                     {"dfsan_abilist.txt", SanitizerKind::DataFlow},
  132                     {"cfi_blacklist.txt", SanitizerKind::CFI},
  134                      SanitizerKind::Undefined | SanitizerKind::Integer |
  134                      SanitizerKind::Undefined | SanitizerKind::Integer |
  135                          SanitizerKind::Nullability |
  136                          SanitizerKind::FloatDivideByZero}};
  146     else if (BL.Mask == SanitizerKind::CFI)
  193           expandSanitizerGroups(SanitizerKind::UndefinedGroup & ~TrapRemove) &
  198       TrapRemove |= expandSanitizerGroups(SanitizerKind::UndefinedGroup);
  220   return !(Sanitizers.Mask & SanitizerKind::CFI & ~TrapSanitizers.Mask) &&
  225   return (Sanitizers.Mask & SanitizerKind::CFI & ~TrapSanitizers.Mask) &&
  282         AllRemove |= SanitizerKind::ObjectSize;
  286         if (Add & SanitizerKind::ObjectSize)
  328       if (CfiCrossDso && (Add & SanitizerKind::CFIMFCall & ~DiagnosedKinds)) {
  332         Add &= ~SanitizerKind::CFIMFCall;
  333         DiagnosedKinds |= SanitizerKind::CFIMFCall;
  347       if ((Add & SanitizerKind::Vptr) && (RTTIMode == ToolChain::RM_Disabled)) {
  362         AllRemove |= SanitizerKind::Vptr;
  375         Add &= ~SanitizerKind::CFIMFCall;
  378       if (Add & SanitizerKind::Fuzzer)
  379         Add |= SanitizerKind::FuzzerNoLink;
  382       if (Add & SanitizerKind::FuzzerNoLink) {
  399       std::make_pair(SanitizerKind::Address,
  400                      SanitizerKind::Thread | SanitizerKind::Memory),
  400                      SanitizerKind::Thread | SanitizerKind::Memory),
  401       std::make_pair(SanitizerKind::Thread, SanitizerKind::Memory),
  401       std::make_pair(SanitizerKind::Thread, SanitizerKind::Memory),
  402       std::make_pair(SanitizerKind::Leak,
  403                      SanitizerKind::Thread | SanitizerKind::Memory),
  403                      SanitizerKind::Thread | SanitizerKind::Memory),
  404       std::make_pair(SanitizerKind::KernelAddress,
  405                      SanitizerKind::Address | SanitizerKind::Leak |
  405                      SanitizerKind::Address | SanitizerKind::Leak |
  406                          SanitizerKind::Thread | SanitizerKind::Memory),
  406                          SanitizerKind::Thread | SanitizerKind::Memory),
  407       std::make_pair(SanitizerKind::HWAddress,
  408                      SanitizerKind::Address | SanitizerKind::Thread |
  408                      SanitizerKind::Address | SanitizerKind::Thread |
  409                          SanitizerKind::Memory | SanitizerKind::KernelAddress),
  409                          SanitizerKind::Memory | SanitizerKind::KernelAddress),
  410       std::make_pair(SanitizerKind::Scudo,
  411                      SanitizerKind::Address | SanitizerKind::HWAddress |
  411                      SanitizerKind::Address | SanitizerKind::HWAddress |
  412                          SanitizerKind::Leak | SanitizerKind::Thread |
  412                          SanitizerKind::Leak | SanitizerKind::Thread |
  413                          SanitizerKind::Memory | SanitizerKind::KernelAddress),
  413                          SanitizerKind::Memory | SanitizerKind::KernelAddress),
  414       std::make_pair(SanitizerKind::SafeStack,
  415                      SanitizerKind::Address | SanitizerKind::HWAddress |
  415                      SanitizerKind::Address | SanitizerKind::HWAddress |
  416                          SanitizerKind::Leak | SanitizerKind::Thread |
  416                          SanitizerKind::Leak | SanitizerKind::Thread |
  417                          SanitizerKind::Memory | SanitizerKind::KernelAddress),
  417                          SanitizerKind::Memory | SanitizerKind::KernelAddress),
  418       std::make_pair(SanitizerKind::KernelHWAddress,
  419                      SanitizerKind::Address | SanitizerKind::HWAddress |
  419                      SanitizerKind::Address | SanitizerKind::HWAddress |
  420                          SanitizerKind::Leak | SanitizerKind::Thread |
  420                          SanitizerKind::Leak | SanitizerKind::Thread |
  421                          SanitizerKind::Memory | SanitizerKind::KernelAddress |
  421                          SanitizerKind::Memory | SanitizerKind::KernelAddress |
  422                          SanitizerKind::SafeStack),
  423       std::make_pair(SanitizerKind::KernelMemory,
  424                      SanitizerKind::Address | SanitizerKind::HWAddress |
  424                      SanitizerKind::Address | SanitizerKind::HWAddress |
  425                          SanitizerKind::Leak | SanitizerKind::Thread |
  425                          SanitizerKind::Leak | SanitizerKind::Thread |
  426                          SanitizerKind::Memory | SanitizerKind::KernelAddress |
  426                          SanitizerKind::Memory | SanitizerKind::KernelAddress |
  427                          SanitizerKind::Scudo | SanitizerKind::SafeStack),
  427                          SanitizerKind::Scudo | SanitizerKind::SafeStack),
  428       std::make_pair(SanitizerKind::MemTag,
  429                      SanitizerKind::Address | SanitizerKind::KernelAddress |
  429                      SanitizerKind::Address | SanitizerKind::KernelAddress |
  430                          SanitizerKind::HWAddress |
  431                          SanitizerKind::KernelHWAddress)};
  447   if ((Kinds & SanitizerKind::Vptr) && (RTTIMode == ToolChain::RM_Disabled)) {
  448     Kinds &= ~SanitizerKind::Vptr;
  457   if ((Kinds & SanitizerKind::ShadowCallStack) &&
  462         << lastArgumentForMask(D, Args, Kinds & SanitizerKind::ShadowCallStack)
  470   if (~Supported & SanitizerKind::Vptr) {
  475       KindsToDiagnose &= ~SanitizerKind::CFI;
  588   if (AllAddedKinds & SanitizerKind::Memory) {
  616   if (AllAddedKinds & SanitizerKind::Thread) {
  628   if (AllAddedKinds & SanitizerKind::CFI) {
  656     SanitizerMask NonTrappingCfi = Kinds & SanitizerKind::CFI & ~TrappingKinds;
  744   if (AllAddedKinds & SanitizerKind::Address) {
  766             << lastArgumentForMask(D, Args, SanitizerKind::Address);
  793     if (AllAddedKinds & SanitizerKind::PointerCompare & ~AllRemove) {
  797     if (AllAddedKinds & SanitizerKind::PointerSubtract & ~AllRemove) {
  805         SanitizerKind::PointerCompare | SanitizerKind::PointerSubtract;
  805         SanitizerKind::PointerCompare | SanitizerKind::PointerSubtract;
  809                                  SanitizerKind::PointerCompare |
  810                                      SanitizerKind::PointerSubtract)
  815   if (AllAddedKinds & SanitizerKind::HWAddress) {
  827   if (AllAddedKinds & SanitizerKind::SafeStack) {
 1035   if (Sanitizers.has(SanitizerKind::HWAddress)) {
 1045   if (Sanitizers.has(SanitizerKind::Memory) ||
 1046       Sanitizers.has(SanitizerKind::Address))
 1059   if (Sanitizers.has(SanitizerKind::MemTag) && !hasTargetFeatureMTE(CmdArgs))
tools/clang/lib/Driver/ToolChain.cpp
  927   SanitizerMask Res = (SanitizerKind::Undefined & ~SanitizerKind::Vptr &
  927   SanitizerMask Res = (SanitizerKind::Undefined & ~SanitizerKind::Vptr &
  928                        ~SanitizerKind::Function) |
  929                       (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
  929                       (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
  930                       SanitizerKind::CFICastStrict |
  931                       SanitizerKind::FloatDivideByZero |
  932                       SanitizerKind::UnsignedIntegerOverflow |
  933                       SanitizerKind::ImplicitConversion |
  934                       SanitizerKind::Nullability | SanitizerKind::LocalBounds;
  934                       SanitizerKind::Nullability | SanitizerKind::LocalBounds;
  941     Res |= SanitizerKind::CFIICall;
  944     Res |= SanitizerKind::ShadowCallStack;
  947     Res |= SanitizerKind::MemTag;
tools/clang/lib/Driver/ToolChains/CloudABI.cpp
  141   Res |= SanitizerKind::SafeStack;
  146   return SanitizerKind::SafeStack;
tools/clang/lib/Driver/ToolChains/Contiki.cpp
   25     Res |= SanitizerKind::SafeStack;
tools/clang/lib/Driver/ToolChains/CrossWindows.cpp
  279   Res |= SanitizerKind::Address;
  280   Res |= SanitizerKind::PointerCompare;
  281   Res |= SanitizerKind::PointerSubtract;
tools/clang/lib/Driver/ToolChains/Darwin.cpp
 2588   Res |= SanitizerKind::Address;
 2589   Res |= SanitizerKind::PointerCompare;
 2590   Res |= SanitizerKind::PointerSubtract;
 2591   Res |= SanitizerKind::Leak;
 2592   Res |= SanitizerKind::Fuzzer;
 2593   Res |= SanitizerKind::FuzzerNoLink;
 2594   Res |= SanitizerKind::Function;
 2601     Res |= SanitizerKind::Vptr;
 2605       Res |= SanitizerKind::Thread;
 2608       Res |= SanitizerKind::Thread;
tools/clang/lib/Driver/ToolChains/FreeBSD.cpp
  430   Res |= SanitizerKind::Address;
  431   Res |= SanitizerKind::PointerCompare;
  432   Res |= SanitizerKind::PointerSubtract;
  433   Res |= SanitizerKind::Vptr;
  435     Res |= SanitizerKind::Leak;
  436     Res |= SanitizerKind::Thread;
  439     Res |= SanitizerKind::Function;
  440     Res |= SanitizerKind::SafeStack;
  441     Res |= SanitizerKind::Fuzzer;
  442     Res |= SanitizerKind::FuzzerNoLink;
  445     Res |= SanitizerKind::Memory;
tools/clang/lib/Driver/ToolChains/Fuchsia.cpp
  335   Res |= SanitizerKind::Address;
  336   Res |= SanitizerKind::PointerCompare;
  337   Res |= SanitizerKind::PointerSubtract;
  338   Res |= SanitizerKind::Fuzzer;
  339   Res |= SanitizerKind::FuzzerNoLink;
  340   Res |= SanitizerKind::SafeStack;
  341   Res |= SanitizerKind::Scudo;
  348     Res |= SanitizerKind::ShadowCallStack;
  350     Res |= SanitizerKind::SafeStack;
tools/clang/lib/Driver/ToolChains/Linux.cpp
 1006   Res |= SanitizerKind::Address;
 1007   Res |= SanitizerKind::PointerCompare;
 1008   Res |= SanitizerKind::PointerSubtract;
 1009   Res |= SanitizerKind::Fuzzer;
 1010   Res |= SanitizerKind::FuzzerNoLink;
 1011   Res |= SanitizerKind::KernelAddress;
 1012   Res |= SanitizerKind::Memory;
 1013   Res |= SanitizerKind::Vptr;
 1014   Res |= SanitizerKind::SafeStack;
 1016     Res |= SanitizerKind::DataFlow;
 1018     Res |= SanitizerKind::Leak;
 1020     Res |= SanitizerKind::Thread;
 1022     Res |= SanitizerKind::KernelMemory;
 1024     Res |= SanitizerKind::Function;
 1027     Res |= SanitizerKind::Scudo;
 1029     Res |= SanitizerKind::HWAddress;
 1030     Res |= SanitizerKind::KernelHWAddress;
tools/clang/lib/Driver/ToolChains/MSVC.cpp
 1362   Res |= SanitizerKind::Address;
 1363   Res |= SanitizerKind::PointerCompare;
 1364   Res |= SanitizerKind::PointerSubtract;
 1365   Res |= SanitizerKind::Fuzzer;
 1366   Res |= SanitizerKind::FuzzerNoLink;
 1367   Res &= ~SanitizerKind::CFIMFCall;
tools/clang/lib/Driver/ToolChains/MinGW.cpp
  462   Res |= SanitizerKind::Address;
  463   Res |= SanitizerKind::PointerCompare;
  464   Res |= SanitizerKind::PointerSubtract;
tools/clang/lib/Driver/ToolChains/Myriad.cpp
  289   return SanitizerKind::Address;
tools/clang/lib/Driver/ToolChains/NetBSD.cpp
  469     Res |= SanitizerKind::Address;
  470     Res |= SanitizerKind::PointerCompare;
  471     Res |= SanitizerKind::PointerSubtract;
  472     Res |= SanitizerKind::Function;
  473     Res |= SanitizerKind::Leak;
  474     Res |= SanitizerKind::SafeStack;
  475     Res |= SanitizerKind::Scudo;
  476     Res |= SanitizerKind::Vptr;
  479     Res |= SanitizerKind::DataFlow;
  480     Res |= SanitizerKind::Fuzzer;
  481     Res |= SanitizerKind::FuzzerNoLink;
  482     Res |= SanitizerKind::HWAddress;
  483     Res |= SanitizerKind::KernelAddress;
  484     Res |= SanitizerKind::KernelHWAddress;
  485     Res |= SanitizerKind::KernelMemory;
  486     Res |= SanitizerKind::Memory;
  487     Res |= SanitizerKind::Thread;
tools/clang/lib/Driver/ToolChains/OpenBSD.cpp
  241     Res |= SanitizerKind::Vptr;
  242     Res |= SanitizerKind::Fuzzer;
  243     Res |= SanitizerKind::FuzzerNoLink;
tools/clang/lib/Driver/ToolChains/PS4CPU.cpp
  427   Res |= SanitizerKind::Address;
  428   Res |= SanitizerKind::PointerCompare;
  429   Res |= SanitizerKind::PointerSubtract;
  430   Res |= SanitizerKind::Vptr;
tools/clang/lib/Driver/ToolChains/Solaris.cpp
  205     Res |= SanitizerKind::Address;
  206     Res |= SanitizerKind::PointerCompare;
  207     Res |= SanitizerKind::PointerSubtract;
  210     Res |= SanitizerKind::Function;
  211   Res |= SanitizerKind::Vptr;
tools/clang/lib/Driver/ToolChains/WebAssembly.cpp
  282     Res |= SanitizerKind::Vptr | SanitizerKind::Leak | SanitizerKind::Address;
  282     Res |= SanitizerKind::Vptr | SanitizerKind::Leak | SanitizerKind::Address;
  282     Res |= SanitizerKind::Vptr | SanitizerKind::Leak | SanitizerKind::Address;
tools/clang/lib/Frontend/CompilerInvocation.cpp
 3529       !LangOpts.Sanitize.has(SanitizerKind::Address) &&
 3530       !LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
 3531       !LangOpts.Sanitize.has(SanitizerKind::Memory) &&
 3532       !LangOpts.Sanitize.has(SanitizerKind::KernelMemory);