Unify alloca, outgoing arg, and prolog construction

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 - grows the stack (moves esp down) by the given
-/// 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, 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, int32_t Amount, Variable *Esp);
-  const int32_t Amount;
-};
-
 /// 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) {
     return new (Func->allocate<InstX86Call>())
         InstX86Call(Func, Dest, CallTarget);
@@ skipping 2339 matching lines @@
 };
 
 /// struct Insts is a template that can be used to instantiate all the X86
 /// instructions for a target with a simple
 ///
 /// using Insts = ::Ice::X86Internal::Insts<TargeT>;
 template <class Machine> struct Insts {
   using FakeRMW = InstX86FakeRMW<Machine>;
   using Label = InstX86Label<Machine>;
 
-  using AdjustStack = InstX86AdjustStack<Machine>;
   using Call = InstX86Call<Machine>;
 
   using Br = InstX86Br<Machine>;
   using Jmp = InstX86Jmp<Machine>;
   using Bswap = InstX86Bswap<Machine>;
   using Neg = InstX86Neg<Machine>;
   using Bsf = InstX86Bsf<Machine>;
   using Bsr = InstX86Bsr<Machine>;
   using Lea = InstX86Lea<Machine>;
   using Cbwdq = InstX86Cbwdq<Machine>;
@@ skipping 438 matching lines @@
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H