Enable memtag sanitizer in all AArch64 toolchains

[chill]

Summary

That sanitizer does not have runtime library or other dependencies.

[vitalybuka]

clang/lib/Driver/ToolChain.cpp

900

this patch affects also cfi and shadow callstack (aarch64_be and armeb)
it should be in a separate patch with corresponding title

911

I am not strongly against it but I don't think IsAArch64 and IsArmArch declare above improve readability here.

[eugenis]

LGTM

clang/lib/Driver/ToolChain.cpp

bool ToolChain::AddFastMathRuntimeIfAvailable(const ArgList &Args,
 
   CmdArgs.push_back(Args.MakeArgString(Path));
   return true;
 }
 
 SanitizerMask ToolChain::getSupportedSanitizers() const {
   // Return sanitizers which don't require runtime support and are not
   // platform dependent.
-
+  const auto Arch = getTriple().getArch();
+  const bool IsAArch64 = Arch == llvm::Triple::aarch64 ||
+                         Arch == llvm::Triple::aarch64_be;
+  const bool IsArmArch = Arch == llvm::Triple::arm ||
+                         Arch == llvm::Triple::armeb;
   SanitizerMask Res = (SanitizerKind::Undefined & ~SanitizerKind::Vptr &
                        ~SanitizerKind::Function) |
                       (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
                       SanitizerKind::CFICastStrict |
                       SanitizerKind::FloatDivideByZero |
                       SanitizerKind::UnsignedIntegerOverflow |
                       SanitizerKind::ImplicitConversion |
                       SanitizerKind::Nullability | SanitizerKind::LocalBounds;
-  if (getTriple().getArch() == llvm::Triple::x86 ||
-      getTriple().getArch() == llvm::Triple::x86_64 ||
-      getTriple().getArch() == llvm::Triple::arm ||
-      getTriple().getArch() == llvm::Triple::aarch64 ||
-      getTriple().getArch() == llvm::Triple::wasm32 ||
-      getTriple().getArch() == llvm::Triple::wasm64)
+  if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64 ||
+      IsAArch64 || IsArmArch ||
+      Arch == llvm::Triple::wasm32 || Arch == llvm::Triple::wasm64)
     Res |= SanitizerKind::CFIICall;
-  if (getTriple().getArch() == llvm::Triple::x86_64 ||
-      getTriple().getArch() == llvm::Triple::aarch64)
+  if (Arch == llvm::Triple::x86_64 || IsAArch64)
     Res |= SanitizerKind::ShadowCallStack;
+  if (IsAArch64)
+    Res |= SanitizerKind::MemTag;
+
   return Res;
 }
 
 void ToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
                                    ArgStringList &CC1Args) const {}
 
 void ToolChain::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
                                     ArgStringList &CC1Args) const {}

clang/lib/Driver/ToolChains/Linux.cpp

if (IsX86 || IsX86_64)
     Res |= SanitizerKind::Function;
   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||
       IsPowerPC64)
     Res |= SanitizerKind::Scudo;
   if (IsX86_64 || IsAArch64) {
     Res |= SanitizerKind::HWAddress;
     Res |= SanitizerKind::KernelHWAddress;
   }
-  if (IsAArch64)
-    Res |= SanitizerKind::MemTag;
   return Res;
 }
 
 void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
                              llvm::opt::ArgStringList &CmdArgs) const {
   if (!needsProfileRT(Args)) return;
 
   // Add linker option -u__llvm_runtime_variable to cause runtime
   // initialization module to be linked in.
   if ((!Args.hasArg(options::OPT_coverage)) &&
       (!Args.hasArg(options::OPT_ftest_coverage)))
     CmdArgs.push_back(Args.MakeArgString(
         Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
   ToolChain::addProfileRTLibs(Args, CmdArgs);
 }