[Driver] Allow for usage of old triple behavior in bundler (#17557)

Recent upstreamed changes force the triple usage with the bundler to use
a 4-field triple value.
The Intel compiler does not take well to these changes. We are not in a
position to move our triple usage when bundling and unbundling (not in a
breaking change period).

Here, we are updating bundler behavior to allow for the older behavior
of accepting triple formats that are 'incomplete'. We can move to using
the forced triple value usage when we are ready or if we even need to
when we move to the new offloading model.

Author: mdtoguchi

clang/lib/Driver/OffloadBundler.cpp

@@ -100,6 +100,36 @@ OffloadTargetInfo::OffloadTargetInfo(const StringRef Target,
   // <triple> := <arch>-<vendor>-<os>-<env>
   SmallVector<StringRef, 6> Components;
   Target.split(Components, '-', /*MaxSplit=*/5);
+  if (Components.size() < 5) {
+    // Handle target inputs that do not fit the <arch>-<vendor>-<os>-<env>
+    // triple format.
+    auto TargetFeatures = Target.split(':');
+    auto TripleOrGPU = TargetFeatures.first.rsplit('-');
+
+    if (clang::StringToOffloadArch(TripleOrGPU.second) !=
+        clang::OffloadArch::UNKNOWN) {
+      auto KindTriple = TripleOrGPU.first.split('-');
+      this->OffloadKind = KindTriple.first;
+
+      // Enforce optional env field to standardize bundles
+      llvm::Triple t = llvm::Triple(KindTriple.second);
+      this->Triple = llvm::Triple(t.getArchName(), t.getVendorName(),
+                                  t.getOSName(), t.getEnvironmentName());
+
+      this->TargetID = Target.substr(Target.find(TripleOrGPU.second));
+    } else {
+      auto KindTriple = TargetFeatures.first.split('-');
+      this->OffloadKind = KindTriple.first;
+
+      // Enforce optional env field to standardize bundles
+      llvm::Triple t = llvm::Triple(KindTriple.second);
+      this->Triple = llvm::Triple(t.getArchName(), t.getVendorName(),
+                                  t.getOSName(), t.getEnvironmentName());
+
+      this->TargetID = "";
+    }
+    return;
+  }
   assert((Components.size() == 5 || Components.size() == 6) &&
          "malformed target string");
 
@@ -2580,7 +2610,10 @@ Error OffloadBundler::UnbundleArchive() {
 bool clang::checkOffloadBundleID(const llvm::StringRef Str) {
   // <kind>-<triple>[-<target id>[:target features]]
   // <triple> := <arch>-<vendor>-<os>-<env>
-  SmallVector<StringRef, 6> Components;
-  Str.split(Components, '-', /*MaxSplit=*/5);
-  return Components.size() == 5 || Components.size() == 6;
+  // FIXME: The Intel Compiler does not currently adhere to the strict
+  // component size.  Consider all checks valid.
+  // SmallVector<StringRef, 6> Components;
+  // Str.split(Components, '-', /*MaxSplit=*/5);
+  // return Components.size() == 5 || Components.size() == 6;
+  return true;
 }

clang/lib/Driver/ToolChains/Clang.cpp

@@ -9959,7 +9959,15 @@ void OffloadBundler::ConstructJob(Compilation &C, const JobAction &JA,
       T.setArchName(ArchName);
       Triples += T.normalize();
     } else {
-      Triples += CurTC->getTriple().normalize(llvm::Triple::CanonicalForm::FOUR_IDENT);
+      // Use of the 4-field triple will be done for HIP only, with other
+      // offload targets not being modified.
+      // TODO: All targets should use the 4-field triple, which can be done
+      //       during an ABI breaking juncture.
+      if (CurKind == Action::OFK_HIP)
+        Triples += CurTC->getTriple().normalize(
+            llvm::Triple::CanonicalForm::FOUR_IDENT);
+      else
+        Triples += CurTC->getTriple().normalize();
     }
     if ((CurKind == Action::OFK_HIP || CurKind == Action::OFK_OpenMP ||
          CurKind == Action::OFK_Cuda || CurKind == Action::OFK_SYCL) &&
@@ -10188,11 +10196,18 @@ void OffloadBundler::ConstructJobMultipleOutputs(
       StringRef Val(
           TCArgs.getLastArg(options::OPT_fsycl_force_target_EQ)->getValue());
       llvm::Triple TT(C.getDriver().getSYCLDeviceTriple(Val));
-      Triples += TT.normalize(
-        llvm::Triple::CanonicalForm::FOUR_IDENT);
-    } else
-      Triples += Dep.DependentToolChain->getTriple().normalize(
-        llvm::Triple::CanonicalForm::FOUR_IDENT);
+      Triples += TT.normalize();
+    } else {
+      // Use of the 4-field triple will be done for HIP only, with other
+      // offload targets not being modified.
+      // TODO: All targets should use the 4-field triple, which can be done
+      //       during an ABI breaking juncture.
+      if (Dep.DependentOffloadKind == Action::OFK_HIP)
+        Triples += Dep.DependentToolChain->getTriple().normalize(
+          llvm::Triple::CanonicalForm::FOUR_IDENT);
+      else
+        Triples += Dep.DependentToolChain->getTriple().normalize();
+    }
     if ((Dep.DependentOffloadKind == Action::OFK_HIP ||
          Dep.DependentOffloadKind == Action::OFK_OpenMP ||
          Dep.DependentOffloadKind == Action::OFK_Cuda ||