test/Transforms/InstCombine/fneg.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instcombine -S | FileCheck %s
   3
   4 declare void @use(float)
   5
   6 ; -(X * C) --> X * (-C)
   7
   8 define float @fmul_fneg(float %x) {
   9 ; CHECK-LABEL: @fmul_fneg(
  10 ; CHECK-NEXT:    [[R:%.*]] = fmul float [[X:%.*]], -4.200000e+01
  11 ; CHECK-NEXT:    ret float [[R]]
  12 ;
  13   %m = fmul float %x, 42.0
  14   %r = fsub float -0.0, %m
  15   ret float %r
  16 }
  17
  18 ; Fast math is not required, but it should be propagated.
  19
  20 define float @fmul_fneg_fmf(float %x) {
  21 ; CHECK-LABEL: @fmul_fneg_fmf(
  22 ; CHECK-NEXT:    [[R:%.*]] = fmul reassoc nsz float [[X:%.*]], -4.200000e+01
  23 ; CHECK-NEXT:    ret float [[R]]
  24 ;
  25   %m = fmul float %x, 42.0
  26   %r = fsub reassoc nsz float -0.0, %m
  27   ret float %r
  28 }
  29
  30 ; Extra use prevents the fold. We don't want to replace the fneg with an fmul.
  31
  32 define float @fmul_fneg_extra_use(float %x) {
  33 ; CHECK-LABEL: @fmul_fneg_extra_use(
  34 ; CHECK-NEXT:    [[M:%.*]] = fmul float [[X:%.*]], 4.200000e+01
  35 ; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[M]]
  36 ; CHECK-NEXT:    call void @use(float [[M]])
  37 ; CHECK-NEXT:    ret float [[R]]
  38 ;
  39   %m = fmul float %x, 42.0
  40   %r = fsub float -0.0, %m
  41   call void @use(float %m)
  42   ret float %r
  43 }
  44
  45 ; Try a vector. Use special constants (NaN, INF, undef) because they don't change anything.
  46
  47 define <4 x double> @fmul_fneg_vec(<4 x double> %x) {
  48 ; CHECK-LABEL: @fmul_fneg_vec(
  49 ; CHECK-NEXT:    [[R:%.*]] = fmul <4 x double> [[X:%.*]], <double -4.200000e+01, double 0x7F80000000000000, double 0xFFF0000000000000, double 0x7FF8000000000000>
  50 ; CHECK-NEXT:    ret <4 x double> [[R]]
  51 ;
  52   %m = fmul <4 x double> %x, <double 42.0, double 0x7FF80000000000000, double 0x7FF0000000000000, double undef>
  53   %r = fsub <4 x double> <double -0.0, double -0.0, double -0.0, double -0.0>, %m
  54   ret <4 x double> %r
  55 }
  56
  57 ; -(X / C) --> X / (-C)
  58
  59 define float @fdiv_op1_constant_fneg(float %x) {
  60 ; CHECK-LABEL: @fdiv_op1_constant_fneg(
  61 ; CHECK-NEXT:    [[R:%.*]] = fdiv float [[X:%.*]], 4.200000e+01
  62 ; CHECK-NEXT:    ret float [[R]]
  63 ;
  64   %d = fdiv float %x, -42.0
  65   %r = fsub float -0.0, %d
  66   ret float %r
  67 }
  68
  69 ; Fast math is not required, but it should be propagated.
  70
  71 define float @fdiv_op1_constant_fneg_fmf(float %x) {
  72 ; CHECK-LABEL: @fdiv_op1_constant_fneg_fmf(
  73 ; CHECK-NEXT:    [[R:%.*]] = fdiv nnan float [[X:%.*]], 4.200000e+01
  74 ; CHECK-NEXT:    ret float [[R]]
  75 ;
  76   %d = fdiv float %x, -42.0
  77   %r = fsub nnan float -0.0, %d
  78   ret float %r
  79 }
  80
  81 ; Extra use prevents the fold. We don't want to replace the fneg with an fdiv.
  82
  83 define float @fdiv_op1_constant_fneg_extra_use(float %x) {
  84 ; CHECK-LABEL: @fdiv_op1_constant_fneg_extra_use(
  85 ; CHECK-NEXT:    [[D:%.*]] = fdiv float [[X:%.*]], 4.200000e+01
  86 ; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[D]]
  87 ; CHECK-NEXT:    call void @use(float [[D]])
  88 ; CHECK-NEXT:    ret float [[R]]
  89 ;
  90   %d = fdiv float %x, 42.0
  91   %r = fsub float -0.0, %d
  92   call void @use(float %d)
  93   ret float %r
  94 }
  95
  96 ; Try a vector. Use special constants (NaN, INF, undef) because they don't change anything.
  97
  98 define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) {
  99 ; CHECK-LABEL: @fdiv_op1_constant_fneg_vec(
 100 ; CHECK-NEXT:    [[R:%.*]] = fdiv <4 x double> [[X:%.*]], <double 4.200000e+01, double 0x7FF800000ABCD000, double 0x7FF0000000000000, double 0x7FF8000000000000>
 101 ; CHECK-NEXT:    ret <4 x double> [[R]]
 102 ;
 103   %d = fdiv <4 x double> %x, <double -42.0, double 0xFFF800000ABCD000, double 0xFFF0000000000000, double undef>
 104   %r = fsub <4 x double> <double -0.0, double -0.0, double -0.0, double -0.0>, %d
 105   ret <4 x double> %r
 106 }
 107
 108 ; -(C / X) --> (-C) / X
 109
 110 define float @fdiv_op0_constant_fneg(float %x) {
 111 ; CHECK-LABEL: @fdiv_op0_constant_fneg(
 112 ; CHECK-NEXT:    [[R:%.*]] = fdiv float -4.200000e+01, [[X:%.*]]
 113 ; CHECK-NEXT:    ret float [[R]]
 114 ;
 115   %d = fdiv float 42.0, %x
 116   %r = fsub float -0.0, %d
 117   ret float %r
 118 }
 119
 120 ; Fast math is not required, but it should be propagated.
 121
 122 define float @fdiv_op0_constant_fneg_fmf(float %x) {
 123 ; CHECK-LABEL: @fdiv_op0_constant_fneg_fmf(
 124 ; CHECK-NEXT:    [[R:%.*]] = fdiv fast float -4.200000e+01, [[X:%.*]]
 125 ; CHECK-NEXT:    ret float [[R]]
 126 ;
 127   %d = fdiv float 42.0, %x
 128   %r = fsub fast float -0.0, %d
 129   ret float %r
 130 }
 131
 132 ; Extra use prevents the fold. We don't want to replace the fneg with an fdiv.
 133
 134 define float @fdiv_op0_constant_fneg_extra_use(float %x) {
 135 ; CHECK-LABEL: @fdiv_op0_constant_fneg_extra_use(
 136 ; CHECK-NEXT:    [[D:%.*]] = fdiv float -4.200000e+01, [[X:%.*]]
 137 ; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[D]]
 138 ; CHECK-NEXT:    call void @use(float [[D]])
 139 ; CHECK-NEXT:    ret float [[R]]
 140 ;
 141   %d = fdiv float -42.0, %x
 142   %r = fsub float -0.0, %d
 143   call void @use(float %d)
 144   ret float %r
 145 }
 146
 147 ; Try a vector. Use special constants (NaN, INF, undef) because they don't change anything.
 148
 149 define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) {
 150 ; CHECK-LABEL: @fdiv_op0_constant_fneg_vec(
 151 ; CHECK-NEXT:    [[R:%.*]] = fdiv <4 x double> <double 4.200000e+01, double 0x7F80000000000000, double 0x7FF0000000000000, double 0x7FF8000000000000>, [[X:%.*]]
 152 ; CHECK-NEXT:    ret <4 x double> [[R]]
 153 ;
 154   %d = fdiv <4 x double> <double -42.0, double 0x7FF80000000000000, double 0xFFF0000000000000, double undef>, %x
 155   %r = fsub <4 x double> <double -0.0, double -0.0, double -0.0, double -0.0>, %d
 156   ret <4 x double> %r
 157 }
 158