assembler/LinkBuffer.h

   1 /*
   2  * Copyright (C) 2009, 2010 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 MacroAssemblerCodePtr CodePtr;
  53     typedef MacroAssembler::Label Label;
  54     typedef MacroAssembler::Jump Jump;
  55     typedef MacroAssembler::JumpList JumpList;
  56     typedef MacroAssembler::Call Call;
  57     typedef MacroAssembler::DataLabel32 DataLabel32;
  58     typedef MacroAssembler::DataLabelPtr DataLabelPtr;
  59     typedef MacroAssembler::JmpDst JmpDst;
  60 #if ENABLE(BRANCH_COMPACTION)
  61     typedef MacroAssembler::LinkRecord LinkRecord;
  62     typedef MacroAssembler::JumpLinkType JumpLinkType;
  63 #endif
  64
  65 public:
  66     // Note: Initialization sequence is significant, since executablePool is a PassRefPtr.
  67     //       First, executablePool is copied into m_executablePool, then the initialization of
  68     //       m_code uses m_executablePool, *not* executablePool, since this is no longer valid.
  69     // The linkOffset parameter should only be non-null when recompiling for exception info
  70     LinkBuffer(MacroAssembler* masm, PassRefPtr<ExecutablePool> executablePool, void* linkOffset)
  71         : m_executablePool(executablePool)
  72         , m_size(0)
  73         , m_code(0)
  74         , m_assembler(masm)
  75 #ifndef NDEBUG
  76         , m_completed(false)
  77 #endif
  78     {
  79         linkCode(linkOffset);
  80     }
  81
  82     ~LinkBuffer()
  83     {
  84         ASSERT(m_completed);
  85     }
  86
  87     // These methods are used to link or set values at code generation time.
  88
  89     void link(Call call, FunctionPtr function)
  90     {
  91         ASSERT(call.isFlagSet(Call::Linkable));
  92         call.m_jmp = applyOffset(call.m_jmp);
  93         MacroAssembler::linkCall(code(), call, function);
  94     }
  95
  96     void link(Jump jump, CodeLocationLabel label)
  97     {
  98         jump.m_jmp = applyOffset(jump.m_jmp);
  99         MacroAssembler::linkJump(code(), jump, label);
 100     }
 101
 102     void link(JumpList list, CodeLocationLabel label)
 103     {
 104         for (unsigned i = 0; i < list.m_jumps.size(); ++i)
 105             link(list.m_jumps[i], label);
 106     }
 107
 108     void patch(DataLabelPtr label, void* value)
 109     {
 110         JmpDst target = applyOffset(label.m_label);
 111         MacroAssembler::linkPointer(code(), target, value);
 112     }
 113
 114     void patch(DataLabelPtr label, CodeLocationLabel value)
 115     {
 116         JmpDst target = applyOffset(label.m_label);
 117         MacroAssembler::linkPointer(code(), target, value.executableAddress());
 118     }
 119
 120     // These methods are used to obtain handles to allow the code to be relinked / repatched later.
 121
 122     CodeLocationCall locationOf(Call call)
 123     {
 124         ASSERT(call.isFlagSet(Call::Linkable));
 125         ASSERT(!call.isFlagSet(Call::Near));
 126         return CodeLocationCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_jmp)));
 127     }
 128
 129     CodeLocationNearCall locationOfNearCall(Call call)
 130     {
 131         ASSERT(call.isFlagSet(Call::Linkable));
 132         ASSERT(call.isFlagSet(Call::Near));
 133         return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_jmp)));
 134     }
 135
 136     CodeLocationLabel locationOf(Label label)
 137     {
 138         return CodeLocationLabel(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
 139     }
 140
 141     CodeLocationDataLabelPtr locationOf(DataLabelPtr label)
 142     {
 143         return CodeLocationDataLabelPtr(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
 144     }
 145
 146     CodeLocationDataLabel32 locationOf(DataLabel32 label)
 147     {
 148         return CodeLocationDataLabel32(MacroAssembler::getLinkerAddress(code(), applyOffset(label.m_label)));
 149     }
 150
 151     // This method obtains the return address of the call, given as an offset from
 152     // the start of the code.
 153     unsigned returnAddressOffset(Call call)
 154     {
 155         call.m_jmp = applyOffset(call.m_jmp);
 156         return MacroAssembler::getLinkerCallReturnOffset(call);
 157     }
 158
 159     // Upon completion of all patching either 'finalizeCode()' or 'finalizeCodeAddendum()' should be called
 160     // once to complete generation of the code.  'finalizeCode()' is suited to situations
 161     // where the executable pool must also be retained, the lighter-weight 'finalizeCodeAddendum()' is
 162     // suited to adding to an existing allocation.
 163     CodeRef finalizeCode()
 164     {
 165         performFinalization();
 166
 167         return CodeRef(m_code, m_executablePool, m_size);
 168     }
 169
 170     CodeLocationLabel finalizeCodeAddendum()
 171     {
 172         performFinalization();
 173
 174         return CodeLocationLabel(code());
 175     }
 176
 177     CodePtr trampolineAt(Label label)
 178     {
 179         return CodePtr(MacroAssembler::AssemblerType_T::getRelocatedAddress(code(), applyOffset(label.m_label)));
 180     }
 181
 182 private:
 183     template <typename T> T applyOffset(T src)
 184     {
 185 #if ENABLE(BRANCH_COMPACTION)
 186         src.m_offset -= m_assembler->executableOffsetFor(src.m_offset);
 187 #endif
 188         return src;
 189     }
 190
 191     // Keep this private! - the underlying code should only be obtained externally via
 192     // finalizeCode() or finalizeCodeAddendum().
 193     void* code()
 194     {
 195         return m_code;
 196     }
 197
 198     void linkCode(void* linkOffset)
 199     {
 200         UNUSED_PARAM(linkOffset);
 201         ASSERT(!m_code);
 202 #if !ENABLE(BRANCH_COMPACTION)
 203         m_code = m_assembler->m_assembler.executableCopy(m_executablePool.get());
 204         m_size = m_assembler->size();
 205 #else
 206         size_t initialSize = m_assembler->size();
 207         m_code = (uint8_t*)m_executablePool->alloc(initialSize);
 208         if (!m_code)
 209             return;
 210         ExecutableAllocator::makeWritable(m_code, m_assembler->size());
 211         uint8_t* inData = (uint8_t*)m_assembler->unlinkedCode();
 212         uint8_t* outData = reinterpret_cast<uint8_t*>(m_code);
 213         const uint8_t* linkBase = linkOffset ? reinterpret_cast<uint8_t*>(linkOffset) : outData;
 214         int readPtr = 0;
 215         int writePtr = 0;
 216         Vector<LinkRecord>& jumpsToLink = m_assembler->jumpsToLink();
 217         unsigned jumpCount = jumpsToLink.size();
 218         for (unsigned i = 0; i < jumpCount; ++i) {
 219             int offset = readPtr - writePtr;
 220             ASSERT(!(offset & 1));
 221
 222             // Copy the instructions from the last jump to the current one.
 223             size_t regionSize = jumpsToLink[i].from() - readPtr;
 224             memcpy(outData + writePtr, inData + readPtr, regionSize);
 225             m_assembler->recordLinkOffsets(readPtr, jumpsToLink[i].from(), offset);
 226             readPtr += regionSize;
 227             writePtr += regionSize;
 228
 229             // Calculate absolute address of the jump target, in the case of backwards
 230             // branches we need to be precise, forward branches we are pessimistic
 231             const uint8_t* target;
 232             if (jumpsToLink[i].to() >= jumpsToLink[i].from())
 233                 target = linkBase + jumpsToLink[i].to() - offset; // Compensate for what we have collapsed so far
 234             else
 235                 target = linkBase + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());
 236
 237             JumpLinkType jumpLinkType = m_assembler->computeJumpType(jumpsToLink[i], linkBase + writePtr, target);
 238             // Compact branch if we can...
 239             if (m_assembler->canCompact(jumpsToLink[i].type())) {
 240                 // Step back in the write stream
 241                 int32_t delta = m_assembler->jumpSizeDelta(jumpsToLink[i].type(), jumpLinkType);
 242                 if (delta) {
 243                     writePtr -= delta;
 244                     m_assembler->recordLinkOffsets(jumpsToLink[i].from() - delta, readPtr, readPtr - writePtr);
 245                 }
 246             }
 247             jumpsToLink[i].setFrom(writePtr);
 248         }
 249         // Copy everything after the last jump
 250         memcpy(outData + writePtr, inData + readPtr, m_assembler->size() - readPtr);
 251         m_assembler->recordLinkOffsets(readPtr, m_assembler->size(), readPtr - writePtr);
 252
 253         // Actually link everything (don't link if we've be given a linkoffset as it's a
 254         // waste of time: linkOffset is used for recompiling to get exception info)
 255         if (!linkOffset) {
 256             for (unsigned i = 0; i < jumpCount; ++i) {
 257                 uint8_t* location = outData + jumpsToLink[i].from();
 258                 uint8_t* target = outData + jumpsToLink[i].to() - m_assembler->executableOffsetFor(jumpsToLink[i].to());
 259                 m_assembler->link(jumpsToLink[i], location, target);
 260             }
 261         }
 262
 263         jumpsToLink.clear();
 264         m_size = writePtr + m_assembler->size() - readPtr;
 265         m_executablePool->tryShrink(m_code, initialSize, m_size);
 266 #endif
 267     }
 268
 269     void performFinalization()
 270     {
 271 #ifndef NDEBUG
 272         ASSERT(!m_completed);
 273         m_completed = true;
 274 #endif
 275
 276         ExecutableAllocator::makeExecutable(code(), m_size);
 277         ExecutableAllocator::cacheFlush(code(), m_size);
 278     }
 279
 280     RefPtr<ExecutablePool> m_executablePool;
 281     size_t m_size;
 282     void* m_code;
 283     MacroAssembler* m_assembler;
 284 #ifndef NDEBUG
 285     bool m_completed;
 286 #endif
 287 };
 288
 289 } // namespace JSC
 290
 291 #endif // ENABLE(ASSEMBLER)
 292
 293 #endif // LinkBuffer_h