jit/JITCode.h

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef JITCode_h
  27 #define JITCode_h
  28
  29 #if ENABLE(JIT)
  30
  31 #include "CallFrame.h"
  32 #include "JSValue.h"
  33 #include "MacroAssemblerCodeRef.h"
  34 #include "Profiler.h"
  35
  36 namespace JSC {
  37
  38     class JSGlobalData;
  39     class RegisterFile;
  40
  41     class JITCode {
  42         typedef MacroAssemblerCodeRef CodeRef;
  43         typedef MacroAssemblerCodePtr CodePtr;
  44     public:
  45         JITCode()
  46         {
  47         }
  48
  49         JITCode(const CodeRef ref)
  50             : m_ref(ref)
  51         {
  52         }
  53
  54         bool operator !() const
  55         {
  56             return !m_ref.m_code.executableAddress();
  57         }
  58
  59         CodePtr addressForCall()
  60         {
  61             return m_ref.m_code;
  62         }
  63
  64         // This function returns the offset in bytes of 'pointerIntoCode' into
  65         // this block of code.  The pointer provided must be a pointer into this
  66         // block of code.  It is ASSERTed that no codeblock >4gb in size.
  67         unsigned offsetOf(void* pointerIntoCode)
  68         {
  69             intptr_t result = reinterpret_cast<intptr_t>(pointerIntoCode) - reinterpret_cast<intptr_t>(m_ref.m_code.executableAddress());
  70             ASSERT(static_cast<intptr_t>(static_cast<unsigned>(result)) == result);
  71             return static_cast<unsigned>(result);
  72         }
  73
  74         // Execute the code!
  75         inline JSValue execute(RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData)
  76         {
  77             JSValue result = JSValue::decode(ctiTrampoline(m_ref.m_code.executableAddress(), registerFile, callFrame, 0, Profiler::enabledProfilerReference(), globalData));
  78             return globalData->exception ? jsNull() : result;
  79         }
  80
  81         void* start()
  82         {
  83             return m_ref.m_code.dataLocation();
  84         }
  85
  86         size_t size()
  87         {
  88             ASSERT(m_ref.m_code.executableAddress());
  89             return m_ref.m_size;
  90         }
  91
  92         ExecutablePool* getExecutablePool()
  93         {
  94             return m_ref.m_executablePool.get();
  95         }
  96
  97         // Host functions are a bit special; they have a m_code pointer but they
  98         // do not individully ref the executable pool containing the trampoline.
  99         static JITCode HostFunction(CodePtr code)
 100         {
 101             return JITCode(code.dataLocation(), 0, 0);
 102         }
 103
 104         void clear()
 105         {
 106             m_ref.~CodeRef();
 107             new (&m_ref) CodeRef();
 108         }
 109
 110     private:
 111         JITCode(void* code, PassRefPtr<ExecutablePool> executablePool, size_t size)
 112             : m_ref(code, executablePool, size)
 113         {
 114         }
 115
 116         CodeRef m_ref;
 117     };
 118
 119 };
 120
 121 #endif
 122
 123 #endif