The Tor Browser: js/src/jit/arm/MoveEmitter-arm.cpp@6474c204b198 (annotated)

js/src/jit/arm/MoveEmitter-arm.cpp@6474c204b198 (annotated)

js/src/jit/arm/MoveEmitter-arm.cpp

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/. */
 #include "jit/arm/MoveEmitter-arm.h"
 using namespace js;
 using namespace js::jit;
 MoveEmitterARM::MoveEmitterARM(MacroAssemblerARMCompat &masm)
   : inCycle_(false),
     masm(masm),
     pushedAtCycle_(-1),
     pushedAtSpill_(-1),
     spilledReg_(InvalidReg),
     spilledFloatReg_(InvalidFloatReg)
 {
     pushedAtStart_ = masm.framePushed();
 }
 void
 MoveEmitterARM::emit(const MoveResolver &moves)
 {
     if (moves.hasCycles()) {
         // Reserve stack for cycle resolution
         masm.reserveStack(sizeof(double));
         pushedAtCycle_ = masm.framePushed();
     }
     for (size_t i = 0; i < moves.numMoves(); i++)
         emit(moves.getMove(i));
 }
 MoveEmitterARM::~MoveEmitterARM()
 {
     assertDone();
 }
 Operand
 MoveEmitterARM::cycleSlot() const
 {
     int offset =  masm.framePushed() - pushedAtCycle_;
     JS_ASSERT(offset < 4096 && offset > -4096);
     return Operand(StackPointer, offset);
 }
 // THIS IS ALWAYS AN LDRAddr.  It should not be wrapped in an operand, methinks
 Operand
 MoveEmitterARM::spillSlot() const
 {
     int offset =  masm.framePushed() - pushedAtSpill_;
     JS_ASSERT(offset < 4096 && offset > -4096);
     return Operand(StackPointer, offset);
 }
 Operand
 MoveEmitterARM::toOperand(const MoveOperand &operand, bool isFloat) const
 {
     if (operand.isMemoryOrEffectiveAddress()) {
         if (operand.base() != StackPointer) {
             JS_ASSERT(operand.disp() < 1024 && operand.disp() > -1024);
             return Operand(operand.base(), operand.disp());
         }
         JS_ASSERT(operand.disp() >= 0);
         // Otherwise, the stack offset may need to be adjusted.
         return Operand(StackPointer, operand.disp() + (masm.framePushed() - pushedAtStart_));
     }
     if (operand.isGeneralReg())
         return Operand(operand.reg());
     JS_ASSERT(operand.isFloatReg());
     return Operand(operand.floatReg());
 }
 Register
 MoveEmitterARM::tempReg()
 {
     if (spilledReg_ != InvalidReg)
         return spilledReg_;
     // For now, just pick r12/ip as the eviction point. This is totally
     // random, and if it ends up being bad, we can use actual heuristics later.
     // r12 is actually a bad choice.  it is the scratch register, which is frequently
     // used for address computations, such as those found when we attempt to access
     // values more than 4096 off of the stack pointer.
     // instead, use lr, the LinkRegister.
     spilledReg_ = r14;
     if (pushedAtSpill_ == -1) {
         masm.Push(spilledReg_);
         pushedAtSpill_ = masm.framePushed();
     } else {
         masm.ma_str(spilledReg_, spillSlot());
     }
     return spilledReg_;
 }
 void
 MoveEmitterARM::breakCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type)
 {
     // There is some pattern:
     //   (A -> B)
     //   (B -> A)
     //
     // This case handles (A -> B), which we reach first. We save B, then allow
     // the original move to continue.
     switch (type) {
       case MoveOp::FLOAT32:
       case MoveOp::DOUBLE:
         if (to.isMemory()) {
             FloatRegister temp = ScratchFloatReg;
             masm.ma_vldr(toOperand(to, true), temp);
             masm.ma_vstr(temp, cycleSlot());
         } else {
             masm.ma_vstr(to.floatReg(), cycleSlot());
         }
         break;
       case MoveOp::INT32:
       case MoveOp::GENERAL:
         // an non-vfp value
         if (to.isMemory()) {
             Register temp = tempReg();
             masm.ma_ldr(toOperand(to, false), temp);
             masm.ma_str(temp, cycleSlot());
         } else {
             if (to.reg() == spilledReg_) {
                 // If the destination was spilled, restore it first.
                 masm.ma_ldr(spillSlot(), spilledReg_);
                 spilledReg_ = InvalidReg;
             }
             masm.ma_str(to.reg(), cycleSlot());
         }
         break;
       default:
         MOZ_ASSUME_UNREACHABLE("Unexpected move type");
     }
 }
 void
 MoveEmitterARM::completeCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type)
 {
     // There is some pattern:
     //   (A -> B)
     //   (B -> A)
     //
     // This case handles (B -> A), which we reach last. We emit a move from the
     // saved value of B, to A.
     switch (type) {
       case MoveOp::FLOAT32:
       case MoveOp::DOUBLE:
         if (to.isMemory()) {
             FloatRegister temp = ScratchFloatReg;
             masm.ma_vldr(cycleSlot(), temp);
             masm.ma_vstr(temp, toOperand(to, true));
         } else {
             masm.ma_vldr(cycleSlot(), to.floatReg());
         }
         break;
       case MoveOp::INT32:
       case MoveOp::GENERAL:
         if (to.isMemory()) {
             Register temp = tempReg();
             masm.ma_ldr(cycleSlot(), temp);
             masm.ma_str(temp, toOperand(to, false));
         } else {
             if (to.reg() == spilledReg_) {
                 // Make sure we don't re-clobber the spilled register later.
                 spilledReg_ = InvalidReg;
             }
             masm.ma_ldr(cycleSlot(), to.reg());
         }
         break;
       default:
         MOZ_ASSUME_UNREACHABLE("Unexpected move type");
     }
 }
 void
 MoveEmitterARM::emitMove(const MoveOperand &from, const MoveOperand &to)
 {
     if (to.isGeneralReg() && to.reg() == spilledReg_) {
         // If the destination is the spilled register, make sure we
         // don't re-clobber its value.
         spilledReg_ = InvalidReg;
     }
     if (from.isGeneralReg()) {
         if (from.reg() == spilledReg_) {
             // If the source is a register that has been spilled, make sure
             // to load the source back into that register.
             masm.ma_ldr(spillSlot(), spilledReg_);
             spilledReg_ = InvalidReg;
         }
         switch (toOperand(to, false).getTag()) {
           case Operand::OP2:
             // secretly must be a register
             masm.ma_mov(from.reg(), to.reg());
             break;
           case Operand::MEM:
             masm.ma_str(from.reg(), toOperand(to, false));
             break;
           default:
             MOZ_ASSUME_UNREACHABLE("strange move!");
         }
     } else if (to.isGeneralReg()) {
         JS_ASSERT(from.isMemoryOrEffectiveAddress());
         if (from.isMemory())
             masm.ma_ldr(toOperand(from, false), to.reg());
         else
             masm.ma_add(from.base(), Imm32(from.disp()), to.reg());
     } else {
         // Memory to memory gpr move.
         Register reg = tempReg();
         JS_ASSERT(from.isMemoryOrEffectiveAddress());
         if (from.isMemory())
             masm.ma_ldr(toOperand(from, false), reg);
         else
             masm.ma_add(from.base(), Imm32(from.disp()), reg);
         JS_ASSERT(to.base() != reg);
         masm.ma_str(reg, toOperand(to, false));
     }
 }
 void
 MoveEmitterARM::emitFloat32Move(const MoveOperand &from, const MoveOperand &to)
 {
     if (from.isFloatReg()) {
         if (to.isFloatReg())
             masm.ma_vmov_f32(from.floatReg(), to.floatReg());
         else
             masm.ma_vstr(VFPRegister(from.floatReg()).singleOverlay(),
                          toOperand(to, true));
     } else if (to.isFloatReg()) {
         masm.ma_vldr(toOperand(from, true),
                      VFPRegister(to.floatReg()).singleOverlay());
     } else {
         // Memory to memory move.
         JS_ASSERT(from.isMemory());
         FloatRegister reg = ScratchFloatReg;
         masm.ma_vldr(toOperand(from, true),
                      VFPRegister(reg).singleOverlay());
         masm.ma_vstr(VFPRegister(reg).singleOverlay(),
                      toOperand(to, true));
     }
 }
 void
 MoveEmitterARM::emitDoubleMove(const MoveOperand &from, const MoveOperand &to)
 {
     if (from.isFloatReg()) {
         if (to.isFloatReg())
             masm.ma_vmov(from.floatReg(), to.floatReg());
         else
             masm.ma_vstr(from.floatReg(), toOperand(to, true));
     } else if (to.isFloatReg()) {
         masm.ma_vldr(toOperand(from, true), to.floatReg());
     } else {
         // Memory to memory move.
         JS_ASSERT(from.isMemory());
         FloatRegister reg = ScratchFloatReg;
         masm.ma_vldr(toOperand(from, true), reg);
         masm.ma_vstr(reg, toOperand(to, true));
     }
 }
 void
 MoveEmitterARM::emit(const MoveOp &move)
 {
     const MoveOperand &from = move.from();
     const MoveOperand &to = move.to();
     if (move.isCycleEnd()) {
         JS_ASSERT(inCycle_);
         completeCycle(from, to, move.type());
         inCycle_ = false;
         return;
     }
     if (move.isCycleBegin()) {
         JS_ASSERT(!inCycle_);
         breakCycle(from, to, move.endCycleType());
         inCycle_ = true;
     }
     switch (move.type()) {
       case MoveOp::FLOAT32:
         emitFloat32Move(from, to);
         break;
       case MoveOp::DOUBLE:
         emitDoubleMove(from, to);
         break;
       case MoveOp::INT32:
       case MoveOp::GENERAL:
         emitMove(from, to);
         break;
       default:
         MOZ_ASSUME_UNREACHABLE("Unexpected move type");
     }
 }
 void
 MoveEmitterARM::assertDone()
 {
     JS_ASSERT(!inCycle_);
 }
 void
 MoveEmitterARM::finish()
 {
     assertDone();
     if (pushedAtSpill_ != -1 && spilledReg_ != InvalidReg)
         masm.ma_ldr(spillSlot(), spilledReg_);
     masm.freeStack(masm.framePushed() - pushedAtStart_);
 }

The Tor Browser / annotate

js/src/jit/arm/MoveEmitter-arm.cpp@6474c204b198 (annotated)

js/src/jit/arm/MoveEmitter-arm.cpp