assembler/LinkBuffer.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 LinkBuffer_h
  27 #define LinkBuffer_h
  28
  29 #if ENABLE(ASSEMBLER)
  30
  31 #include <MacroAssembler.h>
  32 #include <wtf/Noncopyable.h>
  33
  34 namespace JSC {
  35
  36 // LinkBuffer:
  37 //
  38 // This class assists in linking code generated by the macro assembler, once code generation
  39 // has been completed, and the code has been copied to is final location in memory.  At this
  40 // time pointers to labels within the code may be resolved, and relative offsets to external
  41 // addresses may be fixed.
  42 //
  43 // Specifically:
  44 //   * Jump objects may be linked to external targets,
  45 //   * The address of Jump objects may taken, such that it can later be relinked.
  46 //   * The return address of a Call may be acquired.
  47 //   * The address of a Label pointing into the code may be resolved.
  48 //   * The value referenced by a DataLabel may be set.
  49 //
  50 class LinkBuffer : public Noncopyable {
  51     typedef MacroAssemblerCodeRef CodeRef;
  52     typedef MacroAssembler::Label Label;
  53     typedef MacroAssembler::Jump Jump;
  54     typedef MacroAssembler::JumpList JumpList;
  55     typedef MacroAssembler::Call Call;
  56     typedef MacroAssembler::DataLabel32 DataLabel32;
  57     typedef MacroAssembler::DataLabelPtr DataLabelPtr;
  58
  59 public:
  60     // Note: Initialization sequence is significant, since executablePool is a PassRefPtr.
  61     //       First, executablePool is copied into m_executablePool, then the initialization of
  62     //       m_code uses m_executablePool, *not* executablePool, since this is no longer valid.
  63     LinkBuffer(MacroAssembler* masm, PassRefPtr<ExecutablePool> executablePool)
  64         : m_executablePool(executablePool)
  65         , m_code(masm->m_assembler.executableCopy(m_executablePool.get()))
  66         , m_size(masm->m_assembler.size())
  67 #ifndef NDEBUG
  68         , m_completed(false)
  69 #endif
  70     {
  71     }
  72
  73     ~LinkBuffer()
  74     {
  75         ASSERT(m_completed);
  76     }
  77
  78     // These methods are used to link or set values at code generation time.
  79
  80     void link(Call call, FunctionPtr function)
  81     {
  82         ASSERT(call.isFlagSet(Call::Linkable));
  83         MacroAssembler::linkCall(code(), call, function);
  84     }
  85
  86     void link(Jump jump, CodeLocationLabel label)
  87     {
  88         MacroAssembler::linkJump(code(), jump, label);
  89     }
  90
  91     void link(JumpList list, CodeLocationLabel label)
  92     {
  93         for (unsigned i = 0; i < list.m_jumps.size(); ++i)
  94             MacroAssembler::linkJump(code(), list.m_jumps[i], label);
  95     }
  96
  97     void patch(DataLabelPtr label, void* value)
  98     {
  99         MacroAssembler::linkPointer(code(), label.m_label, value);
 100     }
 101
 102     void patch(DataLabelPtr label, CodeLocationLabel value)
 103     {
 104         MacroAssembler::linkPointer(code(), label.m_label, value.executableAddress());
 105     }
 106
 107     // These methods are used to obtain handles to allow the code to be relinked / repatched later.
 108
 109     CodeLocationCall locationOf(Call call)
 110     {
 111         ASSERT(call.isFlagSet(Call::Linkable));
 112         ASSERT(!call.isFlagSet(Call::Near));
 113         return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), call.m_jmp));
 114     }
 115
 116     CodeLocationNearCall locationOfNearCall(Call call)
 117     {
 118         ASSERT(call.isFlagSet(Call::Linkable));
 119         ASSERT(call.isFlagSet(Call::Near));
 120         return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), call.m_jmp));
 121     }
 122
 123     CodeLocationLabel locationOf(Label label)
 124     {
 125         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), label.m_label));
 126     }
 127
 128     CodeLocationDataLabelPtr locationOf(DataLabelPtr label)
 129     {
 130         return CodeLocationDataLabelPtr(MacroAssembler::getLinkerAddress(code(), label.m_label));
 131     }
 132
 133     CodeLocationDataLabel32 locationOf(DataLabel32 label)
 134     {
 135         return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), label.m_label));
 136     }
 137
 138     // This method obtains the return address of the call, given as an offset from
 139     // the start of the code.
 140     unsigned returnAddressOffset(Call call)
 141     {
 142         return MacroAssembler::getLinkerCallReturnOffset(call);
 143     }
 144
 145     // Upon completion of all patching either 'finalizeCode()' or 'finalizeCodeAddendum()' should be called
 146     // once to complete generation of the code.  'finalizeCode()' is suited to situations
 147     // where the executable pool must also be retained, the lighter-weight 'finalizeCodeAddendum()' is
 148     // suited to adding to an existing allocation.
 149     CodeRef finalizeCode()
 150     {
 151         performFinalization();
 152
 153         return CodeRef(m_code, m_executablePool, m_size);
 154     }
 155     CodeLocationLabel finalizeCodeAddendum()
 156     {
 157         performFinalization();
 158
 159         return CodeLocationLabel(code());
 160     }
 161
 162 private:
 163     // Keep this private! - the underlying code should only be obtained externally via
 164     // finalizeCode() or finalizeCodeAddendum().
 165     void* code()
 166     {
 167         return m_code;
 168     }
 169
 170     void performFinalization()
 171     {
 172 #ifndef NDEBUG
 173         ASSERT(!m_completed);
 174         m_completed = true;
 175 #endif
 176
 177         ExecutableAllocator::makeExecutable(code(), m_size);
 178         ExecutableAllocator::cacheFlush(code(), m_size);
 179     }
 180
 181     RefPtr<ExecutablePool> m_executablePool;
 182     void* m_code;
 183     size_t m_size;
 184 #ifndef NDEBUG
 185     bool m_completed;
 186 #endif
 187 };
 188
 189 } // namespace JSC
 190
 191 #endif // ENABLE(ASSEMBLER)
 192
 193 #endif // LinkBuffer_h