test/Transforms/SCCP/ipsccp-basic.ll

   1 ; RUN: opt < %s -ipsccp -S | FileCheck %s
   2 ; RUN: opt < %s -enable-debugify -ipsccp -debugify-quiet -disable-output
   3
   4 ;;======================== test1
   5
   6 define internal i32 @test1a(i32 %A) {
   7         %X = add i32 1, 2
   8         ret i32 %A
   9 }
  10 ; CHECK-LABEL: define internal i32 @test1a(
  11 ; CHECK: ret i32 undef
  12
  13 define i32 @test1b() {
  14         %X = call i32 @test1a( i32 17 )
  15         ret i32 %X
  16
  17 ; CHECK-LABEL: define i32 @test1b(
  18 ; CHECK: ret i32 17
  19 }
  20
  21
  22
  23 ;;======================== test2
  24
  25 define internal i32 @test2a(i32 %A) {
  26         %C = icmp eq i32 %A, 0
  27         br i1 %C, label %T, label %F
  28 T:
  29         %B = call i32 @test2a( i32 0 )
  30         ret i32 0
  31 F:
  32         %C.upgrd.1 = call i32 @test2a(i32 1)
  33         ret i32 %C.upgrd.1
  34 }
  35 ; CHECK-LABEL: define internal i32 @test2a(
  36 ; CHECK-NEXT: br label %T
  37 ; CHECK: ret i32 undef
  38
  39
  40 define i32 @test2b() {
  41         %X = call i32 @test2a(i32 0)
  42         ret i32 %X
  43 }
  44 ; CHECK-LABEL: define i32 @test2b(
  45 ; CHECK-NEXT: %X = call i32 @test2a(i32 0)
  46 ; CHECK-NEXT: ret i32 0
  47
  48
  49 ;;======================== test3
  50
  51 @G = internal global i32 undef
  52
  53 define void @test3a() {
  54         %X = load i32, i32* @G
  55         store i32 %X, i32* @G
  56         ret void
  57 }
  58 ; CHECK-LABEL: define void @test3a(
  59 ; CHECK-NEXT: ret void
  60
  61
  62 define i32 @test3b() {
  63         %V = load i32, i32* @G
  64         %C = icmp eq i32 %V, 17
  65         br i1 %C, label %T, label %F
  66 T:
  67         store i32 17, i32* @G
  68         ret i32 %V
  69 F:
  70         store i32 123, i32* @G
  71         ret i32 0
  72 }
  73 ; CHECK-LABEL: define i32 @test3b(
  74 ; CHECK-NOT: store
  75 ; CHECK: ret i32 0
  76
  77
  78 ;;======================== test4
  79
  80 define internal {i64,i64} @test4a() {
  81   %a = insertvalue {i64,i64} undef, i64 4, 1
  82   %b = insertvalue {i64,i64} %a, i64 5, 0
  83   ret {i64,i64} %b
  84 }
  85
  86 ; CHECK-LABEL: define internal { i64, i64 } @test4a(
  87 ; CHECK-NEXT:   ret { i64, i64 } undef
  88 ; CHECK-NEXT: }
  89
  90 define i64 @test4b() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
  91   %a = invoke {i64,i64} @test4a()
  92           to label %A unwind label %B
  93 A:
  94   %b = extractvalue {i64,i64} %a, 0
  95   %c = call i64 @test4c(i64 %b)
  96   ret i64 %c
  97 B:
  98   %val = landingpad { i8*, i32 }
  99            catch i8* null
 100   ret i64 0
 101 }
 102 ; CHECK: define i64 @test4b()
 103 ; CHECK:   %c = call i64 @test4c(i64 5)
 104 ; CHECK-NEXT:  ret i64 5
 105
 106
 107 define internal i64 @test4c(i64 %a) {
 108   ret i64 %a
 109 }
 110 ; CHECK-LABEL: define internal i64 @test4c(
 111 ; CHECK: ret i64 undef
 112
 113
 114
 115 ;;======================== test5
 116
 117 ; PR4313
 118 define internal {i64,i64} @test5a() {
 119   %a = insertvalue {i64,i64} undef, i64 4, 1
 120   %b = insertvalue {i64,i64} %a, i64 5, 0
 121   ret {i64,i64} %b
 122 }
 123
 124 define i64 @test5b() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 125   %a = invoke {i64,i64} @test5a()
 126           to label %A unwind label %B
 127 A:
 128   %c = call i64 @test5c({i64,i64} %a)
 129   ret i64 %c
 130 B:
 131   %val = landingpad { i8*, i32 }
 132            catch i8* null
 133   ret i64 0
 134 }
 135
 136 ; CHECK: define i64 @test5b()
 137 ; CHECK:     A:
 138 ; CHECK-NEXT:  %c = call i64 @test5c({ i64, i64 } { i64 5, i64 4 })
 139 ; CHECK-NEXT:  ret i64 5
 140
 141 define internal i64 @test5c({i64,i64} %a) {
 142   %b = extractvalue {i64,i64} %a, 0
 143   ret i64 %b
 144 }
 145
 146
 147 ;;======================== test6
 148
 149 define i64 @test6a() {
 150   ret i64 0
 151 }
 152
 153 define i64 @test6b() {
 154   %a = call i64 @test6a()
 155   ret i64 %a
 156 }
 157 ; CHECK-LABEL: define i64 @test6b(
 158 ; CHECK: ret i64 0
 159
 160 ;;======================== test7
 161
 162
 163 %T = type {i32,i32}
 164
 165 define internal %T @test7a(i32 %A) {
 166   %X = add i32 1, %A
 167   %mrv0 = insertvalue %T undef, i32 %X, 0
 168   %mrv1 = insertvalue %T %mrv0, i32 %A, 1
 169   ret %T %mrv1
 170 ; CHECK-LABEL: @test7a(
 171 ; CHECK-NEXT: ret %T undef
 172 }
 173
 174 define i32 @test7b() {
 175         %X = call %T @test7a(i32 17)
 176         %Y = extractvalue %T %X, 0
 177         %Z = add i32 %Y, %Y
 178         ret i32 %Z
 179 ; CHECK-LABEL: define i32 @test7b(
 180 ; CHECK-NEXT: call %T @test7a(i32 17)
 181 ; CHECK-NEXT: ret i32 36
 182 }
 183
 184 ;;======================== test8
 185
 186
 187 define internal {} @test8a(i32 %A, i32* %P) {
 188   store i32 %A, i32* %P
 189   ret {} {}
 190 ; CHECK-LABEL: @test8a(
 191 ; CHECK-NEXT: store i32 5,
 192 ; CHECK-NEXT: ret
 193 }
 194
 195 define void @test8b(i32* %P) {
 196     %X = call {} @test8a(i32 5, i32* %P)
 197     ret void
 198 ; CHECK-LABEL: define void @test8b(
 199 ; CHECK-NEXT: call {} @test8a
 200 ; CHECK-NEXT: ret void
 201 }
 202
 203 ;;======================== test9
 204
 205 @test9g = internal global {  } zeroinitializer
 206
 207 define void @test9() {
 208 entry:
 209         %local_foo = alloca {  }
 210         load {  }, {  }* @test9g
 211         store {  } %0, {  }* %local_foo
 212         ret void
 213 }
 214
 215 ; CHECK-LABEL: define void @test9(
 216 ; CHECK-NEXT: entry:
 217 ; CHECK-NEXT: %local_foo = alloca {}
 218 ; CHECK-NEXT:  store {} zeroinitializer, {}* %local_foo
 219 ; CHECK-NEXT: ret void
 220
 221 declare i32 @__gxx_personality_v0(...)
 222
 223 ;;======================== test10
 224
 225 define i32 @test10a() nounwind {
 226 entry:
 227   %call = call i32 @test10b(i32 undef)
 228   ret i32 %call
 229 ; CHECK-LABEL: define i32 @test10a(
 230 ; CHECK: ret i32 0
 231 }
 232
 233 define internal i32 @test10b(i32 %x) nounwind {
 234 entry:
 235   %r = and i32 %x, 1
 236   ret i32 %r
 237 ; CHECK-LABEL: define internal i32 @test10b(
 238 ; CHECK: ret i32 undef
 239 }
 240
 241 ;;======================== test11
 242
 243 define i64 @test11a() {
 244   %xor = xor i64 undef, undef
 245   ret i64 %xor
 246 ; CHECK-LABEL: define i64 @test11a
 247 ; CHECK: ret i64 0
 248 }
 249
 250 define i64 @test11b() {
 251   %call1 = call i64 @test11a()
 252   %call2 = call i64 @llvm.ctpop.i64(i64 %call1)
 253   ret i64 %call2
 254 ; CHECK-LABEL: define i64 @test11b
 255 ; CHECK: %[[call1:.*]] = call i64 @test11a()
 256 ; CHECK-NOT: call i64 @llvm.ctpop.i64
 257 ; CHECK-NEXT: ret i64 0
 258 }
 259
 260 declare i64 @llvm.ctpop.i64(i64)
 261
 262 ;;======================== test12
 263 ;; Ensure that a struct as an arg to a potentially constant-foldable
 264 ;; function does not crash SCCP (for now it'll just ignores it)
 265
 266 define i1 @test12() {
 267   %c = call i1 @llvm.is.constant.sl_i32i32s({i32, i32} {i32 -1, i32 32})
 268   ret i1 %c
 269 ; CHECK-LABEL: define i1 @test12
 270 ; CHECK: ret i1 %c
 271 }
 272
 273 declare i1 @llvm.is.constant.sl_i32i32s({i32, i32} %a)