llvm/test/Verifier/intrinsic-immarg.ll

   1 ; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
   2
   3 declare ptr @llvm.returnaddress(i32)
   4 define void @return_address(i32 %var) {
   5   ; CHECK: immarg operand has non-immediate parameter
   6   ; CHECK-NEXT: i32 %var
   7   ; CHECK-NEXT: %result = call ptr @llvm.returnaddress(i32 %var)
   8   %result = call ptr @llvm.returnaddress(i32 %var)
   9   ret void
  10 }
  11
  12 declare ptr @llvm.frameaddress(i32)
  13 define void @frame_address(i32 %var) {
  14   ; CHECK: immarg operand has non-immediate parameter
  15   ; CHECK-NEXT: i32 %var
  16   ; CHECK-NEXT: %result = call ptr @llvm.frameaddress.p0(i32 %var)
  17   %result = call ptr @llvm.frameaddress(i32 %var)
  18   ret void
  19 }
  20
  21 declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1)
  22 define void @memcpy(ptr %dest, ptr %src, i1 %is.volatile) {
  23   ; CHECK: immarg operand has non-immediate parameter
  24   ; CHECK-NEXT: i1 %is.volatile
  25   ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr %dest, ptr %src, i32 8, i1 %is.volatile)
  26   call void @llvm.memcpy.p0.p0.i32(ptr %dest, ptr %src, i32 8, i1 %is.volatile)
  27   ret void
  28 }
  29
  30 declare void @llvm.memcpy.inline.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1)
  31 define void @memcpy_inline_is_volatile(ptr %dest, ptr %src, i1 %is.volatile) {
  32   ; CHECK: immarg operand has non-immediate parameter
  33   ; CHECK-NEXT: i1 %is.volatile
  34   ; CHECK-NEXT: call void @llvm.memcpy.inline.p0.p0.i32(ptr %dest, ptr %src, i32 8, i1 %is.volatile)
  35   call void @llvm.memcpy.inline.p0.p0.i32(ptr %dest, ptr %src, i32 8, i1 %is.volatile)
  36   ret void
  37 }
  38
  39 declare void @llvm.memmove.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1)
  40 define void @memmove(ptr %dest, ptr %src, i1 %is.volatile) {
  41   ; CHECK: immarg operand has non-immediate parameter
  42   ; CHECK-NEXT: i1 %is.volatile
  43   ; CHECK-NEXT: call void @llvm.memmove.p0.p0.i32(ptr %dest, ptr %src, i32 8, i1 %is.volatile)
  44   call void @llvm.memmove.p0.p0.i32(ptr %dest, ptr %src, i32 8, i1 %is.volatile)
  45   ret void
  46 }
  47
  48 declare void @llvm.memset.p0.i32(ptr nocapture, i8, i32, i1)
  49 define void @memset(ptr %dest, i8 %val, i1 %is.volatile) {
  50   ; CHECK: immarg operand has non-immediate parameter
  51   ; CHECK-NEXT: i1 %is.volatile
  52   ; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 8, i1 %is.volatile)
  53   call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 8, i1 %is.volatile)
  54   ret void
  55 }
  56
  57 declare void @llvm.memset.inline.p0.i32(ptr nocapture, i8, i32, i1)
  58 define void @memset_inline_is_volatile(ptr %dest, i8 %value, i1 %is.volatile) {
  59   ; CHECK: immarg operand has non-immediate parameter
  60   ; CHECK-NEXT: i1 %is.volatile
  61   ; CHECK-NEXT: call void @llvm.memset.inline.p0.i32(ptr %dest, i8 %value, i32 8, i1 %is.volatile)
  62   call void @llvm.memset.inline.p0.i32(ptr %dest, i8 %value, i32 8, i1 %is.volatile)
  63   ret void
  64 }
  65
  66
  67 declare i64 @llvm.objectsize.i64.p0(ptr, i1, i1, i1)
  68 define void @objectsize(ptr %ptr, i1 %a, i1 %b, i1 %c) {
  69   ; CHECK: immarg operand has non-immediate parameter
  70   ; CHECK-NEXT: i1 %a
  71   ; CHECK-NEXT: %val0 = call i64 @llvm.objectsize.i64.p0(ptr %ptr, i1 %a, i1 false, i1 false)
  72   %val0 = call i64 @llvm.objectsize.i64.p0(ptr %ptr, i1 %a, i1 false, i1 false)
  73
  74   ; CHECK: immarg operand has non-immediate parameter
  75   ; CHECK-NEXT: i1 %b
  76   ; CHECK-NEXT: %val1 = call i64 @llvm.objectsize.i64.p0(ptr %ptr, i1 false, i1 %b, i1 false)
  77   %val1 = call i64 @llvm.objectsize.i64.p0(ptr %ptr, i1 false, i1 %b, i1 false)
  78
  79   ; CHECK: immarg operand has non-immediate parameter
  80   ; CHECK-NEXT: i1 %c
  81   ; CHECK-NEXT: %val2 = call i64 @llvm.objectsize.i64.p0(ptr %ptr, i1 false, i1 false, i1 %c)
  82   %val2 = call i64 @llvm.objectsize.i64.p0(ptr %ptr, i1 false, i1 false, i1 %c)
  83   ret void
  84 }
  85
  86 declare i64 @llvm.smul.fix.i64(i64, i64, i32)
  87 define i64 @smul_fix(i64 %arg0, i64 %arg1, i32 %arg2) {
  88   ; CHECK: immarg operand has non-immediate parameter
  89   ; CHECK-NEXT: i32 %arg2
  90   ; CHECK-NEXT: %ret = call i64 @llvm.smul.fix.i64(i64 %arg0, i64 %arg1, i32 %arg2)
  91   %ret = call i64 @llvm.smul.fix.i64(i64 %arg0, i64 %arg1, i32 %arg2)
  92   ret i64 %ret
  93 }
  94
  95 declare i64 @llvm.smul.fix.sat.i64(i64, i64, i32)
  96 define i64 @smul_fix_sat(i64 %arg0, i64 %arg1, i32 %arg2) {
  97   ; CHECK: immarg operand has non-immediate parameter
  98   ; CHECK-NEXT: i32 %arg2
  99   ; CHECK-NEXT: %ret = call i64 @llvm.smul.fix.sat.i64(i64 %arg0, i64 %arg1, i32 %arg2)
 100   %ret = call i64 @llvm.smul.fix.sat.i64(i64 %arg0, i64 %arg1, i32 %arg2)
 101   ret i64 %ret
 102 }
 103
 104 declare i64 @llvm.umul.fix.i64(i64, i64, i32)
 105 define i64 @umul_fix(i64 %arg0, i64 %arg1, i32 %arg2) {
 106   ; CHECK: immarg operand has non-immediate parameter
 107   ; CHECK-NEXT: i32 %arg2
 108   ; CHECK-NEXT: %ret = call i64 @llvm.umul.fix.i64(i64 %arg0, i64 %arg1, i32 %arg2)
 109   %ret = call i64 @llvm.umul.fix.i64(i64 %arg0, i64 %arg1, i32 %arg2)
 110   ret i64 %ret
 111 }
 112
 113 declare i64 @llvm.umul.fix.sat.i64(i64, i64, i32)
 114 define i64 @umul_fix_sat(i64 %arg0, i64 %arg1, i32 %arg2) {
 115   ; CHECK: immarg operand has non-immediate parameter
 116   ; CHECK-NEXT: i32 %arg2
 117   ; CHECK-NEXT: %ret = call i64 @llvm.umul.fix.sat.i64(i64 %arg0, i64 %arg1, i32 %arg2)
 118   %ret = call i64 @llvm.umul.fix.sat.i64(i64 %arg0, i64 %arg1, i32 %arg2)
 119   ret i64 %ret
 120 }
 121
 122 declare <2 x double> @llvm.masked.load.v2f64.p0(ptr, i32, <2 x i1>, <2 x double>)
 123 define <2 x double> @masked_load(<2 x i1> %mask, ptr %addr, <2 x double> %dst, i32 %align) {
 124   ; CHECK: immarg operand has non-immediate parameter
 125   ; CHECK-NEXT: i32 %align
 126   ; CHECK-NEXT: %res = call <2 x double> @llvm.masked.load.v2f64.p0(ptr %addr, i32 %align, <2 x i1> %mask, <2 x double> %dst)
 127   %res = call <2 x double> @llvm.masked.load.v2f64.p0(ptr %addr, i32 %align, <2 x i1> %mask, <2 x double> %dst)
 128   ret <2 x double> %res
 129 }
 130
 131 declare void @llvm.masked.store.v4i32.p0(<4 x i32>, ptr, i32, <4 x i1>)
 132 define void @masked_store(<4 x i1> %mask, ptr %addr, <4 x i32> %val, i32 %align) {
 133   ; CHECK: immarg operand has non-immediate parameter
 134   ; CHECK-NEXT: i32 %align
 135   ; CHECK-NEXT: call void @llvm.masked.store.v4i32.p0(<4 x i32> %val, ptr %addr, i32 %align, <4 x i1> %mask)
 136   call void @llvm.masked.store.v4i32.p0(<4 x i32> %val, ptr %addr, i32 %align, <4 x i1> %mask)
 137   ret void
 138 }
 139
 140 declare <2 x double> @llvm.masked.gather.v2f64.v2p0(<2 x ptr>, i32, <2 x i1>, <2 x double>)
 141 define <2 x double> @test_gather(<2 x ptr> %ptrs, <2 x i1> %mask, <2 x double> %src0, i32 %align)  {
 142   ; CHECK: immarg operand has non-immediate parameter
 143   ; CHECK: i32 %align
 144   ; CHECK: %res = call <2 x double> @llvm.masked.gather.v2f64.v2p0(<2 x ptr> %ptrs, i32 %align, <2 x i1> %mask, <2 x double> %src0)
 145   %res = call <2 x double> @llvm.masked.gather.v2f64.v2p0(<2 x ptr> %ptrs, i32 %align, <2 x i1> %mask, <2 x double> %src0)
 146   ret <2 x double> %res
 147 }
 148
 149 declare void @llvm.masked.scatter.v8i32.v8p0(<8 x i32>, <8 x ptr>, i32, <8 x i1>)
 150 define void @test_scatter_8i32(<8 x i32> %a1, <8 x ptr> %ptr, <8 x i1> %mask, i32 %align) {
 151   ; CHECK: immarg operand has non-immediate parameter
 152   ; CHECK-NEXT: i32 %align
 153   ; CHECK-NEXT: call void @llvm.masked.scatter.v8i32.v8p0(<8 x i32> %a1, <8 x ptr> %ptr, i32 %align, <8 x i1> %mask)
 154   call void @llvm.masked.scatter.v8i32.v8p0(<8 x i32> %a1, <8 x ptr> %ptr, i32 %align, <8 x i1> %mask)
 155   ret void
 156 }
 157
 158 declare void @llvm.lifetime.start.p0(i64, ptr)
 159 define void @test_lifetime_start(i64 %arg0, ptr %ptr) {
 160   ; CHECK: immarg operand has non-immediate parameter
 161   ; CHECK-NEXT: i64 %arg0
 162   ; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 %arg0, ptr %ptr)
 163   call void @llvm.lifetime.start.p0(i64 %arg0, ptr %ptr)
 164   ret void
 165 }
 166
 167 declare void @llvm.lifetime.end.p0(i64, ptr)
 168 define void @test_lifetime_end(i64 %arg0, ptr %ptr) {
 169   ; CHECK: immarg operand has non-immediate parameter
 170   ; CHECK-NEXT: i64 %arg0
 171   ; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 %arg0, ptr %ptr)
 172   call void @llvm.lifetime.end.p0(i64 %arg0, ptr %ptr)
 173   ret void
 174 }
 175
 176 declare void @llvm.invariant.start.p0(i64, ptr)
 177 define void @test_invariant_start(i64 %arg0, ptr %ptr) {
 178   ; CHECK: immarg operand has non-immediate parameter
 179   ; CHECK-NEXT: i64 %arg0
 180   ; CHECK-NEXT: call void @llvm.invariant.start.p0(i64 %arg0, ptr %ptr)
 181   call void @llvm.invariant.start.p0(i64 %arg0, ptr %ptr)
 182   ret void
 183 }
 184
 185 declare void @llvm.invariant.end.p0(ptr, i64, ptr)
 186 define void @test_invariant_end(ptr %scope, i64 %arg1, ptr %ptr) {
 187   ; CHECK: immarg operand has non-immediate parameter
 188   ; CHECK-NEXT: i64 %arg1
 189   ; CHECK-NEXT: call void @llvm.invariant.end.p0(ptr %scope, i64 %arg1, ptr %ptr)
 190   call void @llvm.invariant.end.p0(ptr %scope, i64 %arg1, ptr %ptr)
 191   ret void
 192 }
 193
 194 declare void @llvm.prefetch(ptr, i32, i32, i32)
 195 define void @test_prefetch(ptr %ptr, i32 %arg0, i32 %arg1) {
 196   ; CHECK: immarg operand has non-immediate parameter
 197   ; CHECK-NEXT: i32 %arg0
 198   ; CHECK-NEXT: call void @llvm.prefetch.p0(ptr %ptr, i32 %arg0, i32 0, i32 0)
 199   ; CHECK: immarg operand has non-immediate parameter
 200   ; CHECK-NEXT:  i32 %arg1
 201   call void @llvm.prefetch(ptr %ptr, i32 %arg0, i32 0, i32 0)
 202   call void @llvm.prefetch(ptr %ptr, i32 0, i32 %arg1, i32 0)
 203   ret void
 204 }
 205
 206 declare void @llvm.localrecover(ptr, ptr, i32)
 207 define void @test_localrecover(ptr %func, ptr %fp, i32 %idx) {
 208   ; CHECK: immarg operand has non-immediate parameter
 209   ; CHECK-NEXT: i32 %idx
 210   ; CHECK-NEXT: call void @llvm.localrecover(ptr %func, ptr %fp, i32 %idx)
 211   call void @llvm.localrecover(ptr %func, ptr %fp, i32 %idx)
 212   ret void
 213 }
 214
 215 declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)
 216
 217 define private void @f() {
 218   ret void
 219 }
 220
 221 define void @calls_statepoint(ptr addrspace(1) %arg0, i64 %arg1, i32 %arg2, i32 %arg4, i32 %arg5) gc "statepoint-example" {
 222   ; CHECK: immarg operand has non-immediate parameter
 223   ; CHECK-NEXT: i64 %arg1
 224   ; CHECK-NEXT: %safepoint0 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 %arg1, i32 0, ptr @f, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 225   ; CHECK: immarg operand has non-immediate parameter
 226   ; CHECK-NEXT: i32 %arg2
 227   ; CHECK-NEXT: %safepoint1 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 %arg2, ptr @f, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 228   ; CHECK: immarg operand has non-immediate parameter
 229   ; CHECK-NEXT: i32 %arg4
 230   ; CHECK-NEXT: %safepoint2 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr @f, i32 %arg4, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 231   ; CHECK: immarg operand has non-immediate parameter
 232   ; CHECK-NEXT: i32 %arg5
 233   ; CHECK-NEXT: %safepoint3 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr @f, i32 0, i32 %arg5, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 234   %safepoint0 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 %arg1, i32 0, ptr @f, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 235   %safepoint1 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 %arg2, ptr @f, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 236   %safepoint2 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr @f, i32 %arg4, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 237   %safepoint3 = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 0, i32 0, ptr @f, i32 0, i32 %arg5, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0, ptr addrspace(1) %arg0)
 238   ret void
 239 }
 240
 241 declare void @llvm.hwasan.check.memaccess(ptr, ptr, i32)
 242
 243 define void @hwasan_check_memaccess(ptr %arg0,ptr %arg1, i32 %arg2) {
 244   ; CHECK: immarg operand has non-immediate parameter
 245   ; CHECK: i32 %arg2
 246   ; CHECK: call void @llvm.hwasan.check.memaccess(ptr %arg0, ptr %arg1, i32 %arg2)
 247   call void @llvm.hwasan.check.memaccess(ptr %arg0,ptr %arg1, i32 %arg2)
 248   ret void
 249 }
 250
 251 declare void @llvm.eh.sjlj.callsite(i32)
 252
 253 define void @eh_sjlj_callsite(i32 %arg0) {
 254   ; CHECK: immarg operand has non-immediate parameter
 255   ; CHECK: i32 %arg0
 256   ; CHECK: call void @llvm.eh.sjlj.callsite(i32 %arg0)
 257   call void @llvm.eh.sjlj.callsite(i32 %arg0)
 258   ret void
 259 }