Don't optimize movs to pushes in -O0 builds.

[thakis]

Summary

X86CallFrameOptimization is an optimization, so it shouldn't run as part of -O0. (Also, the fast-isel + X86CallFrameOptimization frames confuse lldb.)

[labath]

thanks

[rnk]

lgtm

[thakis]

275431, thanks!

lib/Target/X86/X86TargetMachine.cpp

if (TT.isOSWindows() && TT.getArch() == Triple::x86)
     addPass(createX86WinEHStatePass());
   return true;
 }
 
 void X86PassConfig::addPreRegAlloc() {
   if (getOptLevel() != CodeGenOpt::None) {
     addPass(createX86FixupSetCC());
     addPass(createX86OptimizeLEAs());
+    addPass(createX86CallFrameOptimization());
   }
 
-  addPass(createX86CallFrameOptimization());
   addPass(createX86WinAllocaExpander());
 }
 
 void X86PassConfig::addPostRegAlloc() {
   addPass(createX86FloatingPointStackifierPass());
 }
 
 void X86PassConfig::addPreSched2() { addPass(createX86ExpandPseudoPass()); }

test/CodeGen/X86/fast-isel-call.ll

 declare zeroext i1 @foo()  nounwind
 
 declare void @foo2(%struct.s* byval)
 
 define void @test2(%struct.s* %d) nounwind {
   call void @foo2(%struct.s* byval %d )
   ret void
 ; CHECK-LABEL: test2:
-; CHECK: movl (%eax), %[[reg1:e[a-d]x]]
-; CHECK: movl 4(%eax), %[[reg2:e[a-d]x]]
-; CHECK: movl 8(%eax), %[[reg3:e[a-d]x]]
-; CHECK: pushl %[[reg3]]
-; CHECK: pushl %[[reg2]]
-; CHECK: pushl %[[reg1]]
+; CHECK: movl (%eax), %ecx
+; CHECK: movl %ecx, (%esp)
+; CHECK: movl 4(%eax), %ecx
+; CHECK: movl %ecx, 4(%esp)
+; CHECK: movl 8(%eax), %eax
+; CHECK: movl %eax, 8(%esp)
 }
 
 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
 
 define void @test3(i8* %a) {
   call void @llvm.memset.p0i8.i32(i8* %a, i8 0, i32 100, i32 1, i1 false)
   ret void
 ; CHECK-LABEL: test3:

test/CodeGen/X86/win32_sret.ll

 ; LINUX-LABEL:      {{^}}call_foo5:
 
 
 ; Load the address of the result and put it onto stack
 ; The this pointer goes to ECX.
 ; (through %ecx in the -O0 build).
 ; WIN32:      leal {{[0-9]*}}(%esp), %e{{[a-d]}}x
 ; WIN32:      leal {{[0-9]*}}(%esp), %ecx
-; WIN32:      pushl %e{{[a-d]}}x
+; WIN32:      {{pushl %e[a-d]x|movl %e[a-d]x, \(%esp\)}}
 ; WIN32-NEXT: calll "?foo@C5@@QAE?AUS5@@XZ"
 ; WIN32:      retl
   ret void
 }
 
 
 %struct.test6 = type { i32, i32, i32 }
 define void @test6_f(%struct.test6* %x) nounwind {
 ; WIN32-LABEL: _test6_f:
 ; MINGW_X86-LABEL: _test6_f:
 ; CYGWIN-LABEL: _test6_f:
 ; LINUX-LABEL: test6_f:
 
 ; The %x argument is moved to %ecx. It will be the this pointer.
-; WIN32: movl    16(%esp), %ecx
+; WIN32: movl    {{16|20}}(%esp), %ecx
 
 
 ; The sret pointer is (%esp)
-; WIN32:          leal    (%esp), %[[REG:e[a-d]x]]
-; WIN32-NEXT:     pushl   %[[REG]]
+; WIN32:          leal    {{4?}}(%esp), %eax
+; WIN32-NEXT:     {{pushl   %eax|movl %eax, \(%esp\)}}
 
 ; The sret pointer is %ecx
 ; The %x argument is moved to (%esp). It will be the this pointer.
-; MINGW_X86:      leal    (%esp), %ecx
-; MINGW_X86-NEXT: pushl   16(%esp)
+; MINGW_X86:      leal    {{4?}}(%esp), %ecx
+; MINGW_X86-NEXT: {{pushl   16\(%esp\)|movl %eax, \(%esp\)}}
 ; MINGW_X86-NEXT: calll   _test6_g
 
-; CYGWIN:      leal    (%esp), %ecx
-; CYGWIN-NEXT: pushl   16(%esp)
+; CYGWIN:      leal    {{4?}}(%esp), %ecx
+; CYGWIN-NEXT: {{pushl   16\(%esp\)|movl %eax, \(%esp\)}}
 ; CYGWIN-NEXT: calll   _test6_g
 
   %tmp = alloca %struct.test6, align 4
   call x86_thiscallcc void @test6_g(%struct.test6* sret %tmp, %struct.test6* %x)
   ret void
 }
 declare x86_thiscallcc void @test6_g(%struct.test6* sret, %struct.test6*)
 
 ; Flipping the parameters at the IR level generates the same code.
 %struct.test7 = type { i32, i32, i32 }
 define void @test7_f(%struct.test7* %x) nounwind {
 ; WIN32-LABEL: _test7_f:
 ; MINGW_X86-LABEL: _test7_f:
 ; CYGWIN-LABEL: _test7_f:
 ; LINUX-LABEL: test7_f:
 
 ; The %x argument is moved to %ecx on all OSs. It will be the this pointer.
-; WIN32:      movl    16(%esp), %ecx
-; MINGW_X86:  movl    16(%esp), %ecx
-; CYGWIN:     movl    16(%esp), %ecx
+; WIN32:      movl    {{16|20}}(%esp), %ecx
+; MINGW_X86:  movl    {{16|20}}(%esp), %ecx
+; CYGWIN:     movl    {{16|20}}(%esp), %ecx
 
 ; The sret pointer is (%esp)
-; WIN32:          leal    (%esp), %[[REG:e[a-d]x]]
-; WIN32-NEXT:     pushl   %[[REG]]
-; MINGW_X86:      leal    (%esp), %[[REG:e[a-d]x]]
-; MINGW_X86-NEXT: pushl   %[[REG]]
-; CYGWIN:         leal    (%esp), %[[REG:e[a-d]x]]
-; CYGWIN-NEXT:    pushl   %[[REG]]
+; WIN32:          leal    {{4?}}(%esp), %eax
+; WIN32-NEXT:     {{pushl   %eax|movl %eax, \(%esp\)}}
+; MINGW_X86:      leal    {{4?}}(%esp), %eax
+; MINGW_X86-NEXT: {{pushl   %eax|movl %eax, \(%esp\)}}
+; CYGWIN:         leal    {{4?}}(%esp), %eax
+; CYGWIN-NEXT: {{pushl   %eax|movl %eax, \(%esp\)}}
 
   %tmp = alloca %struct.test7, align 4
   call x86_thiscallcc void @test7_g(%struct.test7* %x, %struct.test7* sret %tmp)
   ret void
 }
 
 define x86_thiscallcc void @test7_g(%struct.test7* %in, %struct.test7* sret %out) {
   %s = getelementptr %struct.test7, %struct.test7* %in, i32 0, i32 0