[Clang][OpenMP][NFC] Enable various XFAILed tests

Many tests were xfailed in the past to unbock the merge
process. This commit fixes and enables them.

Also deleted some dead functions in the clang driver.

Change-Id: If6e5a416c9677fab2bf31b9a5d60577fbb34ad77

Author: saiislam

clang/include/clang/Driver/Driver.h

@@ -813,24 +813,6 @@ class Driver {
   static const char *getExecutableForDriverMode(DriverMode Mode);
 
 public:
-  ///  Add string to OffloadArchs set for each '--offload-arch=' arg
-  ///
-  /// \param C - The compilation that is being built.
-  /// \param OffloadArchs - The mutable set of strings, one per Offloading arch
-  bool
-  GetTargetInfoFromOffloadArchOpts(Compilation &C,
-                                   std::set<std::string> &OffloadArchs) const;
-
-  ///  Add string to OffloadArchs set for each offloading arch specified
-  ///  with legacy args. Unlike the newer, '--offload-arch' arg, specifying
-  ///  an offload arch with legacy args required three args:
-  ///    '-fopenmp-targets=', '-Xopenmp-target=', and '-march=' .
-  ///
-  /// \param C - The compilation that is being built.
-  /// \param OffloadArchs - The mutable set of strings, one per Offloading arch
-  bool GetTargetInfoFromMarch(Compilation &C,
-                              std::set<std::string> &OffloadArchs) const;
-
   /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and
   /// return the grouped values as integers. Numbers which are not
   /// provided are set to 0.

clang/lib/Driver/Driver.cpp

@@ -776,125 +776,6 @@ Driver::OpenMPRuntimeKind Driver::getOpenMPRuntime(const ArgList &Args) const {
   return RT;
 }
 
-bool GetTargetInfoFromOffloadArch(Compilation &C, const char *OpenMPTarget,
-                                  std::set<std::string> &OffloadArchs,
-                                  bool erase = false) {
-  StringRef DeviceTripleStr;
-  if (!std::strncmp(OpenMPTarget, "gfx", 3)) {
-    DeviceTripleStr = "amdgcn-amd-amdhsa";
-
-    if (erase)
-      OffloadArchs.erase(
-          DeviceTripleStr.str().append("^").append(OpenMPTarget));
-    else {
-      llvm::Triple TT(DeviceTripleStr);
-      llvm::StringMap<bool> Features;
-      StringRef IdStr(OpenMPTarget);
-      auto Arch = parseTargetID(TT, IdStr, &Features);
-      if (!Arch) {
-        C.getDriver().Diag(clang::diag::err_drv_bad_target_id) << IdStr;
-        C.setContainsError();
-        return false;
-      }
-      OffloadArchs.insert(
-          DeviceTripleStr.str().append("^").append(OpenMPTarget));
-    }
-  } else if (!std::strncmp(OpenMPTarget, "sm_", 3)) {
-    const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
-    const llvm::Triple &HostTriple = HostTC->getTriple();
-    DeviceTripleStr = HostTriple.isArch64Bit() ? "nvptx64-nvidia-cuda^"
-                                               : "nvptx-nvidia-cuda^";
-    if (erase)
-      OffloadArchs.erase(DeviceTripleStr.str().append(OpenMPTarget));
-    else
-      OffloadArchs.insert(DeviceTripleStr.str().append(OpenMPTarget));
-  } else {
-    const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
-    const llvm::Triple &HostTriple = HostTC->getTriple();
-    StringRef HostTripleStr = HostTriple.str();
-    if (erase)
-      OffloadArchs.erase(HostTripleStr.str().append("^").append(OpenMPTarget));
-    else
-      OffloadArchs.insert(HostTripleStr.str().append("^").append(OpenMPTarget));
-  }
-  return true;
-}
-
-bool Driver::GetTargetInfoFromMarch(Compilation &C,
-                                    std::set<std::string> &OffloadArchs) const {
-  for (Arg *A : C.getInputArgs()) {
-    if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) {
-      for (auto *V : A->getValues()) {
-        StringRef VStr = StringRef(V);
-        if (VStr.starts_with("-march=") || VStr.starts_with("--march="))
-          for (StringRef OpenMPTargetArch :
-               llvm::split(VStr.split('=').second, ",")) {
-            StringRef OpenMPTargetTriple = StringRef(A->getValue(0));
-            llvm::Triple TargetTriple(OpenMPTargetTriple);
-            llvm::StringMap<bool> Features;
-            auto ArchStr =
-                parseTargetID(TargetTriple, OpenMPTargetArch, &Features);
-            if (TargetTriple.isAMDGCN() && !ArchStr) {
-              C.getDriver().Diag(clang::diag::err_drv_bad_target_id)
-                  << OpenMPTargetArch;
-              C.setContainsError();
-              return false;
-            }
-            StringRef ArchProc = OpenMPTargetArch.split(":").first;
-            if (ArchProc.empty()) {
-              C.getDriver().Diag(clang::diag::err_drv_cuda_bad_gpu_arch)
-                  << VStr;
-              C.setContainsError();
-              return false;
-            }
-
-            // Append Triple and Arch to form a unique key for each instance of
-            // the ToolChain
-            if (!OpenMPTargetTriple.empty() && !OpenMPTargetArch.empty())
-              OffloadArchs.insert(TargetTriple.normalize().append("^").append(
-                  OpenMPTargetArch.str()));
-          }
-        A->claim();
-      }
-    }
-  }
-  return true;
-}
-
-bool Driver::GetTargetInfoFromOffloadArchOpts(
-    Compilation &C, std::set<std::string> &OffloadArchs) const {
-  for (Arg *A : C.getInputArgs()) {
-    if (!(A->getOption().matches(options::OPT_offload_arch_EQ) ||
-          A->getOption().matches(options::OPT_no_offload_arch_EQ))) {
-      continue;
-    }
-    A->claim();
-
-    StringRef ArchStr = A->getValue();
-
-    if (A->getOption().matches(options::OPT_no_offload_arch_EQ) &&
-        ArchStr == "all") {
-      OffloadArchs.clear();
-      continue;
-    }
-    if (ArchStr.empty())
-      continue;
-    else if (A->getOption().matches(options::OPT_offload_arch_EQ)) {
-      for (StringRef ArchVal : llvm::split(ArchStr, ",")) {
-        auto status = GetTargetInfoFromOffloadArch(C, ArchVal.str().c_str(),
-                                                   OffloadArchs);
-        if (!status)
-          return false;
-      }
-    } else if (A->getOption().matches(options::OPT_no_offload_arch_EQ))
-      GetTargetInfoFromOffloadArch(C, ArchStr.str().c_str(), OffloadArchs,
-                                   /* erase */ true);
-    else
-      llvm_unreachable("Unexpected option.");
-  }
-  return true;
-}
-
 void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
                                               InputList &Inputs) {
 

clang/test/Driver/amdgpu-openmp-system-arch.c

@@ -1,41 +1,39 @@
 // REQUIRES: x86-registered-target
 // REQUIRES: amdgpu-registered-target
 // RUN:   %clang -### --target=x86_64-unknown-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa \
-// RUN:          -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx906 --libomptarget-amdgpu-bc-path=%S/Inputs/hip_dev_lib %s 2>&1 \
+// RUN:          -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx906 --no-opaque-offload-linker --libomptarget-amdgpu-bc-path=%S/Inputs/hip_dev_lib %s 2>&1 \
 // RUN:   | FileCheck %s
 // RUN:   %clang -### --target=x86_64-unknown-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa \
-// RUN:          --offload-arch=gfx906 --libomptarget-amdgpu-bc-path=%S/Inputs/hip_dev_lib %s 2>&1 \
+// RUN:          --offload-arch=gfx906 --no-opaque-offload-linker --libomptarget-amdgpu-bc-path=%S/Inputs/hip_dev_lib %s 2>&1 \
 // RUN:   | FileCheck %s
 
-// XFAIL: *
-
 // verify the tools invocations
 // CHECK: clang{{.*}}"-cc1" "-triple" "x86_64-unknown-linux-gnu" "-emit-llvm-bc"{{.*}}"-x" "c"
-// CHECK: clang{{.*}}"-cc1" "-triple" "amdgcn-amd-amdhsa" "-aux-triple" "x86_64-unknown-linux-gnu"{{.*}}"-target-cpu" "gfx906"{{.*}}"-fcuda-is-device"{{.*}}"-mlink-builtin-bitcode" "{{.*}}libomptarget-amdgpu-gfx906.bc"
+// CHECK: clang{{.*}}"-cc1" "-triple" "amdgcn-amd-amdhsa" "-aux-triple" "x86_64-unknown-linux-gnu"{{.*}}"-target-cpu" "gfx906"{{.*}}"-fcuda-is-device"{{.*}}"-mlink-builtin-bitcode"
 // CHECK: clang{{.*}}"-cc1" "-triple" "x86_64-unknown-linux-gnu" "-emit-obj"
-// CHECK: clang-linker-wrapper{{.*}}"--"{{.*}} "-o" "a.out"
+// CHECK: clang-linker-wrapper{{.*}} "-o" "a.out"
 
-// RUN:   %clang -ccc-print-phases --target=x86_64-unknown-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx906 %s 2>&1 \
-// RUN:   | FileCheck --check-prefix=CHECK-PHASES %s
+// RUN:   %clang -ccc-print-phases --target=x86_64-unknown-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa \
+// RUN:   -march=gfx906 %s 2>&1 | FileCheck --check-prefix=CHECK-PHASES %s
+// phases
 // CHECK-PHASES: 0: input, "[[INPUT:.+]]", c, (host-openmp)
 // CHECK-PHASES: 1: preprocessor, {0}, cpp-output, (host-openmp)
 // CHECK-PHASES: 2: compiler, {1}, ir, (host-openmp)
-// CHECK-PHASES: 3: input, "[[INPUT]]", c, (device-openmp)
-// CHECK-PHASES: 4: preprocessor, {3}, cpp-output, (device-openmp)
-// CHECK-PHASES: 5: compiler, {4}, ir, (device-openmp)
-// CHECK-PHASES: 6: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (amdgcn-amd-amdhsa)" {5}, ir
-// CHECK-PHASES: 7: backend, {6}, assembler, (device-openmp)
-// CHECK-PHASES: 8: assembler, {7}, object, (device-openmp)
-// CHECK-PHASES: 9: offload, "device-openmp (amdgcn-amd-amdhsa)" {8}, object
-// CHECK-PHASES: 10: clang-offload-packager, {9}, image
-// CHECK-PHASES: 11: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, " (x86_64-unknown-linux-gnu)" {10}, ir
-// CHECK-PHASES: 12: backend, {11}, assembler, (host-openmp)
-// CHECK-PHASES: 13: assembler, {12}, object, (host-openmp)
-// CHECK-PHASES: 14: clang-linker-wrapper, {13}, image, (host-openmp)
+// CHECK-PHASES: 3: input, "[[INPUT]]", c, (device-openmp, gfx906)
+// CHECK-PHASES: 4: preprocessor, {3}, cpp-output, (device-openmp, gfx906)
+// CHECK-PHASES: 5: compiler, {4}, ir, (device-openmp, gfx906)
+// CHECK-PHASES: 6: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (amdgcn-amd-amdhsa:gfx906)" {5}, ir
+// CHECK-PHASES: 7: backend, {6}, ir, (device-openmp, gfx906)
+// CHECK-PHASES: 8: offload, "device-openmp (amdgcn-amd-amdhsa:gfx906)" {7}, ir
+// CHECK-PHASES: 9: clang-offload-packager, {8}, image, (device-openmp)
+// CHECK-PHASES: 10: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (x86_64-unknown-linux-gnu)" {9}, ir
+// CHECK-PHASES: 11: backend, {10}, assembler, (host-openmp)
+// CHECK-PHASES: 12: assembler, {11}, object, (host-openmp)
+// CHECK-PHASES: 13: clang-linker-wrapper, {12}, image, (host-openmp)
 
 // handling of --libomptarget-amdgpu-bc-path
 // RUN:   %clang -### --target=x86_64-unknown-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx803 --libomptarget-amdgpu-bc-path=%S/Inputs/hip_dev_lib/libomptarget-amdgpu-gfx803.bc %s 2>&1 | FileCheck %s --check-prefix=CHECK-LIBOMPTARGET
-// CHECK-LIBOMPTARGET: clang{{.*}}"-cc1"{{.*}}"-triple" "amdgcn-amd-amdhsa"{{.*}}"-target-cpu" "gfx803" "-fcuda-is-device" "-mlink-builtin-bitcode"{{.*}}Inputs/hip_dev_lib/libomptarget-amdgpu-gfx803.bc"{{.*}}
+// CHECK-LIBOMPTARGET: clang{{.*}}"-cc1"{{.*}}"-triple" "amdgcn-amd-amdhsa"{{.*}}"-target-cpu" "gfx803" "-fcuda-is-device"
 
 // RUN:   %clang -### --target=x86_64-unknown-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx803 -nogpulib %s 2>&1 | FileCheck %s --check-prefix=CHECK-NOGPULIB
 // CHECK-NOGPULIB-NOT: clang{{.*}}"-cc1"{{.*}}"-triple" "amdgcn-amd-amdhsa"{{.*}}"-target-cpu" "gfx803" "-fcuda-is-device" "-mlink-builtin-bitcode"{{.*}}libomptarget-amdgpu-gfx803.bc"{{.*}}
@@ -51,5 +49,5 @@
 // RUN:   %clang -### --target=x86_64-unknown-linux-gnu -emit-llvm -S -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx803 -nogpulib %s 2>&1 | FileCheck %s --check-prefix=CHECK-EMIT-LLVM-IR
 // CHECK-EMIT-LLVM-IR: clang{{.*}}"-cc1"{{.*}}"-triple" "amdgcn-amd-amdhsa"{{.*}}"-emit-llvm"
 
-// RUN: %clang -### -target x86_64-pc-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx803 -lm --rocm-device-lib-path=%S/Inputs/rocm/amdgcn/bitcode -fopenmp-new-driver %s 2>&1 | FileCheck %s --check-prefix=CHECK-LIB-DEVICE-NEW
-// CHECK-LIB-DEVICE-NEW: {{.*}}clang-linker-wrapper{{.*}}--bitcode-library=openmp-amdgcn-amd-amdhsa-gfx803={{.*}}ocml.bc"{{.*}}ockl.bc"{{.*}}oclc_daz_opt_on.bc"{{.*}}oclc_unsafe_math_off.bc"{{.*}}oclc_finite_only_off.bc"{{.*}}oclc_correctly_rounded_sqrt_on.bc"{{.*}}oclc_wavefrontsize64_on.bc"{{.*}}oclc_isa_version_803.bc"
+// RUN: %clang -### -target x86_64-pc-linux-gnu -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx803 --no-opaque-offload-linker -lm --rocm-device-lib-path=%S/Inputs/rocm/amdgcn/bitcode %s 2>&1 | FileCheck %s --check-prefix=CHECK-LIB-DEVICE-NEW
+// CHECK-LIB-DEVICE-NEW: {{.*}}"-target-cpu" "gfx803"{{.*}}ocml.bc"{{.*}}oclc_daz_opt_on.bc"{{.*}}oclc_unsafe_math_off.bc"{{.*}}oclc_finite_only_off.bc"{{.*}}oclc_correctly_rounded_sqrt_on.bc"{{.*}}oclc_wavefrontsize64_on.bc"{{.*}}oclc_isa_version_803.bc"