[AArch64] Make the memtag sanitizer require the memtag extension

[chill]

Summary

... or otherwise we get an ICE.

[vitalybuka]

clang/lib/Driver/ToolChains/Clang.cpp

1568

Please move back Driver closer to the first use

1631

maybe better place is somewhere near llvm/tools/clang/lib/Driver/SanitizerArgs.cpp:1020

clang/test/Driver/fsanitize.c

194

Can you also add command line where driver accepts flags?

[chill]

clang/lib/Driver/ToolChains/Clang.cpp

1631

The check is target specific, I prefer to keep it in a function that's already target specific anyway.

[chill]

clang/lib/Driver/ToolChains/Clang.cpp

1632

I've already fixed the line length here.

[vitalybuka]

clang/lib/Driver/ToolChains/Clang.cpp

1631

My thoughts here are that the check is both sanitizer specific and platform specific. However it's going to be always sanitizers specific, but in theory we may get more platforms supporting "mte".

Also right now err_stack_tagging_requires_hardware_feature is very platform specific.
Something less specific?

'-fsanitize=memtag' requires hardware support (+memtag)

[eugenis]

clang/lib/Driver/SanitizerArgs.cpp

1042 ↗

(On Diff #214185)

I'm a bit worried that this check can be satisfied by, say, a source file or a relative include path of "+mte".

[chill]

clang/lib/Driver/SanitizerArgs.cpp

1042 ↗

(On Diff #214185)

Fair enough, I've updated the patch.

[eugenis]

LGTM

clang/include/clang/Basic/DiagnosticDriverKinds.td

def warn_slash_u_filename : Warning<"'/U%0' treated as the '/U' option">,
   InGroup<DiagGroup<"slash-u-filename">>;
 def note_use_dashdash : Note<"Use '--' to treat subsequent arguments as filenames">;
 
 def err_drv_ropi_rwpi_incompatible_with_pic : Error<
   "embedded and GOT-based position independence are incompatible">;
 def err_drv_ropi_incompatible_with_cxx : Error<
   "ROPI is not compatible with c++">;
 
+def err_stack_tagging_requires_hardware_feature : Error<
+  "'-fsanitize=memtag' requires the v8.5A Memory Tagging Extension (+memtag)">;
+
 def warn_target_unsupported_nan2008 : Warning<
   "ignoring '-mnan=2008' option because the '%0' architecture does not support it">,
   InGroup<UnsupportedNan>;
 def warn_target_unsupported_nanlegacy : Warning<
   "ignoring '-mnan=legacy' option because the '%0' architecture does not support it">,
   InGroup<UnsupportedNan>;
 def warn_target_unsupported_abslegacy : Warning<
   "ignoring '-mabs=legacy' option because the '%0' architecture does not support it">,

clang/include/clang/Driver/SanitizerArgs.h

public:
   SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
 
   bool needsSharedRt() const { return SharedRuntime; }
 
   bool needsAsanRt() const { return Sanitizers.has(SanitizerKind::Address); }
   bool needsHwasanRt() const {
     return Sanitizers.has(SanitizerKind::HWAddress);
   }
+  bool needsMemtag() const { return Sanitizers.has(SanitizerKind::MemTag); }
   bool needsTsanRt() const { return Sanitizers.has(SanitizerKind::Thread); }
   bool needsMsanRt() const { return Sanitizers.has(SanitizerKind::Memory); }
   bool needsFuzzer() const { return Sanitizers.has(SanitizerKind::Fuzzer); }
   bool needsLsanRt() const {
     return Sanitizers.has(SanitizerKind::Leak) &&
            !Sanitizers.has(SanitizerKind::Address) &&
            !Sanitizers.has(SanitizerKind::HWAddress);
   }

clang/lib/Driver/ToolChains/Clang.cpp

void RenderAArch64ABI(const llvm::Triple &Triple, const ArgList &Args,
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName);
 }
 }
 
 void Clang::AddAArch64TargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
-  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
+  const ToolChain &TC = getToolChain();
+  const llvm::Triple &Triple = TC.getEffectiveTriple();
 
   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
       Args.hasArg(options::OPT_mkernel) ||
       Args.hasArg(options::OPT_fapple_kext))
     CmdArgs.push_back("-disable-red-zone");
 
   if (!Args.hasFlag(options::OPT_mimplicit_float,
                     options::OPT_mno_implicit_float, true))
