js/src/methodjit/InlineFrameAssembler.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * vim: set ts=4 sw=4 et tw=99:
   3  *
   4  * ***** BEGIN LICENSE BLOCK *****
   5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is Mozilla SpiderMonkey JavaScript 1.9 code, released
  18  * May 28, 2008.
  19  *
  20  * The Initial Developer of the Original Code is
  21  *   Brendan Eich <brendan@mozilla.org>
  22  *
  23  * Contributor(s):
  24  *   David Anderson <danderson@mozilla.com>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #if !defined jsjaeger_inl_frame_asm_h__ && defined JS_METHODJIT && defined JS_MONOIC
  41 #define jsjaeger_inl_frame_asm_h__
  42
  43 #include "assembler/assembler/MacroAssembler.h"
  44 #include "assembler/assembler/CodeLocation.h"
  45 #include "methodjit/MethodJIT.h"
  46 #include "CodeGenIncludes.h"
  47
  48 namespace js {
  49 namespace mjit {
  50
  51 struct AdjustedFrame {
  52     AdjustedFrame(uint32 baseOffset)
  53      : baseOffset(baseOffset)
  54     { }
  55
  56     uint32 baseOffset;
  57
  58     JSC::MacroAssembler::Address addrOf(uint32 offset) {
  59         return JSC::MacroAssembler::Address(JSFrameReg, baseOffset + offset);
  60     }
  61 };
  62
  63 /*
  64  * This is used for emitting code to inline callee-side frame creation and
  65  * should jit code equivalent to JSStackFrame::initCallFrameCallerHalf.
  66  *
  67  * Once finished, JSFrameReg is advanced to be the new fp.
  68  */
  69 class InlineFrameAssembler {
  70     typedef JSC::MacroAssembler::RegisterID RegisterID;
  71     typedef JSC::MacroAssembler::Address Address;
  72     typedef JSC::MacroAssembler::Imm32 Imm32;
  73     typedef JSC::MacroAssembler::ImmPtr ImmPtr;
  74     typedef JSC::MacroAssembler::DataLabelPtr DataLabelPtr;
  75
  76     Assembler &masm;
  77     FrameSize  frameSize;       // size of the caller's frame
  78     RegisterID funObjReg;       // register containing the function object (callee)
  79     jsbytecode *pc;             // bytecode location at the caller call site
  80     uint32     flags;           // frame flags
  81
  82   public:
  83     /*
  84      * Register state, so consumers of this class can restrict which registers
  85      * can and can't be clobbered.
  86      */
  87     Registers  tempRegs;
  88
  89     InlineFrameAssembler(Assembler &masm, ic::CallICInfo &ic, uint32 flags)
  90       : masm(masm), pc(ic.pc), flags(flags)
  91     {
  92         frameSize = ic.frameSize;
  93         funObjReg = ic.funObjReg;
  94         tempRegs.takeReg(ic.funPtrReg);
  95         tempRegs.takeReg(funObjReg);
  96     }
  97
  98     InlineFrameAssembler(Assembler &masm, Compiler::CallGenInfo &gen, uint32 flags)
  99       : masm(masm), pc(gen.pc), flags(flags)
 100     {
 101         frameSize = gen.frameSize;
 102         funObjReg = gen.funObjReg;
 103         tempRegs.takeReg(funObjReg);
 104     }
 105
 106     DataLabelPtr assemble(void *ncode)
 107     {
 108         JS_ASSERT((flags & ~JSFRAME_CONSTRUCTING) == 0);
 109
 110         /* Generate JSStackFrame::initCallFrameCallerHalf. */
 111
 112         DataLabelPtr ncodePatch;
 113         if (frameSize.isStatic()) {
 114             uint32 frameDepth = frameSize.staticLocalSlots();
 115             AdjustedFrame newfp(sizeof(JSStackFrame) + frameDepth * sizeof(Value));
 116
 117             Address flagsAddr = newfp.addrOf(JSStackFrame::offsetOfFlags());
 118             masm.store32(Imm32(JSFRAME_FUNCTION | flags), flagsAddr);
 119             Address prevAddr = newfp.addrOf(JSStackFrame::offsetOfPrev());
 120             masm.storePtr(JSFrameReg, prevAddr);
 121             Address ncodeAddr = newfp.addrOf(JSStackFrame::offsetOfncode());
 122             ncodePatch = masm.storePtrWithPatch(ImmPtr(ncode), ncodeAddr);
 123
 124             masm.addPtr(Imm32(sizeof(JSStackFrame) + frameDepth * sizeof(Value)), JSFrameReg);
 125         } else {
 126             /*
 127              * If the frame size is dynamic, then the fast path generated by
 128              * generateFullCallStub must be used. Thus, this code is executed
 129              * after stubs::SplatApplyArgs has been called. SplatApplyArgs
 130              * stores the dynamic stack pointer (i.e., regs.sp after pushing a
 131              * dynamic number of arguments) to VMFrame.regs, so we just load it
 132              * here to get the new frame pointer.
 133              */
 134             RegisterID newfp = tempRegs.takeAnyReg();
 135             masm.loadPtr(FrameAddress(offsetof(VMFrame, regs.sp)), newfp);
 136
 137             Address flagsAddr(newfp, JSStackFrame::offsetOfFlags());
 138             masm.store32(Imm32(JSFRAME_FUNCTION | flags), flagsAddr);
 139             Address prevAddr(newfp, JSStackFrame::offsetOfPrev());
 140             masm.storePtr(JSFrameReg, prevAddr);
 141             Address ncodeAddr(newfp, JSStackFrame::offsetOfncode());
 142             ncodePatch = masm.storePtrWithPatch(ImmPtr(ncode), ncodeAddr);
 143
 144             masm.move(newfp, JSFrameReg);
 145             tempRegs.putReg(newfp);
 146         }
 147
 148         return ncodePatch;
 149     }
 150 };
 151
 152
 153 } /* namespace mjit */
 154 } /* namespace js */
 155
 156 #endif /* jsjaeger_inl_frame_asm_h__ */
 157