1; RUN: not llvm-as < %s 2>&1 | FileCheck %s 2 3target datalayout = "A5" 4 5; CHECK: Calling convention requires void return type 6; CHECK-NEXT: ptr @nonvoid_cc_amdgpu_kernel 7define 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 13define 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 19define 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 25define 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 31define 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 37define 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 43define 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 49define 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 55define 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 61define 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 67define 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 73define 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 79define 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 85define 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 91define 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 97define 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 103define 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 109define 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 115define 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 121define 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 127define 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 133define 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 139define 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 145define 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 151define 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 157define 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 163define 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 169define 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 175define 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 181define 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 187define 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 193define 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 199define 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 205define 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 211define 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 217define amdgpu_cs_chain_preserve void @inalloca_cc_amdgpu_cs_chain_preserve(ptr inalloca(i32) %ptr) { 218 ret void 219} 220 221declare amdgpu_cs_chain void @amdgpu_cs_chain_call_target() 222declare amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_call_target() 223 224define 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} 243