if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
     CmdArgs.push_back("-mllvm");
     if (A->getOption().matches(options::OPT_mno_global_merge))
       CmdArgs.push_back("-aarch64-enable-global-merge=false");
     else
       CmdArgs.push_back("-aarch64-enable-global-merge=true");
   }
 
   // Enable/disable return address signing and indirect branch targets.
+  const Driver &D = TC.getDriver();
   if (Arg *A = Args.getLastArg(options::OPT_msign_return_address_EQ,
                                options::OPT_mbranch_protection_EQ)) {
-
-    const Driver &D = getToolChain().getDriver();
-
     StringRef Scope, Key;
     bool IndirectBranches;
 
     if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
       Scope = A->getValue();
       if (!Scope.equals("none") && !Scope.equals("non-leaf") &&
           !Scope.equals("all"))
         D.Diag(diag::err_invalid_branch_protection)
             << Scope << A->getAsString(Args);
       Key = "a_key";
       IndirectBranches = false;
     } else
       std::tie(Scope, Key, IndirectBranches) =
           ParseAArch64BranchProtection(D, Args, A);
 
     CmdArgs.push_back(
         Args.MakeArgString(Twine("-msign-return-address=") + Scope));
     CmdArgs.push_back(
         Args.MakeArgString(Twine("-msign-return-address-key=") + Key));
     if (IndirectBranches)
       CmdArgs.push_back("-mbranch-target-enforce");
   }
+
+  if (TC.getSanitizerArgs().needsMemtag()) {
+    if (std::find(CmdArgs.begin(), CmdArgs.end(), StringRef("+mte")) == CmdArgs.end()) {
+      D.Diag(diag::err_stack_tagging_requires_hardware_feature);
+    }
+  }
 }
 
 void Clang::AddMIPSTargetArgs(const ArgList &Args,
                               ArgStringList &CmdArgs) const {
   const Driver &D = getToolChain().getDriver();
   StringRef CPUName;
   StringRef ABIName;
   const llvm::Triple &Triple = getToolChain().getTriple();

clang/test/Driver/fsanitize.c

 
 // RUN: %clang -target aarch64-linux-android -fsanitize=memtag,hwaddress -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANMT-SANHA
 // CHECK-SANMT-SANHA: '-fsanitize=memtag' not allowed with '-fsanitize=hwaddress'
 
 // RUN: %clang -target i386-linux-android -fsanitize=memtag -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANMT-BAD-ARCH
 // RUN: %clang -target x86_64-linux-android -fsanitize=memtag -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANMT-BAD-ARCH
 // CHECK-SANMT-BAD-ARCH: unsupported option '-fsanitize=memtag' for target
 
+// RUN: %clang -target aarch64-linux -fsanitize=memtag -march=armv8-a+memtag %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANMT-MT
+// CHECK-SANMT-MT: "-target-feature" "+mte"
+// CHECK-SANMT-MT-SAME: "-fsanitize=memtag"
+
+// RUN: %clang -target aarch64-linux -fsanitize=memtag %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANMT-NOMT
+// CHECK-SANMT-NOMT: '-fsanitize=memtag' requires the v8.5A Memory Tagging Extension (+memtag)
+
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-address-use-after-scope %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-USE-AFTER-SCOPE
 // RUN: %clang_cl --target=x86_64-windows -fsanitize=address -fsanitize-address-use-after-scope -### -- %s 2>&1 | FileCheck %s --check-prefix=CHECK-USE-AFTER-SCOPE
 // CHECK-USE-AFTER-SCOPE: -cc1{{.*}}-fsanitize-address-use-after-scope
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fno-sanitize-address-use-after-scope %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-USE-AFTER-SCOPE-OFF
 // RUN: %clang_cl --target=x86_64-windows -fsanitize=address -fno-sanitize-address-use-after-scope -### -- %s 2>&1 | FileCheck %s --check-prefix=CHECK-USE-AFTER-SCOPE-OFF
 // CHECK-USE-AFTER-SCOPE-OFF-NOT: -cc1{{.*}}address-use-after-scope