test/Transforms/InstCombine/sub.ll

   1 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
   2
   3 ; Optimize subtracts.
   4 ;
   5 ; RUN: opt < %s -instcombine -S | FileCheck %s
   6
   7 define i32 @test1(i32 %A) {
   8         %B = sub i32 %A, %A
   9         ret i32 %B
  10 ; CHECK: @test1
  11 ; CHECK: ret i32 0
  12 }
  13
  14 define i32 @test2(i32 %A) {
  15         %B = sub i32 %A, 0
  16         ret i32 %B
  17 ; CHECK: @test2
  18 ; CHECK: ret i32 %A
  19 }
  20
  21 define i32 @test3(i32 %A) {
  22         %B = sub i32 0, %A
  23         %C = sub i32 0, %B
  24         ret i32 %C
  25 ; CHECK: @test3
  26 ; CHECK: ret i32 %A
  27 }
  28
  29 define i32 @test4(i32 %A, i32 %x) {
  30         %B = sub i32 0, %A
  31         %C = sub i32 %x, %B
  32         ret i32 %C
  33 ; CHECK: @test4
  34 ; CHECK: %C = add i32 %x, %A
  35 ; CHECK: ret i32 %C
  36 }
  37
  38 define i32 @test5(i32 %A, i32 %B, i32 %C) {
  39         %D = sub i32 %B, %C
  40         %E = sub i32 %A, %D
  41         ret i32 %E
  42 ; CHECK: @test5
  43 ; CHECK: %D = sub i32 %C, %B
  44 ; CHECK: %E = add
  45 ; CHECK: ret i32 %E
  46 }
  47
  48 define i32 @test6(i32 %A, i32 %B) {
  49         %C = and i32 %A, %B
  50         %D = sub i32 %A, %C
  51         ret i32 %D
  52 ; CHECK: @test6
  53 ; CHECK-NEXT: xor i32 %B, -1
  54 ; CHECK-NEXT: %D = and i32
  55 ; CHECK-NEXT: ret i32 %D
  56 }
  57
  58 define i32 @test7(i32 %A) {
  59         %B = sub i32 -1, %A
  60         ret i32 %B
  61 ; CHECK: @test7
  62 ; CHECK: %B = xor i32 %A, -1
  63 ; CHECK: ret i32 %B
  64 }
  65
  66 define i32 @test8(i32 %A) {
  67         %B = mul i32 9, %A
  68         %C = sub i32 %B, %A
  69         ret i32 %C
  70 ; CHECK: @test8
  71 ; CHECK: %C = shl i32 %A, 3
  72 ; CHECK: ret i32 %C
  73 }
  74
  75 define i32 @test9(i32 %A) {
  76         %B = mul i32 3, %A
  77         %C = sub i32 %A, %B
  78         ret i32 %C
  79 ; CHECK: @test9
  80 ; CHECK: %C = mul i32 %A, -2
  81 ; CHECK: ret i32 %C
  82 }
  83
  84 define i32 @test10(i32 %A, i32 %B) {
  85         %C = sub i32 0, %A
  86         %D = sub i32 0, %B
  87         %E = mul i32 %C, %D
  88         ret i32 %E
  89 ; CHECK: @test10
  90 ; CHECK: %E = mul i32 %A, %B
  91 ; CHECK: ret i32 %E
  92 }
  93
  94 define i32 @test10a(i32 %A) {
  95         %C = sub i32 0, %A
  96         %E = mul i32 %C, 7
  97         ret i32 %E
  98 ; CHECK: @test10a
  99 ; CHECK: %E = mul i32 %A, -7
 100 ; CHECK: ret i32 %E
 101 }
 102
 103 define i1 @test11(i8 %A, i8 %B) {
 104         %C = sub i8 %A, %B
 105         %cD = icmp ne i8 %C, 0
 106         ret i1 %cD
 107 ; CHECK: @test11
 108 ; CHECK: %cD = icmp ne i8 %A, %B
 109 ; CHECK: ret i1 %cD
 110 }
 111
 112 define i32 @test12(i32 %A) {
 113         %B = ashr i32 %A, 31
 114         %C = sub i32 0, %B
 115         ret i32 %C
 116 ; CHECK: @test12
 117 ; CHECK: %C = lshr i32 %A, 31
 118 ; CHECK: ret i32 %C
 119 }
 120
 121 define i32 @test13(i32 %A) {
 122         %B = lshr i32 %A, 31
 123         %C = sub i32 0, %B
 124         ret i32 %C
 125 ; CHECK: @test13
 126 ; CHECK: %C = ashr i32 %A, 31
 127 ; CHECK: ret i32 %C
 128 }
 129
 130 define i32 @test14(i32 %A) {
 131         %B = lshr i32 %A, 31
 132         %C = bitcast i32 %B to i32
 133         %D = sub i32 0, %C
 134         ret i32 %D
 135 ; CHECK: @test14
 136 ; CHECK: %D = ashr i32 %A, 31
 137 ; CHECK: ret i32 %D
 138 }
 139
 140 define i32 @test15(i32 %A, i32 %B) {
 141         %C = sub i32 0, %A
 142         %D = srem i32 %B, %C
 143         ret i32 %D
 144 ; CHECK: @test15
 145 ; CHECK: %D = srem i32 %B, %A
 146 ; CHECK: ret i32 %D
 147 }
 148
 149 define i32 @test16(i32 %A) {
 150         %X = sdiv i32 %A, 1123
 151         %Y = sub i32 0, %X
 152         ret i32 %Y
 153 ; CHECK: @test16
 154 ; CHECK: %Y = sdiv i32 %A, -1123
 155 ; CHECK: ret i32 %Y
 156 }
 157
 158 ; Can't fold subtract here because negation it might oveflow.
 159 ; PR3142
 160 define i32 @test17(i32 %A) {
 161         %B = sub i32 0, %A
 162         %C = sdiv i32 %B, 1234
 163         ret i32 %C
 164 ; CHECK: @test17
 165 ; CHECK: %B = sub i32 0, %A
 166 ; CHECK: %C = sdiv i32 %B, 1234
 167 ; CHECK: ret i32 %C
 168 }
 169
 170 define i64 @test18(i64 %Y) {
 171         %tmp.4 = shl i64 %Y, 2
 172         %tmp.12 = shl i64 %Y, 2
 173         %tmp.8 = sub i64 %tmp.4, %tmp.12
 174         ret i64 %tmp.8
 175 ; CHECK: @test18
 176 ; CHECK: ret i64 0
 177 }
 178
 179 define i32 @test19(i32 %X, i32 %Y) {
 180         %Z = sub i32 %X, %Y
 181         %Q = add i32 %Z, %Y
 182         ret i32 %Q
 183 ; CHECK: @test19
 184 ; CHECK: ret i32 %X
 185 }
 186
 187 define i1 @test20(i32 %g, i32 %h) {
 188         %tmp.2 = sub i32 %g, %h
 189         %tmp.4 = icmp ne i32 %tmp.2, %g
 190         ret i1 %tmp.4
 191 ; CHECK: @test20
 192 ; CHECK: %tmp.4 = icmp ne i32 %h, 0
 193 ; CHECK: ret i1 %tmp.4
 194 }
 195
 196 define i1 @test21(i32 %g, i32 %h) {
 197         %tmp.2 = sub i32 %g, %h
 198         %tmp.4 = icmp ne i32 %tmp.2, %g
 199         ret i1 %tmp.4
 200 ; CHECK: @test21
 201 ; CHECK: %tmp.4 = icmp ne i32 %h, 0
 202 ; CHECK: ret i1 %tmp.4
 203 }
 204
 205 ; PR2298
 206 define i1 @test22(i32 %a, i32 %b) zeroext nounwind  {
 207         %tmp2 = sub i32 0, %a
 208         %tmp4 = sub i32 0, %b
 209         %tmp5 = icmp eq i32 %tmp2, %tmp4
 210         ret i1 %tmp5
 211 ; CHECK: @test22
 212 ; CHECK: %tmp5 = icmp eq i32 %a, %b
 213 ; CHECK: ret i1 %tmp5
 214 }
 215
 216 ; rdar://7362831
 217 define i32 @test23(i8* %P, i64 %A){
 218   %B = getelementptr inbounds i8* %P, i64 %A
 219   %C = ptrtoint i8* %B to i64
 220   %D = trunc i64 %C to i32
 221   %E = ptrtoint i8* %P to i64
 222   %F = trunc i64 %E to i32
 223   %G = sub i32 %D, %F
 224   ret i32 %G
 225 ; CHECK: @test23
 226 ; CHECK-NEXT: = trunc i64 %A to i32
 227 ; CHECK-NEXT: ret i32
 228 }
 229
 230 define i64 @test24(i8* %P, i64 %A){
 231   %B = getelementptr inbounds i8* %P, i64 %A
 232   %C = ptrtoint i8* %B to i64
 233   %E = ptrtoint i8* %P to i64
 234   %G = sub i64 %C, %E
 235   ret i64 %G
 236 ; CHECK: @test24
 237 ; CHECK-NEXT: ret i64 %A
 238 }
 239
 240 define i64 @test24a(i8* %P, i64 %A){
 241   %B = getelementptr inbounds i8* %P, i64 %A
 242   %C = ptrtoint i8* %B to i64
 243   %E = ptrtoint i8* %P to i64
 244   %G = sub i64 %E, %C
 245   ret i64 %G
 246 ; CHECK: @test24a
 247 ; CHECK-NEXT: sub i64 0, %A
 248 ; CHECK-NEXT: ret i64
 249 }
 250
 251 @Arr = external global [42 x i16]
 252
 253 define i64 @test24b(i8* %P, i64 %A){
 254   %B = getelementptr inbounds [42 x i16]* @Arr, i64 0, i64 %A
 255   %C = ptrtoint i16* %B to i64
 256   %G = sub i64 %C, ptrtoint ([42 x i16]* @Arr to i64)
 257   ret i64 %G
 258 ; CHECK: @test24b
 259 ; CHECK-NEXT: shl i64 %A, 1
 260 ; CHECK-NEXT: ret i64
 261 }
 262
 263
 264 define i64 @test25(i8* %P, i64 %A){
 265   %B = getelementptr inbounds [42 x i16]* @Arr, i64 0, i64 %A
 266   %C = ptrtoint i16* %B to i64
 267   %G = sub i64 %C, ptrtoint (i16* getelementptr ([42 x i16]* @Arr, i64 1, i64 0) to i64)
 268   ret i64 %G
 269 ; CHECK: @test25
 270 ; CHECK-NEXT: shl i64 %A, 1
 271 ; CHECK-NEXT: add i64 {{.*}}, -84
 272 ; CHECK-NEXT: ret i64
 273 }
 274
 275 define i32 @test26(i32 %x) {
 276   %shl = shl i32 3, %x
 277   %neg = sub i32 0, %shl
 278   ret i32 %neg
 279 ; CHECK: @test26
 280 ; CHECK-NEXT: shl i32 -3
 281 ; CHECK-NEXT: ret i32
 282 }
 283
 284 define i32 @test27(i32 %x, i32 %y) {
 285   %mul = mul i32 %y, -8
 286   %sub = sub i32 %x, %mul
 287   ret i32 %sub
 288 ; CHECK: @test27
 289 ; CHECK-NEXT: shl i32 %y, 3
 290 ; CHECK-NEXT: add i32
 291 ; CHECK-NEXT: ret i32
 292 }
 293
 294 define i32 @test28(i32 %x, i32 %y, i32 %z) {
 295   %neg = sub i32 0, %z
 296   %mul = mul i32 %neg, %y
 297   %sub = sub i32 %x, %mul
 298   ret i32 %sub
 299 ; CHECK: @test28
 300 ; CHECK-NEXT: mul i32 %z, %y
 301 ; CHECK-NEXT: add i32
 302 ; CHECK-NEXT: ret i32
 303 }