The Tor Browser: js/src/jit/BaselineFrameInfo.h@6474c204b198 (annotated)

js/src/jit/BaselineFrameInfo.h@6474c204b198 (annotated)

js/src/jit/BaselineFrameInfo.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 */

The Tor Browser / annotate

js/src/jit/BaselineFrameInfo.h@6474c204b198 (annotated)

js/src/jit/BaselineFrameInfo.h