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 #include <wtf/Platform.h> 31 32 #if ENABLE(ASSEMBLER) 33 34 #include "AssemblerBuffer.h" 35 #include <wtf/SegmentedVector.h> 36 37 #define ASSEMBLER_HAS_CONSTANT_POOL 1 38 39 namespace JSC { 40 41 /* 42 On a constant pool 4 or 8 bytes data can be stored. The values can be 43 constants or addresses. The addresses should be 32 or 64 bits. The constants 44 should be double-precisions float or integer numbers which are hard to be 45 encoded as few machine instructions. 46 47 TODO: The pool is desinged to handle both 32 and 64 bits values, but 48 currently only the 4 bytes constants are implemented and tested. 49 50 The AssemblerBuffer can contain multiple constant pools. Each pool is inserted 51 into the instruction stream - protected by a jump instruction from the 52 execution flow. 53 54 The flush mechanism is called when no space remain to insert the next instruction 55 into the pool. Three values are used to determine when the constant pool itself 56 have to be inserted into the instruction stream (Assembler Buffer): 57 58 - maxPoolSize: size of the constant pool in bytes, this value cannot be 59 larger than the maximum offset of a PC relative memory load 60 61 - barrierSize: size of jump instruction in bytes which protects the 62 constant pool from execution 63 64 - maxInstructionSize: maximum length of a machine instruction in bytes 65 66 There are some callbacks which solve the target architecture specific 67 address handling: 68 69 - TYPE patchConstantPoolLoad(TYPE load, int value): 70 patch the 'load' instruction with the index of the constant in the 71 constant pool and return the patched instruction. 72 73 - void patchConstantPoolLoad(void* loadAddr, void* constPoolAddr): 74 patch the a PC relative load instruction at 'loadAddr' address with the 75 final relative offset. The offset can be computed with help of 76 'constPoolAddr' (the address of the constant pool) and index of the 77 constant (which is stored previously in the load instruction itself). 78 79 - TYPE placeConstantPoolBarrier(int size): 80 return with a constant pool barrier instruction which jumps over the 81 constant pool. 82 83 The 'put*WithConstant*' functions should be used to place a data into the 84 constant pool. 85 */ 86 87 template <int maxPoolSize, int barrierSize, int maxInstructionSize, class AssemblerType> 88 class AssemblerBufferWithConstantPool: public AssemblerBuffer { 89 typedef SegmentedVector<uint32_t, 512> LoadOffsets; 90 public: 91 enum { 92 UniqueConst, 93 ReusableConst, 94 UnusedEntry, 95 }; 96 97 AssemblerBufferWithConstantPool() 98 : AssemblerBuffer() 99 , m_numConsts(0) 100 , m_maxDistance(maxPoolSize) 101 , m_lastConstDelta(0) 102 { 103 m_pool = static_cast<uint32_t*>(fastMalloc(maxPoolSize)); 104 m_mask = static_cast<char*>(fastMalloc(maxPoolSize / sizeof(uint32_t))); 105 } 106 107 ~AssemblerBufferWithConstantPool() 108 { 109 fastFree(m_mask); 110 fastFree(m_pool); 111 } 112 113 void ensureSpace(int space) 114 { 115 flushIfNoSpaceFor(space); 116 AssemblerBuffer::ensureSpace(space); 117 } 118 119 void ensureSpace(int insnSpace, int constSpace) 120 { 121 flushIfNoSpaceFor(insnSpace, constSpace); 122 AssemblerBuffer::ensureSpace(insnSpace); 123 } 124 125 bool isAligned(int alignment) 126 { 127 flushIfNoSpaceFor(alignment); 128 return AssemblerBuffer::isAligned(alignment); 129 } 130 131 void putByteUnchecked(int value) 132 { 133 AssemblerBuffer::putByteUnchecked(value); 134 correctDeltas(1); 135 } 136 137 void putByte(int value) 138 { 139 flushIfNoSpaceFor(1); 140 AssemblerBuffer::putByte(value); 141 correctDeltas(1); 142 } 143 144 void putShortUnchecked(int value) 145 { 146 AssemblerBuffer::putShortUnchecked(value); 147 correctDeltas(2); 148 } 149 150 void putShort(int value) 151 { 152 flushIfNoSpaceFor(2); 153 AssemblerBuffer::putShort(value); 154 correctDeltas(2); 155 } 156 157 void putIntUnchecked(int value) 158 { 159 AssemblerBuffer::putIntUnchecked(value); 160 correctDeltas(4); 161 } 162 163 void putInt(int value) 164 { 165 flushIfNoSpaceFor(4); 166 AssemblerBuffer::putInt(value); 167 correctDeltas(4); 168 } 169 170 void putInt64Unchecked(int64_t value) 171 { 172 AssemblerBuffer::putInt64Unchecked(value); 173 correctDeltas(8); 174 } 175 176 int size() 177 { 178 flushIfNoSpaceFor(maxInstructionSize, sizeof(uint64_t)); 179 return AssemblerBuffer::size(); 180 } 181 182 int uncheckedSize() 183 { 184 return AssemblerBuffer::size(); 185 } 186 187 void* executableCopy(ExecutablePool* allocator) 188 { 189 flushConstantPool(false); 190 return AssemblerBuffer::executableCopy(allocator); 191 } 192 193 void putIntWithConstantInt(uint32_t insn, uint32_t constant, bool isReusable = false) 194 { 195 flushIfNoSpaceFor(4, 4); 196 197 m_loadOffsets.append(AssemblerBuffer::size()); 198 if (isReusable) 199 for (int i = 0; i < m_numConsts; ++i) { 200 if (m_mask[i] == ReusableConst && m_pool[i] == constant) { 201 AssemblerBuffer::putInt(AssemblerType::patchConstantPoolLoad(insn, i)); 202 correctDeltas(4); 203 return; 204 } 205 } 206 207 m_pool[m_numConsts] = constant; 208 m_mask[m_numConsts] = static_cast<char>(isReusable ? ReusableConst : UniqueConst); 209 210 AssemblerBuffer::putInt(AssemblerType::patchConstantPoolLoad(insn, m_numConsts)); 211 ++m_numConsts; 212 213 correctDeltas(4, 4); 214 } 215 216 // This flushing mechanism can be called after any unconditional jumps. 217 void flushWithoutBarrier(bool isForced = false) 218 { 219 // Flush if constant pool is more than 60% full to avoid overuse of this function. 220 if (isForced || 5 * m_numConsts > 3 * maxPoolSize / sizeof(uint32_t)) 221 flushConstantPool(false); 222 } 223 224 uint32_t* poolAddress() 225 { 226 return m_pool; 227 } 228 229 int sizeOfConstantPool() 230 { 231 return m_numConsts; 232 } 233 234 private: 235 void correctDeltas(int insnSize) 236 { 237 m_maxDistance -= insnSize; 238 m_lastConstDelta -= insnSize; 239 if (m_lastConstDelta < 0) 240 m_lastConstDelta = 0; 241 } 242 243 void correctDeltas(int insnSize, int constSize) 244 { 245 correctDeltas(insnSize); 246 247 m_maxDistance -= m_lastConstDelta; 248 m_lastConstDelta = constSize; 249 } 250 251 void flushConstantPool(bool useBarrier = true) 252 { 253 if (m_numConsts == 0) 254 return; 255 int alignPool = (AssemblerBuffer::size() + (useBarrier ? barrierSize : 0)) & (sizeof(uint64_t) - 1); 256 257 if (alignPool) 258 alignPool = sizeof(uint64_t) - alignPool; 259 260 // Callback to protect the constant pool from execution 261 if (useBarrier) 262 AssemblerBuffer::putInt(AssemblerType::placeConstantPoolBarrier(m_numConsts * sizeof(uint32_t) + alignPool)); 263 264 if (alignPool) { 265 if (alignPool & 1) 266 AssemblerBuffer::putByte(AssemblerType::padForAlign8); 267 if (alignPool & 2) 268 AssemblerBuffer::putShort(AssemblerType::padForAlign16); 269 if (alignPool & 4) 270 AssemblerBuffer::putInt(AssemblerType::padForAlign32); 271 } 272 273 int constPoolOffset = AssemblerBuffer::size(); 274 append(reinterpret_cast<char*>(m_pool), m_numConsts * sizeof(uint32_t)); 275 276 // Patch each PC relative load 277 for (LoadOffsets::Iterator iter = m_loadOffsets.begin(); iter != m_loadOffsets.end(); ++iter) { 278 void* loadAddr = reinterpret_cast<void*>(m_buffer + *iter); 279 AssemblerType::patchConstantPoolLoad(loadAddr, reinterpret_cast<void*>(m_buffer + constPoolOffset)); 280 } 281 282 m_loadOffsets.clear(); 283 m_numConsts = 0; 284 m_maxDistance = maxPoolSize; 285 } 286 287 void flushIfNoSpaceFor(int nextInsnSize) 288 { 289 if (m_numConsts == 0) 290 return; 291 int lastConstDelta = m_lastConstDelta > nextInsnSize ? m_lastConstDelta - nextInsnSize : 0; 292 if ((m_maxDistance < nextInsnSize + lastConstDelta + barrierSize + (int)sizeof(uint32_t))) 293 flushConstantPool(); 294 } 295 296 void flushIfNoSpaceFor(int nextInsnSize, int nextConstSize) 297 { 298 if (m_numConsts == 0) 299 return; 300 if ((m_maxDistance < nextInsnSize + m_lastConstDelta + nextConstSize + barrierSize + (int)sizeof(uint32_t)) || 301 (m_numConsts * sizeof(uint32_t) + nextConstSize >= maxPoolSize)) 302 flushConstantPool(); 303 } 304 305 uint32_t* m_pool; 306 char* m_mask; 307 LoadOffsets m_loadOffsets; 308 309 int m_numConsts; 310 int m_maxDistance; 311 int m_lastConstDelta; 312 }; 313 314 } // namespace JSC 315 316 #endif // ENABLE(ASSEMBLER) 317 318 #endif // AssemblerBufferWithConstantPool_h 319