[Clang][NCF] Sanitizer options: helpers to check if {Kernel,Hardware}ASan is enabled

[yln]

Summary

Kernel ASan is basically ASan with a few specific settings, but has a
seperate front-end flag. Provide a helper that checks for both, so new
comitters like myself are less likely to forget the Kernel variant.

[vsk]

clang/include/clang/Basic/Sanitizers.h

89

Sorry to bike-shed, but this seems a bit hard to read. How about: 'hasAnyASan'?

[eugenis]

I find the current code more readable than with this change.

clang/include/clang/Basic/Features.def

 #ifndef FEATURE
 #define FEATURE(Name, Predicate)
 #endif
 
 #ifndef EXTENSION
 #define EXTENSION(Name, Predicate)
 #endif
 
-FEATURE(address_sanitizer,
-        LangOpts.Sanitize.hasOneOf(SanitizerKind::Address |
-                                   SanitizerKind::KernelAddress))
-FEATURE(hwaddress_sanitizer,
-        LangOpts.Sanitize.hasOneOf(SanitizerKind::HWAddress |
-                                   SanitizerKind::KernelHWAddress))
+FEATURE(address_sanitizer, LangOpts.Sanitize.hasASanOrKASan())
+FEATURE(hwaddress_sanitizer, LangOpts.Sanitize.hasHWASanOrHWKASan())
 FEATURE(xray_instrument, LangOpts.XRayInstrument)
 FEATURE(undefined_behavior_sanitizer,
         LangOpts.Sanitize.hasOneOf(SanitizerKind::Undefined))
 FEATURE(assume_nonnull, true)
 FEATURE(attribute_analyzer_noreturn, true)
 FEATURE(attribute_availability, true)
 FEATURE(attribute_availability_with_message, true)
 FEATURE(attribute_availability_app_extension, true)

clang/include/clang/Basic/Sanitizers.h

struct SanitizerSet {
   /// Disable the sanitizers specified in \p K.
   void clear(SanitizerMask K = SanitizerKind::All) { Mask &= ~K; }
 
   /// Returns true if no sanitizers are enabled.
   bool empty() const { return Mask == 0; }
 
   /// Bitmask of enabled sanitizers.
   SanitizerMask Mask = 0;
+
+  /// Check if ASan or Kernel ASan are enabled.
+  bool hasASanOrKASan() const {
+    return hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress);
+  }
+
+  /// Check if Hardware ASan or Hardware Kernel ASan are enabled.
+  bool hasHWASanOrHWKASan() const {
+    return hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress);
+  }
+
+  /// Check if any of the following are enabled:
+  /// * ASan
+  /// * Kernel ASan
+  /// * Hardware ASan
+  /// * Hardware Kernel ASan
+  bool hasASanOrKASanOrHWASanOrHWKASan() const {
+    return hasASanOrKASan() || hasHWASanOrHWKASan();
+  }
 };
 
 /// Parse a single value from a -fsanitize= or -fno-sanitize= value list.
 /// Returns a non-zero SanitizerMask, or \c 0 if \p Value is not known.
 SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups);
 
 /// For each sanitizer group bit set in \p Kinds, set the bits for sanitizers
 /// this group enables.

clang/lib/CodeGen/CGCall.cpp

if (SanOpts.has(SanitizerKind::Unreachable)) {
       // attributes of the called function.
       if (auto *F = CI->getCalledFunction())
         F->removeFnAttr(llvm::Attribute::NoReturn);
       CI->removeAttribute(llvm::AttributeList::FunctionIndex,
                           llvm::Attribute::NoReturn);
 
       // Avoid incompatibility with ASan which relies on the `noreturn`
       // attribute to insert handler calls.
-      if (SanOpts.hasOneOf(SanitizerKind::Address |
-                           SanitizerKind::KernelAddress)) {
+      if (SanOpts.hasASanOrKASan()) {
         SanitizerScope SanScope(this);
         llvm::IRBuilder<>::InsertPointGuard IPGuard(Builder);
         Builder.SetInsertPoint(CI);
         auto *FnType = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
         auto *Fn = CGM.CreateRuntimeFunction(FnType, "__asan_handle_no_return");
         EmitNounwindRuntimeCall(Fn);
       }
     }

clang/lib/CodeGen/CodeGenFunction.cpp

for (auto Attr : D->specific_attrs<NoSanitizeAttr>()) {
       if (mask & SanitizerKind::HWAddress)
         SanOpts.set(SanitizerKind::KernelHWAddress, false);
       if (mask & SanitizerKind::KernelHWAddress)
         SanOpts.set(SanitizerKind::HWAddress, false);
     }
   }
 
   // Apply sanitizer attributes to the function.
