| ; RUN: llc < %s -mtriple=i686-windows | FileCheck %s -check-prefix=NORMAL |
| ; RUN: llc < %s -mtriple=x86_64-windows | FileCheck %s -check-prefix=X64 |
| ; RUN: llc < %s -mtriple=i686-windows -force-align-stack -stack-alignment=32 | FileCheck %s -check-prefix=ALIGNED |
| |
| declare void @good(i32 %a, i32 %b, i32 %c, i32 %d) |
| declare void @inreg(i32 %a, i32 inreg %b, i32 %c, i32 %d) |
| declare void @oneparam(i32 %a) |
| declare void @eightparams(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h) |
| |
| |
| ; Here, we should have a reserved frame, so we don't expect pushes |
| ; NORMAL-LABEL: test1: |
| ; NORMAL: subl $16, %esp |
| ; NORMAL-NEXT: movl $4, 12(%esp) |
| ; NORMAL-NEXT: movl $3, 8(%esp) |
| ; NORMAL-NEXT: movl $2, 4(%esp) |
| ; NORMAL-NEXT: movl $1, (%esp) |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test1() { |
| entry: |
| call void @good(i32 1, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; We're optimizing for code size, so we should get pushes for x86, |
| ; even though there is a reserved call frame. |
| ; Make sure we don't touch x86-64 |
| ; NORMAL-LABEL: test1b: |
| ; NORMAL-NOT: subl {{.*}} %esp |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| ; X64-LABEL: test1b: |
| ; X64: movl $1, %ecx |
| ; X64-NEXT: movl $2, %edx |
| ; X64-NEXT: movl $3, %r8d |
| ; X64-NEXT: movl $4, %r9d |
| ; X64-NEXT: callq good |
| define void @test1b() optsize { |
| entry: |
| call void @good(i32 1, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; Same as above, but for minsize |
| ; NORMAL-LABEL: test1c: |
| ; NORMAL-NOT: subl {{.*}} %esp |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test1c() minsize { |
| entry: |
| call void @good(i32 1, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; If we have a reserved frame, we should have pushes |
| ; NORMAL-LABEL: test2: |
| ; NORMAL-NOT: subl {{.*}} %esp |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: call |
| define void @test2(i32 %k) { |
| entry: |
| %a = alloca i32, i32 %k |
| call void @good(i32 1, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; Again, we expect a sequence of 4 immediate pushes |
| ; Checks that we generate the right pushes for >8bit immediates |
| ; NORMAL-LABEL: test2b: |
| ; NORMAL-NOT: subl {{.*}} %esp |
| ; NORMAL: pushl $4096 |
| ; NORMAL-NEXT: pushl $3072 |
| ; NORMAL-NEXT: pushl $2048 |
| ; NORMAL-NEXT: pushl $1024 |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test2b() optsize { |
| entry: |
| call void @good(i32 1024, i32 2048, i32 3072, i32 4096) |
| ret void |
| } |
| |
| ; The first push should push a register |
| ; NORMAL-LABEL: test3: |
| ; NORMAL-NOT: subl {{.*}} %esp |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl %e{{..}} |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test3(i32 %k) optsize { |
| entry: |
| %f = add i32 %k, 1 |
| call void @good(i32 %f, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; We don't support weird calling conventions |
| ; NORMAL-LABEL: test4: |
| ; NORMAL: subl $12, %esp |
| ; NORMAL-NEXT: movl $4, 8(%esp) |
| ; NORMAL-NEXT: movl $3, 4(%esp) |
| ; NORMAL-NEXT: movl $1, (%esp) |
| ; NORMAL-NEXT: movl $2, %eax |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $12, %esp |
| define void @test4() optsize { |
| entry: |
| call void @inreg(i32 1, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; When there is no reserved call frame, check that additional alignment |
| ; is added when the pushes don't add up to the required alignment. |
| ; ALIGNED-LABEL: test5: |
| ; ALIGNED: subl $16, %esp |
| ; ALIGNED-NEXT: pushl $4 |
| ; ALIGNED-NEXT: pushl $3 |
| ; ALIGNED-NEXT: pushl $2 |
| ; ALIGNED-NEXT: pushl $1 |
| ; ALIGNED-NEXT: call |
| define void @test5(i32 %k) { |
| entry: |
| %a = alloca i32, i32 %k |
| call void @good(i32 1, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; When the alignment adds up, do the transformation |
| ; ALIGNED-LABEL: test5b: |
| ; ALIGNED: pushl $8 |
| ; ALIGNED-NEXT: pushl $7 |
| ; ALIGNED-NEXT: pushl $6 |
| ; ALIGNED-NEXT: pushl $5 |
| ; ALIGNED-NEXT: pushl $4 |
| ; ALIGNED-NEXT: pushl $3 |
| ; ALIGNED-NEXT: pushl $2 |
| ; ALIGNED-NEXT: pushl $1 |
| ; ALIGNED-NEXT: call |
| define void @test5b() optsize { |
| entry: |
| call void @eightparams(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8) |
| ret void |
| } |
| |
| ; When having to compensate for the alignment isn't worth it, |
| ; don't use pushes. |
| ; ALIGNED-LABEL: test5c: |
| ; ALIGNED: movl $1, (%esp) |
| ; ALIGNED-NEXT: call |
| define void @test5c() optsize { |
| entry: |
| call void @oneparam(i32 1) |
| ret void |
| } |
| |
| ; Check that pushing the addresses of globals (Or generally, things that |
| ; aren't exactly immediates) isn't broken. |
| ; Fixes PR21878. |
| ; NORMAL-LABEL: test6: |
| ; NORMAL: pushl $_ext |
| ; NORMAL-NEXT: call |
| declare void @f(i8*) |
| @ext = external constant i8 |
| |
| define void @test6() { |
| call void @f(i8* @ext) |
| br label %bb |
| bb: |
| alloca i32 |
| ret void |
| } |
| |
| ; Check that we fold simple cases into the push |
| ; NORMAL-LABEL: test7: |
| ; NORMAL-NOT: subl {{.*}} %esp |
| ; NORMAL: movl 4(%esp), [[EAX:%e..]] |
| ; NORMAL-NEXT: pushl $4 |
| ; NORMAL-NEXT: pushl ([[EAX]]) |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test7(i32* %ptr) optsize { |
| entry: |
| %val = load i32, i32* %ptr |
| call void @good(i32 1, i32 2, i32 %val, i32 4) |
| ret void |
| } |
| |
| ; Fold stack-relative loads into the push, with correct offset |
| ; In particular, at the second push, %b was at 12(%esp) and |
| ; %a wast at 8(%esp), but the second push bumped %esp, so %a |
| ; is now it at 12(%esp) |
| ; NORMAL-LABEL: test8: |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl 12(%esp) |
| ; NORMAL-NEXT: pushl 12(%esp) |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test8(i32 %a, i32 %b) optsize { |
| entry: |
| call void @good(i32 1, i32 %a, i32 %b, i32 4) |
| ret void |
| } |
| |
| ; If one function is using push instructions, and the other isn't |
| ; (because it has frame-index references), then we must resolve |
| ; these references correctly. |
| ; NORMAL-LABEL: test9: |
| ; NORMAL-NOT: leal (%esp), |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| ; NORMAL-NEXT: subl $16, %esp |
| ; NORMAL-NEXT: leal 16(%esp), [[EAX:%e..]] |
| ; NORMAL-NEXT: movl [[EAX]], 12(%esp) |
| ; NORMAL-NEXT: movl $7, 8(%esp) |
| ; NORMAL-NEXT: movl $6, 4(%esp) |
| ; NORMAL-NEXT: movl $5, (%esp) |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test9() optsize { |
| entry: |
| %p = alloca i32, align 4 |
| call void @good(i32 1, i32 2, i32 3, i32 4) |
| %0 = ptrtoint i32* %p to i32 |
| call void @good(i32 5, i32 6, i32 7, i32 %0) |
| ret void |
| } |
| |
| ; We can end up with an indirect call which gets reloaded on the spot. |
| ; Make sure we reference the correct stack slot - we spill into (%esp) |
| ; and reload from 16(%esp) due to the pushes. |
| ; NORMAL-LABEL: test10: |
| ; NORMAL: movl $_good, [[ALLOC:.*]] |
| ; NORMAL-NEXT: movl [[ALLOC]], [[EAX:%e..]] |
| ; NORMAL-NEXT: movl [[EAX]], (%esp) # 4-byte Spill |
| ; NORMAL: nop |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: calll *16(%esp) |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test10() optsize { |
| %stack_fptr = alloca void (i32, i32, i32, i32)* |
| store void (i32, i32, i32, i32)* @good, void (i32, i32, i32, i32)** %stack_fptr |
| %good_ptr = load volatile void (i32, i32, i32, i32)*, void (i32, i32, i32, i32)** %stack_fptr |
| call void asm sideeffect "nop", "~{ax},~{bx},~{cx},~{dx},~{bp},~{si},~{di}"() |
| call void (i32, i32, i32, i32) %good_ptr(i32 1, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; We can't fold the load from the global into the push because of |
| ; interference from the store |
| ; NORMAL-LABEL: test11: |
| ; NORMAL: movl _the_global, [[EAX:%e..]] |
| ; NORMAL-NEXT: movl $42, _the_global |
| ; NORMAL-NEXT: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl [[EAX]] |
| ; NORMAL-NEXT: call |
| ; NORMAL-NEXT: addl $16, %esp |
| @the_global = external global i32 |
| define void @test11() optsize { |
| %myload = load i32, i32* @the_global |
| store i32 42, i32* @the_global |
| call void @good(i32 %myload, i32 2, i32 3, i32 4) |
| ret void |
| } |
| |
| ; Converting one mov into a push isn't worth it when |
| ; doing so forces too much overhead for other calls. |
| ; NORMAL-LABEL: test12: |
| ; NORMAL: subl $16, %esp |
| ; NORMAL-NEXT: movl $4, 8(%esp) |
| ; NORMAL-NEXT: movl $3, 4(%esp) |
| ; NORMAL-NEXT: movl $1, (%esp) |
| ; NORMAL-NEXT: movl $2, %eax |
| ; NORMAL-NEXT: calll _inreg |
| ; NORMAL-NEXT: movl $8, 12(%esp) |
| ; NORMAL-NEXT: movl $7, 8(%esp) |
| ; NORMAL-NEXT: movl $6, 4(%esp) |
| ; NORMAL-NEXT: movl $5, (%esp) |
| ; NORMAL-NEXT: calll _good |
| ; NORMAL-NEXT: movl $12, 8(%esp) |
| ; NORMAL-NEXT: movl $11, 4(%esp) |
| ; NORMAL-NEXT: movl $9, (%esp) |
| ; NORMAL-NEXT: movl $10, %eax |
| ; NORMAL-NEXT: calll _inreg |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test12() optsize { |
| entry: |
| call void @inreg(i32 1, i32 2, i32 3, i32 4) |
| call void @good(i32 5, i32 6, i32 7, i32 8) |
| call void @inreg(i32 9, i32 10, i32 11, i32 12) |
| ret void |
| } |
| |
| ; But if the gains outweigh the overhead, we should do it |
| ; NORMAL-LABEL: test12b: |
| ; NORMAL: pushl $4 |
| ; NORMAL-NEXT: pushl $3 |
| ; NORMAL-NEXT: pushl $2 |
| ; NORMAL-NEXT: pushl $1 |
| ; NORMAL-NEXT: calll _good |
| ; NORMAL-NEXT: addl $16, %esp |
| ; NORMAL-NEXT: subl $12, %esp |
| ; NORMAL-NEXT: movl $8, 8(%esp) |
| ; NORMAL-NEXT: movl $7, 4(%esp) |
| ; NORMAL-NEXT: movl $5, (%esp) |
| ; NORMAL-NEXT: movl $6, %eax |
| ; NORMAL-NEXT: calll _inreg |
| ; NORMAL-NEXT: addl $12, %esp |
| ; NORMAL-NEXT: pushl $12 |
| ; NORMAL-NEXT: pushl $11 |
| ; NORMAL-NEXT: pushl $10 |
| ; NORMAL-NEXT: pushl $9 |
| ; NORMAL-NEXT: calll _good |
| ; NORMAL-NEXT: addl $16, %esp |
| define void @test12b() optsize { |
| entry: |
| call void @good(i32 1, i32 2, i32 3, i32 4) |
| call void @inreg(i32 5, i32 6, i32 7, i32 8) |
| call void @good(i32 9, i32 10, i32 11, i32 12) |
| ret void |
| } |