Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison test/CodeGen/WebAssembly/address-offsets.ll @ 120:1172e4bd9c6f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update 4.0.0
author mir3636
date Fri, 25 Nov 2016 19:14:25 +0900
parents 7d135dc70f03
children 803732b1fca8
comparison
equal deleted inserted replaced
101:34baf5011add 120:1172e4bd9c6f
1 ; RUN: llc < %s -asm-verbose=false | FileCheck %s 1 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
2 2
3 ; Test folding constant offsets and symbols into load and store addresses under 3 ; Test folding constant offsets and symbols into load and store addresses under
4 ; a variety of circumstances. 4 ; a variety of circumstances.
5 5
6 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" 6 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
26 define i32 @load_test0_noinbounds() { 26 define i32 @load_test0_noinbounds() {
27 %t = load i32, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4 27 %t = load i32, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
28 ret i32 %t 28 ret i32 %t
29 } 29 }
30 30
31 ; TODO: load_test1 - load_test8 are disabled because folding GA+reg is disabled
32 ; (there are cases where the value in the reg can be negative).
33 ; Likewise for stores.
34
31 ; CHECK-LABEL: load_test1: 35 ; CHECK-LABEL: load_test1:
32 ; CHECK-NEXT: param i32{{$}} 36 ; CHECK-NEXT: param i32{{$}}
33 ; CHECK-NEXT: result i32{{$}} 37 ; CHECK-NEXT: result i32{{$}}
34 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 38 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
35 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 39 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
36 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 40 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
37 ; CHECK-NEXT: return $pop2{{$}} 41 ; CHECK-NEX T: return $pop2{{$}}
38 define i32 @load_test1(i32 %n) { 42 define i32 @load_test1(i32 %n) {
39 %add = add nsw i32 %n, 10 43 %add = add nsw i32 %n, 10
40 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 44 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
41 %t = load i32, i32* %arrayidx, align 4 45 %t = load i32, i32* %arrayidx, align 4
42 ret i32 %t 46 ret i32 %t
44 48
45 ; CHECK-LABEL: load_test2: 49 ; CHECK-LABEL: load_test2:
46 ; CHECK-NEXT: param i32{{$}} 50 ; CHECK-NEXT: param i32{{$}}
47 ; CHECK-NEXT: result i32{{$}} 51 ; CHECK-NEXT: result i32{{$}}
48 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 52 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
49 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 53 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
50 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 54 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
51 ; CHECK-NEXT: return $pop2{{$}} 55 ; CHECK-NEX T: return $pop2{{$}}
52 define i32 @load_test2(i32 %n) { 56 define i32 @load_test2(i32 %n) {
53 %add = add nsw i32 10, %n 57 %add = add nsw i32 10, %n
54 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 58 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
55 %t = load i32, i32* %arrayidx, align 4 59 %t = load i32, i32* %arrayidx, align 4
56 ret i32 %t 60 ret i32 %t
58 62
59 ; CHECK-LABEL: load_test3: 63 ; CHECK-LABEL: load_test3:
60 ; CHECK-NEXT: param i32{{$}} 64 ; CHECK-NEXT: param i32{{$}}
61 ; CHECK-NEXT: result i32{{$}} 65 ; CHECK-NEXT: result i32{{$}}
62 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 66 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
63 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 67 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
64 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 68 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
65 ; CHECK-NEXT: return $pop2{{$}} 69 ; CHECK-NEX T: return $pop2{{$}}
66 define i32 @load_test3(i32 %n) { 70 define i32 @load_test3(i32 %n) {
67 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n 71 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
68 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 72 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
69 %t = load i32, i32* %add.ptr1, align 4 73 %t = load i32, i32* %add.ptr1, align 4
70 ret i32 %t 74 ret i32 %t
72 76
73 ; CHECK-LABEL: load_test4: 77 ; CHECK-LABEL: load_test4:
74 ; CHECK-NEXT: param i32{{$}} 78 ; CHECK-NEXT: param i32{{$}}
75 ; CHECK-NEXT: result i32{{$}} 79 ; CHECK-NEXT: result i32{{$}}
76 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 80 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
77 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 81 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
78 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 82 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
79 ; CHECK-NEXT: return $pop2{{$}} 83 ; CHECK-NEX T: return $pop2{{$}}
80 define i32 @load_test4(i32 %n) { 84 define i32 @load_test4(i32 %n) {
81 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n 85 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
82 %t = load i32, i32* %add.ptr, align 4 86 %t = load i32, i32* %add.ptr, align 4
83 ret i32 %t 87 ret i32 %t
84 } 88 }
85 89
86 ; CHECK-LABEL: load_test5: 90 ; CHECK-LABEL: load_test5:
87 ; CHECK-NEXT: param i32{{$}} 91 ; CHECK-NEXT: param i32{{$}}
88 ; CHECK-NEXT: result i32{{$}} 92 ; CHECK-NEXT: result i32{{$}}
89 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 93 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
90 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 94 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
91 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 95 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
92 ; CHECK-NEXT: return $pop2{{$}} 96 ; CHECK-NEX T: return $pop2{{$}}
93 define i32 @load_test5(i32 %n) { 97 define i32 @load_test5(i32 %n) {
94 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n 98 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
95 %t = load i32, i32* %add.ptr, align 4 99 %t = load i32, i32* %add.ptr, align 4
96 ret i32 %t 100 ret i32 %t
97 } 101 }
98 102
99 ; CHECK-LABEL: load_test6: 103 ; CHECK-LABEL: load_test6:
100 ; CHECK-NEXT: param i32{{$}} 104 ; CHECK-NEXT: param i32{{$}}
101 ; CHECK-NEXT: result i32{{$}} 105 ; CHECK-NEXT: result i32{{$}}
102 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 106 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
103 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 107 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
104 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 108 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
105 ; CHECK-NEXT: return $pop2{{$}} 109 ; CHECK-NEX T: return $pop2{{$}}
106 define i32 @load_test6(i32 %n) { 110 define i32 @load_test6(i32 %n) {
107 %add = add nsw i32 %n, 10 111 %add = add nsw i32 %n, 10
108 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 112 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
109 %t = load i32, i32* %add.ptr, align 4 113 %t = load i32, i32* %add.ptr, align 4
110 ret i32 %t 114 ret i32 %t
112 116
113 ; CHECK-LABEL: load_test7: 117 ; CHECK-LABEL: load_test7:
114 ; CHECK-NEXT: param i32{{$}} 118 ; CHECK-NEXT: param i32{{$}}
115 ; CHECK-NEXT: result i32{{$}} 119 ; CHECK-NEXT: result i32{{$}}
116 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 120 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
117 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 121 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
118 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 122 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
119 ; CHECK-NEXT: return $pop2{{$}} 123 ; CHECK-NEX T: return $pop2{{$}}
120 define i32 @load_test7(i32 %n) { 124 define i32 @load_test7(i32 %n) {
121 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n 125 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
122 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 126 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
123 %t = load i32, i32* %add.ptr1, align 4 127 %t = load i32, i32* %add.ptr1, align 4
124 ret i32 %t 128 ret i32 %t
126 130
127 ; CHECK-LABEL: load_test8: 131 ; CHECK-LABEL: load_test8:
128 ; CHECK-NEXT: param i32{{$}} 132 ; CHECK-NEXT: param i32{{$}}
129 ; CHECK-NEXT: result i32{{$}} 133 ; CHECK-NEXT: result i32{{$}}
130 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 134 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
131 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 135 ; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}}
132 ; CHECK-NEXT: i32.load $push2=, g+40($pop1){{$}} 136 ; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}}
133 ; CHECK-NEXT: return $pop2{{$}} 137 ; CHECK-NEX T: return $pop2{{$}}
134 define i32 @load_test8(i32 %n) { 138 define i32 @load_test8(i32 %n) {
135 %add = add nsw i32 10, %n 139 %add = add nsw i32 10, %n
136 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 140 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
137 %t = load i32, i32* %add.ptr, align 4 141 %t = load i32, i32* %add.ptr, align 4
138 ret i32 %t 142 ret i32 %t
191 ; CHECK-LABEL: load_test12: 195 ; CHECK-LABEL: load_test12:
192 ; CHECK-NEXT: param i32, i32{{$}} 196 ; CHECK-NEXT: param i32, i32{{$}}
193 ; CHECK-NEXT: result i32{{$}} 197 ; CHECK-NEXT: result i32{{$}}
194 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 198 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
195 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 199 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
196 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 200 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
197 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 201 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
198 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 202 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
199 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} 203 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}}
200 ; CHECK-NEXT: return $pop5{{$}} 204 ; CHECK-NEXT: return $pop5{{$}}
201 define i32 @load_test12(i32* %p, i32 %n) { 205 define i32 @load_test12(i32* %p, i32 %n) {
208 ; CHECK-LABEL: load_test13: 212 ; CHECK-LABEL: load_test13:
209 ; CHECK-NEXT: param i32, i32{{$}} 213 ; CHECK-NEXT: param i32, i32{{$}}
210 ; CHECK-NEXT: result i32{{$}} 214 ; CHECK-NEXT: result i32{{$}}
211 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 215 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
212 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 216 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
213 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 217 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
214 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 218 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
215 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 219 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
216 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} 220 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}}
217 ; CHECK-NEXT: return $pop5{{$}} 221 ; CHECK-NEXT: return $pop5{{$}}
218 define i32 @load_test13(i32* %p, i32 %n) { 222 define i32 @load_test13(i32* %p, i32 %n) {
274 ; CHECK-LABEL: load_test17: 278 ; CHECK-LABEL: load_test17:
275 ; CHECK-NEXT: param i32, i32{{$}} 279 ; CHECK-NEXT: param i32, i32{{$}}
276 ; CHECK-NEXT: result i32{{$}} 280 ; CHECK-NEXT: result i32{{$}}
277 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 281 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
278 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 282 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
279 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 283 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
280 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 284 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
281 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 285 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
282 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} 286 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}}
283 ; CHECK-NEXT: return $pop5{{$}} 287 ; CHECK-NEXT: return $pop5{{$}}
284 define i32 @load_test17(i32* %p, i32 %n) { 288 define i32 @load_test17(i32* %p, i32 %n) {
306 ; CHECK-LABEL: load_test19: 310 ; CHECK-LABEL: load_test19:
307 ; CHECK-NEXT: param i32, i32{{$}} 311 ; CHECK-NEXT: param i32, i32{{$}}
308 ; CHECK-NEXT: result i32{{$}} 312 ; CHECK-NEXT: result i32{{$}}
309 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 313 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
310 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 314 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
311 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 315 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
312 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 316 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
313 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 317 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
314 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} 318 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}}
315 ; CHECK-NEXT: return $pop5{{$}} 319 ; CHECK-NEXT: return $pop5{{$}}
316 define i32 @load_test19(i32* %p, i32 %n) { 320 define i32 @load_test19(i32* %p, i32 %n) {
336 ; CHECK-LABEL: load_test21: 340 ; CHECK-LABEL: load_test21:
337 ; CHECK-NEXT: param i32, i32{{$}} 341 ; CHECK-NEXT: param i32, i32{{$}}
338 ; CHECK-NEXT: result i32{{$}} 342 ; CHECK-NEXT: result i32{{$}}
339 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 343 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
340 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 344 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
341 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 345 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
342 ; CHECK-NEXT: i32.const $push3=, -40{{$}} 346 ; CHECK-NEXT: i32.const $push3=, -40{{$}}
343 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 347 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
344 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} 348 ; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}}
345 ; CHECK-NEXT: return $pop5{{$}} 349 ; CHECK-NEXT: return $pop5{{$}}
346 define i32 @load_test21(i32* %p, i32 %n) { 350 define i32 @load_test21(i32* %p, i32 %n) {
351 } 355 }
352 356
353 ; CHECK-LABEL: store_test0: 357 ; CHECK-LABEL: store_test0:
354 ; CHECK-NEXT: param i32{{$}} 358 ; CHECK-NEXT: param i32{{$}}
355 ; CHECK-NEXT: i32.const $push0=, 0{{$}} 359 ; CHECK-NEXT: i32.const $push0=, 0{{$}}
356 ; CHECK-NEXT: i32.store $discard=, g+40($pop0), $0{{$}} 360 ; CHECK-NEXT: i32.store g+40($pop0), $0{{$}}
357 ; CHECK-NEXT: return{{$}} 361 ; CHECK-NEXT: return{{$}}
358 define void @store_test0(i32 %i) { 362 define void @store_test0(i32 %i) {
359 store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4 363 store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
360 ret void 364 ret void
361 } 365 }
362 366
363 ; CHECK-LABEL: store_test0_noinbounds: 367 ; CHECK-LABEL: store_test0_noinbounds:
364 ; CHECK-NEXT: param i32{{$}} 368 ; CHECK-NEXT: param i32{{$}}
365 ; CHECK-NEXT: i32.const $push0=, 0{{$}} 369 ; CHECK-NEXT: i32.const $push0=, 0{{$}}
366 ; CHECK-NEXT: i32.store $discard=, g+40($pop0), $0{{$}} 370 ; CHECK-NEXT: i32.store g+40($pop0), $0{{$}}
367 ; CHECK-NEXT: return{{$}} 371 ; CHECK-NEXT: return{{$}}
368 define void @store_test0_noinbounds(i32 %i) { 372 define void @store_test0_noinbounds(i32 %i) {
369 store i32 %i, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4 373 store i32 %i, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
370 ret void 374 ret void
371 } 375 }
372 376
373 ; CHECK-LABEL: store_test1: 377 ; CHECK-LABEL: store_test1:
374 ; CHECK-NEXT: param i32, i32{{$}} 378 ; CHECK-NEXT: param i32, i32{{$}}
375 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 379 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
376 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 380 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
377 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 381 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
378 ; CHECK-NEXT: return{{$}} 382 ; CHECK-NEX T: return{{$}}
379 define void @store_test1(i32 %n, i32 %i) { 383 define void @store_test1(i32 %n, i32 %i) {
380 %add = add nsw i32 %n, 10 384 %add = add nsw i32 %n, 10
381 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 385 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
382 store i32 %i, i32* %arrayidx, align 4 386 store i32 %i, i32* %arrayidx, align 4
383 ret void 387 ret void
385 389
386 ; CHECK-LABEL: store_test2: 390 ; CHECK-LABEL: store_test2:
387 ; CHECK-NEXT: param i32, i32{{$}} 391 ; CHECK-NEXT: param i32, i32{{$}}
388 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 392 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
389 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 393 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
390 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 394 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
391 ; CHECK-NEXT: return{{$}} 395 ; CHECK-NEX T: return{{$}}
392 define void @store_test2(i32 %n, i32 %i) { 396 define void @store_test2(i32 %n, i32 %i) {
393 %add = add nsw i32 10, %n 397 %add = add nsw i32 10, %n
394 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 398 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
395 store i32 %i, i32* %arrayidx, align 4 399 store i32 %i, i32* %arrayidx, align 4
396 ret void 400 ret void
398 402
399 ; CHECK-LABEL: store_test3: 403 ; CHECK-LABEL: store_test3:
400 ; CHECK-NEXT: param i32, i32{{$}} 404 ; CHECK-NEXT: param i32, i32{{$}}
401 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 405 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
402 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 406 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
403 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 407 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
404 ; CHECK-NEXT: return{{$}} 408 ; CHECK-NEX T: return{{$}}
405 define void @store_test3(i32 %n, i32 %i) { 409 define void @store_test3(i32 %n, i32 %i) {
406 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n 410 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
407 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 411 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
408 store i32 %i, i32* %add.ptr1, align 4 412 store i32 %i, i32* %add.ptr1, align 4
409 ret void 413 ret void
411 415
412 ; CHECK-LABEL: store_test4: 416 ; CHECK-LABEL: store_test4:
413 ; CHECK-NEXT: param i32, i32{{$}} 417 ; CHECK-NEXT: param i32, i32{{$}}
414 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 418 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
415 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 419 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
416 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 420 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
417 ; CHECK-NEXT: return{{$}} 421 ; CHECK-NEX T: return{{$}}
418 define void @store_test4(i32 %n, i32 %i) { 422 define void @store_test4(i32 %n, i32 %i) {
419 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n 423 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
420 store i32 %i, i32* %add.ptr, align 4 424 store i32 %i, i32* %add.ptr, align 4
421 ret void 425 ret void
422 } 426 }
423 427
424 ; CHECK-LABEL: store_test5: 428 ; CHECK-LABEL: store_test5:
425 ; CHECK-NEXT: param i32, i32{{$}} 429 ; CHECK-NEXT: param i32, i32{{$}}
426 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 430 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
427 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 431 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
428 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 432 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
429 ; CHECK-NEXT: return{{$}} 433 ; CHECK-NEX T: return{{$}}
430 define void @store_test5(i32 %n, i32 %i) { 434 define void @store_test5(i32 %n, i32 %i) {
431 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n 435 %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
432 store i32 %i, i32* %add.ptr, align 4 436 store i32 %i, i32* %add.ptr, align 4
433 ret void 437 ret void
434 } 438 }
435 439
436 ; CHECK-LABEL: store_test6: 440 ; CHECK-LABEL: store_test6:
437 ; CHECK-NEXT: param i32, i32{{$}} 441 ; CHECK-NEXT: param i32, i32{{$}}
438 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 442 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
439 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 443 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
440 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 444 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
441 ; CHECK-NEXT: return{{$}} 445 ; CHECK-NEX T: return{{$}}
442 define void @store_test6(i32 %n, i32 %i) { 446 define void @store_test6(i32 %n, i32 %i) {
443 %add = add nsw i32 %n, 10 447 %add = add nsw i32 %n, 10
444 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 448 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
445 store i32 %i, i32* %add.ptr, align 4 449 store i32 %i, i32* %add.ptr, align 4
446 ret void 450 ret void
448 452
449 ; CHECK-LABEL: store_test7: 453 ; CHECK-LABEL: store_test7:
450 ; CHECK-NEXT: param i32, i32{{$}} 454 ; CHECK-NEXT: param i32, i32{{$}}
451 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 455 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
452 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 456 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
453 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 457 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
454 ; CHECK-NEXT: return{{$}} 458 ; CHECK-NEX T: return{{$}}
455 define void @store_test7(i32 %n, i32 %i) { 459 define void @store_test7(i32 %n, i32 %i) {
456 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n 460 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
457 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 461 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
458 store i32 %i, i32* %add.ptr1, align 4 462 store i32 %i, i32* %add.ptr1, align 4
459 ret void 463 ret void
461 465
462 ; CHECK-LABEL: store_test8: 466 ; CHECK-LABEL: store_test8:
463 ; CHECK-NEXT: param i32, i32{{$}} 467 ; CHECK-NEXT: param i32, i32{{$}}
464 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 468 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
465 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 469 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
466 ; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}} 470 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
467 ; CHECK-NEXT: return{{$}} 471 ; CHECK-NEX T: return{{$}}
468 define void @store_test8(i32 %n, i32 %i) { 472 define void @store_test8(i32 %n, i32 %i) {
469 %add = add nsw i32 10, %n 473 %add = add nsw i32 10, %n
470 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 474 %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
471 store i32 %i, i32* %add.ptr, align 4 475 store i32 %i, i32* %add.ptr, align 4
472 ret void 476 ret void
473 } 477 }
474 478
475 ; CHECK-LABEL: store_test9: 479 ; CHECK-LABEL: store_test9:
476 ; CHECK-NEXT: param i32{{$}} 480 ; CHECK-NEXT: param i32{{$}}
477 ; CHECK-NEXT: i32.const $push0=, 0{{$}} 481 ; CHECK-NEXT: i32.const $push0=, 0{{$}}
478 ; CHECK-NEXT: i32.store $discard=, g-40($pop0), $0{{$}} 482 ; CHECK-NEXT: i32.store g-40($pop0), $0{{$}}
479 ; CHECK-NEXT: return{{$}} 483 ; CHECK-NEXT: return{{$}}
480 define void @store_test9(i32 %i) { 484 define void @store_test9(i32 %i) {
481 store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4 485 store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4
482 ret void 486 ret void
483 } 487 }
486 ; CHECK-NEXT: param i32, i32{{$}} 490 ; CHECK-NEXT: param i32, i32{{$}}
487 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 491 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
488 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} 492 ; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}}
489 ; CHECK-NEXT: i32.const $push2=, g-40{{$}} 493 ; CHECK-NEXT: i32.const $push2=, g-40{{$}}
490 ; CHECK-NEXT: i32.add $push3=, $pop1, $pop2{{$}} 494 ; CHECK-NEXT: i32.add $push3=, $pop1, $pop2{{$}}
491 ; CHECK-NEXT: i32.store $discard=, 0($pop3), $1{{$}} 495 ; CHECK-NEXT: i32.store 0($pop3), $1{{$}}
492 ; CHECK-NEXT: return{{$}} 496 ; CHECK-NEXT: return{{$}}
493 define void @store_test10(i32 %n, i32 %i) { 497 define void @store_test10(i32 %n, i32 %i) {
494 %add = add nsw i32 %n, -10 498 %add = add nsw i32 %n, -10
495 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add 499 %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
496 store i32 %i, i32* %arrayidx, align 4 500 store i32 %i, i32* %arrayidx, align 4
497 ret void 501 ret void
498 } 502 }
499 503
500 ; CHECK-LABEL: store_test11: 504 ; CHECK-LABEL: store_test11:
501 ; CHECK-NEXT: param i32, i32{{$}} 505 ; CHECK-NEXT: param i32, i32{{$}}
502 ; CHECK-NEXT: i32.store $discard=, 40($0), $1{{$}} 506 ; CHECK-NEXT: i32.store 40($0), $1{{$}}
503 ; CHECK-NEXT: return{{$}} 507 ; CHECK-NEXT: return{{$}}
504 define void @store_test11(i32* %p, i32 %i) { 508 define void @store_test11(i32* %p, i32 %i) {
505 %arrayidx = getelementptr inbounds i32, i32* %p, i32 10 509 %arrayidx = getelementptr inbounds i32, i32* %p, i32 10
506 store i32 %i, i32* %arrayidx, align 4 510 store i32 %i, i32* %arrayidx, align 4
507 ret void 511 ret void
509 513
510 ; CHECK-LABEL: store_test11_noinbounds: 514 ; CHECK-LABEL: store_test11_noinbounds:
511 ; CHECK-NEXT: param i32, i32{{$}} 515 ; CHECK-NEXT: param i32, i32{{$}}
512 ; CHECK-NEXT: i32.const $push0=, 40{{$}} 516 ; CHECK-NEXT: i32.const $push0=, 40{{$}}
513 ; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}} 517 ; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}}
514 ; CHECK-NEXT: i32.store $discard=, 0($pop1), $1{{$}} 518 ; CHECK-NEXT: i32.store 0($pop1), $1{{$}}
515 ; CHECK-NEXT: return{{$}} 519 ; CHECK-NEXT: return{{$}}
516 define void @store_test11_noinbounds(i32* %p, i32 %i) { 520 define void @store_test11_noinbounds(i32* %p, i32 %i) {
517 %arrayidx = getelementptr i32, i32* %p, i32 10 521 %arrayidx = getelementptr i32, i32* %p, i32 10
518 store i32 %i, i32* %arrayidx, align 4 522 store i32 %i, i32* %arrayidx, align 4
519 ret void 523 ret void
521 525
522 ; CHECK-LABEL: store_test12: 526 ; CHECK-LABEL: store_test12:
523 ; CHECK-NEXT: param i32, i32, i32{{$}} 527 ; CHECK-NEXT: param i32, i32, i32{{$}}
524 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 528 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
525 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 529 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
526 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 530 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
527 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 531 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
528 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 532 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
529 ; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}} 533 ; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
530 ; CHECK-NEXT: return{{$}} 534 ; CHECK-NEXT: return{{$}}
531 define void @store_test12(i32* %p, i32 %n, i32 %i) { 535 define void @store_test12(i32* %p, i32 %n, i32 %i) {
532 %add = add nsw i32 %n, 10 536 %add = add nsw i32 %n, 10
533 %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add 537 %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
534 store i32 %i, i32* %arrayidx, align 4 538 store i32 %i, i32* %arrayidx, align 4
537 541
538 ; CHECK-LABEL: store_test13: 542 ; CHECK-LABEL: store_test13:
539 ; CHECK-NEXT: param i32, i32, i32{{$}} 543 ; CHECK-NEXT: param i32, i32, i32{{$}}
540 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 544 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
541 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 545 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
542 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 546 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
543 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 547 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
544 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 548 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
545 ; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}} 549 ; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
546 ; CHECK-NEXT: return{{$}} 550 ; CHECK-NEXT: return{{$}}
547 define void @store_test13(i32* %p, i32 %n, i32 %i) { 551 define void @store_test13(i32* %p, i32 %n, i32 %i) {
548 %add = add nsw i32 10, %n 552 %add = add nsw i32 10, %n
549 %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add 553 %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
550 store i32 %i, i32* %arrayidx, align 4 554 store i32 %i, i32* %arrayidx, align 4
554 ; CHECK-LABEL: store_test14: 558 ; CHECK-LABEL: store_test14:
555 ; CHECK-NEXT: param i32, i32, i32{{$}} 559 ; CHECK-NEXT: param i32, i32, i32{{$}}
556 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 560 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
557 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 561 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
558 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} 562 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
559 ; CHECK-NEXT: i32.store $discard=, 40($pop2), $2{{$}} 563 ; CHECK-NEXT: i32.store 40($pop2), $2{{$}}
560 ; CHECK-NEXT: return{{$}} 564 ; CHECK-NEXT: return{{$}}
561 define void @store_test14(i32* %p, i32 %n, i32 %i) { 565 define void @store_test14(i32* %p, i32 %n, i32 %i) {
562 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n 566 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
563 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 567 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
564 store i32 %i, i32* %add.ptr1, align 4 568 store i32 %i, i32* %add.ptr1, align 4
570 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 574 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
571 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 575 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
572 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} 576 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
573 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 577 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
574 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 578 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
575 ; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}} 579 ; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
576 ; CHECK-NEXT: return{{$}} 580 ; CHECK-NEXT: return{{$}}
577 define void @store_test15(i32* %p, i32 %n, i32 %i) { 581 define void @store_test15(i32* %p, i32 %n, i32 %i) {
578 %add.ptr = getelementptr inbounds i32, i32* %p, i32 10 582 %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
579 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n 583 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
580 store i32 %i, i32* %add.ptr1, align 4 584 store i32 %i, i32* %add.ptr1, align 4
586 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 590 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
587 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 591 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
588 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} 592 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
589 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 593 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
590 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 594 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
591 ; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}} 595 ; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
592 ; CHECK-NEXT: return{{$}} 596 ; CHECK-NEXT: return{{$}}
593 define void @store_test16(i32* %p, i32 %n, i32 %i) { 597 define void @store_test16(i32* %p, i32 %n, i32 %i) {
594 %add.ptr = getelementptr inbounds i32, i32* %p, i32 10 598 %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
595 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n 599 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
596 store i32 %i, i32* %add.ptr1, align 4 600 store i32 %i, i32* %add.ptr1, align 4
599 603
600 ; CHECK-LABEL: store_test17: 604 ; CHECK-LABEL: store_test17:
601 ; CHECK-NEXT: param i32, i32, i32{{$}} 605 ; CHECK-NEXT: param i32, i32, i32{{$}}
602 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 606 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
603 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 607 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
604 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 608 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
605 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 609 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
606 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 610 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
607 ; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}} 611 ; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
608 ; CHECK-NEXT: return{{$}} 612 ; CHECK-NEXT: return{{$}}
609 define void @store_test17(i32* %p, i32 %n, i32 %i) { 613 define void @store_test17(i32* %p, i32 %n, i32 %i) {
610 %add = add nsw i32 %n, 10 614 %add = add nsw i32 %n, 10
611 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add 615 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
612 store i32 %i, i32* %add.ptr, align 4 616 store i32 %i, i32* %add.ptr, align 4
616 ; CHECK-LABEL: store_test18: 620 ; CHECK-LABEL: store_test18:
617 ; CHECK-NEXT: param i32, i32, i32{{$}} 621 ; CHECK-NEXT: param i32, i32, i32{{$}}
618 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 622 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
619 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 623 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
620 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} 624 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
621 ; CHECK-NEXT: i32.store $discard=, 40($pop2), $2{{$}} 625 ; CHECK-NEXT: i32.store 40($pop2), $2{{$}}
622 ; CHECK-NEXT: return{{$}} 626 ; CHECK-NEXT: return{{$}}
623 define void @store_test18(i32* %p, i32 %n, i32 %i) { 627 define void @store_test18(i32* %p, i32 %n, i32 %i) {
624 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n 628 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
625 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 629 %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
626 store i32 %i, i32* %add.ptr1, align 4 630 store i32 %i, i32* %add.ptr1, align 4
629 633
630 ; CHECK-LABEL: store_test19: 634 ; CHECK-LABEL: store_test19:
631 ; CHECK-NEXT: param i32, i32, i32{{$}} 635 ; CHECK-NEXT: param i32, i32, i32{{$}}
632 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 636 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
633 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 637 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
634 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 638 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
635 ; CHECK-NEXT: i32.const $push3=, 40{{$}} 639 ; CHECK-NEXT: i32.const $push3=, 40{{$}}
636 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 640 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
637 ; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}} 641 ; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
638 ; CHECK-NEXT: return{{$}} 642 ; CHECK-NEXT: return{{$}}
639 define void @store_test19(i32* %p, i32 %n, i32 %i) { 643 define void @store_test19(i32* %p, i32 %n, i32 %i) {
640 %add = add nsw i32 10, %n 644 %add = add nsw i32 10, %n
641 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add 645 %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
642 store i32 %i, i32* %add.ptr, align 4 646 store i32 %i, i32* %add.ptr, align 4
645 649
646 ; CHECK-LABEL: store_test20: 650 ; CHECK-LABEL: store_test20:
647 ; CHECK-NEXT: param i32, i32{{$}} 651 ; CHECK-NEXT: param i32, i32{{$}}
648 ; CHECK-NEXT: i32.const $push0=, -40{{$}} 652 ; CHECK-NEXT: i32.const $push0=, -40{{$}}
649 ; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}} 653 ; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}}
650 ; CHECK-NEXT: i32.store $discard=, 0($pop1), $1{{$}} 654 ; CHECK-NEXT: i32.store 0($pop1), $1{{$}}
651 ; CHECK-NEXT: return{{$}} 655 ; CHECK-NEXT: return{{$}}
652 define void @store_test20(i32* %p, i32 %i) { 656 define void @store_test20(i32* %p, i32 %i) {
653 %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10 657 %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10
654 store i32 %i, i32* %arrayidx, align 4 658 store i32 %i, i32* %arrayidx, align 4
655 ret void 659 ret void
657 661
658 ; CHECK-LABEL: store_test21: 662 ; CHECK-LABEL: store_test21:
659 ; CHECK-NEXT: param i32, i32, i32{{$}} 663 ; CHECK-NEXT: param i32, i32, i32{{$}}
660 ; CHECK-NEXT: i32.const $push0=, 2{{$}} 664 ; CHECK-NEXT: i32.const $push0=, 2{{$}}
661 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} 665 ; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}}
662 ; CHECK-NEXT: i32.add $push2=, $pop1, $0{{$}} 666 ; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}}
663 ; CHECK-NEXT: i32.const $push3=, -40{{$}} 667 ; CHECK-NEXT: i32.const $push3=, -40{{$}}
664 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} 668 ; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
665 ; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}} 669 ; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
666 ; CHECK-NEXT: return{{$}} 670 ; CHECK-NEXT: return{{$}}
667 define void @store_test21(i32* %p, i32 %n, i32 %i) { 671 define void @store_test21(i32* %p, i32 %n, i32 %i) {
668 %add = add nsw i32 %n, -10 672 %add = add nsw i32 %n, -10
669 %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add 673 %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
670 store i32 %i, i32* %arrayidx, align 4 674 store i32 %i, i32* %arrayidx, align 4