-  if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
+  if (SanOpts.hasASanOrKASan())
     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
-  if (SanOpts.hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress))
+  if (SanOpts.hasHWASanOrHWKASan())
     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
   if (SanOpts.has(SanitizerKind::Thread))
     Fn->addFnAttr(llvm::Attribute::SanitizeThread);
   if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
   if (SanOpts.has(SanitizerKind::SafeStack))
     Fn->addFnAttr(llvm::Attribute::SafeStack);
   if (SanOpts.has(SanitizerKind::ShadowCallStack))

clang/lib/CodeGen/SanitizerMetadata.cpp

 using namespace CodeGen;
 
 SanitizerMetadata::SanitizerMetadata(CodeGenModule &CGM) : CGM(CGM) {}
 
 void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV,
                                            SourceLocation Loc, StringRef Name,
                                            QualType Ty, bool IsDynInit,
                                            bool IsBlacklisted) {
-  if (!CGM.getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address |
-                                           SanitizerKind::KernelAddress |
-                                           SanitizerKind::HWAddress |
-                                           SanitizerKind::KernelHWAddress))
+  if (!CGM.getLangOpts().Sanitize.hasASanOrKASanOrHWASanOrHWKASan())
     return;
   IsDynInit &= !CGM.isInSanitizerBlacklist(GV, Loc, Ty, "init");
   IsBlacklisted |= CGM.isInSanitizerBlacklist(GV, Loc, Ty);
 
   llvm::Metadata *LocDescr = nullptr;
   llvm::Metadata *GlobalName = nullptr;
   llvm::LLVMContext &VMContext = CGM.getLLVMContext();
   if (!IsBlacklisted) {
void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV,
   llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalMetadata);
   llvm::NamedMDNode *AsanGlobals =
       CGM.getModule().getOrInsertNamedMetadata("llvm.asan.globals");
   AsanGlobals->addOperand(ThisGlobal);
 }
 
 void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV,
                                            const VarDecl &D, bool IsDynInit) {
-  if (!CGM.getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address |
-                                           SanitizerKind::KernelAddress |
-                                           SanitizerKind::HWAddress |
-                                           SanitizerKind::KernelHWAddress))
+  if (!CGM.getLangOpts().Sanitize.hasASanOrKASanOrHWASanOrHWKASan())
     return;
   std::string QualName;
   llvm::raw_string_ostream OS(QualName);
   D.printQualifiedName(OS);
 
   bool IsBlacklisted = false;
   for (auto Attr : D.specific_attrs<NoSanitizeAttr>())
     if (Attr->getMask() & SanitizerKind::Address)
       IsBlacklisted = true;
   reportGlobalToASan(GV, D.getLocation(), OS.str(), D.getType(), IsDynInit,
                      IsBlacklisted);
 }
 
 void SanitizerMetadata::disableSanitizerForGlobal(llvm::GlobalVariable *GV) {
   // For now, just make sure the global is not modified by the ASan
   // instrumentation.
-  if (CGM.getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address |
-                                          SanitizerKind::KernelAddress |
-                                          SanitizerKind::HWAddress |
-                                          SanitizerKind::KernelHWAddress))
+  if (CGM.getLangOpts().Sanitize.hasASanOrKASanOrHWASanOrHWKASan())
     reportGlobalToASan(GV, SourceLocation(), "", QualType(), false, true);
 }
 
 void SanitizerMetadata::disableSanitizerForInstruction(llvm::Instruction *I) {
   I->setMetadata(CGM.getModule().getMDKindID("nosanitize"),
                  llvm::MDNode::get(CGM.getLLVMContext(), None));
 }