[llvm-branch-commits] [clang] clang: Move Triple computing logic to separate function (PR #189262)

[Matt Arsenault via llvm-branch-commits]

https://github.com/arsenm created https://github.com/llvm/llvm-project/pull/189262

None

>From 688327661d7e6802f9f3c9d4af1061de4996c8c7 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Wed, 4 Mar 2026 16:40:22 +0100
Subject: [PATCH] clang: Move Triple computing logic to separate function

---
 clang/include/clang/Basic/OffloadArch.h |  4 ++++
 clang/lib/Basic/OffloadArch.cpp         | 16 ++++++++++++++++
 clang/lib/Driver/Driver.cpp             | 19 +++++++------------
 3 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/clang/include/clang/Basic/OffloadArch.h b/clang/include/clang/Basic/OffloadArch.h
index b2aa891462289..531e5e37935eb 100644
--- a/clang/include/clang/Basic/OffloadArch.h
+++ b/clang/include/clang/Basic/OffloadArch.h
@@ -11,6 +11,7 @@
 
 namespace llvm {
 class StringRef;
+class Triple;
 } // namespace llvm
 
 namespace clang {
@@ -151,6 +152,9 @@ const char *OffloadArchToVirtualArchString(OffloadArch A);
 // OffloadArch::Unknown if the string is not recognized.
 OffloadArch StringToOffloadArch(llvm::StringRef S);
 
+llvm::StringRef OffloadArchToTriple(const llvm::Triple &DefaultToolchainTriple,
+                                    OffloadArch ID);
+
 } // namespace clang
 
 #endif // LLVM_CLANG_BASIC_OFFLOADARCH_H
diff --git a/clang/lib/Basic/OffloadArch.cpp b/clang/lib/Basic/OffloadArch.cpp
index 56a1dad8222ba..d15df3deca74b 100644
--- a/clang/lib/Basic/OffloadArch.cpp
+++ b/clang/lib/Basic/OffloadArch.cpp
@@ -9,6 +9,7 @@
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/TargetParser/Triple.h"
 
 namespace clang {
 
@@ -146,4 +147,19 @@ OffloadArch StringToOffloadArch(llvm::StringRef S) {
   return Result->Arch;
 }
 
+llvm::StringRef OffloadArchToTriple(const llvm::Triple &DefaultToolchainTriple,
+                                    OffloadArch ID) {
+  if (ID == OffloadArch::AMDGCNSPIRV)
+    return "spirv64-amd-amdhsa";
+
+  if (IsNVIDIAOffloadArch(ID))
+    return DefaultToolchainTriple.isArch64Bit() ? "nvptx64-nvidia-cuda"
+                                                : "nvptx-nvidia-cuda";
+
+  if (IsAMDOffloadArch(ID))
+    return "amdgcn-amd-amdhsa";
+
+  return "";
+}
+
 } // namespace clang
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
index f67dfcf1d3609..6afdf58f3c5da 100644
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -995,30 +995,25 @@ inferOffloadToolchains(Compilation &C, Action::OffloadKind Kind) {
       return llvm::DenseSet<llvm::StringRef>();
     }
 
-    StringRef Triple;
-    if (ID == OffloadArch::AMDGCNSPIRV)
-      Triple = "spirv64-amd-amdhsa";
-    else if (IsNVIDIAOffloadArch(ID))
-      Triple = C.getDefaultToolChain().getTriple().isArch64Bit()
-                   ? "nvptx64-nvidia-cuda"
-                   : "nvptx-nvidia-cuda";
-    else if (IsAMDOffloadArch(ID))
-      Triple = "amdgcn-amd-amdhsa";
-    else
+    llvm::StringRef TripleStr =
+        OffloadArchToTriple(C.getDefaultToolChain().getTriple(), ID);
+    if (TripleStr.empty())
       continue;
 
+    llvm::Triple Triple(TripleStr);
+
     // Make a new argument that dispatches this argument to the appropriate
     // toolchain. This is required when we infer it and create potentially
     // incompatible toolchains from the global option.
     Option Opt = C.getDriver().getOpts().getOption(options::OPT_Xarch__);
     unsigned Index = C.getArgs().getBaseArgs().MakeIndex("-Xarch_");
     Arg *A = new Arg(Opt, C.getArgs().getArgString(Index), Index,
-                     C.getArgs().MakeArgString(Triple.split("-").first),
+                     C.getArgs().MakeArgString(Triple.getArchName()),
                      C.getArgs().MakeArgString("--offload-arch=" + Arch));
     A->claim();
     C.getArgs().append(A);
     C.getArgs().AddSynthesizedArg(A);
-    Triples.insert(Triple);
+    Triples.insert(TripleStr);
   }
 
   // Infer the default target triple if no specific architectures are given.