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 37namespace 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 85template <int maxPoolSize, int barrierSize, int maxInstructionSize, class AssemblerType> 86class AssemblerBufferWithConstantPool : public AssemblerBuffer { 87 typedef SegmentedVector<uint32_t, 512> LoadOffsets; 88 using AssemblerBuffer::putIntegral; 89 using AssemblerBuffer::putIntegralUnchecked; 90public: 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 PassRefPtr<ExecutableMemoryHandle> executableCopy(VM& vm, void* ownerUID, JITCompilationEffort effort) 199 { 200 flushConstantPool(false); 201 return AssemblerBuffer::executableCopy(vm, ownerUID, effort); 202 } 203 204 void putShortWithConstantInt(uint16_t insn, uint32_t constant, bool isReusable = false) 205 { 206 putIntegralWithConstantInt(insn, constant, isReusable); 207 } 208 209 void putIntWithConstantInt(uint32_t insn, uint32_t constant, bool isReusable = false) 210 { 211 putIntegralWithConstantInt(insn, constant, isReusable); 212 } 213 214 // This flushing mechanism can be called after any unconditional jumps. 215 void flushWithoutBarrier(bool isForced = false) 216 { 217 // Flush if constant pool is more than 60% full to avoid overuse of this function. 218 if (isForced || 5 * static_cast<uint32_t>(m_numConsts) > 3 * maxPoolSize / sizeof(uint32_t)) 219 flushConstantPool(false); 220 } 221 222 uint32_t* poolAddress() 223 { 224 return m_pool; 225 } 226 227 int sizeOfConstantPool() 228 { 229 return m_numConsts; 230 } 231 232private: 233 void correctDeltas(int insnSize) 234 { 235 m_maxDistance -= insnSize; 236 m_lastConstDelta -= insnSize; 237 if (m_lastConstDelta < 0) 238 m_lastConstDelta = 0; 239 } 240 241 void correctDeltas(int insnSize, int constSize) 242 { 243 correctDeltas(insnSize); 244 245 m_maxDistance -= m_lastConstDelta; 246 m_lastConstDelta = constSize; 247 } 248 249 template<typename IntegralType> 250 void putIntegralWithConstantInt(IntegralType insn, uint32_t constant, bool isReusable) 251 { 252 if (!m_numConsts) 253 m_maxDistance = maxPoolSize; 254 flushIfNoSpaceFor(sizeof(IntegralType), 4); 255 256 m_loadOffsets.append(codeSize()); 257 if (isReusable) { 258 for (int i = 0; i < m_numConsts; ++i) { 259 if (m_mask[i] == ReusableConst && m_pool[i] == constant) { 260 putIntegral(static_cast<IntegralType>(AssemblerType::patchConstantPoolLoad(insn, i))); 261 correctDeltas(sizeof(IntegralType)); 262 return; 263 } 264 } 265 } 266 267 m_pool[m_numConsts] = constant; 268 m_mask[m_numConsts] = static_cast<char>(isReusable ? ReusableConst : UniqueConst); 269 270 putIntegral(static_cast<IntegralType>(AssemblerType::patchConstantPoolLoad(insn, m_numConsts))); 271 ++m_numConsts; 272 273 correctDeltas(sizeof(IntegralType), 4); 274 } 275 276 void flushConstantPool(bool useBarrier = true) 277 { 278 if (m_numConsts == 0) 279 return; 280 int alignPool = (codeSize() + (useBarrier ? barrierSize : 0)) & (sizeof(uint64_t) - 1); 281 282 if (alignPool) 283 alignPool = sizeof(uint64_t) - alignPool; 284 285 // Callback to protect the constant pool from execution 286 if (useBarrier) 287 putIntegral(AssemblerType::placeConstantPoolBarrier(m_numConsts * sizeof(uint32_t) + alignPool)); 288 289 if (alignPool) { 290 if (alignPool & 1) 291 AssemblerBuffer::putByte(AssemblerType::padForAlign8); 292 if (alignPool & 2) 293 AssemblerBuffer::putShort(AssemblerType::padForAlign16); 294 if (alignPool & 4) 295 AssemblerBuffer::putInt(AssemblerType::padForAlign32); 296 } 297 298 int constPoolOffset = codeSize(); 299 append(reinterpret_cast<char*>(m_pool), m_numConsts * sizeof(uint32_t)); 300 301 // Patch each PC relative load 302 for (LoadOffsets::Iterator iter = m_loadOffsets.begin(); iter != m_loadOffsets.end(); ++iter) { 303 void* loadAddr = reinterpret_cast<char*>(data()) + *iter; 304 AssemblerType::patchConstantPoolLoad(loadAddr, reinterpret_cast<char*>(data()) + constPoolOffset); 305 } 306 307 m_loadOffsets.clear(); 308 m_numConsts = 0; 309 } 310 311 void flushIfNoSpaceFor(int nextInsnSize) 312 { 313 if (m_numConsts == 0) 314 return; 315 int lastConstDelta = m_lastConstDelta > nextInsnSize ? m_lastConstDelta - nextInsnSize : 0; 316 if ((m_maxDistance < nextInsnSize + lastConstDelta + barrierSize + (int)sizeof(uint32_t))) 317 flushConstantPool(); 318 } 319 320 void flushIfNoSpaceFor(int nextInsnSize, int nextConstSize) 321 { 322 if (m_numConsts == 0) 323 return; 324 if ((m_maxDistance < nextInsnSize + m_lastConstDelta + nextConstSize + barrierSize + (int)sizeof(uint32_t)) || 325 (m_numConsts * sizeof(uint32_t) + nextConstSize >= maxPoolSize)) 326 flushConstantPool(); 327 } 328 329 uint32_t* m_pool; 330 char* m_mask; 331 LoadOffsets m_loadOffsets; 332 333 int m_numConsts; 334 int m_maxDistance; 335 int m_lastConstDelta; 336}; 337 338} // namespace JSC 339 340#endif // ENABLE(ASSEMBLER) 341 342#endif // AssemblerBufferWithConstantPool_h 343