clang/test/CodeGenCUDA/amdgpu-kernel-arg-pointer-type.cu

   1 // REQUIRES: x86-registered-target
   2 // REQUIRES: amdgpu-registered-target
   3
   4 // RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -fcuda-is-device -emit-llvm -x hip %s -o - | FileCheck --check-prefixes=COMMON,CHECK %s
   5 // RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -fcuda-is-device -emit-llvm -x hip %s -disable-O0-optnone -o - | opt -S -O2 | FileCheck %s --check-prefixes=COMMON,OPT
   6 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -x hip %s -o - | FileCheck -check-prefix=HOST %s
   7
   8 #include "Inputs/cuda.h"
   9
  10 // Coerced struct from `struct S` without all generic pointers lowered into
  11 // global ones.
  12
  13 // On the host-side compilation, generic pointer won't be coerced.
  14 // HOST-NOT: %struct.S.coerce
  15 // HOST-NOT: %struct.T.coerce
  16
  17 // HOST: define{{.*}} void @_Z22__device_stub__kernel1Pi(ptr noundef %x)
  18 // COMMON-LABEL: define{{.*}} amdgpu_kernel void @_Z7kernel1Pi(ptr addrspace(1){{.*}} %x.coerce)
  19 // CHECK:     ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
  20 // CHECK-NOT: ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
  21 // OPT: [[VAL:%.*]] = load i32, ptr addrspace(1) %x.coerce, align 4, !amdgpu.noclobber ![[MD:[0-9]+]]
  22 // OPT: [[INC:%.*]] = add nsw i32 [[VAL]], 1
  23 // OPT: store i32 [[INC]], ptr addrspace(1) %x.coerce, align 4
  24 // OPT: ret void
  25 __global__ void kernel1(int *x) {
  26   x[0]++;
  27 }
  28
  29 // HOST: define{{.*}} void @_Z22__device_stub__kernel2Ri(ptr noundef nonnull align 4 dereferenceable(4) %x)
  30 // COMMON-LABEL: define{{.*}} amdgpu_kernel void @_Z7kernel2Ri(ptr addrspace(1){{.*}} nonnull align 4 dereferenceable(4) %x.coerce)
  31 // CHECK:     ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
  32 // CHECK-NOT: ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
  33 // OPT: [[VAL:%.*]] = load i32, ptr addrspace(1) %x.coerce, align 4, !amdgpu.noclobber ![[MD]]
  34 // OPT: [[INC:%.*]] = add nsw i32 [[VAL]], 1
  35 // OPT: store i32 [[INC]], ptr addrspace(1) %x.coerce, align 4
  36 // OPT: ret void
  37 __global__ void kernel2(int &x) {
  38   x++;
  39 }
  40
  41 // HOST: define{{.*}} void @_Z22__device_stub__kernel3PU3AS2iPU3AS1i(ptr addrspace(2)  noundef %x, ptr addrspace(1) noundef %y)
  42 // CHECK-LABEL: define{{.*}} amdgpu_kernel void  @_Z7kernel3PU3AS2iPU3AS1i(ptr addrspace(2){{.*}} %x, ptr addrspace(1){{.*}} %y)
  43 // CHECK-NOT: ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
  44 __global__ void kernel3(__attribute__((address_space(2))) int *x,
  45                         __attribute__((address_space(1))) int *y) {
  46   y[0] = x[0];
  47 }
  48
  49 // COMMON-LABEL: define{{.*}} void @_Z4funcPi(ptr{{.*}} %x)
  50 // CHECK-NOT: ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
  51 __device__ void func(int *x) {
  52   x[0]++;
  53 }
  54
  55 struct S {
  56   int *x;
  57   float *y;
  58 };
  59 // `by-val` struct is passed by-indirect-alias (a mix of by-ref and indirect
  60 // by-val). However, the enhanced address inferring pass should be able to
  61 // assume they are global pointers.
  62 //
  63 // HOST: define{{.*}} void @_Z22__device_stub__kernel41S(ptr %s.coerce0, ptr %s.coerce1)
  64 // COMMON-LABEL: define{{.*}} amdgpu_kernel void @_Z7kernel41S(ptr addrspace(4){{.*}} byref(%struct.S) align 8 %0)
  65 // OPT: [[P0:%.*]] = load ptr, ptr addrspace(4) %0, align 8
  66 // OPT: [[G0:%.*]] ={{.*}} addrspacecast ptr [[P0]] to ptr addrspace(1)
  67 // OPT: [[R1:%.*]] = getelementptr inbounds i8, ptr addrspace(4) %0, i64 8
  68 // OPT: [[P1:%.*]] = load ptr, ptr addrspace(4) [[R1]], align 8
  69 // OPT: [[G1:%.*]] ={{.*}} addrspacecast ptr [[P1]] to ptr addrspace(1)
  70 // OPT: [[V0:%.*]] = load i32, ptr addrspace(1) [[G0]], align 4, !amdgpu.noclobber ![[MD]]
  71 // OPT: [[INC:%.*]] = add nsw i32 [[V0]], 1
  72 // OPT: store i32 [[INC]], ptr addrspace(1) [[G0]], align 4
  73 // OPT: [[V1:%.*]] = load float, ptr addrspace(1) [[G1]], align 4
  74 // OPT: [[ADD:%.*]] = fadd contract float [[V1]], 1.000000e+00
  75 // OPT: store float [[ADD]], ptr addrspace(1) [[G1]], align 4
  76 // OPT: ret void
  77 __global__ void kernel4(struct S s) {
  78   s.x[0]++;
  79   s.y[0] += 1.f;
  80 }
  81
  82 // If a pointer to struct is passed, only the pointer itself is coerced into the global one.
  83 // HOST: define{{.*}} void @_Z22__device_stub__kernel5P1S(ptr noundef %s)
  84 // COMMON-LABEL: define{{.*}} amdgpu_kernel void @_Z7kernel5P1S(ptr addrspace(1){{.*}} %s.coerce)
  85 __global__ void kernel5(struct S *s) {
  86   s->x[0]++;
  87   s->y[0] += 1.f;
  88 }
  89
  90 struct T {
  91   float *x[2];
  92 };
  93 // `by-val` array is passed by-indirect-alias (a mix of by-ref and indirect
  94 // by-val). However, the enhanced address inferring pass should be able to
  95 // assume they are global pointers.
  96 //
  97 // HOST: define{{.*}} void @_Z22__device_stub__kernel61T(ptr %t.coerce0, ptr %t.coerce1)
  98 // COMMON-LABEL: define{{.*}} amdgpu_kernel void @_Z7kernel61T(ptr addrspace(4){{.*}} byref(%struct.T) align 8 %0)
  99 // OPT: [[P0:%.*]] = load ptr, ptr addrspace(4) %0, align 8
 100 // OPT: [[G0:%.*]] ={{.*}} addrspacecast ptr [[P0]] to ptr addrspace(1)
 101 // OPT: [[R1:%.*]] = getelementptr inbounds i8, ptr addrspace(4) %0, i64 8
 102 // OPT: [[P1:%.*]] = load ptr, ptr addrspace(4) [[R1]], align 8
 103 // OPT: [[G1:%.*]] ={{.*}} addrspacecast ptr [[P1]] to ptr addrspace(1)
 104 // OPT: [[V0:%.*]] = load float, ptr addrspace(1) [[G0]], align 4, !amdgpu.noclobber ![[MD]]
 105 // OPT: [[ADD0:%.*]] = fadd contract float [[V0]], 1.000000e+00
 106 // OPT: store float [[ADD0]], ptr addrspace(1) [[G0]], align 4
 107 // OPT: [[V1:%.*]] = load float, ptr addrspace(1) [[G1]], align 4
 108 // OPT: [[ADD1:%.*]] = fadd contract float [[V1]], 2.000000e+00
 109 // OPT: store float [[ADD1]], ptr addrspace(1) [[G1]], align 4
 110 // OPT: ret void
 111 __global__ void kernel6(struct T t) {
 112   t.x[0][0] += 1.f;
 113   t.x[1][0] += 2.f;
 114 }
 115
 116 // Check that coerced pointers retain the noalias attribute when qualified with __restrict.
 117 // HOST: define{{.*}} void @_Z22__device_stub__kernel7Pi(ptr noalias noundef %x)
 118 // COMMON-LABEL: define{{.*}} amdgpu_kernel void @_Z7kernel7Pi(ptr addrspace(1) noalias{{.*}} %x.coerce)
 119 __global__ void kernel7(int *__restrict x) {
 120   x[0]++;
 121 }
 122
 123 // Single element struct.
 124 struct SS {
 125   float *x;
 126 };
 127 // HOST: define{{.*}} void @_Z22__device_stub__kernel82SS(ptr %a.coerce)
 128 // COMMON-LABEL: define{{.*}} amdgpu_kernel void @_Z7kernel82SS(ptr addrspace(1){{.*}} %a.coerce)
 129 // CHECK:     ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
 130 // CHECK-NOT: ={{.*}} addrspacecast ptr addrspace(1) %{{.*}} to ptr
 131 // OPT: [[VAL:%.*]] = load float, ptr addrspace(1) %a.coerce, align 4, !amdgpu.noclobber ![[MD]]
 132 // OPT: [[INC:%.*]] = fadd contract float [[VAL]], 3.000000e+00
 133 // OPT: store float [[INC]], ptr addrspace(1) %a.coerce, align 4
 134 // OPT: ret void
 135 __global__ void kernel8(struct SS a) {
 136   *a.x += 3.f;
 137 }