The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-

  * vim: set ts=8 sts=4 et sw=4 tw=99:

  * This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #ifndef jit_LIR_Common_h

 #define jit_LIR_Common_h

 #include "jit/shared/Assembler-shared.h"

 // This file declares LIR instructions that are common to every platform.

 namespace js {

 namespace jit {

 class Range;

 template <size_t Temps, size_t ExtraUses = 0>

 class LBinaryMath : public LInstructionHelper<1, 2 + ExtraUses, Temps>

 {

   public:

     const LAllocation *lhs() {

         return this->getOperand(0);

     }

     const LAllocation *rhs() {

         return this->getOperand(1);

     }

 };

 // Simplifies register allocation since the first instruction of a block is

 // guaranteed to have no uses.

 class LLabel : public LInstructionHelper<0, 0, 0>

 {

   public:

     LIR_HEADER(Label)

 };

 class LNop : public LInstructionHelper<0, 0, 0>

 {

   public:

     LIR_HEADER(Nop)

 };

 // An LOsiPoint captures a snapshot after a call and ensures enough space to

 // patch in a call to the invalidation mechanism.

 //

 // Note: LSafepoints are 1:1 with LOsiPoints, so it holds a reference to the

 // corresponding LSafepoint to inform it of the LOsiPoint's masm offset when it

 // gets CG'd.

 class LOsiPoint : public LInstructionHelper<0, 0, 0>

 {

     LSafepoint *safepoint_;

   public:

     LOsiPoint(LSafepoint *safepoint, LSnapshot *snapshot)

       : safepoint_(safepoint)

     {

         JS_ASSERT(safepoint && snapshot);

         assignSnapshot(snapshot);

     }

     LSafepoint *associatedSafepoint() {

         return safepoint_;

     }

     LIR_HEADER(OsiPoint)

 };

 class LMove

 {

     LAllocation *from_;

     LAllocation *to_;

     LDefinition::Type type_;

   public:

     LMove(LAllocation *from, LAllocation *to, LDefinition::Type type)

       : from_(from),

         to_(to),

         type_(type)

     { }

     LAllocation *from() {

         return from_;

     }

     const LAllocation *from() const {

         return from_;

     }

     LAllocation *to() {

         return to_;

     }

     const LAllocation *to() const {

         return to_;

     }

     LDefinition::Type type() const {

         return type_;

     }

 };

 class LMoveGroup : public LInstructionHelper<0, 0, 0>

 {

     js::Vector<LMove, 2, IonAllocPolicy> moves_;

     LMoveGroup(TempAllocator &alloc)

       : moves_(alloc)

     { }

   public:

     LIR_HEADER(MoveGroup)

     static LMoveGroup *New(TempAllocator &alloc) {

         return new(alloc) LMoveGroup(alloc);

     }

     void printOperands(FILE *fp);

     // Add a move which takes place simultaneously with all others in the group.

     bool add(LAllocation *from, LAllocation *to, LDefinition::Type type);

     // Add a move which takes place after existing moves in the group.

     bool addAfter(LAllocation *from, LAllocation *to, LDefinition::Type type);

     size_t numMoves() const {

         return moves_.length();

     }

     const LMove &getMove(size_t i) const {

         return moves_[i];

     }

 };

 // Constant 32-bit integer.

 class LInteger : public LInstructionHelper<1, 0, 0>

 {

     int32_t i32_;

   public:

     LIR_HEADER(Integer)

     LInteger(int32_t i32)

       : i32_(i32)

     { }

     int32_t getValue() const {

         return i32_;

     }

 };

 // Constant pointer.

 class LPointer : public LInstructionHelper<1, 0, 0>

 {

   public:

     enum Kind {

         GC_THING,

         NON_GC_THING

     };

   private:

     void *ptr_;

     Kind kind_;

   public:

     LIR_HEADER(Pointer)

     LPointer(gc::Cell *ptr)

       : ptr_(ptr), kind_(GC_THING)

     { }

     LPointer(void *ptr, Kind kind)

       : ptr_(ptr), kind_(kind)

     { }

     void *ptr() const {

         return ptr_;

     }

     Kind kind() const {

         return kind_;

     }

     const char *extraName() const {

         return kind_ == GC_THING ? "GC_THING" : "NON_GC_THING";

     }

     gc::Cell *gcptr() const {

         JS_ASSERT(kind() == GC_THING);

         return (gc::Cell *) ptr_;

     }

 };

 // Constant double.

 class LDouble : public LInstructionHelper<1, 0, 0>

 {

     double d_;

   public:

     LIR_HEADER(Double);

     LDouble(double d) : d_(d)

     { }

     double getDouble() const {

         return d_;

     }

 };

 // Constant float32.

 class LFloat32 : public LInstructionHelper<1, 0, 0>

 {

     float f_;

   public:

     LIR_HEADER(Float32);

     LFloat32(float f)

       : f_(f)

     { }

     float getFloat() const {

         return f_;

     }

 };

 // A constant Value.

 class LValue : public LInstructionHelper<BOX_PIECES, 0, 0>

 {

     Value v_;

   public:

     LIR_HEADER(Value)

     LValue(const Value &v)

       : v_(v)

     { }

     Value value() const {

         return v_;

     }

 };

 // Clone an object literal such as we are not modifying the object contained in

 // the sources.

 class LCloneLiteral : public LCallInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(CloneLiteral)

     LCloneLiteral(const LAllocation &obj)

     {

         setOperand(0, obj);

     }

     const LAllocation *getObjectLiteral() {

         return getOperand(0);

     }

     MCloneLiteral *mir() const {

         return mir_->toCloneLiteral();

     }

 };

 // Formal argument for a function, returning a box. Formal arguments are

 // initially read from the stack.

 class LParameter : public LInstructionHelper<BOX_PIECES, 0, 0>

 {

   public:

     LIR_HEADER(Parameter)

 };

 // Stack offset for a word-sized immutable input value to a frame.

 class LCallee : public LInstructionHelper<1, 0, 0>

 {

   public:

     LIR_HEADER(Callee)

 };

 // Base class for control instructions (goto, branch, etc.)

 template <size_t Succs, size_t Operands, size_t Temps>

 class LControlInstructionHelper : public LInstructionHelper<0, Operands, Temps> {

     mozilla::Array<MBasicBlock *, Succs> successors_;

   public:

     virtual size_t numSuccessors() const MOZ_FINAL MOZ_OVERRIDE { return Succs; }

     virtual MBasicBlock *getSuccessor(size_t i) const MOZ_FINAL MOZ_OVERRIDE {

         return successors_[i];

     }

     virtual void setSuccessor(size_t i, MBasicBlock *successor) MOZ_FINAL MOZ_OVERRIDE {

         successors_[i] = successor;

     }

 };

 // Jumps to the start of a basic block.

 class LGoto : public LControlInstructionHelper<1, 0, 0>

 {

   public:

     LIR_HEADER(Goto)

     LGoto(MBasicBlock *block)

     {

          setSuccessor(0, block);

     }

     MBasicBlock *target() const {

         return getSuccessor(0);

     }

 };

 class LNewSlots : public LCallInstructionHelper<1, 0, 3>

 {

   public:

     LIR_HEADER(NewSlots)

     LNewSlots(const LDefinition &temp1, const LDefinition &temp2, const LDefinition &temp3) {

         setTemp(0, temp1);

         setTemp(1, temp2);

         setTemp(2, temp3);

     }

     const LDefinition *temp1() {

         return getTemp(0);

     }

     const LDefinition *temp2() {

         return getTemp(1);

     }

     const LDefinition *temp3() {

         return getTemp(2);

     }

     MNewSlots *mir() const {

         return mir_->toNewSlots();

     }

 };

 class LNewArray : public LInstructionHelper<1, 0, 1>

 {

   public:

     LIR_HEADER(NewArray)

     LNewArray(const LDefinition &temp) {

         setTemp(0, temp);

     }

     const char *extraName() const {

         return mir()->shouldUseVM() ? "VMCall" : nullptr;

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     MNewArray *mir() const {

         return mir_->toNewArray();

     }

 };

 class LNewObject : public LInstructionHelper<1, 0, 1>

 {

   public:

     LIR_HEADER(NewObject)

     LNewObject(const LDefinition &temp) {

         setTemp(0, temp);

     }

     const char *extraName() const {

         return mir()->shouldUseVM() ? "VMCall" : nullptr;

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     MNewObject *mir() const {

         return mir_->toNewObject();

     }

 };

 class LNewPar : public LInstructionHelper<1, 1, 2>

 {

   public:

     LIR_HEADER(NewPar);

     LNewPar(const LAllocation &cx, const LDefinition &temp1, const LDefinition &temp2) {

         setOperand(0, cx);

         setTemp(0, temp1);

         setTemp(1, temp2);

     }

     MNewPar *mir() const {

         return mir_->toNewPar();

     }

     const LAllocation *forkJoinContext() {

         return getOperand(0);

     }

     const LDefinition *getTemp0() {

         return getTemp(0);

     }

     const LDefinition *getTemp1() {

         return getTemp(1);

     }

 };

 class LNewDenseArrayPar : public LCallInstructionHelper<1, 2, 3>

 {

   public:

     LIR_HEADER(NewDenseArrayPar);

     LNewDenseArrayPar(const LAllocation &cx, const LAllocation &length,

                       const LDefinition &temp1, const LDefinition &temp2, const LDefinition &temp3)

     {

         setOperand(0, cx);

         setOperand(1, length);

         setTemp(0, temp1);

         setTemp(1, temp2);

         setTemp(2, temp3);

     }

     MNewDenseArrayPar *mir() const {

         return mir_->toNewDenseArrayPar();

     }

     const LAllocation *forkJoinContext() {

         return getOperand(0);

     }

     const LAllocation *length() {

         return getOperand(1);

     }

     const LDefinition *getTemp0() {

         return getTemp(0);

     }

     const LDefinition *getTemp1() {

         return getTemp(1);

     }

     const LDefinition *getTemp2() {

         return getTemp(2);

     }

 };

 // Allocates a new DeclEnvObject.

 //

 // This instruction generates two possible instruction sets:

 //   (1) An inline allocation of the call object is attempted.

 //   (2) Otherwise, a callVM create a new object.

 //

 class LNewDeclEnvObject : public LInstructionHelper<1, 0, 1>

 {

   public:

     LIR_HEADER(NewDeclEnvObject);

     LNewDeclEnvObject(const LDefinition &temp) {

         setTemp(0, temp);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     MNewDeclEnvObject *mir() const {

         return mir_->toNewDeclEnvObject();

     }

 };

 // Allocates a new CallObject. The inputs are:

 //      slots: either a reg representing a HeapSlot *, or a placeholder

 //             meaning that no slots pointer is needed.

 //

 // This instruction generates two possible instruction sets:

 //   (1) If the call object is extensible, this is a callVM to create the

 //       call object.

 //   (2) Otherwise, an inline allocation of the call object is attempted.

 //

 class LNewCallObject : public LInstructionHelper<1, 1, 1>

 {

   public:

     LIR_HEADER(NewCallObject)

     LNewCallObject(const LAllocation &slots, const LDefinition &temp) {

         setOperand(0, slots);

         setTemp(0, temp);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     const LAllocation *slots() {

         return getOperand(0);

     }

     MNewCallObject *mir() const {

         return mir_->toNewCallObject();

     }

 };

 // Allocates a new CallObject with singleton type through an out-of-line VM

 // call. The inputs are:

 //      slots: either a reg representing a HeapSlot *, or a placeholder

 //             meaning that no slots pointer is needed.

 //

 class LNewSingletonCallObject : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NewSingletonCallObject)

     LNewSingletonCallObject(const LAllocation &slots) {

         setOperand(0, slots);

     }

     const LAllocation *slots() {

         return getOperand(0);

     }

     MNewCallObjectBase * mir() const {

         MOZ_ASSERT(mir_->isNewCallObject() || mir_->isNewRunOnceCallObject());

         return static_cast<MNewCallObjectBase *>(mir_);

     }

 };

 class LNewCallObjectPar : public LInstructionHelper<1, 2, 2>

 {

     LNewCallObjectPar(const LAllocation &cx, const LAllocation &slots,

                       const LDefinition &temp1, const LDefinition &temp2)

     {

         setOperand(0, cx);

         setOperand(1, slots);

         setTemp(0, temp1);

         setTemp(1, temp2);

     }

 public:

     LIR_HEADER(NewCallObjectPar);

     static LNewCallObjectPar *NewWithSlots(TempAllocator &alloc,

                                            const LAllocation &cx, const LAllocation &slots,

                                            const LDefinition &temp1, const LDefinition &temp2)

     {

         return new(alloc) LNewCallObjectPar(cx, slots, temp1, temp2);

     }

     static LNewCallObjectPar *NewSansSlots(TempAllocator &alloc,

                                            const LAllocation &cx,

                                            const LDefinition &temp1, const LDefinition &temp2)

     {

         LAllocation slots = LConstantIndex::Bogus();

         return new(alloc) LNewCallObjectPar(cx, slots, temp1, temp2);

     }

     const LAllocation *forkJoinContext() {

         return getOperand(0);

     }

     const LAllocation *slots() {

         return getOperand(1);

     }

     const bool hasDynamicSlots() {

         // TO INVESTIGATE: Felix tried using isRegister() method here,

         // but for useFixed(_, CallTempN), isRegister() is false (and

         // isUse() is true).  So for now ignore that and try to match

         // the LConstantIndex::Bogus() generated above instead.

         return slots() && ! slots()->isConstant();

     }

     const MNewCallObjectPar *mir() const {

         return mir_->toNewCallObjectPar();

     }

     const LDefinition *getTemp0() {

         return getTemp(0);

     }

     const LDefinition *getTemp1() {

         return getTemp(1);

     }

 };

 class LNewDerivedTypedObject : public LCallInstructionHelper<1, 3, 0>

 {

   public:

     LIR_HEADER(NewDerivedTypedObject);

     LNewDerivedTypedObject(const LAllocation &type,

                            const LAllocation &owner,

                            const LAllocation &offset) {

         setOperand(0, type);

         setOperand(1, owner);

         setOperand(2, offset);

     }

     const LAllocation *type() {

         return getOperand(0);

     }

     const LAllocation *owner() {

         return getOperand(1);

     }

     const LAllocation *offset() {

         return getOperand(2);

     }

 };

 class LNewStringObject : public LInstructionHelper<1, 1, 1>

 {

   public:

     LIR_HEADER(NewStringObject)

     LNewStringObject(const LAllocation &input, const LDefinition &temp) {

         setOperand(0, input);

         setTemp(0, temp);

     }

     const LAllocation *input() {

         return getOperand(0);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     MNewStringObject *mir() const {

         return mir_->toNewStringObject();

     }

 };

 class LAbortPar : public LInstructionHelper<0, 0, 0>

 {

   public:

     LIR_HEADER(AbortPar);

 };

 class LInitElem : public LCallInstructionHelper<0, 1 + 2*BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(InitElem)

     LInitElem(const LAllocation &object) {

         setOperand(0, object);

     }

     static const size_t IdIndex = 1;

     static const size_t ValueIndex = 1 + BOX_PIECES;

     const LAllocation *getObject() {

         return getOperand(0);

     }

     MInitElem *mir() const {

         return mir_->toInitElem();

     }

 };

 class LInitElemGetterSetter : public LCallInstructionHelper<0, 2 + BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(InitElemGetterSetter)

     LInitElemGetterSetter(const LAllocation &object, const LAllocation &value) {

         setOperand(0, object);

         setOperand(1, value);

     }

     static const size_t IdIndex = 2;

     const LAllocation *object() {

         return getOperand(0);

     }

     const LAllocation *value() {

         return getOperand(1);

     }

     MInitElemGetterSetter *mir() const {

         return mir_->toInitElemGetterSetter();

     }

 };

 // Takes in an Object and a Value.

 class LMutateProto : public LCallInstructionHelper<0, 1 + BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(MutateProto)

     LMutateProto(const LAllocation &object) {

         setOperand(0, object);

     }

     static const size_t ValueIndex = 1;

     const LAllocation *getObject() {

         return getOperand(0);

     }

     const LAllocation *getValue() {

         return getOperand(1);

     }

 };

 // Takes in an Object and a Value.

 class LInitProp : public LCallInstructionHelper<0, 1 + BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(InitProp)

     LInitProp(const LAllocation &object) {

         setOperand(0, object);

     }

     static const size_t ValueIndex = 1;

     const LAllocation *getObject() {

         return getOperand(0);

     }

     const LAllocation *getValue() {

         return getOperand(1);

     }

     MInitProp *mir() const {

         return mir_->toInitProp();

     }

 };

 class LInitPropGetterSetter : public LCallInstructionHelper<0, 2, 0>

 {

   public:

     LIR_HEADER(InitPropGetterSetter)

     LInitPropGetterSetter(const LAllocation &object, const LAllocation &value) {

         setOperand(0, object);

         setOperand(1, value);

     }

     const LAllocation *object() {

         return getOperand(0);

     }

     const LAllocation *value() {

         return getOperand(1);

     }

     MInitPropGetterSetter *mir() const {

         return mir_->toInitPropGetterSetter();

     }

 };

 class LCheckOverRecursed : public LInstructionHelper<0, 0, 0>

 {

   public:

     LIR_HEADER(CheckOverRecursed)

     LCheckOverRecursed()

     { }

 };

 class LCheckOverRecursedPar : public LInstructionHelper<0, 1, 1>

 {

   public:

     LIR_HEADER(CheckOverRecursedPar);

     LCheckOverRecursedPar(const LAllocation &cx, const LDefinition &tempReg) {

         setOperand(0, cx);

         setTemp(0, tempReg);

     }

     const LAllocation *forkJoinContext() {

         return getOperand(0);

     }

     const LDefinition *getTempReg() {

         return getTemp(0);

     }

 };

 // Alternative to LInterruptCheck which does not emit an explicit check of the

 // interrupt flag but relies on the loop backedge being patched via a signal

 // handler.

 class LInterruptCheckImplicit : public LInstructionHelper<0, 0, 0>

 {

     Label *oolEntry_;

   public:

     LIR_HEADER(InterruptCheckImplicit)

     LInterruptCheckImplicit()

       : oolEntry_(nullptr)

     {}

     Label *oolEntry() {

         return oolEntry_;

     }

     void setOolEntry(Label *oolEntry) {

         oolEntry_ = oolEntry;

     }

 };

 class LInterruptCheckPar : public LInstructionHelper<0, 1, 1>

 {

   public:

     LIR_HEADER(InterruptCheckPar);

     LInterruptCheckPar(const LAllocation &cx, const LDefinition &tempReg) {

         setOperand(0, cx);

         setTemp(0, tempReg);

     }

     const LAllocation *forkJoinContext() {

         return getOperand(0);

     }

     const LDefinition *getTempReg() {

         return getTemp(0);

     }

 };

 class LDefVar : public LCallInstructionHelper<0, 1, 0>

 {

   public:

     LIR_HEADER(DefVar)

     LDefVar(const LAllocation &scopeChain)

     {

         setOperand(0, scopeChain);

     }

     const LAllocation *scopeChain() {

         return getOperand(0);

     }

     MDefVar *mir() const {

         return mir_->toDefVar();

     }

 };

 class LDefFun : public LCallInstructionHelper<0, 1, 0>

 {

   public:

     LIR_HEADER(DefFun)

     LDefFun(const LAllocation &scopeChain)

     {

         setOperand(0, scopeChain);

     }

     const LAllocation *scopeChain() {

         return getOperand(0);

     }

     MDefFun *mir() const {

         return mir_->toDefFun();

     }

 };

 class LTypeOfV : public LInstructionHelper<1, BOX_PIECES, 1>

 {

   public:

     LIR_HEADER(TypeOfV)

     LTypeOfV(const LDefinition &tempToUnbox) {

         setTemp(0, tempToUnbox);

     }

     static const size_t Input = 0;

     const LDefinition *tempToUnbox() {

         return getTemp(0);

     }

     MTypeOf *mir() const {

         return mir_->toTypeOf();

     }

 };

 class LToIdV : public LInstructionHelper<BOX_PIECES, 2 * BOX_PIECES, 1>

 {

   public:

     LIR_HEADER(ToIdV)

     LToIdV(const LDefinition &temp)

     {

         setTemp(0, temp);

     }

     static const size_t Object = 0;

     static const size_t Index = BOX_PIECES;

     MToId *mir() const {

         return mir_->toToId();

     }

     const LDefinition *tempFloat() {

         return getTemp(0);

     }

 };

 // Allocate an object for |new| on the caller-side,

 // when there is no templateObject or prototype known

 class LCreateThis : public LCallInstructionHelper<BOX_PIECES, 1, 0>

 {

   public:

     LIR_HEADER(CreateThis)

     LCreateThis(const LAllocation &callee)

     {

         setOperand(0, callee);

     }

     const LAllocation *getCallee() {

         return getOperand(0);

     }

     MCreateThis *mir() const {

         return mir_->toCreateThis();

     }

 };

 // Allocate an object for |new| on the caller-side,

 // when the prototype is known.

 class LCreateThisWithProto : public LCallInstructionHelper<1, 2, 0>

 {

   public:

     LIR_HEADER(CreateThisWithProto)

     LCreateThisWithProto(const LAllocation &callee, const LAllocation &prototype)

     {

         setOperand(0, callee);

         setOperand(1, prototype);

     }

     const LAllocation *getCallee() {

         return getOperand(0);

     }

     const LAllocation *getPrototype() {

         return getOperand(1);

     }

     MCreateThis *mir() const {

         return mir_->toCreateThis();

     }

 };

 // Allocate an object for |new| on the caller-side.

 // Always performs object initialization with a fast path.

 class LCreateThisWithTemplate : public LInstructionHelper<1, 0, 1>

 {

   public:

     LIR_HEADER(CreateThisWithTemplate)

     LCreateThisWithTemplate(const LDefinition &temp) {

         setTemp(0, temp);

     }

     MCreateThisWithTemplate *mir() const {

         return mir_->toCreateThisWithTemplate();

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

 };

 // Allocate a new arguments object for the frame.

 class LCreateArgumentsObject : public LCallInstructionHelper<1, 1, 1>

 {

   public:

     LIR_HEADER(CreateArgumentsObject)

     LCreateArgumentsObject(const LAllocation &callObj, const LDefinition &temp)

     {

         setOperand(0, callObj);

         setTemp(0, temp);

     }

     const LAllocation *getCallObject() {

         return getOperand(0);

     }

     MCreateArgumentsObject *mir() const {

         return mir_->toCreateArgumentsObject();

     }

 };

 // Get argument from arguments object.

 class LGetArgumentsObjectArg : public LInstructionHelper<BOX_PIECES, 1, 1>

 {

   public:

     LIR_HEADER(GetArgumentsObjectArg)

     LGetArgumentsObjectArg(const LAllocation &argsObj, const LDefinition &temp)

     {

         setOperand(0, argsObj);

         setTemp(0, temp);

     }

     const LAllocation *getArgsObject() {

         return getOperand(0);

     }

     MGetArgumentsObjectArg *mir() const {

         return mir_->toGetArgumentsObjectArg();

     }

 };

 // Set argument on arguments object.

 class LSetArgumentsObjectArg : public LInstructionHelper<0, 1 + BOX_PIECES, 1>

 {

   public:

     LIR_HEADER(SetArgumentsObjectArg)

     LSetArgumentsObjectArg(const LAllocation &argsObj, const LDefinition &temp)

     {

         setOperand(0, argsObj);

         setTemp(0, temp);

     }

     const LAllocation *getArgsObject() {

         return getOperand(0);

     }

     MSetArgumentsObjectArg *mir() const {

         return mir_->toSetArgumentsObjectArg();

     }

     static const size_t ValueIndex = 1;

 };

 // If the Value is an Object, return unbox(Value).

 // Otherwise, return the other Object.

 class LReturnFromCtor : public LInstructionHelper<1, BOX_PIECES + 1, 0>

 {

   public:

     LIR_HEADER(ReturnFromCtor)

     LReturnFromCtor(const LAllocation &object)

     {

         // Value set by useBox() during lowering.

         setOperand(LReturnFromCtor::ObjectIndex, object);

     }

     const LAllocation *getObject() {

         return getOperand(LReturnFromCtor::ObjectIndex);

     }

     static const size_t ValueIndex = 0;

     static const size_t ObjectIndex = BOX_PIECES;

 };

 class LComputeThis : public LInstructionHelper<1, BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(ComputeThis)

     static const size_t ValueIndex = 0;

     const LDefinition *output() {

         return getDef(0);

     }

     MComputeThis *mir() const {

         return mir_->toComputeThis();

     }

 };

 class LLoadArrowThis : public LInstructionHelper<BOX_PIECES, 1, 0>

 {

   public:

     LLoadArrowThis(const LAllocation &callee) {

         setOperand(0, callee);

     }

     LIR_HEADER(LoadArrowThis)

     const LAllocation *callee() {

         return getOperand(0);

     }

 };

 // Writes a typed argument for a function call to the frame's argument vector.

 class LStackArgT : public LInstructionHelper<0, 1, 0>

 {

     uint32_t argslot_; // Index into frame-scope argument vector.

     MIRType type_;

   public:

     LIR_HEADER(StackArgT)

     LStackArgT(uint32_t argslot, MIRType type, const LAllocation &arg)

       : argslot_(argslot),

         type_(type)

     {

         setOperand(0, arg);

     }

     uint32_t argslot() const {

         return argslot_;

     }

     MIRType type() const {

         return type_;

     }

     const LAllocation *getArgument() {

         return getOperand(0);

     }

 };

 // Writes an untyped argument for a function call to the frame's argument vector.

 class LStackArgV : public LInstructionHelper<0, BOX_PIECES, 0>

 {

     uint32_t argslot_; // Index into frame-scope argument vector.

   public:

     LIR_HEADER(StackArgV)

     LStackArgV(uint32_t argslot)

       : argslot_(argslot)

     { }

     uint32_t argslot() const {

         return argslot_;

     }

 };

 // Common code for LIR descended from MCall.

 template <size_t Defs, size_t Operands, size_t Temps>

 class LJSCallInstructionHelper : public LCallInstructionHelper<Defs, Operands, Temps>

 {

   public:

     uint32_t argslot() const {

         return mir()->numStackArgs();

     }

     MCall *mir() const {

         return this->mir_->toCall();

     }

     bool hasSingleTarget() const {

         return getSingleTarget() != nullptr;

     }

     JSFunction *getSingleTarget() const {

         return mir()->getSingleTarget();

     }

     // The number of stack arguments is the max between the number of formal

     // arguments and the number of actual arguments. The number of stack

     // argument includes the |undefined| padding added in case of underflow.

     // Does not include |this|.

     uint32_t numStackArgs() const {

         JS_ASSERT(mir()->numStackArgs() >= 1);

         return mir()->numStackArgs() - 1; // |this| is not a formal argument.

     }

     // Does not include |this|.

     uint32_t numActualArgs() const {

         return mir()->numActualArgs();

     }

 };

 // Generates a polymorphic callsite, wherein the function being called is

 // unknown and anticipated to vary.

 class LCallGeneric : public LJSCallInstructionHelper<BOX_PIECES, 1, 2>

 {

   public:

     LIR_HEADER(CallGeneric)

     LCallGeneric(const LAllocation &func, const LDefinition &nargsreg,

                  const LDefinition &tmpobjreg)

     {

         setOperand(0, func);

         setTemp(0, nargsreg);

         setTemp(1, tmpobjreg);

     }

     const LAllocation *getFunction() {

         return getOperand(0);

     }

     const LDefinition *getNargsReg() {

         return getTemp(0);

     }

     const LDefinition *getTempObject() {

         return getTemp(1);

     }

 };

 // Generates a hardcoded callsite for a known, non-native target.

 class LCallKnown : public LJSCallInstructionHelper<BOX_PIECES, 1, 1>

 {

   public:

     LIR_HEADER(CallKnown)

     LCallKnown(const LAllocation &func, const LDefinition &tmpobjreg)

     {

         setOperand(0, func);

         setTemp(0, tmpobjreg);

     }

     const LAllocation *getFunction() {

         return getOperand(0);

     }

     const LDefinition *getTempObject() {

         return getTemp(0);

     }

 };

 // Generates a hardcoded callsite for a known, native target.

 class LCallNative : public LJSCallInstructionHelper<BOX_PIECES, 0, 4>

 {

   public:

     LIR_HEADER(CallNative)

     LCallNative(const LDefinition &argContext, const LDefinition &argUintN,

                 const LDefinition &argVp, const LDefinition &tmpreg)

     {

         // Registers used for callWithABI().

         setTemp(0, argContext);

         setTemp(1, argUintN);

         setTemp(2, argVp);

         // Temporary registers.

         setTemp(3, tmpreg);

     }

     const LDefinition *getArgContextReg() {

         return getTemp(0);

     }

     const LDefinition *getArgUintNReg() {

         return getTemp(1);

     }

     const LDefinition *getArgVpReg() {

         return getTemp(2);

     }

     const LDefinition *getTempReg() {

         return getTemp(3);

     }

 };

 // Generates a hardcoded callsite for a known, DOM-native target.

 class LCallDOMNative : public LJSCallInstructionHelper<BOX_PIECES, 0, 4>

 {

   public:

     LIR_HEADER(CallDOMNative)

     LCallDOMNative(const LDefinition &argJSContext, const LDefinition &argObj,

                    const LDefinition &argPrivate, const LDefinition &argArgs)

     {

         setTemp(0, argJSContext);

         setTemp(1, argObj);

         setTemp(2, argPrivate);

         setTemp(3, argArgs);

     }

     const LDefinition *getArgJSContext() {

         return getTemp(0);

     }

     const LDefinition *getArgObj() {

         return getTemp(1);

     }

     const LDefinition *getArgPrivate() {

         return getTemp(2);

     }

     const LDefinition *getArgArgs() {

         return getTemp(3);

     }

 };

 class LBail : public LInstructionHelper<0, 0, 0>

 {

   public:

     LIR_HEADER(Bail)

 };

 template <size_t defs, size_t ops>

 class LDOMPropertyInstructionHelper : public LCallInstructionHelper<defs, 1 + ops, 3>

 {

   protected:

     LDOMPropertyInstructionHelper(const LDefinition &JSContextReg, const LAllocation &ObjectReg,

                                   const LDefinition &PrivReg, const LDefinition &ValueReg)

     {

         this->setOperand(0, ObjectReg);

         this->setTemp(0, JSContextReg);

         this->setTemp(1, PrivReg);

         this->setTemp(2, ValueReg);

     }

   public:

     const LDefinition *getJSContextReg() {

         return this->getTemp(0);

     }

     const LAllocation *getObjectReg() {

         return this->getOperand(0);

     }

     const LDefinition *getPrivReg() {

         return this->getTemp(1);

     }

     const LDefinition *getValueReg() {

         return this->getTemp(2);

     }

 };

 class LGetDOMProperty : public LDOMPropertyInstructionHelper<BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(GetDOMProperty)

     LGetDOMProperty(const LDefinition &JSContextReg, const LAllocation &ObjectReg,

                     const LDefinition &PrivReg, const LDefinition &ValueReg)

       : LDOMPropertyInstructionHelper<BOX_PIECES, 0>(JSContextReg, ObjectReg,

                                                      PrivReg, ValueReg)

     { }

     MGetDOMProperty *mir() const {

         return mir_->toGetDOMProperty();

     }

 };

 class LGetDOMMember : public LInstructionHelper<BOX_PIECES, 1, 0>

 {

   public:

     LIR_HEADER(GetDOMMember);

     LGetDOMMember(const LAllocation &object) {

         setOperand(0, object);

     }

     const LAllocation *object() {

         return getOperand(0);

     }

     MGetDOMMember *mir() const {

         return mir_->toGetDOMMember();

     }

 };

 class LSetDOMProperty : public LDOMPropertyInstructionHelper<0, BOX_PIECES>

 {

   public:

     LIR_HEADER(SetDOMProperty)

     LSetDOMProperty(const LDefinition &JSContextReg, const LAllocation &ObjectReg,

                     const LDefinition &PrivReg, const LDefinition &ValueReg)

       : LDOMPropertyInstructionHelper<0, BOX_PIECES>(JSContextReg, ObjectReg,

                                                      PrivReg, ValueReg)

     { }

     static const size_t Value = 1;

     MSetDOMProperty *mir() const {

         return mir_->toSetDOMProperty();

     }

 };

 // Generates a polymorphic callsite, wherein the function being called is

 // unknown and anticipated to vary.

 class LApplyArgsGeneric : public LCallInstructionHelper<BOX_PIECES, BOX_PIECES + 2, 2>

 {

   public:

     LIR_HEADER(ApplyArgsGeneric)

     LApplyArgsGeneric(const LAllocation &func, const LAllocation &argc,

                       const LDefinition &tmpobjreg, const LDefinition &tmpcopy)

     {

         setOperand(0, func);

         setOperand(1, argc);

         setTemp(0, tmpobjreg);

         setTemp(1, tmpcopy);

     }

     MApplyArgs *mir() const {

         return mir_->toApplyArgs();

     }

     bool hasSingleTarget() const {

         return getSingleTarget() != nullptr;

     }

     JSFunction *getSingleTarget() const {

         return mir()->getSingleTarget();

     }

     const LAllocation *getFunction() {

         return getOperand(0);

     }

     const LAllocation *getArgc() {

         return getOperand(1);

     }

     static const size_t ThisIndex = 2;

     const LDefinition *getTempObject() {

         return getTemp(0);

     }

     const LDefinition *getTempCopy() {

         return getTemp(1);

     }

 };

 class LArraySplice : public LCallInstructionHelper<0, 3, 0>

 {

   public:

     LIR_HEADER(ArraySplice)

     LArraySplice(const LAllocation &object, const LAllocation &start,

                  const LAllocation &deleteCount)

     {

         setOperand(0, object);

         setOperand(1, start);

         setOperand(2, deleteCount);

     }

     MArraySplice *mir() const {

         return mir_->toArraySplice();

     }

     const LAllocation *getObject() {

         return getOperand(0);

     }

     const LAllocation *getStart() {

         return getOperand(1);

     }

     const LAllocation *getDeleteCount() {

         return getOperand(2);

     }

 };

 class LGetDynamicName : public LCallInstructionHelper<BOX_PIECES, 2, 3>

 {

   public:

     LIR_HEADER(GetDynamicName)

     LGetDynamicName(const LAllocation &scopeChain, const LAllocation &name,

                     const LDefinition &temp1, const LDefinition &temp2, const LDefinition &temp3)

     {

         setOperand(0, scopeChain);

         setOperand(1, name);

         setTemp(0, temp1);

         setTemp(1, temp2);

         setTemp(2, temp3);

     }

     MGetDynamicName *mir() const {

         return mir_->toGetDynamicName();

     }

     const LAllocation *getScopeChain() {

         return getOperand(0);

     }

     const LAllocation *getName() {

         return getOperand(1);

     }

     const LDefinition *temp1() {

         return getTemp(0);

     }

     const LDefinition *temp2() {

         return getTemp(1);

     }

     const LDefinition *temp3() {

         return getTemp(2);

     }

 };

 class LFilterArgumentsOrEvalS : public LCallInstructionHelper<0, 1, 2>

 {

   public:

     LIR_HEADER(FilterArgumentsOrEvalS)

     LFilterArgumentsOrEvalS(const LAllocation &string, const LDefinition &temp1,

                             const LDefinition &temp2)

     {

         setOperand(0, string);

         setTemp(0, temp1);

         setTemp(1, temp2);

     }

     MFilterArgumentsOrEval *mir() const {

         return mir_->toFilterArgumentsOrEval();

     }

     const LAllocation *getString() {

         return getOperand(0);

     }

     const LDefinition *temp1() {

         return getTemp(0);

     }

     const LDefinition *temp2() {

         return getTemp(1);

     }

 };

 class LFilterArgumentsOrEvalV : public LCallInstructionHelper<0, BOX_PIECES, 3>

 {

   public:

     LIR_HEADER(FilterArgumentsOrEvalV)

     LFilterArgumentsOrEvalV(const LDefinition &temp1, const LDefinition &temp2,

                             const LDefinition &temp3)

     {

         setTemp(0, temp1);

         setTemp(1, temp2);

         setTemp(2, temp3);

     }

     static const size_t Input = 0;

     MFilterArgumentsOrEval *mir() const {

         return mir_->toFilterArgumentsOrEval();

     }

     const LDefinition *temp1() {

         return getTemp(0);

     }

     const LDefinition *temp2() {

         return getTemp(1);

     }

     const LDefinition *temp3() {

         return getTemp(2);

     }

 };

 class LCallDirectEvalS : public LCallInstructionHelper<BOX_PIECES, 2 + BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(CallDirectEvalS)

     LCallDirectEvalS(const LAllocation &scopeChain, const LAllocation &string)

     {

         setOperand(0, scopeChain);

         setOperand(1, string);

     }

     static const size_t ThisValue = 2;

     MCallDirectEval *mir() const {

         return mir_->toCallDirectEval();

     }

     const LAllocation *getScopeChain() {

         return getOperand(0);

     }

     const LAllocation *getString() {

         return getOperand(1);

     }

 };

 class LCallDirectEvalV : public LCallInstructionHelper<BOX_PIECES, 1 + (2 * BOX_PIECES), 0>

 {

   public:

     LIR_HEADER(CallDirectEvalV)

     LCallDirectEvalV(const LAllocation &scopeChain)

     {

         setOperand(0, scopeChain);

     }

     static const size_t Argument = 1;

     static const size_t ThisValue = 1 + BOX_PIECES;

     MCallDirectEval *mir() const {

         return mir_->toCallDirectEval();

     }

     const LAllocation *getScopeChain() {

         return getOperand(0);

     }

 };

 // Takes in either an integer or boolean input and tests it for truthiness.

 class LTestIAndBranch : public LControlInstructionHelper<2, 1, 0>

 {

   public:

     LIR_HEADER(TestIAndBranch)

     LTestIAndBranch(const LAllocation &in, MBasicBlock *ifTrue, MBasicBlock *ifFalse)

     {

         setOperand(0, in);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

 };

 // Takes in either an integer or boolean input and tests it for truthiness.

 class LTestDAndBranch : public LControlInstructionHelper<2, 1, 0>

 {

   public:

     LIR_HEADER(TestDAndBranch)

     LTestDAndBranch(const LAllocation &in, MBasicBlock *ifTrue, MBasicBlock *ifFalse)

     {

         setOperand(0, in);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

 };

 // Takes in either an integer or boolean input and tests it for truthiness.

 class LTestFAndBranch : public LControlInstructionHelper<2, 1, 0>

 {

   public:

     LIR_HEADER(TestFAndBranch)

     LTestFAndBranch(const LAllocation &in, MBasicBlock *ifTrue, MBasicBlock *ifFalse)

     {

         setOperand(0, in);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

 };

 // Takes an object and tests it for truthiness.  An object is falsy iff it

 // emulates |undefined|; see js::EmulatesUndefined.

 class LTestOAndBranch : public LControlInstructionHelper<2, 1, 1>

 {

   public:

     LIR_HEADER(TestOAndBranch)

     LTestOAndBranch(const LAllocation &input, MBasicBlock *ifTruthy, MBasicBlock *ifFalsy,

                     const LDefinition &temp)

     {

         setOperand(0, input);

         setSuccessor(0, ifTruthy);

         setSuccessor(1, ifFalsy);

         setTemp(0, temp);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     MBasicBlock *ifTruthy() {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalsy() {

         return getSuccessor(1);

     }

     MTest *mir() {

         return mir_->toTest();

     }

 };

 // Takes in a boxed value and tests it for truthiness.

 class LTestVAndBranch : public LControlInstructionHelper<2, BOX_PIECES, 3>

 {

   public:

     LIR_HEADER(TestVAndBranch)

     LTestVAndBranch(MBasicBlock *ifTruthy, MBasicBlock *ifFalsy, const LDefinition &temp0,

                     const LDefinition &temp1, const LDefinition &temp2)

     {

         setSuccessor(0, ifTruthy);

         setSuccessor(1, ifFalsy);

         setTemp(0, temp0);

         setTemp(1, temp1);

         setTemp(2, temp2);

     }

     const char *extraName() const {

         return mir()->operandMightEmulateUndefined() ? "MightEmulateUndefined" : nullptr;

     }

     static const size_t Input = 0;

     const LDefinition *tempFloat() {

         return getTemp(0);

     }

     const LDefinition *temp1() {

         return getTemp(1);

     }

     const LDefinition *temp2() {

         return getTemp(2);

     }

     MBasicBlock *ifTruthy() {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalsy() {

         return getSuccessor(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

 };

 // Dispatches control flow to a successor based on incoming JSFunction*.

 // Used to implemenent polymorphic inlining.

 class LFunctionDispatch : public LInstructionHelper<0, 1, 0>

 {

     // Dispatch is performed based on a function -> block map

     // stored in the MIR.

   public:

     LIR_HEADER(FunctionDispatch);

     LFunctionDispatch(const LAllocation &in) {

         setOperand(0, in);

     }

     MFunctionDispatch *mir() {

         return mir_->toFunctionDispatch();

     }

 };

 class LTypeObjectDispatch : public LInstructionHelper<0, 1, 1>

 {

     // Dispatch is performed based on a TypeObject -> block

     // map inferred by the MIR.

   public:

     LIR_HEADER(TypeObjectDispatch);

     LTypeObjectDispatch(const LAllocation &in, const LDefinition &temp) {

         setOperand(0, in);

         setTemp(0, temp);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     MTypeObjectDispatch *mir() {

         return mir_->toTypeObjectDispatch();

     }

 };

 // Compares two integral values of the same JS type, either integer or object.

 // For objects, both operands are in registers.

 class LCompare : public LInstructionHelper<1, 2, 0>

 {

     JSOp jsop_;

   public:

     LIR_HEADER(Compare)

     LCompare(JSOp jsop, const LAllocation &left, const LAllocation &right)

       : jsop_(jsop)

     {

         setOperand(0, left);

         setOperand(1, right);

     }

     JSOp jsop() const {

         return jsop_;

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

     MCompare *mir() {

         return mir_->toCompare();

     }

     const char *extraName() const {

         return js_CodeName[jsop_];

     }

 };

 // Compares two integral values of the same JS type, either integer or object.

 // For objects, both operands are in registers.

 class LCompareAndBranch : public LControlInstructionHelper<2, 2, 0>

 {

     MCompare *cmpMir_;

     JSOp jsop_;

   public:

     LIR_HEADER(CompareAndBranch)

     LCompareAndBranch(MCompare *cmpMir, JSOp jsop,

                       const LAllocation &left, const LAllocation &right,

                       MBasicBlock *ifTrue, MBasicBlock *ifFalse)

       : cmpMir_(cmpMir), jsop_(jsop)

     {

         setOperand(0, left);

         setOperand(1, right);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     JSOp jsop() const {

         return jsop_;

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

     MCompare *cmpMir() const {

         return cmpMir_;

     }

     const char *extraName() const {

         return js_CodeName[jsop_];

     }

 };

 class LCompareD : public LInstructionHelper<1, 2, 0>

 {

   public:

     LIR_HEADER(CompareD)

     LCompareD(const LAllocation &left, const LAllocation &right) {

         setOperand(0, left);

         setOperand(1, right);

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

     MCompare *mir() {

         return mir_->toCompare();

     }

 };

 class LCompareF : public LInstructionHelper<1, 2, 0>

 {

   public:

     LIR_HEADER(CompareF)

     LCompareF(const LAllocation &left, const LAllocation &right) {

         setOperand(0, left);

         setOperand(1, right);

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

     MCompare *mir() {

         return mir_->toCompare();

     }

 };

 class LCompareDAndBranch : public LControlInstructionHelper<2, 2, 0>

 {

     MCompare *cmpMir_;

   public:

     LIR_HEADER(CompareDAndBranch)

     LCompareDAndBranch(MCompare *cmpMir, const LAllocation &left, const LAllocation &right,

                        MBasicBlock *ifTrue, MBasicBlock *ifFalse)

       : cmpMir_(cmpMir)

     {

         setOperand(0, left);

         setOperand(1, right);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

     MCompare *cmpMir() const {

         return cmpMir_;

     }

 };

 class LCompareFAndBranch : public LControlInstructionHelper<2, 2, 0>

 {

     MCompare *cmpMir_;

   public:

     LIR_HEADER(CompareFAndBranch)

     LCompareFAndBranch(MCompare *cmpMir, const LAllocation &left, const LAllocation &right,

                        MBasicBlock *ifTrue, MBasicBlock *ifFalse)

       : cmpMir_(cmpMir)

     {

         setOperand(0, left);

         setOperand(1, right);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

     MCompare *cmpMir() const {

         return cmpMir_;

     }

 };

 class LCompareS : public LInstructionHelper<1, 2, 1>

 {

   public:

     LIR_HEADER(CompareS)

     LCompareS(const LAllocation &left, const LAllocation &right,

               const LDefinition &temp) {

         setOperand(0, left);

         setOperand(1, right);

         setTemp(0, temp);

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     MCompare *mir() {

         return mir_->toCompare();

     }

 };

 // strict-equality between value and string.

 class LCompareStrictS : public LInstructionHelper<1, BOX_PIECES + 1, 2>

 {

   public:

     LIR_HEADER(CompareStrictS)

     LCompareStrictS(const LAllocation &rhs, const LDefinition &temp0,

                     const LDefinition &temp1) {

         setOperand(BOX_PIECES, rhs);

         setTemp(0, temp0);

         setTemp(1, temp1);

     }

     static const size_t Lhs = 0;

     const LAllocation *right() {

         return getOperand(BOX_PIECES);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     const LDefinition *tempToUnbox() {

         return getTemp(1);

     }

     MCompare *mir() {

         return mir_->toCompare();

     }

 };

 // Used for strict-equality comparisons where one side is a boolean

 // and the other is a value. Note that CompareI is used to compare

 // two booleans.

 class LCompareB : public LInstructionHelper<1, BOX_PIECES + 1, 0>

 {

   public:

     LIR_HEADER(CompareB)

     LCompareB(const LAllocation &rhs) {

         setOperand(BOX_PIECES, rhs);

     }

     static const size_t Lhs = 0;

     const LAllocation *rhs() {

         return getOperand(BOX_PIECES);

     }

     MCompare *mir() {

         return mir_->toCompare();

     }

 };

 class LCompareBAndBranch : public LControlInstructionHelper<2, BOX_PIECES + 1, 0>

 {

     MCompare *cmpMir_;

   public:

     LIR_HEADER(CompareBAndBranch)

     LCompareBAndBranch(MCompare *cmpMir, const LAllocation &rhs,

                        MBasicBlock *ifTrue, MBasicBlock *ifFalse)

       : cmpMir_(cmpMir)

     {

         setOperand(BOX_PIECES, rhs);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     static const size_t Lhs = 0;

     const LAllocation *rhs() {

         return getOperand(BOX_PIECES);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

     MCompare *cmpMir() const {

         return cmpMir_;

     }

 };

 class LCompareV : public LInstructionHelper<1, 2 * BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(CompareV)

     static const size_t LhsInput = 0;

     static const size_t RhsInput = BOX_PIECES;

     MCompare *mir() const {

         return mir_->toCompare();

     }

 };

 class LCompareVAndBranch : public LControlInstructionHelper<2, 2 * BOX_PIECES, 0>

 {

     MCompare *cmpMir_;

   public:

     LIR_HEADER(CompareVAndBranch)

     static const size_t LhsInput = 0;

     static const size_t RhsInput = BOX_PIECES;

     LCompareVAndBranch(MCompare *cmpMir, MBasicBlock *ifTrue, MBasicBlock *ifFalse)

       : cmpMir_(cmpMir)

     {

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

     MCompare *cmpMir() const {

         return cmpMir_;

     }

 };

 class LCompareVM : public LCallInstructionHelper<1, 2 * BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(CompareVM)

     static const size_t LhsInput = 0;

     static const size_t RhsInput = BOX_PIECES;

     MCompare *mir() const {

         return mir_->toCompare();

     }

 };

 class LBitAndAndBranch : public LControlInstructionHelper<2, 2, 0>

 {

   public:

     LIR_HEADER(BitAndAndBranch)

     LBitAndAndBranch(MBasicBlock *ifTrue, MBasicBlock *ifFalse)

     {

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     const LAllocation *left() {

         return getOperand(0);

     }

     const LAllocation *right() {

         return getOperand(1);

     }

 };

 class LIsNullOrLikeUndefined : public LInstructionHelper<1, BOX_PIECES, 2>

 {

   public:

     LIR_HEADER(IsNullOrLikeUndefined)

     LIsNullOrLikeUndefined(const LDefinition &temp, const LDefinition &tempToUnbox)

     {

         setTemp(0, temp);

         setTemp(1, tempToUnbox);

     }

     static const size_t Value = 0;

     MCompare *mir() {

         return mir_->toCompare();

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     const LDefinition *tempToUnbox() {

         return getTemp(1);

     }

 };

 class LIsNullOrLikeUndefinedAndBranch : public LControlInstructionHelper<2, BOX_PIECES, 2>

 {

     MCompare *cmpMir_;

   public:

     LIR_HEADER(IsNullOrLikeUndefinedAndBranch)

     LIsNullOrLikeUndefinedAndBranch(MCompare *cmpMir, MBasicBlock *ifTrue, MBasicBlock *ifFalse,

                                     const LDefinition &temp, const LDefinition &tempToUnbox)

       : cmpMir_(cmpMir)

     {

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

         setTemp(0, temp);

         setTemp(1, tempToUnbox);

     }

     static const size_t Value = 0;

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

     MCompare *cmpMir() const {

         return cmpMir_;

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     const LDefinition *tempToUnbox() {

         return getTemp(1);

     }

 };

 // Takes an object and tests whether it emulates |undefined|, as determined by

 // the JSCLASS_EMULATES_UNDEFINED class flag on unwrapped objects.  See also

 // js::EmulatesUndefined.

 class LEmulatesUndefined : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(EmulatesUndefined)

     LEmulatesUndefined(const LAllocation &input)

     {

         setOperand(0, input);

     }

     MCompare *mir() {

         return mir_->toCompare();

     }

 };

 class LEmulatesUndefinedAndBranch : public LControlInstructionHelper<2, 1, 1>

 {

     MCompare *cmpMir_;

   public:

     LIR_HEADER(EmulatesUndefinedAndBranch)

     LEmulatesUndefinedAndBranch(MCompare *cmpMir, const LAllocation &input,

                                 MBasicBlock *ifTrue, MBasicBlock *ifFalse,

                                 const LDefinition &temp)

       : cmpMir_(cmpMir)

     {

         setOperand(0, input);

         setSuccessor(0, ifTrue);

         setSuccessor(1, ifFalse);

         setTemp(0, temp);

     }

     MBasicBlock *ifTrue() const {

         return getSuccessor(0);

     }

     MBasicBlock *ifFalse() const {

         return getSuccessor(1);

     }

     MTest *mir() const {

         return mir_->toTest();

     }

     MCompare *cmpMir() const {

         return cmpMir_;

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

 };

 // Not operation on an integer.

 class LNotI : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NotI)

     LNotI(const LAllocation &input) {

         setOperand(0, input);

     }

 };

 // Not operation on a double.

 class LNotD : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NotD)

     LNotD(const LAllocation &input) {

         setOperand(0, input);

     }

     MNot *mir() {

         return mir_->toNot();

     }

 };

 // Not operation on a float32.

 class LNotF : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NotF)

     LNotF(const LAllocation &input) {

         setOperand(0, input);

     }

     MNot *mir() {

         return mir_->toNot();

     }

 };

 // Boolean complement operation on an object.

 class LNotO : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NotO)

     LNotO(const LAllocation &input)

     {

         setOperand(0, input);

     }

     MNot *mir() {

         return mir_->toNot();

     }

 };

 // Boolean complement operation on a value.

 class LNotV : public LInstructionHelper<1, BOX_PIECES, 3>

 {

   public:

     LIR_HEADER(NotV)

     static const size_t Input = 0;

     LNotV(const LDefinition &temp0, const LDefinition &temp1, const LDefinition &temp2)

     {

         setTemp(0, temp0);

         setTemp(1, temp1);

         setTemp(2, temp2);

     }

     const LDefinition *tempFloat() {

         return getTemp(0);

     }

     const LDefinition *temp1() {

         return getTemp(1);

     }

     const LDefinition *temp2() {

         return getTemp(2);

     }

     MNot *mir() {

         return mir_->toNot();

     }

 };

 // Bitwise not operation, takes a 32-bit integer as input and returning

 // a 32-bit integer result as an output.

 class LBitNotI : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(BitNotI)

 };

 // Call a VM function to perform a BITNOT operation.

 class LBitNotV : public LCallInstructionHelper<1, BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(BitNotV)

     static const size_t Input = 0;

 };

 // Binary bitwise operation, taking two 32-bit integers as inputs and returning

 // a 32-bit integer result as an output.

 class LBitOpI : public LInstructionHelper<1, 2, 0>

 {

     JSOp op_;

   public:

     LIR_HEADER(BitOpI)

     LBitOpI(JSOp op)

       : op_(op)

     { }

     const char *extraName() const {

         if (bitop() == JSOP_URSH && mir_->toUrsh()->bailoutsDisabled())

             return "ursh:BailoutsDisabled";

         return js_CodeName[op_];

     }

     JSOp bitop() const {

         return op_;

     }

 };

 // Call a VM function to perform a bitwise operation.

 class LBitOpV : public LCallInstructionHelper<1, 2 * BOX_PIECES, 0>

 {

     JSOp jsop_;

   public:

     LIR_HEADER(BitOpV)

     LBitOpV(JSOp jsop)

       : jsop_(jsop)

     { }

     JSOp jsop() const {

         return jsop_;

     }

     const char *extraName() const {

         return js_CodeName[jsop_];

     }

     static const size_t LhsInput = 0;

     static const size_t RhsInput = BOX_PIECES;

 };

 // Shift operation, taking two 32-bit integers as inputs and returning

 // a 32-bit integer result as an output.

 class LShiftI : public LBinaryMath<0>

 {

     JSOp op_;

   public:

     LIR_HEADER(ShiftI)

     LShiftI(JSOp op)

       : op_(op)

     { }

     JSOp bitop() {

         return op_;

     }

     MInstruction *mir() {

         return mir_->toInstruction();

     }

     const char *extraName() const {

         return js_CodeName[op_];

     }

 };

 class LUrshD : public LBinaryMath<1>

 {

   public:

     LIR_HEADER(UrshD)

     LUrshD(const LAllocation &lhs, const LAllocation &rhs, const LDefinition &temp) {

         setOperand(0, lhs);

         setOperand(1, rhs);

         setTemp(0, temp);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

 };

 // Returns from the function being compiled (not used in inlined frames). The

 // input must be a box.

 class LReturn : public LInstructionHelper<0, BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(Return)

 };

 class LThrow : public LCallInstructionHelper<0, BOX_PIECES, 0>

 {

   public:

     LIR_HEADER(Throw)

     static const size_t Value = 0;

 };

 class LMinMaxI : public LInstructionHelper<1, 2, 0>

 {

   public:

     LIR_HEADER(MinMaxI)

     LMinMaxI(const LAllocation &first, const LAllocation &second)

     {

         setOperand(0, first);

         setOperand(1, second);

     }

     const LAllocation *first() {

         return this->getOperand(0);

     }

     const LAllocation *second() {

         return this->getOperand(1);

     }

     const LDefinition *output() {

         return this->getDef(0);

     }

     MMinMax *mir() const {

         return mir_->toMinMax();

     }

     const char *extraName() const {

         return mir()->isMax() ? "Max" : "Min";

     }

 };

 class LMinMaxD : public LInstructionHelper<1, 2, 0>

 {

   public:

     LIR_HEADER(MinMaxD)

     LMinMaxD(const LAllocation &first, const LAllocation &second)

     {

         setOperand(0, first);

         setOperand(1, second);

     }

     const LAllocation *first() {

         return this->getOperand(0);

     }

     const LAllocation *second() {

         return this->getOperand(1);

     }

     const LDefinition *output() {

         return this->getDef(0);

     }

     MMinMax *mir() const {

         return mir_->toMinMax();

     }

     const char *extraName() const {

         return mir()->isMax() ? "Max" : "Min";

     }

 };

 // Negative of an integer

 class LNegI : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NegI);

     LNegI(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 // Negative of a double.

 class LNegD : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NegD)

     LNegD(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 // Negative of a float32.

 class LNegF : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(NegF)

     LNegF(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 // Absolute value of an integer.

 class LAbsI : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(AbsI)

     LAbsI(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 // Absolute value of a double.

 class LAbsD : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(AbsD)

     LAbsD(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 // Absolute value of a float32.

 class LAbsF : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(AbsF)

     LAbsF(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 // Square root of a double.

 class LSqrtD : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(SqrtD)

     LSqrtD(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 // Square root of a float32.

 class LSqrtF : public LInstructionHelper<1, 1, 0>

 {

   public:

     LIR_HEADER(SqrtF)

     LSqrtF(const LAllocation &num) {

         setOperand(0, num);

     }

 };

 class LAtan2D : public LCallInstructionHelper<1, 2, 1>

 {

   public:

     LIR_HEADER(Atan2D)

     LAtan2D(const LAllocation &y, const LAllocation &x, const LDefinition &temp) {

         setOperand(0, y);

         setOperand(1, x);

         setTemp(0, temp);

     }

     const LAllocation *y() {

         return getOperand(0);

     }

     const LAllocation *x() {

         return getOperand(1);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     const LDefinition *output() {

         return getDef(0);

     }

 };

 class LHypot : public LCallInstructionHelper<1, 2, 1>

 {

   public:

     LIR_HEADER(Hypot)

     LHypot(const LAllocation &x, const LAllocation &y, const LDefinition &temp) {

         setOperand(0, x);

         setOperand(1, y);

         setTemp(0, temp);

     }

     const LAllocation *x() {

         return getOperand(0);

     }

     const LAllocation *y() {

         return getOperand(1);

     }

     const LDefinition *temp() {

         return getTemp(0);

     }

     const LDefinition *output() {

         return getDef(0);

     }

 };

 // Double raised to an integer power.

 class LPowI : public LCallInstructionHelper<1, 2, 1>

 {

   public:

     LIR_HEADER(PowI)

     LPowI(const LAllocation &value, const LAllocation &power, const LDefinition &temp) {

         setOperand(0, value);

         setOperand(1, power);

         setTemp(0, temp);

     }

     const LAllocation *value() {