Eliminate stack adjustment for float-returning functions

src/IceInstX86Base.h

 //===- subzero/src/IceInstX86Base.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 387 matching lines @@
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Jmp);
   }
 
 private:
   InstX86Jmp(Cfg *Func, Operand *Target);
 };
 
-/// AdjustStack instruction - subtracts esp by the given amount and updates the
-/// stack offset during code emission.
+/// AdjustStack instruction - grows the stack (moves esp down) by the given

[Jim Stichnoth, 2015/11/13 23:30:33]

Optional.  I like your idea of breaking this into two pseudo-instructions, e.g.
GrowStack and ContractStack, which abstracts away the built-in assumption of
which direction the stack grows.

You could probably do this through minor template wizardry:

  template <class Machine>
  template <bool Grow>
  class InstX86AdjustStack ... {
    const uint32_t Amount;
    constexpr bool IsGrow = Grow;
  };

  ...
  using GrowStack = InstX86AdjustStack<Machine><true>;
  using ContractStack = InstX86AdjustStack<Machine><false>;

(Completely untested, but hopefully illustrative.)

[sehr, 2015/11/14 00:30:56]

I like the idea too (obviously), but can't make the template stuff work at the
moment.  I prefer to punt this from this CL.

+/// amount.  If the amount is negative, it shrinks the stack (moves esp up).
+/// It also updates the target lowering StackAdjustment during code emission.
 template <class Machine>
 class InstX86AdjustStack final : public InstX86Base<Machine> {
   InstX86AdjustStack() = delete;
   InstX86AdjustStack(const InstX86AdjustStack &) = delete;
   InstX86AdjustStack &operator=(const InstX86AdjustStack &) = delete;
 
 public:
-  static InstX86AdjustStack *create(Cfg *Func, SizeT Amount, Variable *Esp) {
+  static InstX86AdjustStack *create(Cfg *Func, int32_t Amount, Variable *Esp) {
     return new (Func->allocate<InstX86AdjustStack>())
         InstX86AdjustStack(Func, Amount, Esp);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst,
                                            InstX86Base<Machine>::Adjuststack);
   }
 
 private:
-  InstX86AdjustStack(Cfg *Func, SizeT Amount, Variable *Esp);
-  SizeT Amount;
+  InstX86AdjustStack(Cfg *Func, int32_t Amount, Variable *Esp);
+  int32_t Amount;

[Jim Stichnoth, 2015/11/13 23:30:33]

Oops, this should be const.

[sehr, 2015/11/14 00:30:56]

Done.

 };
 
 /// Call instruction. Arguments should have already been pushed.
 template <class Machine> class InstX86Call final : public InstX86Base<Machine> {
   InstX86Call() = delete;
   InstX86Call(const InstX86Call &) = delete;
   InstX86Call &operator=(const InstX86Call &) = delete;
 
 public:
   static InstX86Call *create(Cfg *Func, Variable *Dest, Operand *CallTarget) {
@@ skipping 2800 matching lines @@
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H