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_BaselineFrameInfo_h

 #define jit_BaselineFrameInfo_h

 #ifdef JS_ION

 #include "mozilla/Alignment.h"

 #include "jit/BaselineFrame.h"

 #include "jit/BaselineRegisters.h"

 #include "jit/FixedList.h"

 #include "jit/IonMacroAssembler.h"

 namespace js {

 namespace jit {

 struct BytecodeInfo;

 // FrameInfo overview.

 //

 // FrameInfo is used by the compiler to track values stored in the frame. This

 // includes locals, arguments and stack values. Locals and arguments are always

 // fully synced. Stack values can either be synced, stored as constant, stored in

 // a Value register or refer to a local slot. Syncing a StackValue ensures it's

 // stored on the stack, e.g. kind == Stack.

 //

 // To see how this works, consider the following statement:

 //

 //    var y = x + 9;

 //

 // Here two values are pushed: StackValue(LocalSlot(0)) and StackValue(Int32Value(9)).

 // Only when we reach the ADD op, code is generated to load the operands directly

 // into the right operand registers and sync all other stack values.

 //

 // For stack values, the following invariants hold (and are checked between ops):

 //

 // (1) If a value is synced (kind == Stack), all values below it must also be synced.

 //     In other words, values with kind other than Stack can only appear on top of the

 //     abstract stack.

 //

 // (2) When we call a stub or IC, all values still on the stack must be synced.

 // Represents a value pushed on the stack. Note that StackValue is not used for

 // locals or arguments since these are always fully synced.

 class StackValue

 {

   public:

     enum Kind {

         Constant,

         Register,

         Stack,

         LocalSlot,

         ArgSlot,

         ThisSlot

 #ifdef DEBUG

         // In debug builds, assert Kind is initialized.

         , Uninitialized

 #endif

     };

   private:

     Kind kind_;

     union {

         struct {

             Value v;

         } constant;

         struct {

             mozilla::AlignedStorage2<ValueOperand> reg;

         } reg;

         struct {

             uint32_t slot;

         } local;

         struct {

             uint32_t slot;

         } arg;

     } data;

     JSValueType knownType_;

   public:

     StackValue() {

         reset();

     }

     Kind kind() const {

         return kind_;

     }

     bool hasKnownType() const {

         return knownType_ != JSVAL_TYPE_UNKNOWN;

     }

     bool hasKnownType(JSValueType type) const {

         JS_ASSERT(type != JSVAL_TYPE_UNKNOWN);

         return knownType_ == type;

     }

     bool isKnownBoolean() const {

         return hasKnownType(JSVAL_TYPE_BOOLEAN);

     }

     JSValueType knownType() const {

         JS_ASSERT(hasKnownType());

         return knownType_;

     }

     void reset() {

 #ifdef DEBUG

         kind_ = Uninitialized;

         knownType_ = JSVAL_TYPE_UNKNOWN;

 #endif

     }

     Value constant() const {

         JS_ASSERT(kind_ == Constant);

         return data.constant.v;

     }

     ValueOperand reg() const {

         JS_ASSERT(kind_ == Register);

         return *data.reg.reg.addr();

     }

     uint32_t localSlot() const {

         JS_ASSERT(kind_ == LocalSlot);

         return data.local.slot;

     }

     uint32_t argSlot() const {

         JS_ASSERT(kind_ == ArgSlot);

         return data.arg.slot;

     }

     void setConstant(const Value &v) {

         kind_ = Constant;

         data.constant.v = v;

         knownType_ = v.isDouble() ? JSVAL_TYPE_DOUBLE : v.extractNonDoubleType();

     }

     void setRegister(const ValueOperand &val, JSValueType knownType = JSVAL_TYPE_UNKNOWN) {

         kind_ = Register;

         *data.reg.reg.addr() = val;

         knownType_ = knownType;

     }

     void setLocalSlot(uint32_t slot) {

         kind_ = LocalSlot;

         data.local.slot = slot;

         knownType_ = JSVAL_TYPE_UNKNOWN;

     }

     void setArgSlot(uint32_t slot) {

         kind_ = ArgSlot;

         data.arg.slot = slot;

         knownType_ = JSVAL_TYPE_UNKNOWN;

     }

     void setThis() {

         kind_ = ThisSlot;

         knownType_ = JSVAL_TYPE_UNKNOWN;

     }

     void setStack() {

         kind_ = Stack;

         knownType_ = JSVAL_TYPE_UNKNOWN;

     }

 };

 enum StackAdjustment { AdjustStack, DontAdjustStack };

 class FrameInfo

 {

     JSScript *script;

     MacroAssembler &masm;

     FixedList<StackValue> stack;

     size_t spIndex;

   public:

     FrameInfo(JSScript *script, MacroAssembler &masm)

       : script(script),

         masm(masm),

         stack(),

         spIndex(0)

     { }

     bool init(TempAllocator &alloc);

     uint32_t nlocals() const {

         return script->nfixed();

     }

     uint32_t nargs() const {

         return script->functionNonDelazifying()->nargs();

     }

   private:

     inline StackValue *rawPush() {

         StackValue *val = &stack[spIndex++];

         val->reset();

         return val;

     }

   public:

     inline size_t stackDepth() const {

         return spIndex;

     }

     inline void setStackDepth(uint32_t newDepth) {

         if (newDepth <= stackDepth()) {

             spIndex = newDepth;

         } else {

             uint32_t diff = newDepth - stackDepth();

             for (uint32_t i = 0; i < diff; i++) {

                 StackValue *val = rawPush();

                 val->setStack();

             }

             JS_ASSERT(spIndex == newDepth);

         }

     }

     inline StackValue *peek(int32_t index) const {

         JS_ASSERT(index < 0);

         return const_cast<StackValue *>(&stack[spIndex + index]);

     }

     inline void pop(StackAdjustment adjust = AdjustStack) {

         spIndex--;

         StackValue *popped = &stack[spIndex];

         if (adjust == AdjustStack && popped->kind() == StackValue::Stack)

             masm.addPtr(Imm32(sizeof(Value)), BaselineStackReg);

         // Assert when anything uses this value.

         popped->reset();

     }

     inline void popn(uint32_t n, StackAdjustment adjust = AdjustStack) {

         uint32_t poppedStack = 0;

         for (uint32_t i = 0; i < n; i++) {

             if (peek(-1)->kind() == StackValue::Stack)

                 poppedStack++;

             pop(DontAdjustStack);

         }

         if (adjust == AdjustStack && poppedStack > 0)

             masm.addPtr(Imm32(sizeof(Value) * poppedStack), BaselineStackReg);

     }

     inline void push(const Value &val) {

         StackValue *sv = rawPush();

         sv->setConstant(val);

     }

     inline void push(const ValueOperand &val, JSValueType knownType=JSVAL_TYPE_UNKNOWN) {

         StackValue *sv = rawPush();

         sv->setRegister(val, knownType);

     }

     inline void pushLocal(uint32_t local) {

         JS_ASSERT(local < nlocals());

         StackValue *sv = rawPush();

         sv->setLocalSlot(local);

     }

     inline void pushArg(uint32_t arg) {

         StackValue *sv = rawPush();

         sv->setArgSlot(arg);

     }

     inline void pushThis() {

         StackValue *sv = rawPush();

         sv->setThis();

     }

     inline void pushScratchValue() {

         masm.pushValue(addressOfScratchValue());

         StackValue *sv = rawPush();

         sv->setStack();

     }

     inline Address addressOfLocal(size_t local) const {

         JS_ASSERT(local < nlocals());

         return Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfLocal(local));

     }

     Address addressOfArg(size_t arg) const {

         JS_ASSERT(arg < nargs());

         return Address(BaselineFrameReg, BaselineFrame::offsetOfArg(arg));

     }

     Address addressOfThis() const {

         return Address(BaselineFrameReg, BaselineFrame::offsetOfThis());

     }

     Address addressOfCallee() const {

         return Address(BaselineFrameReg, BaselineFrame::offsetOfCalleeToken());

     }

     Address addressOfScopeChain() const {

         return Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfScopeChain());

     }

     Address addressOfFlags() const {

         return Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfFlags());

     }

     Address addressOfEvalScript() const {

         return Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfEvalScript());

     }

     Address addressOfReturnValue() const {

         return Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfReturnValue());

     }

     Address addressOfStackValue(const StackValue *value) const {

         JS_ASSERT(value->kind() == StackValue::Stack);

         size_t slot = value - &stack[0];

         JS_ASSERT(slot < stackDepth());

         return Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfLocal(nlocals() + slot));

     }

     Address addressOfScratchValue() const {

         return Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfScratchValue());

     }

     void popValue(ValueOperand dest);

     void sync(StackValue *val);

     void syncStack(uint32_t uses);

     uint32_t numUnsyncedSlots();

     void popRegsAndSync(uint32_t uses);

     inline void assertSyncedStack() const {

         JS_ASSERT_IF(stackDepth() > 0, peek(-1)->kind() == StackValue::Stack);

     }

 #ifdef DEBUG

     // Assert the state is valid before excuting "pc".

     void assertValidState(const BytecodeInfo &info);

 #else

     inline void assertValidState(const BytecodeInfo &info) {}

 #endif

 };

 } // namespace jit

 } // namespace js

 #endif // JS_ION

 #endif /* jit_BaselineFrameInfo_h */