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 #include <wtf/Platform.h>
     30 
     31 #if ENABLE(JIT)
     32 
     33 #include "CallFrame.h"
     34 #include "JSValue.h"
     35 #include "MacroAssemblerCodeRef.h"
     36 #include "Profiler.h"
     37 
     38 namespace JSC {
     39 
     40     class JSGlobalData;
     41     class RegisterFile;
     42 
     43     class JITCode {
     44         typedef MacroAssemblerCodeRef CodeRef;
     45         typedef MacroAssemblerCodePtr CodePtr;
     46     public:
     47         JITCode()
     48         {
     49         }
     50 
     51         JITCode(const CodeRef ref)
     52             : m_ref(ref)
     53         {
     54         }
     55 
     56         bool operator !() const
     57         {
     58             return !m_ref.m_code.executableAddress();
     59         }
     60 
     61         CodePtr addressForCall()
     62         {
     63             return m_ref.m_code;
     64         }
     65 
     66         // This function returns the offset in bytes of 'pointerIntoCode' into
     67         // this block of code.  The pointer provided must be a pointer into this
     68         // block of code.  It is ASSERTed that no codeblock >4gb in size.
     69         unsigned offsetOf(void* pointerIntoCode)
     70         {
     71             intptr_t result = reinterpret_cast<intptr_t>(pointerIntoCode) - reinterpret_cast<intptr_t>(m_ref.m_code.executableAddress());
     72             ASSERT(static_cast<intptr_t>(static_cast<unsigned>(result)) == result);
     73             return static_cast<unsigned>(result);
     74         }
     75 
     76         // Execute the code!
     77         inline JSValue execute(RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData, JSValue* exception)
     78         {
     79             return JSValue::decode(ctiTrampoline(m_ref.m_code.executableAddress(), registerFile, callFrame, exception, Profiler::enabledProfilerReference(), globalData));
     80         }
     81 
     82         void* start()
     83         {
     84             return m_ref.m_code.dataLocation();
     85         }
     86 
     87         size_t size()
     88         {
     89             ASSERT(m_ref.m_code.executableAddress());
     90             return m_ref.m_size;
     91         }
     92 
     93         ExecutablePool* getExecutablePool()
     94         {
     95             return m_ref.m_executablePool.get();
     96         }
     97 
     98         // Host functions are a bit special; they have a m_code pointer but they
     99         // do not individully ref the executable pool containing the trampoline.
    100         static JITCode HostFunction(CodePtr code)
    101         {
    102             return JITCode(code.dataLocation(), 0, 0);
    103         }
    104 
    105     private:
    106         JITCode(void* code, PassRefPtr<ExecutablePool> executablePool, size_t size)
    107             : m_ref(code, executablePool, size)
    108         {
    109         }
    110 
    111         CodeRef m_ref;
    112     };
    113 
    114 };
    115 
    116 #endif
    117 
    118 #endif
    119