Reserve space for scalar FP returns in the stack frame

src/IceInstX86BaseImpl.h

 //===- subzero/src/IceInstX86BaseImpl.h - Generic X86 instructions -*- C++ -*=//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 2529 matching lines @@
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "nop (variant = " << Variant << ")";
 }
 
 template <class Machine> void InstX86Fld<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   Type Ty = this->getSrc(0)->getType();
-  SizeT Width = typeWidthInBytes(Ty);
   const auto *Var = llvm::dyn_cast<Variable>(this->getSrc(0));
   if (Var && Var->hasReg()) {
     // This is a physical xmm register, so we need to spill it to a temporary
-    // stack slot.
-    Str << "\tsubl\t$" << Width << ", %esp"
-        << "\n";
+    // stack slot.  Function prolog emission guarantees that there is sufficient
+    // space to do this.
     Str << "\tmov"
         << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString << "\t";
     Var->emit(Func);
     Str << ", (%esp)\n";
     Str << "\tfld" << this->getFldString(Ty) << "\t"
-        << "(%esp)\n";
-    Str << "\taddl\t$" << Width << ", %esp";
+        << "(%esp)";
     return;
   }
   Str << "\tfld" << this->getFldString(Ty) << "\t";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Fld<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 1);
   const Operand *Src = this->getSrc(0);
   auto *Target = InstX86Base<Machine>::getTarget(Func);
   Type Ty = Src->getType();
   if (const auto *Var = llvm::dyn_cast<Variable>(Src)) {
     if (Var->hasReg()) {
       // This is a physical xmm register, so we need to spill it to a temporary
-      // stack slot.
-      Immediate Width(typeWidthInBytes(Ty));
-      Asm->sub(IceType_i32,
-               InstX86Base<Machine>::Traits::RegisterSet::Encoded_Reg_esp,
-               Width);
+      // stack slot.  Function prolog emission guarantees that there is
+      // sufficient space to do this.
       typename InstX86Base<Machine>::Traits::Address StackSlot =
           typename InstX86Base<Machine>::Traits::Address(
               InstX86Base<Machine>::Traits::RegisterSet::Encoded_Reg_esp, 0,
               AssemblerFixup::NoFixup);
       Asm->movss(Ty, StackSlot,
                  InstX86Base<Machine>::Traits::getEncodedXmm(Var->getRegNum()));
       Asm->fld(Ty, StackSlot);
-      Asm->add(IceType_i32,
-               InstX86Base<Machine>::Traits::RegisterSet::Encoded_Reg_esp,
-               Width);
     } else {
       typename InstX86Base<Machine>::Traits::Address StackAddr(
           Target->stackVarToAsmOperand(Var));
       Asm->fld(Ty, StackAddr);
     }
   } else if (const auto *Mem = llvm::dyn_cast<
                  typename InstX86Base<Machine>::Traits::X86OperandMem>(Src)) {
     assert(Mem->getSegmentRegister() ==
            InstX86Base<Machine>::Traits::X86OperandMem::DefaultSegment);
     Asm->fld(Ty, Mem->toAsmAddress(Asm, Target));
@@ skipping 33 matching lines @@
   }
   // Dest is a physical (xmm) register, so st(0) needs to go through memory.
   // Hack this by using caller-reserved memory at the top of stack, spilling
   // st(0) there, and loading it into the xmm register.
   Str << "\tfstp" << this->getFldString(Ty) << "\t"
       << "(%esp)\n";
   Str << "\tmov" << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString
       << "\t"
       << "(%esp), ";
   this->getDest()->emit(Func);
-  Str << "\n";
 }
 
 template <class Machine>
 void InstX86Fstp<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 0);
   const Variable *Dest = this->getDest();
   // TODO(jvoung,stichnot): Utilize this by setting Dest to nullptr to
   // "partially" delete the fstp if the Dest is unused. Even if Dest is unused,
@@ skipping 584 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "IACA_END";
 }
 
 } // end of namespace X86Internal
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX86BASEIMPL_H