test/CodeGen/SystemZ/vec-const-13.ll

   1 ; Test vector replicates that use VECTOR GENERATE MASK, v16i8 version.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z13 | FileCheck %s
   4
   5 ; Test a word-granularity replicate with the lowest value that cannot use
   6 ; VREPIF.
   7 define <16 x i8> @f1() {
   8 ; CHECK-LABEL: f1:
   9 ; CHECK: vgmf %v24, 16, 16
  10 ; CHECK: br %r14
  11   ret <16 x i8> <i8 0, i8 0, i8 128, i8 0,
  12                  i8 0, i8 0, i8 128, i8 0,
  13                  i8 0, i8 0, i8 128, i8 0,
  14                  i8 0, i8 0, i8 128, i8 0>
  15 }
  16
  17 ; Test a word-granularity replicate that has the lower 17 bits set.
  18 define <16 x i8> @f2() {
  19 ; CHECK-LABEL: f2:
  20 ; CHECK: vgmf %v24, 15, 31
  21 ; CHECK: br %r14
  22   ret <16 x i8> <i8 0, i8 1, i8 255, i8 255,
  23                  i8 0, i8 1, i8 255, i8 255,
  24                  i8 0, i8 1, i8 255, i8 255,
  25                  i8 0, i8 1, i8 255, i8 255>
  26 }
  27
  28 ; Test a word-granularity replicate that has the upper 15 bits set.
  29 define <16 x i8> @f3() {
  30 ; CHECK-LABEL: f3:
  31 ; CHECK: vgmf %v24, 0, 14
  32 ; CHECK: br %r14
  33   ret <16 x i8> <i8 255, i8 254, i8 0, i8 0,
  34                  i8 255, i8 254, i8 0, i8 0,
  35                  i8 255, i8 254, i8 0, i8 0,
  36                  i8 255, i8 254, i8 0, i8 0>
  37 }
  38
  39 ; Test a word-granularity replicate that has middle bits set.
  40 define <16 x i8> @f4() {
  41 ; CHECK-LABEL: f4:
  42 ; CHECK: vgmf %v24, 12, 17
  43 ; CHECK: br %r14
  44   ret <16 x i8> <i8 0, i8 15, i8 192, i8 0,
  45                  i8 0, i8 15, i8 192, i8 0,
  46                  i8 0, i8 15, i8 192, i8 0,
  47                  i8 0, i8 15, i8 192, i8 0>
  48 }
  49
  50 ; Test a word-granularity replicate with a wrap-around mask.
  51 define <16 x i8> @f5() {
  52 ; CHECK-LABEL: f5:
  53 ; CHECK: vgmf %v24, 17, 15
  54 ; CHECK: br %r14
  55   ret <16 x i8> <i8 255, i8 255, i8 127, i8 255,
  56                  i8 255, i8 255, i8 127, i8 255,
  57                  i8 255, i8 255, i8 127, i8 255,
  58                  i8 255, i8 255, i8 127, i8 255>
  59 }
  60
  61 ; Test a doubleword-granularity replicate with the lowest value that cannot
  62 ; use VREPIG.
  63 define <16 x i8> @f6() {
  64 ; CHECK-LABEL: f6:
  65 ; CHECK: vgmg %v24, 48, 48
  66 ; CHECK: br %r14
  67   ret <16 x i8> <i8 0, i8 0, i8 0, i8 0,
  68                  i8 0, i8 0, i8 128, i8 0,
  69                  i8 0, i8 0, i8 0, i8 0,
  70                  i8 0, i8 0, i8 128, i8 0>
  71 }
  72
  73 ; Test a doubleword-granularity replicate that has the lower 22 bits set.
  74 define <16 x i8> @f7() {
  75 ; CHECK-LABEL: f7:
  76 ; CHECK: vgmg %v24, 42, 63
  77 ; CHECK: br %r14
  78   ret <16 x i8> <i8 0, i8 0, i8 0, i8 0,
  79                  i8 0, i8 63, i8 255, i8 255,
  80                  i8 0, i8 0, i8 0, i8 0,
  81                  i8 0, i8 63, i8 255, i8 255>
  82 }
  83
  84 ; Test a doubleword-granularity replicate that has the upper 45 bits set.
  85 define <16 x i8> @f8() {
  86 ; CHECK-LABEL: f8:
  87 ; CHECK: vgmg %v24, 0, 44
  88 ; CHECK: br %r14
  89   ret <16 x i8> <i8 255, i8 255, i8 255, i8 255,
  90                  i8 255, i8 248, i8 0, i8 0,
  91                  i8 255, i8 255, i8 255, i8 255,
  92                  i8 255, i8 248, i8 0, i8 0>
  93 }
  94
  95 ; Test a doubleword-granularity replicate that has middle bits set.
  96 define <16 x i8> @f9() {
  97 ; CHECK-LABEL: f9:
  98 ; CHECK: vgmg %v24, 31, 42
  99 ; CHECK: br %r14
 100   ret <16 x i8> <i8 0, i8 0, i8 0, i8 1,
 101                  i8 255, i8 224, i8 0, i8 0,
 102                  i8 0, i8 0, i8 0, i8 1,
 103                  i8 255, i8 224, i8 0, i8 0>
 104 }
 105
 106 ; Test a doubleword-granularity replicate with a wrap-around mask.
 107 define <16 x i8> @f10() {
 108 ; CHECK-LABEL: f10:
 109 ; CHECK: vgmg %v24, 18, 0
 110 ; CHECK: br %r14
 111   ret <16 x i8> <i8 128, i8 0, i8 63, i8 255,
 112                  i8 255, i8 255, i8 255, i8 255,
 113                  i8 128, i8 0, i8 63, i8 255,
 114                  i8 255, i8 255, i8 255, i8 255>
 115 }
 116
 117 ; Retest f1 with arbitrary undefs instead of 0s.
 118 define <16 x i8> @f11() {
 119 ; CHECK-LABEL: f11:
 120 ; CHECK: vgmf %v24, 16, 16
 121 ; CHECK: br %r14
 122   ret <16 x i8> <i8 0, i8 undef, i8 128, i8 0,
 123                  i8 0, i8 0, i8 128, i8 undef,
 124                  i8 undef, i8 0, i8 128, i8 0,
 125                  i8 undef, i8 undef, i8 128, i8 0>
 126 }
 127
 128 ; Try a case where we want consistent undefs to be treated as 0.
 129 define <16 x i8> @f12() {
 130 ; CHECK-LABEL: f12:
 131 ; CHECK: vgmf %v24, 15, 23
 132 ; CHECK: br %r14
 133   ret <16 x i8> <i8 undef, i8 1, i8 255, i8 0,
 134                  i8 undef, i8 1, i8 255, i8 0,
 135                  i8 undef, i8 1, i8 255, i8 0,
 136                  i8 undef, i8 1, i8 255, i8 0>
 137 }
 138
 139 ; ...and again with the lower bits of the replicated constant.
 140 define <16 x i8> @f13() {
 141 ; CHECK-LABEL: f13:
 142 ; CHECK: vgmf %v24, 15, 22
 143 ; CHECK: br %r14
 144   ret <16 x i8> <i8 0, i8 1, i8 254, i8 undef,
 145                  i8 0, i8 1, i8 254, i8 undef,
 146                  i8 0, i8 1, i8 254, i8 undef,
 147                  i8 0, i8 1, i8 254, i8 undef>
 148 }
 149
 150 ; Try a case where we want consistent undefs to be treated as -1.
 151 define <16 x i8> @f14() {
 152 ; CHECK-LABEL: f14:
 153 ; CHECK: vgmf %v24, 28, 8
 154 ; CHECK: br %r14
 155   ret <16 x i8> <i8 undef, i8 128, i8 0, i8 15,
 156                  i8 undef, i8 128, i8 0, i8 15,
 157                  i8 undef, i8 128, i8 0, i8 15,
 158                  i8 undef, i8 128, i8 0, i8 15>
 159 }
 160
 161 ; ...and again with the lower bits of the replicated constant.
 162 define <16 x i8> @f15() {
 163 ; CHECK-LABEL: f15:
 164 ; CHECK: vgmf %v24, 18, 3
 165 ; CHECK: br %r14
 166   ret <16 x i8> <i8 240, i8 0, i8 63, i8 undef,
 167                  i8 240, i8 0, i8 63, i8 undef,
 168                  i8 240, i8 0, i8 63, i8 undef,
 169                  i8 240, i8 0, i8 63, i8 undef>
 170 }
 171
 172 ; Repeat f9 with arbitrary undefs.
 173 define <16 x i8> @f16() {
 174 ; CHECK-LABEL: f16:
 175 ; CHECK: vgmg %v24, 31, 42
 176 ; CHECK: br %r14
 177   ret <16 x i8> <i8 undef, i8 0, i8 undef, i8 1,
 178                  i8 255, i8 undef, i8 0, i8 0,
 179                  i8 0, i8 0, i8 0, i8 1,
 180                  i8 undef, i8 224, i8 undef, i8 undef>
 181 }
 182
 183 ; Try a case where we want some consistent undefs to be treated as 0
 184 ; and some to be treated as 255.
 185 define <16 x i8> @f17() {
 186 ; CHECK-LABEL: f17:
 187 ; CHECK: vgmg %v24, 23, 35
 188 ; CHECK: br %r14
 189   ret <16 x i8> <i8 0, i8 undef, i8 1, i8 undef,
 190                  i8 240, i8 undef, i8 0, i8 0,
 191                  i8 0, i8 undef, i8 1, i8 undef,
 192                  i8 240, i8 undef, i8 0, i8 0>
 193 }