llvm/test/CodeGen/DirectX/WaveActiveSum.ll

   1 ; RUN: opt -S -scalarizer -dxil-op-lower -mtriple=dxil-pc-shadermodel6.3-library < %s | FileCheck %s
   2
   3 ; Test that for scalar values, WaveActiveSum maps down to the DirectX op
   4
   5 define noundef half @wave_active_sum_half(half noundef %expr) {
   6 entry:
   7 ; CHECK: call half @dx.op.waveActiveOp.f16(i32 119, half %expr, i8 0, i8 0)
   8   %ret = call half @llvm.dx.wave.reduce.sum.f16(half %expr)
   9   ret half %ret
  10 }
  11
  12 define noundef float @wave_active_sum_float(float noundef %expr) {
  13 entry:
  14 ; CHECK: call float @dx.op.waveActiveOp.f32(i32 119, float %expr, i8 0, i8 0)
  15   %ret = call float @llvm.dx.wave.reduce.sum.f32(float %expr)
  16   ret float %ret
  17 }
  18
  19 define noundef double @wave_active_sum_double(double noundef %expr) {
  20 entry:
  21 ; CHECK: call double @dx.op.waveActiveOp.f64(i32 119, double %expr, i8 0, i8 0)
  22   %ret = call double @llvm.dx.wave.reduce.sum.f64(double %expr)
  23   ret double %ret
  24 }
  25
  26 define noundef i16 @wave_active_sum_i16(i16 noundef %expr) {
  27 entry:
  28 ; CHECK: call i16 @dx.op.waveActiveOp.i16(i32 119, i16 %expr, i8 0, i8 0)
  29   %ret = call i16 @llvm.dx.wave.reduce.sum.i16(i16 %expr)
  30   ret i16 %ret
  31 }
  32
  33 define noundef i32 @wave_active_sum_i32(i32 noundef %expr) {
  34 entry:
  35 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr, i8 0, i8 0)
  36   %ret = call i32 @llvm.dx.wave.reduce.sum.i32(i32 %expr)
  37   ret i32 %ret
  38 }
  39
  40 define noundef i64 @wave_active_sum_i64(i64 noundef %expr) {
  41 entry:
  42 ; CHECK: call i64 @dx.op.waveActiveOp.i64(i32 119, i64 %expr, i8 0, i8 0)
  43   %ret = call i64 @llvm.dx.wave.reduce.sum.i64(i64 %expr)
  44   ret i64 %ret
  45 }
  46
  47 define noundef i16 @wave_active_usum_i16(i16 noundef %expr) {
  48 entry:
  49 ; CHECK: call i16 @dx.op.waveActiveOp.i16(i32 119, i16 %expr, i8 0, i8 1)
  50   %ret = call i16 @llvm.dx.wave.reduce.usum.i16(i16 %expr)
  51   ret i16 %ret
  52 }
  53
  54 define noundef i32 @wave_active_usum_i32(i32 noundef %expr) {
  55 entry:
  56 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr, i8 0, i8 1)
  57   %ret = call i32 @llvm.dx.wave.reduce.usum.i32(i32 %expr)
  58   ret i32 %ret
  59 }
  60
  61 define noundef i64 @wave_active_usum_i64(i64 noundef %expr) {
  62 entry:
  63 ; CHECK: call i64 @dx.op.waveActiveOp.i64(i32 119, i64 %expr, i8 0, i8 1)
  64   %ret = call i64 @llvm.dx.wave.reduce.usum.i64(i64 %expr)
  65   ret i64 %ret
  66 }
  67
  68 declare half @llvm.dx.wave.reduce.sum.f16(half)
  69 declare float @llvm.dx.wave.reduce.sum.f32(float)
  70 declare double @llvm.dx.wave.reduce.sum.f64(double)
  71
  72 declare i16 @llvm.dx.wave.reduce.sum.i16(i16)
  73 declare i32 @llvm.dx.wave.reduce.sum.i32(i32)
  74 declare i64 @llvm.dx.wave.reduce.sum.i64(i64)
  75
  76 declare i16 @llvm.dx.wave.reduce.usum.i16(i16)
  77 declare i32 @llvm.dx.wave.reduce.usum.i32(i32)
  78 declare i64 @llvm.dx.wave.reduce.usum.i64(i64)
  79
  80 ; Test that for vector values, WaveActiveSum scalarizes and maps down to the
  81 ; DirectX op
  82
  83 define noundef <2 x half> @wave_active_sum_v2half(<2 x half> noundef %expr) {
  84 entry:
  85 ; CHECK: call half @dx.op.waveActiveOp.f16(i32 119, half %expr.i0, i8 0, i8 0)
  86 ; CHECK: call half @dx.op.waveActiveOp.f16(i32 119, half %expr.i1, i8 0, i8 0)
  87   %ret = call <2 x half> @llvm.dx.wave.reduce.sum.v2f16(<2 x half> %expr)
  88   ret <2 x half> %ret
  89 }
  90
  91 define noundef <3 x i32> @wave_active_sum_v3i32(<3 x i32> noundef %expr) {
  92 entry:
  93 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr.i0, i8 0, i8 0)
  94 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr.i1, i8 0, i8 0)
  95 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr.i2, i8 0, i8 0)
  96   %ret = call <3 x i32> @llvm.dx.wave.reduce.sum.v3i32(<3 x i32> %expr)
  97   ret <3 x i32> %ret
  98 }
  99
 100 define noundef <4 x double> @wave_active_sum_v4f64(<4 x double> noundef %expr) {
 101 entry:
 102 ; CHECK: call double @dx.op.waveActiveOp.f64(i32 119, double %expr.i0, i8 0, i8 0)
 103 ; CHECK: call double @dx.op.waveActiveOp.f64(i32 119, double %expr.i1, i8 0, i8 0)
 104 ; CHECK: call double @dx.op.waveActiveOp.f64(i32 119, double %expr.i2, i8 0, i8 0)
 105 ; CHECK: call double @dx.op.waveActiveOp.f64(i32 119, double %expr.i3, i8 0, i8 0)
 106   %ret = call <4 x double> @llvm.dx.wave.reduce.sum.v464(<4 x double> %expr)
 107   ret <4 x double> %ret
 108 }
 109
 110 declare <2 x half> @llvm.dx.wave.reduce.sum.v2f16(<2 x half>)
 111 declare <3 x i32> @llvm.dx.wave.reduce.sum.v3i32(<3 x i32>)
 112 declare <4 x double> @llvm.dx.wave.reduce.sum.v4f64(<4 x double>)
 113
 114 define noundef <2 x i16> @wave_active_usum_v2i16(<2 x i16> noundef %expr) {
 115 entry:
 116 ; CHECK: call i16 @dx.op.waveActiveOp.i16(i32 119, i16 %expr.i0, i8 0, i8 1)
 117 ; CHECK: call i16 @dx.op.waveActiveOp.i16(i32 119, i16 %expr.i1, i8 0, i8 1)
 118   %ret = call <2 x i16> @llvm.dx.wave.reduce.usum.v2f16(<2 x i16> %expr)
 119   ret <2 x i16> %ret
 120 }
 121
 122 define noundef <3 x i32> @wave_active_usum_v3i32(<3 x i32> noundef %expr) {
 123 entry:
 124 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr.i0, i8 0, i8 1)
 125 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr.i1, i8 0, i8 1)
 126 ; CHECK: call i32 @dx.op.waveActiveOp.i32(i32 119, i32 %expr.i2, i8 0, i8 1)
 127   %ret = call <3 x i32> @llvm.dx.wave.reduce.usum.v3i32(<3 x i32> %expr)
 128   ret <3 x i32> %ret
 129 }
 130
 131 define noundef <4 x i64> @wave_active_usum_v4f64(<4 x i64> noundef %expr) {
 132 entry:
 133 ; CHECK: call i64 @dx.op.waveActiveOp.i64(i32 119, i64 %expr.i0, i8 0, i8 1)
 134 ; CHECK: call i64 @dx.op.waveActiveOp.i64(i32 119, i64 %expr.i1, i8 0, i8 1)
 135 ; CHECK: call i64 @dx.op.waveActiveOp.i64(i32 119, i64 %expr.i2, i8 0, i8 1)
 136 ; CHECK: call i64 @dx.op.waveActiveOp.i64(i32 119, i64 %expr.i3, i8 0, i8 1)
 137   %ret = call <4 x i64> @llvm.dx.wave.reduce.usum.v464(<4 x i64> %expr)
 138   ret <4 x i64> %ret
 139 }
 140
 141 declare <2 x i16> @llvm.dx.wave.reduce.usum.v2f16(<2 x i16>)
 142 declare <3 x i32> @llvm.dx.wave.reduce.usum.v3i32(<3 x i32>)
 143 declare <4 x i64> @llvm.dx.wave.reduce.usum.v4f64(<4 x i64>)