[OpenMP][CUDA][AMDGPU] Accept case insensitive subarchitecture names

[jhuber6]

Summary

The offloading toolchains are typically built by specifing a
subarchitecture during compilation via --offload-arch=. This patch
allows users to input subarchitecture names that ignore the case. So if
the user inputs gfx90A it will treat it as gfx90a. This is primarily
for user convenicence.

[tra]

Is that really something we need/want to do? I've never seen anyone complaining about this particular issue.

clang/gcc are case-sensitive for similar options, like -march: https://godbolt.org/z/3jKzTda7h
I think offloading options should behave consistently in that regard. If we do want to make arch/CPU names case-agnostic, it should be done for all such options.

[jhuber6]

In D135614#3847775, @tra wrote:

Is that really something we need/want to do? I've never seen anyone complaining about this particular issue.

clang/gcc are case-sensitive for similar options, like -march: https://godbolt.org/z/3jKzTda7h
I think offloading options should behave consistently in that regard. If we do want to make arch/CPU names case-agnostic, it should be done for all such options.

This came up with someone @jdoerfert worked with and I figured it was easy to implement. There is a precedent for -march to be case sensitive, I'm not sure if it's an issue here since it's a little arbitrary. Alternatively we could make it a warning.

[yaxunl]

I am not sure whether it is a good idea to allow gfx90A in --offload-arch, since it is not documented in LLVM AMDGPU usage. @b-sumner @arsenm

[arsenm]

I don't really have an opinion here. I'd probably lean towards a "did you mean" kind of warning

[b-sumner]

I don't particularly see a need for this. I am not opposed to a "did you mean" in the error diagnostic.

[b-sumner]

Also, we may want to use uppercase for other purposes in the future.

[jdoerfert]

First, as noted, I asked @jhuber6 to update this.

In D135614#3847775, @tra wrote:

Is that really something we need/want to do? I've never seen anyone complaining about this particular issue.

I have, and not only once. Hence the request for a change.

clang/gcc are case-sensitive for similar options, like -march: https://godbolt.org/z/3jKzTda7h
I think offloading options should behave consistently in that regard. If we do want to make arch/CPU names case-agnostic, it should be done for all such options.

I don't disagree. Major difference is though that march returns a nice list of options in your example.
For offload-arch the situations is less user friendly: https://godbolt.org/z/oWYvvjTTq

In D135614#3849656, @b-sumner wrote:

Also, we may want to use uppercase for other purposes in the future.

gfx90a != gfx90A but both valid? Please, no.

In D135614#3849635, @yaxunl wrote:

I am not sure whether it is a good idea to allow gfx90A in --offload-arch, since it is not documented in LLVM AMDGPU usage. @b-sumner @arsenm

I'm not sure which documentation you mean but if it's https://llvm.org/docs/AMDGPUUsage.html, then I doubt any "end user" will have read it.
Arguably it's for compiler writers and not even in the frontend documentation. Maybe there is something else I don't know about?

In D135614#3849639, @arsenm wrote:

I don't really have an opinion here. I'd probably lean towards a "did you mean" kind of warning

Since listing all options might not be great, I agree that we could emit a warning for upper/lower case situations instead. (FWIW, not only for amdgpu btw.)
@tra, would that be OK for you?

clang/lib/Basic/Cuda.cpp

