[SanitizerBinaryMetadata] Do not add to GPU code

[melver]

Summary

SanitizerBinaryMetadata should only apply to to host code, and not GPU
code. Recently AMD GPU target code has experimental sanitizer support.

If we're compiling a mixed host/device source file, only add sanitizer
metadata to host code.

[tra]

LGTM for NVPTX.

llvm/lib/Transforms/Instrumentation/SanitizerBinaryMetadata.cpp

134

Nit: assert(!(TargetTriple.isNVPTX() || TargetTriple.isAMDGPU())) would be a bit easier to read.

[melver]

Simplify assert.

clang/lib/Driver/SanitizerArgs.cpp

 }
 
 void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
                             llvm::opt::ArgStringList &CmdArgs,
                             types::ID InputType) const {
   // NVPTX doesn't currently support sanitizers.  Bailing out here means
   // that e.g. -fsanitize=address applies only to host code, which is what we
   // want for now.
-  //
+  if (TC.getTriple().isNVPTX())
+    return;
   // AMDGPU sanitizer support is experimental and controlled by -fgpu-sanitize.
-  if (TC.getTriple().isNVPTX() ||
-      (TC.getTriple().isAMDGPU() &&
-       !Args.hasFlag(options::OPT_fgpu_sanitize, options::OPT_fno_gpu_sanitize,
-                     true)))
+  bool GPUSanitize = false;
+  if (TC.getTriple().isAMDGPU()) {
+    if (!Args.hasFlag(options::OPT_fgpu_sanitize, options::OPT_fno_gpu_sanitize,
+                      true))
       return;
+    GPUSanitize = true;
+  }
 
   // Translate available CoverageFeatures to corresponding clang-cc1 flags.
   // Do it even if Sanitizers.empty() since some forms of coverage don't require
   // sanitizers.
   std::pair<int, const char *> CoverageFlags[] = {
       std::make_pair(CoverageFunc, "-fsanitize-coverage-type=1"),
       std::make_pair(CoverageBB, "-fsanitize-coverage-type=2"),
       std::make_pair(CoverageEdge, "-fsanitize-coverage-type=3"),
for (auto F : CoverageFlags) {
     if (CoverageFeatures & F.first)
       CmdArgs.push_back(F.second);
   }
   addSpecialCaseListOpt(
       Args, CmdArgs, "-fsanitize-coverage-allowlist=", CoverageAllowlistFiles);
   addSpecialCaseListOpt(Args, CmdArgs, "-fsanitize-coverage-ignorelist=",
                         CoverageIgnorelistFiles);
 
+  if (!GPUSanitize) {
     // Translate available BinaryMetadataFeatures to corresponding clang-cc1
-  // flags. Does not depend on any other sanitizers.
+    // flags. Does not depend on any other sanitizers. Unsupported on GPUs.
     const std::pair<int, std::string> BinaryMetadataFlags[] = {
         std::make_pair(BinaryMetadataCovered, "covered"),
         std::make_pair(BinaryMetadataAtomics, "atomics"),
         std::make_pair(BinaryMetadataUAR, "uar")};
     for (const auto &F : BinaryMetadataFlags) {
       if (BinaryMetadataFeatures & F.first)
         CmdArgs.push_back(
             Args.MakeArgString("-fexperimental-sanitize-metadata=" + F.second));
     }
     addSpecialCaseListOpt(Args, CmdArgs,
                           "-fexperimental-sanitize-metadata-ignorelist=",
                           BinaryMetadataIgnorelistFiles);
+  }
 
   if (TC.getTriple().isOSWindows() && needsUbsanRt()) {
     // Instruct the code generator to embed linker directives in the object file
     // that cause the required runtime libraries to be linked.
     CmdArgs.push_back(
         Args.MakeArgString("--dependent-lib=" +
                            TC.getCompilerRTBasename(Args, "ubsan_standalone")));
     if (types::isCXX(InputType))

llvm/lib/Transforms/Instrumentation/SanitizerBinaryMetadata.cpp

 public:
   SanitizerBinaryMetadata(Module &M, SanitizerBinaryMetadataOptions Opts,
                           std::unique_ptr<SpecialCaseList> Ignorelist)
       : Mod(M), Options(transformOptionsFromCl(std::move(Opts))),
         Ignorelist(std::move(Ignorelist)), TargetTriple(M.getTargetTriple()),
         IRB(M.getContext()) {
     // FIXME: Make it work with other formats.
     assert(TargetTriple.isOSBinFormatELF() && "ELF only");
+    assert(!(TargetTriple.isNVPTX() || TargetTriple.isAMDGPU()) &&
+           "Device targets are not supported");
   }
 
   bool run();
 
 private:
   uint32_t getVersion() const {
     uint32_t Version = kVersionBase;
     const auto CM = Mod.getCodeModel();