Home | History | Annotate | Download | only in jit 
      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     private:
    105         JITCode(void* code, PassRefPtr<ExecutablePool> executablePool, size_t size)
    106             : m_ref(code, executablePool, size)
    107         {
    108         }
    109 
    110         CodeRef m_ref;
    111     };
    112 
    113 };
    114 
    115 #endif
    116 
    117 #endif
    118