Suzero. X8664. NaCl Sandboxing.

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 319 matching lines @@
   public:
     static InstX86Label *create(Cfg *Func, TargetLowering *Target) {
       return new (Func->allocate<InstX86Label>()) InstX86Label(Func, Target);
     }
     uint32_t getEmitInstCount() const override { return 0; }
     IceString getName(const Cfg *Func) const;
     SizeT getNumber() const { return Number; }
     void emit(const Cfg *Func) const override;
     void emitIAS(const Cfg *Func) const override;
     void dump(const Cfg *Func) const override;
+    void setIsReturnLocation(bool Value) { IsReturnLocation = Value; }
 
   private:
     InstX86Label(Cfg *Func, TargetLowering *Target);
 
     SizeT Number; // used for unique label generation.
+    bool IsReturnLocation = false;
   };
 
   /// Conditional and unconditional branch instruction.
   class InstX86Br final : public InstX86Base {
     InstX86Br() = delete;
     InstX86Br(const InstX86Br &) = delete;
     InstX86Br &operator=(const InstX86Br &) = delete;
 
   public:
     enum Mode { Near, Far };
@@ skipping 166 matching lines @@
   static void emitIASVariableBlendInst(const Inst *Inst, const Cfg *Func,
                                        const XmmEmitterRegOp &Emitter);
 
   static void emitIASXmmShift(const Cfg *Func, Type Ty, const Variable *Var,
                               const Operand *Src,
                               const XmmEmitterShiftOp &Emitter);
 
   /// Emit a two-operand (GPR) instruction, where the dest operand is a Variable
   /// that's guaranteed to be a register.
   template <bool VarCanBeByte = true, bool SrcCanBeByte = true>
-  static void emitIASRegOpTyGPR(const Cfg *Func, Type Ty, const Variable *Dst,
-                                const Operand *Src,
+  static void emitIASRegOpTyGPR(const Cfg *Func, bool IsLea, Type Ty,
+                                const Variable *Dst, const Operand *Src,
                                 const GPREmitterRegOp &Emitter);
 
   /// Instructions of the form x := op(x).
   template <typename InstX86Base::InstKindX86 K>
   class InstX86BaseInplaceopGPR : public InstX86Base {
     InstX86BaseInplaceopGPR() = delete;
     InstX86BaseInplaceopGPR(const InstX86BaseInplaceopGPR &) = delete;
     InstX86BaseInplaceopGPR &
     operator=(const InstX86BaseInplaceopGPR &) = delete;
 
@@ skipping 63 matching lines @@
       Str << "\t";
       this->getSrc(0)->emit(Func);
       Str << ", ";
       this->getDest()->emit(Func);
     }
     void emitIAS(const Cfg *Func) const override {
       assert(this->getSrcSize() == 1);
       const Variable *Var = this->getDest();
       Type Ty = Var->getType();
       const Operand *Src = this->getSrc(0);
-      emitIASRegOpTyGPR(Func, Ty, Var, Src, Emitter);
+      constexpr bool IsLea = K == InstX86Base::Lea;
+      emitIASRegOpTyGPR(Func, IsLea, Ty, Var, Src, Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getSrc(0)->getType() << " ";
       this->dumpSources(Func);
     }
     static bool classof(const Inst *Inst) {
@@ skipping 109 matching lines @@
     using Base = InstX86BaseBinopGPR<K>;
 
     void emit(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       this->emitTwoAddress(Func, Opcode);
     }
     void emitIAS(const Cfg *Func) const override {
       Type Ty = this->getDest()->getType();
       assert(this->getSrcSize() == 2);
-      emitIASRegOpTyGPR(Func, Ty, this->getDest(), this->getSrc(1), Emitter);
+      constexpr bool ThisIsLEA = K == InstX86Base::Lea;
+      static_assert(!ThisIsLEA, "Lea should be a unaryop.");
+      emitIASRegOpTyGPR(Func, !ThisIsLEA, Ty, this->getDest(), this->getSrc(1),
+                        Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
     static bool classof(const Inst *Inst) {
@@ skipping 412 matching lines @@
     static InstX86Movzx *create(Cfg *Func, Variable *Dest, Operand *Src) {
       assert(typeWidthInBytes(Dest->getType()) >
              typeWidthInBytes(Src->getType()));
       return new (Func->allocate<InstX86Movzx>()) InstX86Movzx(Func, Dest, Src);
     }
 
     void emit(const Cfg *Func) const override;
 
     void emitIAS(const Cfg *Func) const override;
 
+    void setMustKeep() { MustKeep = true; }
+
   private:
+    bool MustKeep = false;
+
     InstX86Movzx(Cfg *Func, Variable *Dest, Operand *Src)
         : InstX86BaseUnaryopGPR<InstX86Base::Movzx>(Func, Dest, Src) {}
+
+    bool mayBeElided(const Variable *Dest, const Operand *Src) const;
   };
 
   class InstX86Movd : public InstX86BaseUnaryopXmm<InstX86Base::Movd> {
   public:
     static InstX86Movd *create(Cfg *Func, Variable *Dest, Operand *Src) {
       return new (Func->allocate<InstX86Movd>()) InstX86Movd(Func, Dest, Src);
     }
 
     void emit(const Cfg *Func) const override;
 
@@ skipping 1426 matching lines @@
   private:
     InstX86Pop(Cfg *Func, Variable *Dest);
   };
 
   class InstX86Push final : public InstX86Base {
     InstX86Push() = delete;
     InstX86Push(const InstX86Push &) = delete;
     InstX86Push &operator=(const InstX86Push &) = delete;
 
   public:
-    static InstX86Push *create(Cfg *Func, Variable *Source) {
+    static InstX86Push *create(Cfg *Func, InstX86Label *Label) {
+      return new (Func->allocate<InstX86Push>()) InstX86Push(Func, Label);
+    }
+    static InstX86Push *create(Cfg *Func, Operand *Source) {
       return new (Func->allocate<InstX86Push>()) InstX86Push(Func, Source);
     }
     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::isClassof(Inst, InstX86Base::Push);
     }
 
   private:
-    InstX86Push(Cfg *Func, Variable *Source);
+    InstX86Label *Label = nullptr;
+
+    InstX86Push(Cfg *Func, Operand *Source);
+    InstX86Push(Cfg *Func, InstX86Label *Label);
   };
 
   /// Ret instruction. Currently only supports the "ret" version that does not
   /// pop arguments. This instruction takes a Source operand (for non-void
   /// returning functions) for liveness analysis, though a FakeUse before the
   /// ret would do just as well.
   class InstX86Ret final : public InstX86Base {
     InstX86Ret() = delete;
     InstX86Ret(const InstX86Ret &) = delete;
     InstX86Ret &operator=(const InstX86Ret &) = delete;
@@ skipping 847 matching lines @@
           &InstImpl<TraitsType>::Assembler::psrl};                             \
   }                                                                            \
   }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H