auto result = std::find_if(
       std::begin(arch_names), std::end(arch_names),
       [A](const CudaArchToStringMap &map) { return A == map.arch; });
   if (result == std::end(arch_names))
     return "unknown";
   return result->virtual_arch_name;
 }
 
 CudaArch StringToCudaArch(llvm::StringRef S) {
-  auto result = std::find_if(
-      std::begin(arch_names), std::end(arch_names),
-      [S](const CudaArchToStringMap &map) { return S == map.arch_name; });
+  auto result = std::find_if(std::begin(arch_names), std::end(arch_names),
+                             [S](const CudaArchToStringMap &map) {
+                               return S.equals_insensitive(map.arch_name);
+                             });
   if (result == std::end(arch_names))
     return CudaArch::UNKNOWN;
   return result->arch;
 }
 
 CudaVersion MinVersionForCudaArch(CudaArch A) {
   if (A == CudaArch::UNKNOWN)
     return CudaVersion::UNKNOWN;

clang/test/Driver/openmp-offload-infer.c

 // CHECK: "-cc1" "-triple" "amdgcn-amd-amdhsa" "-aux-triple" "x86_64-unknown-linux-gnu"{{.*}}"-target-cpu" "gfx803"
 // CHECK: "-cc1" "-triple" "nvptx64-nvidia-cuda" "-aux-triple" "x86_64-unknown-linux-gnu"{{.*}}"-target-cpu" "sm_52"
 // CHECK: "-cc1" "-triple" "x86_64-unknown-linux-gnu"{{.*}}"-emit-obj"
 // CHECK: clang-linker-wrapper{{.*}}"--"{{.*}} "-o" "a.out"
 
 // RUN:   %clang -### --target=x86_64-unknown-linux-gnu -ccc-print-bindings -fopenmp \
 // RUN:     --offload-arch=sm_70 --offload-arch=gfx908:sramecc+:xnack- \
 // RUN:     -nogpulib %s 2>&1 | FileCheck %s --check-prefix=CHECK-NVIDIA-AMDGPU
+// RUN:   %clang -### --target=x86_64-unknown-linux-gnu -ccc-print-bindings -fopenmp \
+// RUN:     --offload-arch=SM_70 --offload-arch=GFX908:sramecc+:xnack- \
+// RUN:     -nogpulib %s 2>&1 | FileCheck %s --check-prefix=CHECK-NVIDIA-AMDGPU
 
 // CHECK-NVIDIA-AMDGPU: "x86_64-unknown-linux-gnu" - "clang", inputs: ["[[INPUT:.+]]"], output: "[[HOST_BC:.+]]"
 // CHECK-NVIDIA-AMDGPU: "amdgcn-amd-amdhsa" - "clang", inputs: ["[[INPUT]]", "[[HOST_BC]]"], output: "[[AMD_BC:.+]]"
 // CHECK-NVIDIA-AMDGPU: "nvptx64-nvidia-cuda" - "clang", inputs: ["[[INPUT]]", "[[HOST_BC]]"], output: "[[NVIDIA_PTX:.+]]"
 // CHECK-NVIDIA-AMDGPU: "nvptx64-nvidia-cuda" - "NVPTX::Assembler", inputs: ["[[NVIDIA_PTX]]"], output: "[[NVIDIA_CUBIN:.+]]"
 // CHECK-NVIDIA-AMDGPU: "x86_64-unknown-linux-gnu" - "Offload::Packager", inputs: ["[[AMD_BC]]", "[[NVIDIA_CUBIN]]"], output: "[[BINARY:.+]]"
 // CHECK-NVIDIA-AMDGPU: "x86_64-unknown-linux-gnu" - "clang", inputs: ["[[HOST_BC]]", "[[BINARY]]"], output: "[[HOST_OBJ:.+]]"
 // CHECK-NVIDIA-AMDGPU: "x86_64-unknown-linux-gnu" - "Offload::Linker", inputs: ["[[HOST_OBJ]]"], output: "a.out"

llvm/lib/Support/TargetParser.cpp

 StringRef llvm::AMDGPU::getArchNameR600(GPUKind AK) {
   if (const auto *Entry = getArchEntry(AK, R600GPUs))
     return Entry->CanonicalName;
   return "";
 }
 
 AMDGPU::GPUKind llvm::AMDGPU::parseArchAMDGCN(StringRef CPU) {
   for (const auto &C : AMDGCNGPUs) {
-    if (CPU == C.Name)
+    if (CPU.equals_insensitive(C.Name))
       return C.Kind;
   }
 
   return AMDGPU::GPUKind::GK_NONE;
 }
 
 AMDGPU::GPUKind llvm::AMDGPU::parseArchR600(StringRef CPU) {
   for (const auto &C : R600GPUs) {