llvm/test/Verifier/amdgpu-cc.ll

   1 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
   2
   3 target datalayout = "A5"
   4
   5 ; CHECK: Calling convention requires void return type
   6 ; CHECK-NEXT: ptr @nonvoid_cc_amdgpu_kernel
   7 define amdgpu_kernel i32 @nonvoid_cc_amdgpu_kernel() {
   8   ret i32 0
   9 }
  10
  11 ; CHECK: Calling convention does not support varargs or perfect forwarding!
  12 ; CHECK-NEXT: ptr @varargs_amdgpu_kernel
  13 define amdgpu_kernel void @varargs_amdgpu_kernel(...) {
  14   ret void
  15 }
  16
  17 ; CHECK: Calling convention does not allow sret
  18 ; CHECK-NEXT: ptr @sret_cc_amdgpu_kernel_as0
  19 define amdgpu_kernel void @sret_cc_amdgpu_kernel_as0(ptr sret(i32) %ptr) {
  20   ret void
  21 }
  22
  23 ; CHECK: Calling convention does not allow sret
  24 ; CHECK-NEXT: ptr @sret_cc_amdgpu_kernel
  25 define amdgpu_kernel void @sret_cc_amdgpu_kernel(ptr addrspace(5) sret(i32) %ptr) {
  26   ret void
  27 }
  28
  29 ; CHECK: Calling convention does not support varargs or perfect forwarding!
  30 ; CHECK-NEXT: ptr @varargs_amdgpu_vs
  31 define amdgpu_vs void @varargs_amdgpu_vs(...) {
  32   ret void
  33 }
  34
  35 ; CHECK: Calling convention does not support varargs or perfect forwarding!
  36 ; CHECK-NEXT: ptr @varargs_amdgpu_gs
  37 define amdgpu_gs void @varargs_amdgpu_gs(...) {
  38   ret void
  39 }
  40
  41 ; CHECK: Calling convention does not support varargs or perfect forwarding!
  42 ; CHECK-NEXT: ptr @varargs_amdgpu_ps
  43 define amdgpu_ps void @varargs_amdgpu_ps(...) {
  44   ret void
  45 }
  46
  47 ; CHECK: Calling convention does not support varargs or perfect forwarding!
  48 ; CHECK-NEXT: ptr @varargs_amdgpu_cs
  49 define amdgpu_cs void @varargs_amdgpu_cs(...) {
  50   ret void
  51 }
  52
  53 ; CHECK: Calling convention requires void return type
  54 ; CHECK-NEXT: ptr @nonvoid_cc_spir_kernel
  55 define spir_kernel i32 @nonvoid_cc_spir_kernel() {
  56   ret i32 0
  57 }
  58
  59 ; CHECK: Calling convention does not support varargs or perfect forwarding!
  60 ; CHECK-NEXT: ptr @varargs_spir_kernel
  61 define spir_kernel void @varargs_spir_kernel(...) {
  62   ret void
  63 }
  64
  65 ; CHECK: Calling convention disallows byval
  66 ; CHECK-NEXT: ptr @byval_cc_amdgpu_kernel
  67 define amdgpu_kernel void @byval_cc_amdgpu_kernel(ptr addrspace(5) byval(i32) %ptr) {
  68   ret void
  69 }
  70
  71 ; CHECK: Calling convention disallows byval
  72 ; CHECK-NEXT: ptr @byval_as1_cc_amdgpu_kernel
  73 define amdgpu_kernel void @byval_as1_cc_amdgpu_kernel(ptr addrspace(1) byval(i32) %ptr) {
  74   ret void
  75 }
  76
  77 ; CHECK: Calling convention disallows byval
  78 ; CHECK-NEXT: ptr @byval_as0_cc_amdgpu_kernel
  79 define amdgpu_kernel void @byval_as0_cc_amdgpu_kernel(ptr byval(i32) %ptr) {
  80   ret void
  81 }
  82
  83 ; CHECK: Calling convention disallows byval
  84 ; CHECK-NEXT: ptr @byval_cc_amdgpu_vs
  85 define amdgpu_vs void @byval_cc_amdgpu_vs(ptr addrspace(5) byval(i32) %ptr) {
  86   ret void
  87 }
  88
  89 ; CHECK: Calling convention disallows byval
  90 ; CHECK-NEXT: ptr @byval_cc_amdgpu_hs
  91 define amdgpu_hs void @byval_cc_amdgpu_hs(ptr addrspace(5) byval(i32) %ptr) {
  92   ret void
  93 }
  94
  95 ; CHECK: Calling convention disallows byval
  96 ; CHECK-NEXT: ptr @byval_cc_amdgpu_gs
  97 define amdgpu_gs void @byval_cc_amdgpu_gs(ptr addrspace(5) byval(i32) %ptr) {
  98   ret void
  99 }
 100
 101 ; CHECK: Calling convention disallows byval
 102 ; CHECK-NEXT: ptr @byval_cc_amdgpu_ps
 103 define amdgpu_ps void @byval_cc_amdgpu_ps(ptr addrspace(5) byval(i32) %ptr) {
 104   ret void
 105 }
 106
 107 ; CHECK: Calling convention disallows byval
 108 ; CHECK-NEXT: ptr @byval_cc_amdgpu_cs
 109 define amdgpu_cs void @byval_cc_amdgpu_cs(ptr addrspace(5) byval(i32) %ptr) {
 110   ret void
 111 }
 112
 113 ; CHECK: Calling convention disallows preallocated
 114 ; CHECK-NEXT: ptr @preallocated_as0_cc_amdgpu_kernel
 115 define amdgpu_kernel void @preallocated_as0_cc_amdgpu_kernel(ptr preallocated(i32) %ptr) {
 116   ret void
 117 }
 118
 119 ; CHECK: Calling convention disallows inalloca
 120 ; CHECK-NEXT: ptr @inalloca_as0_cc_amdgpu_kernel
 121 define amdgpu_kernel void @inalloca_as0_cc_amdgpu_kernel(ptr inalloca(i32) %ptr) {
 122   ret void
 123 }
 124
 125 ; CHECK: Calling convention disallows stack byref
 126 ; CHECK-NEXT: ptr @byref_as5_cc_amdgpu_kernel
 127 define amdgpu_kernel void @byref_as5_cc_amdgpu_kernel(ptr addrspace(5) byref(i32) %ptr) {
 128   ret void
 129 }
 130
 131 ; CHECK: Calling convention requires void return type
 132 ; CHECK-NEXT: ptr @nonvoid_cc_amdgpu_cs_chain
 133 define amdgpu_cs_chain i32 @nonvoid_cc_amdgpu_cs_chain() {
 134   ret i32 0
 135 }
 136
 137 ; CHECK: Calling convention does not support varargs or perfect forwarding!
 138 ; CHECK-NEXT: ptr @varargs_amdgpu_cs_chain
 139 define amdgpu_cs_chain void @varargs_amdgpu_cs_chain(...) {
 140   ret void
 141 }
 142
 143 ; CHECK: Calling convention does not allow sret
 144 ; CHECK-NEXT: ptr @sret_cc_amdgpu_cs_chain_as0
 145 define amdgpu_cs_chain void @sret_cc_amdgpu_cs_chain_as0(ptr sret(i32) %ptr) {
 146   ret void
 147 }
 148
 149 ; CHECK: Calling convention disallows byval
 150 ; CHECK-NEXT: ptr @byval_cc_amdgpu_cs_chain
 151 define amdgpu_cs_chain void @byval_cc_amdgpu_cs_chain(ptr addrspace(1) byval(i32) %ptr) {
 152   ret void
 153 }
 154
 155 ; CHECK: Calling convention disallows stack byref
 156 ; CHECK-NEXT: ptr @byref_cc_amdgpu_cs_chain
 157 define amdgpu_cs_chain void @byref_cc_amdgpu_cs_chain(ptr addrspace(5) byref(i32) %ptr) {
 158   ret void
 159 }
 160
 161 ; CHECK: Calling convention disallows preallocated
 162 ; CHECK-NEXT: ptr @preallocated_cc_amdgpu_cs_chain
 163 define amdgpu_cs_chain void @preallocated_cc_amdgpu_cs_chain(ptr preallocated(i32) %ptr) {
 164   ret void
 165 }
 166
 167 ; CHECK: Calling convention disallows inalloca
 168 ; CHECK-NEXT: ptr @inalloca_cc_amdgpu_cs_chain
 169 define amdgpu_cs_chain void @inalloca_cc_amdgpu_cs_chain(ptr inalloca(i32) %ptr) {
 170   ret void
 171 }
 172
 173 ; CHECK: Calling convention requires void return type
 174 ; CHECK-NEXT: ptr @nonvoid_cc_amdgpu_cs_chain_preserve
 175 define amdgpu_cs_chain_preserve i32 @nonvoid_cc_amdgpu_cs_chain_preserve() {
 176   ret i32 0
 177 }
 178
 179 ; CHECK: Calling convention does not support varargs or perfect forwarding!
 180 ; CHECK-NEXT: ptr @varargs_amdgpu_cs_chain_preserve
 181 define amdgpu_cs_chain_preserve void @varargs_amdgpu_cs_chain_preserve(...) {
 182   ret void
 183 }
 184
 185 ; CHECK: Calling convention does not allow sret
 186 ; CHECK-NEXT: ptr @sret_cc_amdgpu_cs_chain_preserve_as0
 187 define amdgpu_cs_chain_preserve void @sret_cc_amdgpu_cs_chain_preserve_as0(ptr sret(i32) %ptr) {
 188   ret void
 189 }
 190
 191 ; CHECK: Calling convention does not allow sret
 192 ; CHECK-NEXT: ptr @sret_cc_amdgpu_cs_chain_preserve
 193 define amdgpu_cs_chain_preserve void @sret_cc_amdgpu_cs_chain_preserve(ptr addrspace(5) sret(i32) %ptr) {
 194   ret void
 195 }
 196
 197 ; CHECK: Calling convention disallows byval
 198 ; CHECK-NEXT: ptr @byval_cc_amdgpu_cs_chain_preserve
 199 define amdgpu_cs_chain_preserve void @byval_cc_amdgpu_cs_chain_preserve(ptr addrspace(1) byval(i32) %ptr) {
 200   ret void
 201 }
 202
 203 ; CHECK: Calling convention disallows stack byref
 204 ; CHECK-NEXT: ptr @byref_cc_amdgpu_cs_chain_preserve
 205 define amdgpu_cs_chain_preserve void @byref_cc_amdgpu_cs_chain_preserve(ptr addrspace(5) byref(i32) %ptr) {
 206   ret void
 207 }
 208
 209 ; CHECK: Calling convention disallows preallocated
 210 ; CHECK-NEXT: ptr @preallocated_cc_amdgpu_cs_chain_preserve
 211 define amdgpu_cs_chain_preserve void @preallocated_cc_amdgpu_cs_chain_preserve(ptr preallocated(i32) %ptr) {
 212   ret void
 213 }
 214
 215 ; CHECK: Calling convention disallows inalloca
 216 ; CHECK-NEXT: ptr @inalloca_cc_amdgpu_cs_chain_preserve
 217 define amdgpu_cs_chain_preserve void @inalloca_cc_amdgpu_cs_chain_preserve(ptr inalloca(i32) %ptr) {
 218   ret void
 219 }
 220
 221 declare amdgpu_cs_chain void @amdgpu_cs_chain_call_target()
 222 declare amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_call_target()
 223
 224 define amdgpu_cs_chain void @cant_call_amdgpu_cs_chain_functions(ptr %f) {
 225   ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
 226   ; CHECK-NEXT: call amdgpu_cs_chain
 227   call amdgpu_cs_chain void @amdgpu_cs_chain_call_target()
 228
 229   ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
 230   ; CHECK-NEXT: call amdgpu_cs_chain_preserve
 231   call amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_call_target()
 232
 233   ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
 234   ; CHECK-NEXT: call amdgpu_cs_chain
 235   call amdgpu_cs_chain void %f()
 236
 237   ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
 238   ; CHECK-NEXT: call amdgpu_cs_chain
 239   call amdgpu_cs_chain_preserve void %f()
 240
 241   ret void
 242 }