assembler/AssemblerBufferWithConstantPool.h

   1 /*
   2  * Copyright (C) 2009 University of Szeged
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY UNIVERSITY OF SZEGED ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL UNIVERSITY OF SZEGED OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #ifndef AssemblerBufferWithConstantPool_h
  28 #define AssemblerBufferWithConstantPool_h
  29
  30 #if ENABLE(ASSEMBLER)
  31
  32 #include "AssemblerBuffer.h"
  33 #include <wtf/SegmentedVector.h>
  34
  35 #define ASSEMBLER_HAS_CONSTANT_POOL 1
  36
  37 namespace JSC {
  38
  39 /*
  40     On a constant pool 4 or 8 bytes data can be stored. The values can be
  41     constants or addresses. The addresses should be 32 or 64 bits. The constants
  42     should be double-precisions float or integer numbers which are hard to be
  43     encoded as few machine instructions.
  44
  45     TODO: The pool is desinged to handle both 32 and 64 bits values, but
  46     currently only the 4 bytes constants are implemented and tested.
  47
  48     The AssemblerBuffer can contain multiple constant pools. Each pool is inserted
  49     into the instruction stream - protected by a jump instruction from the
  50     execution flow.
  51
  52     The flush mechanism is called when no space remain to insert the next instruction
  53     into the pool. Three values are used to determine when the constant pool itself
  54     have to be inserted into the instruction stream (Assembler Buffer):
  55
  56     - maxPoolSize: size of the constant pool in bytes, this value cannot be
  57         larger than the maximum offset of a PC relative memory load
  58
  59     - barrierSize: size of jump instruction in bytes which protects the
  60         constant pool from execution
  61
  62     - maxInstructionSize: maximum length of a machine instruction in bytes
  63
  64     There are some callbacks which solve the target architecture specific
  65     address handling:
  66
  67     - TYPE patchConstantPoolLoad(TYPE load, int value):
  68         patch the 'load' instruction with the index of the constant in the
  69         constant pool and return the patched instruction.
  70
  71     - void patchConstantPoolLoad(void* loadAddr, void* constPoolAddr):
  72         patch the a PC relative load instruction at 'loadAddr' address with the
  73         final relative offset. The offset can be computed with help of
  74         'constPoolAddr' (the address of the constant pool) and index of the
  75         constant (which is stored previously in the load instruction itself).
  76
  77     - TYPE placeConstantPoolBarrier(int size):
  78         return with a constant pool barrier instruction which jumps over the
  79         constant pool.
  80
  81     The 'put*WithConstant*' functions should be used to place a data into the
  82     constant pool.
  83 */
  84
  85 template <int maxPoolSize, int barrierSize, int maxInstructionSize, class AssemblerType>
  86 class AssemblerBufferWithConstantPool : public AssemblerBuffer {
  87     typedef SegmentedVector<uint32_t, 512> LoadOffsets;
  88     using AssemblerBuffer::putIntegral;
  89     using AssemblerBuffer::putIntegralUnchecked;
  90 public:
  91     typedef struct {
  92         short high;
  93         short low;
  94     } TwoShorts;
  95
  96     enum {
  97         UniqueConst,
  98         ReusableConst,
  99         UnusedEntry,
 100     };
 101
 102     AssemblerBufferWithConstantPool()
 103         : AssemblerBuffer()
 104         , m_numConsts(0)
 105         , m_maxDistance(maxPoolSize)
 106         , m_lastConstDelta(0)
 107     {
 108         m_pool = static_cast<uint32_t*>(fastMalloc(maxPoolSize));
 109         m_mask = static_cast<char*>(fastMalloc(maxPoolSize / sizeof(uint32_t)));
 110     }
 111
 112     ~AssemblerBufferWithConstantPool()
 113     {
 114         fastFree(m_mask);
 115         fastFree(m_pool);
 116     }
 117
 118     void ensureSpace(int space)
 119     {
 120         flushIfNoSpaceFor(space);
 121         AssemblerBuffer::ensureSpace(space);
 122     }
 123
 124     void ensureSpace(int insnSpace, int constSpace)
 125     {
 126         flushIfNoSpaceFor(insnSpace, constSpace);
 127         AssemblerBuffer::ensureSpace(insnSpace);
 128     }
 129
 130     void ensureSpaceForAnyInstruction(int amount = 1)
 131     {
 132         flushIfNoSpaceFor(amount * maxInstructionSize, amount * sizeof(uint64_t));
 133     }
 134
 135     bool isAligned(int alignment)
 136     {
 137         flushIfNoSpaceFor(alignment);
 138         return AssemblerBuffer::isAligned(alignment);
 139     }
 140
 141     void putByteUnchecked(int value)
 142     {
 143         AssemblerBuffer::putByteUnchecked(value);
 144         correctDeltas(1);
 145     }
 146
 147     void putByte(int value)
 148     {
 149         flushIfNoSpaceFor(1);
 150         AssemblerBuffer::putByte(value);
 151         correctDeltas(1);
 152     }
 153
 154     void putShortUnchecked(int value)
 155     {
 156         AssemblerBuffer::putShortUnchecked(value);
 157         correctDeltas(2);
 158     }
 159
 160     void putShort(int value)
 161     {
 162         flushIfNoSpaceFor(2);
 163         AssemblerBuffer::putShort(value);
 164         correctDeltas(2);
 165     }
 166
 167     void putIntUnchecked(int value)
 168     {
 169         AssemblerBuffer::putIntUnchecked(value);
 170         correctDeltas(4);
 171     }
 172
 173     void putInt(int value)
 174     {
 175         flushIfNoSpaceFor(4);
 176         AssemblerBuffer::putInt(value);
 177         correctDeltas(4);
 178     }
 179
 180     void putInt64Unchecked(int64_t value)
 181     {
 182         AssemblerBuffer::putInt64Unchecked(value);
 183         correctDeltas(8);
 184     }
 185
 186     void putIntegral(TwoShorts value)
 187     {
 188         putIntegral(value.high);
 189         putIntegral(value.low);
 190     }
 191
 192     void putIntegralUnchecked(TwoShorts value)
 193     {
 194         putIntegralUnchecked(value.high);
 195         putIntegralUnchecked(value.low);
 196     }
 197
 198     void putShortWithConstantInt(uint16_t insn, uint32_t constant, bool isReusable = false)
 199     {
 200         putIntegralWithConstantInt(insn, constant, isReusable);
 201     }
 202
 203     void putIntWithConstantInt(uint32_t insn, uint32_t constant, bool isReusable = false)
 204     {
 205         putIntegralWithConstantInt(insn, constant, isReusable);
 206     }
 207
 208     // This flushing mechanism can be called after any unconditional jumps.
 209     void flushWithoutBarrier(bool isForced = false)
 210     {
 211         // Flush if constant pool is more than 60% full to avoid overuse of this function.
 212         if (isForced || 5 * static_cast<uint32_t>(m_numConsts) > 3 * maxPoolSize / sizeof(uint32_t))
 213             flushConstantPool(false);
 214     }
 215
 216     uint32_t* poolAddress()
 217     {
 218         return m_pool;
 219     }
 220
 221     int sizeOfConstantPool()
 222     {
 223         return m_numConsts;
 224     }
 225
 226     void flushConstantPool(bool useBarrier = true)
 227     {
 228         if (!m_numConsts)
 229             return;
 230         int alignPool = (codeSize() + (useBarrier ? barrierSize : 0)) & (sizeof(uint64_t) - 1);
 231
 232         if (alignPool)
 233             alignPool = sizeof(uint64_t) - alignPool;
 234
 235         // Callback to protect the constant pool from execution
 236         if (useBarrier)
 237             putIntegral(AssemblerType::placeConstantPoolBarrier(m_numConsts * sizeof(uint32_t) + alignPool));
 238
 239         if (alignPool) {
 240             if (alignPool & 1)
 241                 AssemblerBuffer::putByte(AssemblerType::padForAlign8);
 242             if (alignPool & 2)
 243                 AssemblerBuffer::putShort(AssemblerType::padForAlign16);
 244             if (alignPool & 4)
 245                 AssemblerBuffer::putInt(AssemblerType::padForAlign32);
 246         }
 247
 248         int constPoolOffset = codeSize();
 249         append(reinterpret_cast<char*>(m_pool), m_numConsts * sizeof(uint32_t));
 250
 251         // Patch each PC relative load
 252         for (LoadOffsets::Iterator iter = m_loadOffsets.begin(); iter != m_loadOffsets.end(); ++iter) {
 253             void* loadAddr = reinterpret_cast<char*>(data()) + *iter;
 254             AssemblerType::patchConstantPoolLoad(loadAddr, reinterpret_cast<char*>(data()) + constPoolOffset);
 255         }
 256
 257         m_loadOffsets.clear();
 258         m_numConsts = 0;
 259     }
 260
 261 private:
 262     void correctDeltas(int insnSize)
 263     {
 264         m_maxDistance -= insnSize;
 265         m_lastConstDelta -= insnSize;
 266         if (m_lastConstDelta < 0)
 267             m_lastConstDelta = 0;
 268     }
 269
 270     void correctDeltas(int insnSize, int constSize)
 271     {
 272         correctDeltas(insnSize);
 273
 274         m_maxDistance -= m_lastConstDelta;
 275         m_lastConstDelta = constSize;
 276     }
 277
 278     template<typename IntegralType>
 279     void putIntegralWithConstantInt(IntegralType insn, uint32_t constant, bool isReusable)
 280     {
 281         if (!m_numConsts)
 282             m_maxDistance = maxPoolSize;
 283         flushIfNoSpaceFor(sizeof(IntegralType), 4);
 284
 285         m_loadOffsets.append(codeSize());
 286         if (isReusable) {
 287             for (int i = 0; i < m_numConsts; ++i) {
 288                 if (m_mask[i] == ReusableConst && m_pool[i] == constant) {
 289                     putIntegral(static_cast<IntegralType>(AssemblerType::patchConstantPoolLoad(insn, i)));
 290                     correctDeltas(sizeof(IntegralType));
 291                     return;
 292                 }
 293             }
 294         }
 295
 296         m_pool[m_numConsts] = constant;
 297         m_mask[m_numConsts] = static_cast<char>(isReusable ? ReusableConst : UniqueConst);
 298
 299         putIntegral(static_cast<IntegralType>(AssemblerType::patchConstantPoolLoad(insn, m_numConsts)));
 300         ++m_numConsts;
 301
 302         correctDeltas(sizeof(IntegralType), 4);
 303     }
 304
 305     void flushIfNoSpaceFor(int nextInsnSize)
 306     {
 307         if (m_numConsts == 0)
 308             return;
 309         int lastConstDelta = m_lastConstDelta > nextInsnSize ? m_lastConstDelta - nextInsnSize : 0;
 310         if ((m_maxDistance < nextInsnSize + lastConstDelta + barrierSize + (int)sizeof(uint32_t)))
 311             flushConstantPool();
 312     }
 313
 314     void flushIfNoSpaceFor(int nextInsnSize, int nextConstSize)
 315     {
 316         if (m_numConsts == 0)
 317             return;
 318         if ((m_maxDistance < nextInsnSize + m_lastConstDelta + nextConstSize + barrierSize + (int)sizeof(uint32_t)) ||
 319             (m_numConsts * sizeof(uint32_t) + nextConstSize >= maxPoolSize))
 320             flushConstantPool();
 321     }
 322
 323     uint32_t* m_pool;
 324     char* m_mask;
 325     LoadOffsets m_loadOffsets;
 326
 327     int m_numConsts;
 328     int m_maxDistance;
 329     int m_lastConstDelta;
 330 };
 331
 332 } // namespace JSC
 333
 334 #endif // ENABLE(ASSEMBLER)
 335
 336 #endif // AssemblerBufferWithConstantPool_h