assembler/MacroAssemblerCodeRef.h

   1 /*
   2  * Copyright (C) 2009 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 MacroAssemblerCodeRef_h
  27 #define MacroAssemblerCodeRef_h
  28
  29 #include "ExecutableAllocator.h"
  30 #include "PassRefPtr.h"
  31 #include "RefPtr.h"
  32 #include "UnusedParam.h"
  33
  34 #if ENABLE(ASSEMBLER)
  35
  36 // ASSERT_VALID_CODE_POINTER checks that ptr is a non-null pointer, and that it is a valid
  37 // instruction address on the platform (for example, check any alignment requirements).
  38 #if CPU(ARM_THUMB2)
  39 // ARM/thumb instructions must be 16-bit aligned, but all code pointers to be loaded
  40 // into the processor are decorated with the bottom bit set, indicating that this is
  41 // thumb code (as oposed to 32-bit traditional ARM).  The first test checks for both
  42 // decorated and undectorated null, and the second test ensures that the pointer is
  43 // decorated.
  44 #define ASSERT_VALID_CODE_POINTER(ptr) \
  45     ASSERT(reinterpret_cast<intptr_t>(ptr) & ~1); \
  46     ASSERT(reinterpret_cast<intptr_t>(ptr) & 1)
  47 #define ASSERT_VALID_CODE_OFFSET(offset) \
  48     ASSERT(!(offset & 1)) // Must be multiple of 2.
  49 #else
  50 #define ASSERT_VALID_CODE_POINTER(ptr) \
  51     ASSERT(ptr)
  52 #define ASSERT_VALID_CODE_OFFSET(offset) // Anything goes!
  53 #endif
  54
  55 namespace JSC {
  56
  57 // FunctionPtr:
  58 //
  59 // FunctionPtr should be used to wrap pointers to C/C++ functions in JSC
  60 // (particularly, the stub functions).
  61 class FunctionPtr {
  62 public:
  63     FunctionPtr()
  64         : m_value(0)
  65     {
  66     }
  67
  68     template<typename FunctionType>
  69     explicit FunctionPtr(FunctionType* value)
  70 #if COMPILER(RVCT)
  71      // RVTC compiler needs C-style cast as it fails with the following error
  72      // Error:  #694: reinterpret_cast cannot cast away const or other type qualifiers
  73         : m_value((void*)(value))
  74 #else
  75         : m_value(reinterpret_cast<void*>(value))
  76 #endif
  77     {
  78         ASSERT_VALID_CODE_POINTER(m_value);
  79     }
  80
  81     void* value() const { return m_value; }
  82     void* executableAddress() const { return m_value; }
  83
  84
  85 private:
  86     void* m_value;
  87 };
  88
  89 // ReturnAddressPtr:
  90 //
  91 // ReturnAddressPtr should be used to wrap return addresses generated by processor
  92 // 'call' instructions exectued in JIT code.  We use return addresses to look up
  93 // exception and optimization information, and to repatch the call instruction
  94 // that is the source of the return address.
  95 class ReturnAddressPtr {
  96 public:
  97     ReturnAddressPtr()
  98         : m_value(0)
  99     {
 100     }
 101
 102     explicit ReturnAddressPtr(void* value)
 103         : m_value(value)
 104     {
 105         ASSERT_VALID_CODE_POINTER(m_value);
 106     }
 107
 108     explicit ReturnAddressPtr(FunctionPtr function)
 109         : m_value(function.value())
 110     {
 111         ASSERT_VALID_CODE_POINTER(m_value);
 112     }
 113
 114     void* value() const { return m_value; }
 115
 116 private:
 117     void* m_value;
 118 };
 119
 120 // MacroAssemblerCodePtr:
 121 //
 122 // MacroAssemblerCodePtr should be used to wrap pointers to JIT generated code.
 123 class MacroAssemblerCodePtr {
 124 public:
 125     MacroAssemblerCodePtr()
 126         : m_value(0)
 127     {
 128     }
 129
 130     explicit MacroAssemblerCodePtr(void* value)
 131 #if CPU(ARM_THUMB2)
 132         // Decorate the pointer as a thumb code pointer.
 133         : m_value(reinterpret_cast<char*>(value) + 1)
 134 #else
 135         : m_value(value)
 136 #endif
 137     {
 138         ASSERT_VALID_CODE_POINTER(m_value);
 139     }
 140
 141     explicit MacroAssemblerCodePtr(ReturnAddressPtr ra)
 142         : m_value(ra.value())
 143     {
 144         ASSERT_VALID_CODE_POINTER(m_value);
 145     }
 146
 147     void* executableAddress() const { return m_value; }
 148 #if CPU(ARM_THUMB2)
 149     // To use this pointer as a data address remove the decoration.
 150     void* dataLocation() const { ASSERT_VALID_CODE_POINTER(m_value); return reinterpret_cast<char*>(m_value) - 1; }
 151 #else
 152     void* dataLocation() const { ASSERT_VALID_CODE_POINTER(m_value); return m_value; }
 153 #endif
 154
 155     bool operator!()
 156     {
 157         return !m_value;
 158     }
 159
 160 private:
 161     void* m_value;
 162 };
 163
 164 // MacroAssemblerCodeRef:
 165 //
 166 // A reference to a section of JIT generated code.  A CodeRef consists of a
 167 // pointer to the code, and a ref pointer to the pool from within which it
 168 // was allocated.
 169 class MacroAssemblerCodeRef {
 170 public:
 171     MacroAssemblerCodeRef()
 172         : m_size(0)
 173     {
 174     }
 175
 176     MacroAssemblerCodeRef(void* code, PassRefPtr<ExecutablePool> executablePool, size_t size)
 177         : m_code(code)
 178         , m_executablePool(executablePool)
 179         , m_size(size)
 180     {
 181     }
 182
 183     MacroAssemblerCodePtr m_code;
 184     RefPtr<ExecutablePool> m_executablePool;
 185     size_t m_size;
 186 };
 187
 188 } // namespace JSC
 189
 190 #endif // ENABLE(ASSEMBLER)
 191
 192 #endif // MacroAssemblerCodeRef_h