Handle ptr addrspaces in kernel args

Change the asmprinter so that it will not force .const or .shared
pointers to be changed to .global ones if they are explicitly
annotated with those address-spaces (even though they are not
expected to be present).

Unify the code-path for printing addrspace annotations for both
CUDA and CL, and only coerce generic pointers into .global pointers
on CUDA.

Emit alignment info for both CL and CUDA, but omit it on CUDA if
it is not explicitly supplied.

Update tests to have both aligned and unaligned pointers in all
relevant addrspaces.

Author: LewisCrawford

llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp

@@ -1603,35 +1603,34 @@ void NVPTXAsmPrinter::emitFunctionParamList(const Function *F, raw_ostream &O) {
           O << "\t.param .u" << PTySizeInBits << " ";
 
           int addrSpace = PTy->getAddressSpace();
-          if (static_cast<NVPTXTargetMachine &>(TM).getDrvInterface() ==
-              NVPTX::CUDA) {
+          const bool IsCUDA =
+              static_cast<NVPTXTargetMachine &>(TM).getDrvInterface() ==
+              NVPTX::CUDA;
+
+          O << ".ptr ";
+          switch (addrSpace) {
+          default:
             // Special handling for pointer arguments to kernel
             // CUDA kernels assume that pointers are in global address space
             // See:
             // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parameter-state-space
-            O << ".ptr .global ";
-            if (I->getParamAlign().valueOrOne() != 1) {
-              Align ParamAlign = I->getParamAlign().value();
-              O << ".align " << ParamAlign.value() << " ";
-            }
-          } else {
-            switch (addrSpace) {
-            default:
-              O << ".ptr ";
-              break;
-            case ADDRESS_SPACE_CONST:
-              O << ".ptr .const ";
-              break;
-            case ADDRESS_SPACE_SHARED:
-              O << ".ptr .shared ";
-              break;
-            case ADDRESS_SPACE_GLOBAL:
-              O << ".ptr .global ";
-              break;
-            }
-            Align ParamAlign = I->getParamAlign().valueOrOne();
-            O << ".align " << ParamAlign.value() << " ";
+            if (IsCUDA)
+              O << " .global ";
+            break;
+          case ADDRESS_SPACE_CONST:
+            O << " .const ";
+            break;
+          case ADDRESS_SPACE_SHARED:
+            O << " .shared ";
+            break;
+          case ADDRESS_SPACE_GLOBAL:
+            O << " .global ";
+            break;
           }
+
+          Align ParamAlign = I->getParamAlign().valueOrOne();
+          if (ParamAlign != 1 || !IsCUDA)
+            O << ".align " << ParamAlign.value() << " ";
           O << TLI->getParamName(F, paramIndex);
           continue;
         }

llvm/test/CodeGen/NVPTX/kernel-param-align.ll

@@ -1,13 +1,19 @@
-; RUN: llc < %s -march=nvptx64 -mcpu=sm_72 2>&1 | FileCheck %s
-; RUN: %if ptxas %{ llc < %s -march=nvptx64 -mcpu=sm_72 | %ptxas-verify %}
+; RUN: llc < %s -march=nvptx64 -mcpu=sm_60 | FileCheck %s
+; RUN: %if ptxas %{ llc < %s -march=nvptx64 -mcpu=sm_60 | %ptxas-verify %}
 
 %struct.Large = type { [16 x double] }
 
 ; CHECK-LABEL: .entry func_align(
-; CHECK: .param .u64 .ptr .global .align 16 func_align_param_0,
-; CHECK: .param .u64 .ptr .global func_align_param_1,
-; CHECK: .param .u64 .ptr .global func_align_param_2
-define void @func_align(ptr nocapture readonly align 16 %input, ptr nocapture %out, ptr addrspace(3) %n) {
+; CHECK: .param .u64 .ptr .global .align 16 func_align_param_0
+; CHECK: .param .u64 .ptr .global .align 16 func_align_param_1
+; CHECK: .param .u64 .ptr .global .align 16 func_align_param_2
+; CHECK: .param .u64 .ptr .shared .align 16 func_align_param_3
+; CHECK: .param .u64 .ptr .const  .align 16 func_align_param_4
+define void @func_align(ptr nocapture readonly align 16 %input,
+                        ptr nocapture align 16 %out,
+                        ptr addrspace(1) align 16 %global,
+                        ptr addrspace(3) align 16 %shared,
+                        ptr addrspace(4) align 16 %const) {
 entry:
   %0 = addrspacecast ptr %out to ptr addrspace(1)
   %1 = addrspacecast ptr %input to ptr addrspace(1)
@@ -17,11 +23,17 @@ entry:
   ret void
 }
 
-; CHECK-LABEL: .entry func(
-; CHECK: .param .u64 .ptr .global func_param_0,
-; CHECK: .param .u64 .ptr .global func_param_1,
-; CHECK: .param .u32 func_param_2
-define void @func(ptr nocapture readonly %input, ptr nocapture %out, i32 %n) {
+; CHECK-LABEL: .entry func_noalign(
+; CHECK: .param .u64 .ptr .global func_noalign_param_0
+; CHECK: .param .u64 .ptr .global func_noalign_param_1
+; CHECK: .param .u64 .ptr .global func_noalign_param_2
+; CHECK: .param .u64 .ptr .shared func_noalign_param_3
+; CHECK: .param .u64 .ptr .const func_noalign_param_4
+define void @func_noalign(ptr nocapture readonly %input,
+                          ptr nocapture %out,
+                          ptr addrspace(1) %global,
+                          ptr addrspace(3) %shared,
+                          ptr addrspace(4) %const) {
 entry:
   %0 = addrspacecast ptr %out to ptr addrspace(1)
   %1 = addrspacecast ptr %input to ptr addrspace(1)
@@ -33,4 +45,4 @@ entry:
 
 !nvvm.annotations = !{!0, !1}
 !0 = !{ptr @func_align, !"kernel", i32 1}
-!1 = !{ptr @func, !"kernel", i32 1}
+!1 = !{ptr @func_noalign, !"kernel", i32 1}