test/Transforms/Float2Int/basic.ll

   1 ; RUN: opt < %s -float2int -S | FileCheck %s
   2
   3 ;
   4 ; Positive tests
   5 ;
   6
   7 ; CHECK-LABEL: @simple1
   8 ; CHECK:  %1 = zext i8 %a to i32
   9 ; CHECK:  %2 = add i32 %1, 1
  10 ; CHECK:  %3 = trunc i32 %2 to i16
  11 ; CHECK:  ret i16 %3
  12 define i16 @simple1(i8 %a) {
  13   %1 = uitofp i8 %a to float
  14   %2 = fadd float %1, 1.0
  15   %3 = fptoui float %2 to i16
  16   ret i16 %3
  17 }
  18
  19 ; CHECK-LABEL: @simple2
  20 ; CHECK:  %1 = zext i8 %a to i32
  21 ; CHECK:  %2 = sub i32 %1, 1
  22 ; CHECK:  %3 = trunc i32 %2 to i8
  23 ; CHECK:  ret i8 %3
  24 define i8 @simple2(i8 %a) {
  25   %1 = uitofp i8 %a to float
  26   %2 = fsub float %1, 1.0
  27   %3 = fptoui float %2 to i8
  28   ret i8 %3
  29 }
  30
  31 ; CHECK-LABEL: @simple3
  32 ; CHECK:  %1 = zext i8 %a to i32
  33 ; CHECK:  %2 = sub i32 %1, 1
  34 ; CHECK:  ret i32 %2
  35 define i32 @simple3(i8 %a) {
  36   %1 = uitofp i8 %a to float
  37   %2 = fsub float %1, 1.0
  38   %3 = fptoui float %2 to i32
  39   ret i32 %3
  40 }
  41
  42 ; CHECK-LABEL: @cmp
  43 ; CHECK:  %1 = zext i8 %a to i32
  44 ; CHECK:  %2 = zext i8 %b to i32
  45 ; CHECK:  %3 = icmp slt i32 %1, %2
  46 ; CHECK:  ret i1 %3
  47 define i1 @cmp(i8 %a, i8 %b) {
  48   %1 = uitofp i8 %a to float
  49   %2 = uitofp i8 %b to float
  50   %3 = fcmp ult float %1, %2
  51   ret i1 %3
  52 }
  53
  54 ; CHECK-LABEL: @simple4
  55 ; CHECK:  %1 = zext i32 %a to i64
  56 ; CHECK:  %2 = add i64 %1, 1
  57 ; CHECK:  %3 = trunc i64 %2 to i32
  58 ; CHECK:  ret i32 %3
  59 define i32 @simple4(i32 %a) {
  60   %1 = uitofp i32 %a to double
  61   %2 = fadd double %1, 1.0
  62   %3 = fptoui double %2 to i32
  63   ret i32 %3
  64 }
  65
  66 ; CHECK-LABEL: @simple5
  67 ; CHECK:  %1 = zext i8 %a to i32
  68 ; CHECK:  %2 = zext i8 %b to i32
  69 ; CHECK:  %3 = add i32 %1, 1
  70 ; CHECK:  %4 = mul i32 %3, %2
  71 ; CHECK:  ret i32 %4
  72 define i32 @simple5(i8 %a, i8 %b) {
  73   %1 = uitofp i8 %a to float
  74   %2 = uitofp i8 %b to float
  75   %3 = fadd float %1, 1.0
  76   %4 = fmul float %3, %2
  77   %5 = fptoui float %4 to i32
  78   ret i32 %5
  79 }
  80
  81 ; The two chains don't interact - failure of one shouldn't
  82 ; cause failure of the other.
  83
  84 ; CHECK-LABEL: @multi1
  85 ; CHECK:  %1 = zext i8 %a to i32
  86 ; CHECK:  %2 = zext i8 %b to i32
  87 ; CHECK:  %fc = uitofp i8 %c to float
  88 ; CHECK:  %x1 = add i32 %1, %2
  89 ; CHECK:  %z = fadd float %fc, %d
  90 ; CHECK:  %w = fptoui float %z to i32
  91 ; CHECK:  %r = add i32 %x1, %w
  92 ; CHECK:  ret i32 %r
  93 define i32 @multi1(i8 %a, i8 %b, i8 %c, float %d) {
  94   %fa = uitofp i8 %a to float
  95   %fb = uitofp i8 %b to float
  96   %fc = uitofp i8 %c to float
  97   %x = fadd float %fa, %fb
  98   %y = fptoui float %x to i32
  99   %z = fadd float %fc, %d
 100   %w = fptoui float %z to i32
 101   %r = add i32 %y, %w
 102   ret i32 %r
 103 }
 104
 105 ; CHECK-LABEL: @simple_negzero
 106 ; CHECK:  %1 = zext i8 %a to i32
 107 ; CHECK:  %2 = add i32 %1, 0
 108 ; CHECK:  %3 = trunc i32 %2 to i16
 109 ; CHECK:  ret i16 %3
 110 define i16 @simple_negzero(i8 %a) {
 111   %1 = uitofp i8 %a to float
 112   %2 = fadd fast float %1, -0.0
 113   %3 = fptoui float %2 to i16
 114   ret i16 %3
 115 }
 116
 117 ; CHECK-LABEL: @simple_negative
 118 ; CHECK: %1 = sext i8 %call to i32
 119 ; CHECK: %mul1 = mul i32 %1, -3
 120 ; CHECK: %2 = trunc i32 %mul1 to i8
 121 ; CHECK: %conv3 = sext i8 %2 to i32
 122 ; CHECK: ret i32 %conv3
 123 define i32 @simple_negative(i8 %call) {
 124   %conv1 = sitofp i8 %call to float
 125   %mul = fmul float %conv1, -3.000000e+00
 126   %conv2 = fptosi float %mul to i8
 127   %conv3 = sext i8 %conv2 to i32
 128   ret i32 %conv3
 129 }
 130
 131 ;
 132 ; Negative tests
 133 ;
 134
 135 ; CHECK-LABEL: @neg_multi1
 136 ; CHECK:  %fa = uitofp i8 %a to float
 137 ; CHECK:  %fc = uitofp i8 %c to float
 138 ; CHECK:  %x = fadd float %fa, %fc
 139 ; CHECK:  %y = fptoui float %x to i32
 140 ; CHECK:  %z = fadd float %fc, %d
 141 ; CHECK:  %w = fptoui float %z to i32
 142 ; CHECK:  %r = add i32 %y, %w
 143 ; CHECK:  ret i32 %r
 144 ; The two chains intersect, which means because one fails, no
 145 ; transform can occur.
 146 define i32 @neg_multi1(i8 %a, i8 %b, i8 %c, float %d) {
 147   %fa = uitofp i8 %a to float
 148   %fc = uitofp i8 %c to float
 149   %x = fadd float %fa, %fc
 150   %y = fptoui float %x to i32
 151   %z = fadd float %fc, %d
 152   %w = fptoui float %z to i32
 153   %r = add i32 %y, %w
 154   ret i32 %r
 155 }
 156
 157 ; CHECK-LABEL: @neg_muld
 158 ; CHECK:  %fa = uitofp i32 %a to double
 159 ; CHECK:  %fb = uitofp i32 %b to double
 160 ; CHECK:  %mul = fmul double %fa, %fb
 161 ; CHECK:  %r = fptoui double %mul to i64
 162 ; CHECK:  ret i64 %r
 163 ; The i32 * i32 = i64, which has 64 bits, which is greater than the 52 bits
 164 ; that can be exactly represented in a double.
 165 define i64 @neg_muld(i32 %a, i32 %b) {
 166   %fa = uitofp i32 %a to double
 167   %fb = uitofp i32 %b to double
 168   %mul = fmul double %fa, %fb
 169   %r = fptoui double %mul to i64
 170   ret i64 %r
 171 }
 172
 173 ; CHECK-LABEL: @neg_mulf
 174 ; CHECK:  %fa = uitofp i16 %a to float
 175 ; CHECK:  %fb = uitofp i16 %b to float
 176 ; CHECK:  %mul = fmul float %fa, %fb
 177 ; CHECK:  %r = fptoui float %mul to i32
 178 ; CHECK:  ret i32 %r
 179 ; The i16 * i16 = i32, which can't be represented in a float, but can in a
 180 ; double. This should fail, as the written code uses floats, not doubles so
 181 ; the original result may be inaccurate.
 182 define i32 @neg_mulf(i16 %a, i16 %b) {
 183   %fa = uitofp i16 %a to float
 184   %fb = uitofp i16 %b to float
 185   %mul = fmul float %fa, %fb
 186   %r = fptoui float %mul to i32
 187   ret i32 %r
 188 }
 189
 190 ; CHECK-LABEL: @neg_cmp
 191 ; CHECK:  %1 = uitofp i8 %a to float
 192 ; CHECK:  %2 = uitofp i8 %b to float
 193 ; CHECK:  %3 = fcmp false float %1, %2
 194 ; CHECK:  ret i1 %3
 195 ; "false" doesn't have an icmp equivalent.
 196 define i1 @neg_cmp(i8 %a, i8 %b) {
 197   %1 = uitofp i8 %a to float
 198   %2 = uitofp i8 %b to float
 199   %3 = fcmp false float %1, %2
 200   ret i1 %3
 201 }
 202
 203 ; CHECK-LABEL: @neg_div
 204 ; CHECK:  %1 = uitofp i8 %a to float
 205 ; CHECK:  %2 = fdiv float %1, 1.0
 206 ; CHECK:  %3 = fptoui float %2 to i16
 207 ; CHECK:  ret i16 %3
 208 ; Division isn't a supported operator.
 209 define i16 @neg_div(i8 %a) {
 210   %1 = uitofp i8 %a to float
 211   %2 = fdiv float %1, 1.0
 212   %3 = fptoui float %2 to i16
 213   ret i16 %3
 214 }
 215
 216 ; CHECK-LABEL: @neg_remainder
 217 ; CHECK:  %1 = uitofp i8 %a to float
 218 ; CHECK:  %2 = fadd float %1, 1.2
 219 ; CHECK:  %3 = fptoui float %2 to i16
 220 ; CHECK:  ret i16 %3
 221 ; 1.2 is not an integer.
 222 define i16 @neg_remainder(i8 %a) {
 223   %1 = uitofp i8 %a to float
 224   %2 = fadd float %1, 1.25
 225   %3 = fptoui float %2 to i16
 226   ret i16 %3
 227 }
 228
 229 ; CHECK-LABEL: @neg_toolarge
 230 ; CHECK:  %1 = uitofp i80 %a to fp128
 231 ; CHECK:  %2 = fadd fp128 %1, %1
 232 ; CHECK:  %3 = fptoui fp128 %2 to i80
 233 ; CHECK:  ret i80 %3
 234 ; i80 > i64, which is the largest bitwidth handleable by default.
 235 define i80 @neg_toolarge(i80 %a) {
 236   %1 = uitofp i80 %a to fp128
 237   %2 = fadd fp128 %1, %1
 238   %3 = fptoui fp128 %2 to i80
 239   ret i80 %3
 240 }
 241
 242 ; CHECK-LABEL: @neg_calluser
 243 ; CHECK: sitofp
 244 ; CHECK: fcmp
 245 ; The sequence %1..%3 cannot be converted because %4 uses %2.
 246 define i32 @neg_calluser(i32 %value) {
 247   %1 = sitofp i32 %value to double
 248   %2 = fadd double %1, 1.0
 249   %3 = fcmp olt double %2, 0.000000e+00
 250   %4 = tail call double @g(double %2)
 251   %5 = fptosi double %4 to i32
 252   %6 = zext i1 %3 to i32
 253   %7 = add i32 %6, %5
 254   ret i32 %7
 255 }
 256 declare double @g(double)
 257
 258 ; CHECK-LABEL: @neg_vector
 259 ; CHECK:  %1 = uitofp <4 x i8> %a to <4 x float>
 260 ; CHECK:  %2 = fptoui <4 x float> %1 to <4 x i16>
 261 ; CHECK:  ret <4 x i16> %2
 262 define <4 x i16> @neg_vector(<4 x i8> %a) {
 263   %1 = uitofp <4 x i8> %a to <4 x float>
 264   %2 = fptoui <4 x float> %1 to <4 x i16>
 265   ret <4 x i16> %2
 266 }