The Tor Browser: js/src/jit/shared/Lowering-shared-inl.h@6474c204b198 (annotated)

js/src/jit/shared/Lowering-shared-inl.h@6474c204b198 (annotated)

js/src/jit/shared/Lowering-shared-inl.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_shared_Lowering_shared_inl_h
 #define jit_shared_Lowering_shared_inl_h
 #include "jit/shared/Lowering-shared.h"
 #include "jit/MIR.h"
 #include "jit/MIRGenerator.h"
 namespace js {
 namespace jit {
 bool
 LIRGeneratorShared::emitAtUses(MInstruction *mir)
 {
     JS_ASSERT(mir->canEmitAtUses());
     mir->setEmittedAtUses();
     mir->setVirtualRegister(0);
     return true;
 }
 LUse
 LIRGeneratorShared::use(MDefinition *mir, LUse policy)
 {
     // It is illegal to call use() on an instruction with two defs.
 #if BOX_PIECES > 1
     JS_ASSERT(mir->type() != MIRType_Value);
 #endif
     if (!ensureDefined(mir))
         return policy;
     policy.setVirtualRegister(mir->virtualRegister());
     return policy;
 }
 template <size_t X, size_t Y> bool
 LIRGeneratorShared::define(LInstructionHelper<1, X, Y> *lir, MDefinition *mir, const LDefinition &def)
 {
     // Call instructions should use defineReturn.
     JS_ASSERT(!lir->isCall());
     uint32_t vreg = getVirtualRegister();
     if (vreg >= MAX_VIRTUAL_REGISTERS)
         return false;
     // Assign the definition and a virtual register. Then, propagate this
     // virtual register to the MIR, so we can map MIR to LIR during lowering.
     lir->setDef(0, def);
     lir->getDef(0)->setVirtualRegister(vreg);
     lir->setMir(mir);
     mir->setVirtualRegister(vreg);
     return add(lir);
 }
 template <size_t X, size_t Y> bool
 LIRGeneratorShared::define(LInstructionHelper<1, X, Y> *lir, MDefinition *mir, LDefinition::Policy policy)
 {
     LDefinition::Type type = LDefinition::TypeFrom(mir->type());
     return define(lir, mir, LDefinition(type, policy));
 }
 template <size_t X, size_t Y> bool
 LIRGeneratorShared::defineFixed(LInstructionHelper<1, X, Y> *lir, MDefinition *mir, const LAllocation &output)
 {
     LDefinition::Type type = LDefinition::TypeFrom(mir->type());
     LDefinition def(type, LDefinition::PRESET);
     def.setOutput(output);
     // Add an LNop to avoid regalloc problems if the next op uses this value
     // with a fixed or at-start policy.
     if (!define(lir, mir, def))
         return false;
     if (gen->optimizationInfo().registerAllocator() == RegisterAllocator_LSRA) {
         if (!add(new(alloc()) LNop))
             return false;
     }
     return true;
 }
 template <size_t Ops, size_t Temps> bool
 LIRGeneratorShared::defineReuseInput(LInstructionHelper<1, Ops, Temps> *lir, MDefinition *mir, uint32_t operand)
 {
     // The input should be used at the start of the instruction, to avoid moves.
     JS_ASSERT(lir->getOperand(operand)->toUse()->usedAtStart());
     LDefinition::Type type = LDefinition::TypeFrom(mir->type());
     LDefinition def(type, LDefinition::MUST_REUSE_INPUT);
     def.setReusedInput(operand);
     return define(lir, mir, def);
 }
 template <size_t Ops, size_t Temps> bool
 LIRGeneratorShared::defineBox(LInstructionHelper<BOX_PIECES, Ops, Temps> *lir, MDefinition *mir,
                               LDefinition::Policy policy)
 {
     // Call instructions should use defineReturn.
     JS_ASSERT(!lir->isCall());
     uint32_t vreg = getVirtualRegister();
     if (vreg >= MAX_VIRTUAL_REGISTERS)
         return false;
 #if defined(JS_NUNBOX32)
     lir->setDef(0, LDefinition(vreg + VREG_TYPE_OFFSET, LDefinition::TYPE, policy));
     lir->setDef(1, LDefinition(vreg + VREG_DATA_OFFSET, LDefinition::PAYLOAD, policy));
     if (getVirtualRegister() >= MAX_VIRTUAL_REGISTERS)
         return false;
 #elif defined(JS_PUNBOX64)
     lir->setDef(0, LDefinition(vreg, LDefinition::BOX, policy));
 #endif
     lir->setMir(mir);
     mir->setVirtualRegister(vreg);
     return add(lir);
 }
 bool
 LIRGeneratorShared::defineReturn(LInstruction *lir, MDefinition *mir)
 {
     lir->setMir(mir);
     JS_ASSERT(lir->isCall());
     uint32_t vreg = getVirtualRegister();
     if (vreg >= MAX_VIRTUAL_REGISTERS)
         return false;
     switch (mir->type()) {
       case MIRType_Value:
 #if defined(JS_NUNBOX32)
         lir->setDef(TYPE_INDEX, LDefinition(vreg + VREG_TYPE_OFFSET, LDefinition::TYPE,
                                             LGeneralReg(JSReturnReg_Type)));
         lir->setDef(PAYLOAD_INDEX, LDefinition(vreg + VREG_DATA_OFFSET, LDefinition::PAYLOAD,
                                                LGeneralReg(JSReturnReg_Data)));
         if (getVirtualRegister() >= MAX_VIRTUAL_REGISTERS)
             return false;
 #elif defined(JS_PUNBOX64)
         lir->setDef(0, LDefinition(vreg, LDefinition::BOX, LGeneralReg(JSReturnReg)));
 #endif
         break;
       case MIRType_Float32:
         lir->setDef(0, LDefinition(vreg, LDefinition::FLOAT32, LFloatReg(ReturnFloatReg)));
         break;
       case MIRType_Double:
         lir->setDef(0, LDefinition(vreg, LDefinition::DOUBLE, LFloatReg(ReturnFloatReg)));
         break;
       default:
         LDefinition::Type type = LDefinition::TypeFrom(mir->type());
         JS_ASSERT(type != LDefinition::DOUBLE && type != LDefinition::FLOAT32);
         lir->setDef(0, LDefinition(vreg, type, LGeneralReg(ReturnReg)));
         break;
     }
     mir->setVirtualRegister(vreg);
     if (!add(lir))
         return false;
     if (gen->optimizationInfo().registerAllocator() == RegisterAllocator_LSRA) {
         if (!add(new(alloc()) LNop))
             return false;
     }
     return true;
 }
 // In LIR, we treat booleans and integers as the same low-level type (INTEGER).
 // When snapshotting, we recover the actual JS type from MIR. This function
 // checks that when making redefinitions, we don't accidentally coerce two
 // incompatible types.
 static inline bool
 IsCompatibleLIRCoercion(MIRType to, MIRType from)
 {
     if (to == from)
         return true;
     if ((to == MIRType_Int32 || to == MIRType_Boolean) &&
         (from == MIRType_Int32 || from == MIRType_Boolean)) {
         return true;
     }
     return false;
 }
 bool
 LIRGeneratorShared::redefine(MDefinition *def, MDefinition *as)
 {
     JS_ASSERT(IsCompatibleLIRCoercion(def->type(), as->type()));
     // Try to emit MIR marked as emitted-at-uses at, well, uses. For
     // snapshotting reasons we delay the MIRTypes match, or when we are
     // coercing between bool and int32 constants.
     if (as->isEmittedAtUses() &&
         (def->type() == as->type() ||
          (as->isConstant() &&
           (def->type() == MIRType_Int32 || def->type() == MIRType_Boolean) &&
           (as->type() == MIRType_Int32 || as->type() == MIRType_Boolean))))
     {
         MDefinition *replacement;
         if (def->type() != as->type()) {
             Value v = as->toConstant()->value();
             if (as->type() == MIRType_Int32)
                 replacement = MConstant::New(alloc(), BooleanValue(v.toInt32()));
             else
                 replacement = MConstant::New(alloc(), Int32Value(v.toBoolean()));
             if (!emitAtUses(replacement->toInstruction()))
                 return false;
         } else {
             replacement = as;
         }
         def->replaceAllUsesWith(replacement);
         return true;
     }
     if (!ensureDefined(as))
         return false;
     def->setVirtualRegister(as->virtualRegister());
     return true;
 }
 bool
 LIRGeneratorShared::defineAs(LInstruction *outLir, MDefinition *outMir, MDefinition *inMir)
 {
     uint32_t vreg = inMir->virtualRegister();
     LDefinition::Policy policy = LDefinition::PASSTHROUGH;
     if (outMir->type() == MIRType_Value) {
 #ifdef JS_NUNBOX32
         outLir->setDef(TYPE_INDEX,
                        LDefinition(vreg + VREG_TYPE_OFFSET, LDefinition::TYPE, policy));
         outLir->setDef(PAYLOAD_INDEX,
                        LDefinition(vreg + VREG_DATA_OFFSET, LDefinition::PAYLOAD, policy));
 #elif JS_PUNBOX64
         outLir->setDef(0, LDefinition(vreg, LDefinition::BOX, policy));
 #else
 # error "Unexpected boxing type"
 #endif
     } else {
         outLir->setDef(0, LDefinition(vreg, LDefinition::TypeFrom(inMir->type()), policy));
     }
     outLir->setMir(outMir);
     return redefine(outMir, inMir);
 }
 bool
 LIRGeneratorShared::ensureDefined(MDefinition *mir)
 {
     if (mir->isEmittedAtUses()) {
         if (!mir->toInstruction()->accept(this))
             return false;
         JS_ASSERT(mir->isLowered());
     }
     return true;
 }
 LUse
 LIRGeneratorShared::useRegister(MDefinition *mir)
 {
     return use(mir, LUse(LUse::REGISTER));
 }
 LUse
 LIRGeneratorShared::useRegisterAtStart(MDefinition *mir)
 {
     return use(mir, LUse(LUse::REGISTER, true));
 }
 LUse
 LIRGeneratorShared::use(MDefinition *mir)
 {
     return use(mir, LUse(LUse::ANY));
 }
 LUse
 LIRGeneratorShared::useAtStart(MDefinition *mir)
 {
     return use(mir, LUse(LUse::ANY, true));
 }
 LAllocation
 LIRGeneratorShared::useOrConstant(MDefinition *mir)
 {
     if (mir->isConstant())
         return LAllocation(mir->toConstant()->vp());
     return use(mir);
 }
 LAllocation
 LIRGeneratorShared::useRegisterOrConstant(MDefinition *mir)
 {
     if (mir->isConstant())
         return LAllocation(mir->toConstant()->vp());
     return useRegister(mir);
 }
 LAllocation
 LIRGeneratorShared::useRegisterOrConstantAtStart(MDefinition *mir)
 {
     if (mir->isConstant())
         return LAllocation(mir->toConstant()->vp());
     return useRegisterAtStart(mir);
 }
 LAllocation
 LIRGeneratorShared::useRegisterOrNonNegativeConstantAtStart(MDefinition *mir)
 {
     if (mir->isConstant() && mir->toConstant()->value().toInt32() >= 0)
         return LAllocation(mir->toConstant()->vp());
     return useRegisterAtStart(mir);
 }
 LAllocation
 LIRGeneratorShared::useRegisterOrNonDoubleConstant(MDefinition *mir)
 {
     if (mir->isConstant() && mir->type() != MIRType_Double && mir->type() != MIRType_Float32)
         return LAllocation(mir->toConstant()->vp());
     return useRegister(mir);
 }
 #if defined(JS_CODEGEN_ARM)
 LAllocation
 LIRGeneratorShared::useAnyOrConstant(MDefinition *mir)
 {
     return useRegisterOrConstant(mir);
 }
 LAllocation
 LIRGeneratorShared::useStorable(MDefinition *mir)
 {
     return useRegister(mir);
 }
 LAllocation
 LIRGeneratorShared::useStorableAtStart(MDefinition *mir)
 {
     return useRegisterAtStart(mir);
 }
 LAllocation
 LIRGeneratorShared::useAny(MDefinition *mir)
 {
     return useRegister(mir);
 }
 #else
 LAllocation
 LIRGeneratorShared::useAnyOrConstant(MDefinition *mir)
 {
     return useOrConstant(mir);
 }
 LAllocation
 LIRGeneratorShared::useAny(MDefinition *mir)
 {
     return use(mir);
 }
 LAllocation
 LIRGeneratorShared::useStorable(MDefinition *mir)
 {
     return useRegisterOrConstant(mir);
 }
 LAllocation
 LIRGeneratorShared::useStorableAtStart(MDefinition *mir)
 {
     return useRegisterOrConstantAtStart(mir);
 }
 #endif
 LAllocation
 LIRGeneratorShared::useKeepaliveOrConstant(MDefinition *mir)
 {
     if (mir->isConstant())
         return LAllocation(mir->toConstant()->vp());
     return use(mir, LUse(LUse::KEEPALIVE));
 }
 LUse
 LIRGeneratorShared::useFixed(MDefinition *mir, Register reg)
 {
     return use(mir, LUse(reg));
 }
 LUse
 LIRGeneratorShared::useFixedAtStart(MDefinition *mir, Register reg)
 {
     return use(mir, LUse(reg, true));
 }
 LUse
 LIRGeneratorShared::useFixed(MDefinition *mir, FloatRegister reg)
 {
     return use(mir, LUse(reg));
 }
 LUse
 LIRGeneratorShared::useFixed(MDefinition *mir, AnyRegister reg)
 {
     return reg.isFloat() ? use(mir, reg.fpu()) : use(mir, reg.gpr());
 }
 LDefinition
 LIRGeneratorShared::temp(LDefinition::Type type, LDefinition::Policy policy)
 {
     uint32_t vreg = getVirtualRegister();
     if (vreg >= MAX_VIRTUAL_REGISTERS) {
         gen->abort("max virtual registers");
         return LDefinition();
     }
     return LDefinition(vreg, type, policy);
 }
 LDefinition
 LIRGeneratorShared::tempFixed(Register reg)
 {
     LDefinition t = temp(LDefinition::GENERAL);
     t.setOutput(LGeneralReg(reg));
     return t;
 }
 LDefinition
 LIRGeneratorShared::tempFloat32()
 {
     return temp(LDefinition::FLOAT32);
 }
 LDefinition
 LIRGeneratorShared::tempDouble()
 {
     return temp(LDefinition::DOUBLE);
 }
 LDefinition
 LIRGeneratorShared::tempCopy(MDefinition *input, uint32_t reusedInput)
 {
     JS_ASSERT(input->virtualRegister());
     LDefinition t = temp(LDefinition::TypeFrom(input->type()), LDefinition::MUST_REUSE_INPUT);
     t.setReusedInput(reusedInput);
     return t;
 }
 template <typename T> void
 LIRGeneratorShared::annotate(T *ins)
 {
     ins->setId(lirGraph_.getInstructionId());
 }
 template <typename T> bool
 LIRGeneratorShared::add(T *ins, MInstruction *mir)
 {
     JS_ASSERT(!ins->isPhi());
     current->add(ins);
     if (mir) {
         JS_ASSERT(current == mir->block()->lir());
         ins->setMir(mir);
     }
     annotate(ins);
     return true;
 }
 #ifdef JS_NUNBOX32
 // Returns the virtual register of a js::Value-defining instruction. This is
 // abstracted because MBox is a special value-returning instruction that
 // redefines its input payload if its input is not constant. Therefore, it is
 // illegal to request a box's payload by adding VREG_DATA_OFFSET to its raw id.
 static inline uint32_t
 VirtualRegisterOfPayload(MDefinition *mir)
 {
     if (mir->isBox()) {
         MDefinition *inner = mir->toBox()->getOperand(0);
         if (!inner->isConstant() && inner->type() != MIRType_Double && inner->type() != MIRType_Float32)
             return inner->virtualRegister();
     }
     if (mir->isTypeBarrier())
         return VirtualRegisterOfPayload(mir->getOperand(0));
     return mir->virtualRegister() + VREG_DATA_OFFSET;
 }
 // Note: always call ensureDefined before calling useType/usePayload,
 // so that emitted-at-use operands are handled correctly.
 LUse
 LIRGeneratorShared::useType(MDefinition *mir, LUse::Policy policy)
 {
     JS_ASSERT(mir->type() == MIRType_Value);
     return LUse(mir->virtualRegister() + VREG_TYPE_OFFSET, policy);
 }
 LUse
 LIRGeneratorShared::usePayload(MDefinition *mir, LUse::Policy policy)
 {
     JS_ASSERT(mir->type() == MIRType_Value);
     return LUse(VirtualRegisterOfPayload(mir), policy);
 }
 LUse
 LIRGeneratorShared::usePayloadAtStart(MDefinition *mir, LUse::Policy policy)
 {
     JS_ASSERT(mir->type() == MIRType_Value);
     return LUse(VirtualRegisterOfPayload(mir), policy, true);
 }
 LUse
 LIRGeneratorShared::usePayloadInRegisterAtStart(MDefinition *mir)
 {
     return usePayloadAtStart(mir, LUse::REGISTER);
 }
 bool
 LIRGeneratorShared::fillBoxUses(LInstruction *lir, size_t n, MDefinition *mir)
 {
     if (!ensureDefined(mir))
         return false;
     lir->getOperand(n)->toUse()->setVirtualRegister(mir->virtualRegister() + VREG_TYPE_OFFSET);
     lir->getOperand(n + 1)->toUse()->setVirtualRegister(VirtualRegisterOfPayload(mir));
     return true;
 }
 #endif
 } // namespace jit
 } // namespace js
 #endif /* jit_shared_Lowering_shared_inl_h */

The Tor Browser / annotate

js/src/jit/shared/Lowering-shared-inl.h@6474c204b198 (annotated)

js/src/jit/shared/Lowering-shared-inl.h