Source/JavaScriptCore/jit/JITInlineMethods.h

   1 /*
   2  * Copyright (C) 2008 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 JITInlineMethods_h
  27 #define JITInlineMethods_h
  28
  29
  30 #if ENABLE(JIT)
  31
  32 namespace JSC {
  33
  34 /* Deprecated: Please use JITStubCall instead. */
  35
  36 ALWAYS_INLINE void JIT::emitGetJITStubArg(unsigned argumentNumber, RegisterID dst)
  37 {
  38     unsigned argumentStackOffset = (argumentNumber * (sizeof(JSValue) / sizeof(void*))) + JITSTACKFRAME_ARGS_INDEX;
  39     peek(dst, argumentStackOffset);
  40 }
  41
  42 ALWAYS_INLINE bool JIT::isOperandConstantImmediateDouble(unsigned src)
  43 {
  44     return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isDouble();
  45 }
  46
  47 ALWAYS_INLINE JSValue JIT::getConstantOperand(unsigned src)
  48 {
  49     ASSERT(m_codeBlock->isConstantRegisterIndex(src));
  50     return m_codeBlock->getConstant(src);
  51 }
  52
  53 ALWAYS_INLINE void JIT::emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
  54 {
  55     storePtr(from, payloadFor(entry, callFrameRegister));
  56 }
  57
  58 ALWAYS_INLINE void JIT::emitPutCellToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
  59 {
  60 #if USE(JSVALUE32_64)
  61     store32(TrustedImm32(JSValue::CellTag), tagFor(entry, callFrameRegister));
  62 #endif
  63     storePtr(from, payloadFor(entry, callFrameRegister));
  64 }
  65
  66 ALWAYS_INLINE void JIT::emitPutIntToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
  67 {
  68     store32(TrustedImm32(Int32Tag), intTagFor(entry, callFrameRegister));
  69     store32(from, intPayloadFor(entry, callFrameRegister));
  70 }
  71
  72 ALWAYS_INLINE void JIT::emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)
  73 {
  74     storePtr(TrustedImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
  75 }
  76
  77 ALWAYS_INLINE void JIT::emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
  78 {
  79     loadPtr(Address(from, entry * sizeof(Register)), to);
  80 #if USE(JSVALUE64)
  81     killLastResultRegister();
  82 #endif
  83 }
  84
  85 ALWAYS_INLINE void JIT::emitLoadCharacterString(RegisterID src, RegisterID dst, JumpList& failures)
  86 {
  87     failures.append(branchPtr(NotEqual, Address(src, JSCell::classInfoOffset()), TrustedImmPtr(&JSString::s_info)));
  88     failures.append(branch32(NotEqual, MacroAssembler::Address(src, ThunkHelpers::jsStringLengthOffset()), TrustedImm32(1)));
  89     loadPtr(MacroAssembler::Address(src, ThunkHelpers::jsStringValueOffset()), dst);
  90     failures.append(branchTest32(Zero, dst));
  91     loadPtr(MacroAssembler::Address(dst, ThunkHelpers::stringImplFlagsOffset()), regT1);
  92     loadPtr(MacroAssembler::Address(dst, ThunkHelpers::stringImplDataOffset()), dst);
  93
  94     JumpList is16Bit;
  95     JumpList cont8Bit;
  96     is16Bit.append(branchTest32(Zero, regT1, TrustedImm32(ThunkHelpers::stringImpl8BitFlag())));
  97     load8(MacroAssembler::Address(dst, 0), dst);
  98     cont8Bit.append(jump());
  99     is16Bit.link(this);
 100     load16(MacroAssembler::Address(dst, 0), dst);
 101     cont8Bit.link(this);
 102 }
 103
 104 ALWAYS_INLINE void JIT::emitGetFromCallFrameHeader32(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
 105 {
 106     load32(Address(from, entry * sizeof(Register)), to);
 107 #if USE(JSVALUE64)
 108     killLastResultRegister();
 109 #endif
 110 }
 111
 112 ALWAYS_INLINE JIT::Call JIT::emitNakedCall(CodePtr function)
 113 {
 114     ASSERT(m_bytecodeOffset != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeOffset is set.
 115
 116     Call nakedCall = nearCall();
 117     m_calls.append(CallRecord(nakedCall, m_bytecodeOffset, function.executableAddress()));
 118     return nakedCall;
 119 }
 120
 121 ALWAYS_INLINE bool JIT::atJumpTarget()
 122 {
 123     while (m_jumpTargetsPosition < m_codeBlock->numberOfJumpTargets() && m_codeBlock->jumpTarget(m_jumpTargetsPosition) <= m_bytecodeOffset) {
 124         if (m_codeBlock->jumpTarget(m_jumpTargetsPosition) == m_bytecodeOffset)
 125             return true;
 126         ++m_jumpTargetsPosition;
 127     }
 128     return false;
 129 }
 130
 131 #if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL
 132
 133 ALWAYS_INLINE void JIT::beginUninterruptedSequence(int insnSpace, int constSpace)
 134 {
 135     JSInterfaceJIT::beginUninterruptedSequence();
 136 #if CPU(ARM_TRADITIONAL)
 137 #ifndef NDEBUG
 138     // Ensure the label after the sequence can also fit
 139     insnSpace += sizeof(ARMWord);
 140     constSpace += sizeof(uint64_t);
 141 #endif
 142
 143     ensureSpace(insnSpace, constSpace);
 144
 145 #elif CPU(SH4)
 146 #ifndef NDEBUG
 147     insnSpace += sizeof(SH4Word);
 148     constSpace += sizeof(uint64_t);
 149 #endif
 150
 151     m_assembler.ensureSpace(insnSpace + m_assembler.maxInstructionSize + 2, constSpace + 8);
 152 #endif
 153
 154 #if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL
 155 #ifndef NDEBUG
 156     m_uninterruptedInstructionSequenceBegin = label();
 157     m_uninterruptedConstantSequenceBegin = sizeOfConstantPool();
 158 #endif
 159 #endif
 160 }
 161
 162 ALWAYS_INLINE void JIT::endUninterruptedSequence(int insnSpace, int constSpace, int dst)
 163 {
 164     UNUSED_PARAM(dst);
 165 #if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL
 166     /* There are several cases when the uninterrupted sequence is larger than
 167      * maximum required offset for pathing the same sequence. Eg.: if in a
 168      * uninterrupted sequence the last macroassembler's instruction is a stub
 169      * call, it emits store instruction(s) which should not be included in the
 170      * calculation of length of uninterrupted sequence. So, the insnSpace and
 171      * constSpace should be upper limit instead of hard limit.
 172      */
 173 #if CPU(SH4)
 174     if ((dst > 15) || (dst < -16)) {
 175         insnSpace += 8;
 176         constSpace += 2;
 177     }
 178
 179     if (((dst >= -16) && (dst < 0)) || ((dst > 7) && (dst <= 15)))
 180         insnSpace += 8;
 181 #endif
 182     ASSERT(differenceBetween(m_uninterruptedInstructionSequenceBegin, label()) <= insnSpace);
 183     ASSERT(sizeOfConstantPool() - m_uninterruptedConstantSequenceBegin <= constSpace);
 184 #endif
 185     JSInterfaceJIT::endUninterruptedSequence();
 186 }
 187
 188 #endif
 189
 190 #if CPU(ARM)
 191
 192 ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)
 193 {
 194     move(linkRegister, reg);
 195 }
 196
 197 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)
 198 {
 199     move(reg, linkRegister);
 200 }
 201
 202 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)
 203 {
 204     loadPtr(address, linkRegister);
 205 }
 206 #elif CPU(SH4)
 207
 208 ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)
 209 {
 210     m_assembler.stspr(reg);
 211 }
 212
 213 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)
 214 {
 215     m_assembler.ldspr(reg);
 216 }
 217
 218 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)
 219 {
 220     loadPtrLinkReg(address);
 221 }
 222
 223 #elif CPU(MIPS)
 224
 225 ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)
 226 {
 227     move(returnAddressRegister, reg);
 228 }
 229
 230 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)
 231 {
 232     move(reg, returnAddressRegister);
 233 }
 234
 235 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)
 236 {
 237     loadPtr(address, returnAddressRegister);
 238 }
 239
 240 #else // CPU(X86) || CPU(X86_64)
 241
 242 ALWAYS_INLINE void JIT::preserveReturnAddressAfterCall(RegisterID reg)
 243 {
 244     pop(reg);
 245 }
 246
 247 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(RegisterID reg)
 248 {
 249     push(reg);
 250 }
 251
 252 ALWAYS_INLINE void JIT::restoreReturnAddressBeforeReturn(Address address)
 253 {
 254     push(address);
 255 }
 256
 257 #endif
 258
 259 ALWAYS_INLINE void JIT::restoreArgumentReference()
 260 {
 261     move(stackPointerRegister, firstArgumentRegister);
 262     poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
 263 }
 264
 265 ALWAYS_INLINE void JIT::updateTopCallFrame()
 266 {
 267     ASSERT(static_cast<int>(m_bytecodeOffset) >= 0);
 268     if (m_bytecodeOffset) {
 269 #if USE(JSVALUE32_64)
 270         storePtr(TrustedImmPtr(m_codeBlock->instructions().begin() + m_bytecodeOffset + 1), intTagFor(RegisterFile::ArgumentCount));
 271 #else
 272         store32(TrustedImm32(m_bytecodeOffset + 1), intTagFor(RegisterFile::ArgumentCount));
 273 #endif
 274     }
 275     storePtr(callFrameRegister, &m_globalData->topCallFrame);
 276 }
 277
 278 ALWAYS_INLINE void JIT::restoreArgumentReferenceForTrampoline()
 279 {
 280 #if CPU(X86)
 281     // Within a trampoline the return address will be on the stack at this point.
 282     addPtr(TrustedImm32(sizeof(void*)), stackPointerRegister, firstArgumentRegister);
 283 #elif CPU(ARM)
 284     move(stackPointerRegister, firstArgumentRegister);
 285 #elif CPU(SH4)
 286     move(stackPointerRegister, firstArgumentRegister);
 287 #endif
 288     // In the trampoline on x86-64, the first argument register is not overwritten.
 289 }
 290
 291 ALWAYS_INLINE JIT::Jump JIT::checkStructure(RegisterID reg, Structure* structure)
 292 {
 293     return branchPtr(NotEqual, Address(reg, JSCell::structureOffset()), TrustedImmPtr(structure));
 294 }
 295
 296 ALWAYS_INLINE void JIT::linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator& iter, int vReg)
 297 {
 298     if (!m_codeBlock->isKnownNotImmediate(vReg))
 299         linkSlowCase(iter);
 300 }
 301
 302 ALWAYS_INLINE void JIT::addSlowCase(Jump jump)
 303 {
 304     ASSERT(m_bytecodeOffset != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeOffset is set.
 305
 306     m_slowCases.append(SlowCaseEntry(jump, m_bytecodeOffset));
 307 }
 308
 309 ALWAYS_INLINE void JIT::addSlowCase(JumpList jumpList)
 310 {
 311     ASSERT(m_bytecodeOffset != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeOffset is set.
 312
 313     const JumpList::JumpVector& jumpVector = jumpList.jumps();
 314     size_t size = jumpVector.size();
 315     for (size_t i = 0; i < size; ++i)
 316         m_slowCases.append(SlowCaseEntry(jumpVector[i], m_bytecodeOffset));
 317 }
 318
 319 ALWAYS_INLINE void JIT::addSlowCase()
 320 {
 321     ASSERT(m_bytecodeOffset != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeOffset is set.
 322
 323     Jump emptyJump; // Doing it this way to make Windows happy.
 324     m_slowCases.append(SlowCaseEntry(emptyJump, m_bytecodeOffset));
 325 }
 326
 327 ALWAYS_INLINE void JIT::addJump(Jump jump, int relativeOffset)
 328 {
 329     ASSERT(m_bytecodeOffset != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeOffset is set.
 330
 331     m_jmpTable.append(JumpTable(jump, m_bytecodeOffset + relativeOffset));
 332 }
 333
 334 ALWAYS_INLINE void JIT::emitJumpSlowToHot(Jump jump, int relativeOffset)
 335 {
 336     ASSERT(m_bytecodeOffset != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeOffset is set.
 337
 338     jump.linkTo(m_labels[m_bytecodeOffset + relativeOffset], this);
 339 }
 340
 341 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotObject(RegisterID structureReg)
 342 {
 343     return branch8(Below, Address(structureReg, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType));
 344 }
 345
 346 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotType(RegisterID baseReg, RegisterID scratchReg, JSType type)
 347 {
 348     loadPtr(Address(baseReg, JSCell::structureOffset()), scratchReg);
 349     return branch8(NotEqual, Address(scratchReg, Structure::typeInfoTypeOffset()), TrustedImm32(type));
 350 }
 351
 352 #if ENABLE(SAMPLING_FLAGS)
 353 ALWAYS_INLINE void JIT::setSamplingFlag(int32_t flag)
 354 {
 355     ASSERT(flag >= 1);
 356     ASSERT(flag <= 32);
 357     or32(TrustedImm32(1u << (flag - 1)), AbsoluteAddress(SamplingFlags::addressOfFlags()));
 358 }
 359
 360 ALWAYS_INLINE void JIT::clearSamplingFlag(int32_t flag)
 361 {
 362     ASSERT(flag >= 1);
 363     ASSERT(flag <= 32);
 364     and32(TrustedImm32(~(1u << (flag - 1))), AbsoluteAddress(SamplingFlags::addressOfFlags()));
 365 }
 366 #endif
 367
 368 #if ENABLE(SAMPLING_COUNTERS)
 369 ALWAYS_INLINE void JIT::emitCount(AbstractSamplingCounter& counter, int32_t count)
 370 {
 371     add64(TrustedImm32(count), AbsoluteAddress(counter.addressOfCounter()));
 372 }
 373 #endif
 374
 375 #if ENABLE(OPCODE_SAMPLING)
 376 #if CPU(X86_64)
 377 ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)
 378 {
 379     move(TrustedImmPtr(m_interpreter->sampler()->sampleSlot()), X86Registers::ecx);
 380     storePtr(TrustedImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), X86Registers::ecx);
 381 }
 382 #else
 383 ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)
 384 {
 385     storePtr(TrustedImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), m_interpreter->sampler()->sampleSlot());
 386 }
 387 #endif
 388 #endif
 389
 390 #if ENABLE(CODEBLOCK_SAMPLING)
 391 #if CPU(X86_64)
 392 ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)
 393 {
 394     move(TrustedImmPtr(m_interpreter->sampler()->codeBlockSlot()), X86Registers::ecx);
 395     storePtr(TrustedImmPtr(codeBlock), X86Registers::ecx);
 396 }
 397 #else
 398 ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)
 399 {
 400     storePtr(TrustedImmPtr(codeBlock), m_interpreter->sampler()->codeBlockSlot());
 401 }
 402 #endif
 403 #endif
 404
 405 ALWAYS_INLINE bool JIT::isOperandConstantImmediateChar(unsigned src)
 406 {
 407     return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isString() && asString(getConstantOperand(src).asCell())->length() == 1;
 408 }
 409
 410 template <typename ClassType, bool destructor, typename StructureType> inline void JIT::emitAllocateBasicJSObject(StructureType structure, RegisterID result, RegisterID storagePtr)
 411 {
 412     MarkedAllocator* allocator = 0;
 413     if (destructor)
 414         allocator = &m_globalData->heap.allocatorForObjectWithDestructor(sizeof(ClassType));
 415     else
 416         allocator = &m_globalData->heap.allocatorForObjectWithoutDestructor(sizeof(ClassType));
 417     loadPtr(&allocator->m_firstFreeCell, result);
 418     addSlowCase(branchTestPtr(Zero, result));
 419
 420     // remove the object from the free list
 421     loadPtr(Address(result), storagePtr);
 422     storePtr(storagePtr, &allocator->m_firstFreeCell);
 423
 424     // initialize the object's structure
 425     storePtr(structure, Address(result, JSCell::structureOffset()));
 426
 427     // initialize the object's classInfo pointer
 428     storePtr(TrustedImmPtr(&ClassType::s_info), Address(result, JSCell::classInfoOffset()));
 429
 430     // initialize the inheritor ID
 431     storePtr(TrustedImmPtr(0), Address(result, JSObject::offsetOfInheritorID()));
 432
 433     // initialize the object's property storage pointer
 434     addPtr(TrustedImm32(sizeof(JSObject)), result, storagePtr);
 435     storePtr(storagePtr, Address(result, ClassType::offsetOfPropertyStorage()));
 436 }
 437
 438 template <typename T> inline void JIT::emitAllocateJSFinalObject(T structure, RegisterID result, RegisterID scratch)
 439 {
 440     emitAllocateBasicJSObject<JSFinalObject, false, T>(structure, result, scratch);
 441 }
 442
 443 inline void JIT::emitAllocateJSFunction(FunctionExecutable* executable, RegisterID scopeChain, RegisterID result, RegisterID storagePtr)
 444 {
 445     emitAllocateBasicJSObject<JSFunction, true>(TrustedImmPtr(m_codeBlock->globalObject()->namedFunctionStructure()), result, storagePtr);
 446
 447     // store the function's scope chain
 448     storePtr(scopeChain, Address(result, JSFunction::offsetOfScopeChain()));
 449
 450     // store the function's executable member
 451     storePtr(TrustedImmPtr(executable), Address(result, JSFunction::offsetOfExecutable()));
 452
 453     // store the function's name
 454     ASSERT(executable->nameValue());
 455     int functionNameOffset = sizeof(JSValue) * m_codeBlock->globalObject()->functionNameOffset();
 456     storePtr(TrustedImmPtr(executable->nameValue()), Address(regT1, functionNameOffset + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
 457 #if USE(JSVALUE32_64)
 458     store32(TrustedImm32(JSValue::CellTag), Address(regT1, functionNameOffset + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
 459 #endif
 460 }
 461
 462 inline void JIT::emitAllocateBasicStorage(size_t size, RegisterID result, RegisterID storagePtr)
 463 {
 464     CopiedAllocator* allocator = &m_globalData->heap.storageAllocator();
 465
 466     // FIXME: We need to check for wrap-around.
 467     // Check to make sure that the allocation will fit in the current block.
 468     loadPtr(&allocator->m_currentOffset, result);
 469     addPtr(TrustedImm32(size), result);
 470     loadPtr(&allocator->m_currentBlock, storagePtr);
 471     addPtr(TrustedImm32(HeapBlock::s_blockSize), storagePtr);
 472     addSlowCase(branchPtr(AboveOrEqual, result, storagePtr));
 473
 474     // Load the original offset.
 475     loadPtr(&allocator->m_currentOffset, result);
 476
 477     // Bump the pointer forward.
 478     move(result, storagePtr);
 479     addPtr(TrustedImm32(size), storagePtr);
 480     storePtr(storagePtr, &allocator->m_currentOffset);
 481 }
 482
 483 inline void JIT::emitAllocateJSArray(unsigned valuesRegister, unsigned length, RegisterID cellResult, RegisterID storageResult, RegisterID storagePtr)
 484 {
 485     unsigned initialLength = std::max(length, 4U);
 486     size_t initialStorage = JSArray::storageSize(initialLength);
 487
 488     // Allocate the cell for the array.
 489     emitAllocateBasicJSObject<JSArray, false>(TrustedImmPtr(m_codeBlock->globalObject()->arrayStructure()), cellResult, storagePtr);
 490
 491     // Allocate the backing store for the array.
 492     emitAllocateBasicStorage(initialStorage, storageResult, storagePtr);
 493
 494     // Store all the necessary info in the ArrayStorage.
 495     storePtr(storageResult, Address(storageResult, ArrayStorage::allocBaseOffset()));
 496     store32(Imm32(length), Address(storageResult, ArrayStorage::lengthOffset()));
 497     store32(Imm32(length), Address(storageResult, ArrayStorage::numValuesInVectorOffset()));
 498
 499     // Store the newly allocated ArrayStorage.
 500     storePtr(storageResult, Address(cellResult, JSArray::storageOffset()));
 501
 502     // Store the vector length and index bias.
 503     store32(Imm32(initialLength), Address(cellResult, JSArray::vectorLengthOffset()));
 504     store32(TrustedImm32(0), Address(cellResult, JSArray::indexBiasOffset()));
 505
 506     // Initialize the sparse value map.
 507     storePtr(TrustedImmPtr(0), Address(cellResult, JSArray::sparseValueMapOffset()));
 508
 509         // Store the values we have.
 510     for (unsigned i = 0; i < length; i++) {
 511 #if USE(JSVALUE64)
 512         loadPtr(Address(callFrameRegister, (valuesRegister + i) * sizeof(Register)), storagePtr);
 513         storePtr(storagePtr, Address(storageResult, ArrayStorage::vectorOffset() + sizeof(WriteBarrier<Unknown>) * i));
 514 #else
 515         load32(Address(callFrameRegister, (valuesRegister + i) * sizeof(Register)), storagePtr);
 516         store32(storagePtr, Address(storageResult, ArrayStorage::vectorOffset() + sizeof(WriteBarrier<Unknown>) * i));
 517         load32(Address(callFrameRegister, (valuesRegister + i) * sizeof(Register) + sizeof(uint32_t)), storagePtr);
 518         store32(storagePtr, Address(storageResult, ArrayStorage::vectorOffset() + sizeof(WriteBarrier<Unknown>) * i + sizeof(uint32_t)));
 519 #endif
 520     }
 521
 522     // Zero out the remaining slots.
 523     for (unsigned i = length; i < initialLength; i++) {
 524 #if USE(JSVALUE64)
 525         storePtr(TrustedImmPtr(0), Address(storageResult, ArrayStorage::vectorOffset() + sizeof(WriteBarrier<Unknown>) * i));
 526 #else
 527         store32(TrustedImm32(static_cast<int>(JSValue::EmptyValueTag)), Address(storageResult, ArrayStorage::vectorOffset() + sizeof(WriteBarrier<Unknown>) * i + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
 528         store32(TrustedImm32(0), Address(storageResult, ArrayStorage::vectorOffset() + sizeof(WriteBarrier<Unknown>) * i + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
 529 #endif
 530     }
 531 }
 532
 533 #if ENABLE(VALUE_PROFILER)
 534 inline void JIT::emitValueProfilingSite(ValueProfile* valueProfile)
 535 {
 536     ASSERT(shouldEmitProfiling());
 537     ASSERT(valueProfile);
 538
 539     const RegisterID value = regT0;
 540 #if USE(JSVALUE32_64)
 541     const RegisterID valueTag = regT1;
 542 #endif
 543     const RegisterID scratch = regT3;
 544
 545     if (ValueProfile::numberOfBuckets == 1) {
 546         // We're in a simple configuration: only one bucket, so we can just do a direct
 547         // store.
 548 #if USE(JSVALUE64)
 549         storePtr(value, valueProfile->m_buckets);
 550 #else
 551         EncodedValueDescriptor* descriptor = bitwise_cast<EncodedValueDescriptor*>(valueProfile->m_buckets);
 552         store32(value, &descriptor->asBits.payload);
 553         store32(valueTag, &descriptor->asBits.tag);
 554 #endif
 555         return;
 556     }
 557
 558     if (m_randomGenerator.getUint32() & 1)
 559         add32(TrustedImm32(1), bucketCounterRegister);
 560     else
 561         add32(TrustedImm32(3), bucketCounterRegister);
 562     and32(TrustedImm32(ValueProfile::bucketIndexMask), bucketCounterRegister);
 563     move(TrustedImmPtr(valueProfile->m_buckets), scratch);
 564 #if USE(JSVALUE64)
 565     storePtr(value, BaseIndex(scratch, bucketCounterRegister, TimesEight));
 566 #elif USE(JSVALUE32_64)
 567     store32(value, BaseIndex(scratch, bucketCounterRegister, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
 568     store32(valueTag, BaseIndex(scratch, bucketCounterRegister, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
 569 #endif
 570 }
 571
 572 inline void JIT::emitValueProfilingSite(unsigned bytecodeOffset)
 573 {
 574     if (!shouldEmitProfiling())
 575         return;
 576     emitValueProfilingSite(m_codeBlock->valueProfileForBytecodeOffset(bytecodeOffset));
 577 }
 578
 579 inline void JIT::emitValueProfilingSite()
 580 {
 581     emitValueProfilingSite(m_bytecodeOffset);
 582 }
 583 #endif
 584
 585 #if USE(JSVALUE32_64)
 586
 587 inline void JIT::emitLoadTag(int index, RegisterID tag)
 588 {
 589     RegisterID mappedTag;
 590     if (getMappedTag(index, mappedTag)) {
 591         move(mappedTag, tag);
 592         unmap(tag);
 593         return;
 594     }
 595
 596     if (m_codeBlock->isConstantRegisterIndex(index)) {
 597         move(Imm32(getConstantOperand(index).tag()), tag);
 598         unmap(tag);
 599         return;
 600     }
 601
 602     load32(tagFor(index), tag);
 603     unmap(tag);
 604 }
 605
 606 inline void JIT::emitLoadPayload(int index, RegisterID payload)
 607 {
 608     RegisterID mappedPayload;
 609     if (getMappedPayload(index, mappedPayload)) {
 610         move(mappedPayload, payload);
 611         unmap(payload);
 612         return;
 613     }
 614
 615     if (m_codeBlock->isConstantRegisterIndex(index)) {
 616         move(Imm32(getConstantOperand(index).payload()), payload);
 617         unmap(payload);
 618         return;
 619     }
 620
 621     load32(payloadFor(index), payload);
 622     unmap(payload);
 623 }
 624
 625 inline void JIT::emitLoad(const JSValue& v, RegisterID tag, RegisterID payload)
 626 {
 627     move(Imm32(v.payload()), payload);
 628     move(Imm32(v.tag()), tag);
 629 }
 630
 631 inline void JIT::emitLoad(int index, RegisterID tag, RegisterID payload, RegisterID base)
 632 {
 633     ASSERT(tag != payload);
 634
 635     if (base == callFrameRegister) {
 636         ASSERT(payload != base);
 637         emitLoadPayload(index, payload);
 638         emitLoadTag(index, tag);
 639         return;
 640     }
 641
 642     if (payload == base) { // avoid stomping base
 643         load32(tagFor(index, base), tag);
 644         load32(payloadFor(index, base), payload);
 645         return;
 646     }
 647
 648     load32(payloadFor(index, base), payload);
 649     load32(tagFor(index, base), tag);
 650 }
 651
 652 inline void JIT::emitLoad2(int index1, RegisterID tag1, RegisterID payload1, int index2, RegisterID tag2, RegisterID payload2)
 653 {
 654     if (isMapped(index1)) {
 655         emitLoad(index1, tag1, payload1);
 656         emitLoad(index2, tag2, payload2);
 657         return;
 658     }
 659     emitLoad(index2, tag2, payload2);
 660     emitLoad(index1, tag1, payload1);
 661 }
 662
 663 inline void JIT::emitLoadDouble(int index, FPRegisterID value)
 664 {
 665     if (m_codeBlock->isConstantRegisterIndex(index)) {
 666         WriteBarrier<Unknown>& inConstantPool = m_codeBlock->constantRegister(index);
 667         loadDouble(&inConstantPool, value);
 668     } else
 669         loadDouble(addressFor(index), value);
 670 }
 671
 672 inline void JIT::emitLoadInt32ToDouble(int index, FPRegisterID value)
 673 {
 674     if (m_codeBlock->isConstantRegisterIndex(index)) {
 675         WriteBarrier<Unknown>& inConstantPool = m_codeBlock->constantRegister(index);
 676         char* bytePointer = reinterpret_cast<char*>(&inConstantPool);
 677         convertInt32ToDouble(AbsoluteAddress(bytePointer + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), value);
 678     } else
 679         convertInt32ToDouble(payloadFor(index), value);
 680 }
 681
 682 inline void JIT::emitStore(int index, RegisterID tag, RegisterID payload, RegisterID base)
 683 {
 684     store32(payload, payloadFor(index, base));
 685     store32(tag, tagFor(index, base));
 686 }
 687
 688 inline void JIT::emitStoreInt32(int index, RegisterID payload, bool indexIsInt32)
 689 {
 690     store32(payload, payloadFor(index, callFrameRegister));
 691     if (!indexIsInt32)
 692         store32(TrustedImm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
 693 }
 694
 695 inline void JIT::emitStoreAndMapInt32(int index, RegisterID tag, RegisterID payload, bool indexIsInt32, size_t opcodeLength)
 696 {
 697     emitStoreInt32(index, payload, indexIsInt32);
 698     map(m_bytecodeOffset + opcodeLength, index, tag, payload);
 699 }
 700
 701 inline void JIT::emitStoreInt32(int index, TrustedImm32 payload, bool indexIsInt32)
 702 {
 703     store32(payload, payloadFor(index, callFrameRegister));
 704     if (!indexIsInt32)
 705         store32(TrustedImm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
 706 }
 707
 708 inline void JIT::emitStoreCell(int index, RegisterID payload, bool indexIsCell)
 709 {
 710     store32(payload, payloadFor(index, callFrameRegister));
 711     if (!indexIsCell)
 712         store32(TrustedImm32(JSValue::CellTag), tagFor(index, callFrameRegister));
 713 }
 714
 715 inline void JIT::emitStoreBool(int index, RegisterID payload, bool indexIsBool)
 716 {
 717     store32(payload, payloadFor(index, callFrameRegister));
 718     if (!indexIsBool)
 719         store32(TrustedImm32(JSValue::BooleanTag), tagFor(index, callFrameRegister));
 720 }
 721
 722 inline void JIT::emitStoreDouble(int index, FPRegisterID value)
 723 {
 724     storeDouble(value, addressFor(index));
 725 }
 726
 727 inline void JIT::emitStore(int index, const JSValue constant, RegisterID base)
 728 {
 729     store32(Imm32(constant.payload()), payloadFor(index, base));
 730     store32(Imm32(constant.tag()), tagFor(index, base));
 731 }
 732
 733 ALWAYS_INLINE void JIT::emitInitRegister(unsigned dst)
 734 {
 735     emitStore(dst, jsUndefined());
 736 }
 737
 738 inline bool JIT::isLabeled(unsigned bytecodeOffset)
 739 {
 740     for (size_t numberOfJumpTargets = m_codeBlock->numberOfJumpTargets(); m_jumpTargetIndex != numberOfJumpTargets; ++m_jumpTargetIndex) {
 741         unsigned jumpTarget = m_codeBlock->jumpTarget(m_jumpTargetIndex);
 742         if (jumpTarget == bytecodeOffset)
 743             return true;
 744         if (jumpTarget > bytecodeOffset)
 745             return false;
 746     }
 747     return false;
 748 }
 749
 750 inline void JIT::map(unsigned bytecodeOffset, int virtualRegisterIndex, RegisterID tag, RegisterID payload)
 751 {
 752     if (isLabeled(bytecodeOffset))
 753         return;
 754
 755     m_mappedBytecodeOffset = bytecodeOffset;
 756     m_mappedVirtualRegisterIndex = virtualRegisterIndex;
 757     m_mappedTag = tag;
 758     m_mappedPayload = payload;
 759
 760     ASSERT(!canBeOptimized() || m_mappedPayload == regT0);
 761     ASSERT(!canBeOptimized() || m_mappedTag == regT1);
 762 }
 763
 764 inline void JIT::unmap(RegisterID registerID)
 765 {
 766     if (m_mappedTag == registerID)
 767         m_mappedTag = (RegisterID)-1;
 768     else if (m_mappedPayload == registerID)
 769         m_mappedPayload = (RegisterID)-1;
 770 }
 771
 772 inline void JIT::unmap()
 773 {
 774     m_mappedBytecodeOffset = (unsigned)-1;
 775     m_mappedVirtualRegisterIndex = RegisterFile::ReturnPC;
 776     m_mappedTag = (RegisterID)-1;
 777     m_mappedPayload = (RegisterID)-1;
 778 }
 779
 780 inline bool JIT::isMapped(int virtualRegisterIndex)
 781 {
 782     if (m_mappedBytecodeOffset != m_bytecodeOffset)
 783         return false;
 784     if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)
 785         return false;
 786     return true;
 787 }
 788
 789 inline bool JIT::getMappedPayload(int virtualRegisterIndex, RegisterID& payload)
 790 {
 791     if (m_mappedBytecodeOffset != m_bytecodeOffset)
 792         return false;
 793     if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)
 794         return false;
 795     if (m_mappedPayload == (RegisterID)-1)
 796         return false;
 797     payload = m_mappedPayload;
 798     return true;
 799 }
 800
 801 inline bool JIT::getMappedTag(int virtualRegisterIndex, RegisterID& tag)
 802 {
 803     if (m_mappedBytecodeOffset != m_bytecodeOffset)
 804         return false;
 805     if (m_mappedVirtualRegisterIndex != virtualRegisterIndex)
 806         return false;
 807     if (m_mappedTag == (RegisterID)-1)
 808         return false;
 809     tag = m_mappedTag;
 810     return true;
 811 }
 812
 813 inline void JIT::emitJumpSlowCaseIfNotJSCell(int virtualRegisterIndex)
 814 {
 815     if (!m_codeBlock->isKnownNotImmediate(virtualRegisterIndex)) {
 816         if (m_codeBlock->isConstantRegisterIndex(virtualRegisterIndex))
 817             addSlowCase(jump());
 818         else
 819             addSlowCase(emitJumpIfNotJSCell(virtualRegisterIndex));
 820     }
 821 }
 822
 823 inline void JIT::emitJumpSlowCaseIfNotJSCell(int virtualRegisterIndex, RegisterID tag)
 824 {
 825     if (!m_codeBlock->isKnownNotImmediate(virtualRegisterIndex)) {
 826         if (m_codeBlock->isConstantRegisterIndex(virtualRegisterIndex))
 827             addSlowCase(jump());
 828         else
 829             addSlowCase(branch32(NotEqual, tag, TrustedImm32(JSValue::CellTag)));
 830     }
 831 }
 832
 833 ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(unsigned src)
 834 {
 835     return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isInt32();
 836 }
 837
 838 ALWAYS_INLINE bool JIT::getOperandConstantImmediateInt(unsigned op1, unsigned op2, unsigned& op, int32_t& constant)
 839 {
 840     if (isOperandConstantImmediateInt(op1)) {
 841         constant = getConstantOperand(op1).asInt32();
 842         op = op2;
 843         return true;
 844     }
 845
 846     if (isOperandConstantImmediateInt(op2)) {
 847         constant = getConstantOperand(op2).asInt32();
 848         op = op1;
 849         return true;
 850     }
 851
 852     return false;
 853 }
 854
 855 #else // USE(JSVALUE32_64)
 856
 857 ALWAYS_INLINE void JIT::killLastResultRegister()
 858 {
 859     m_lastResultBytecodeRegister = std::numeric_limits<int>::max();
 860 }
 861
 862 // get arg puts an arg from the SF register array into a h/w register
 863 ALWAYS_INLINE void JIT::emitGetVirtualRegister(int src, RegisterID dst)
 864 {
 865     ASSERT(m_bytecodeOffset != (unsigned)-1); // This method should only be called during hot/cold path generation, so that m_bytecodeOffset is set.
 866
 867     // TODO: we want to reuse values that are already in registers if we can - add a register allocator!
 868     if (m_codeBlock->isConstantRegisterIndex(src)) {
 869         JSValue value = m_codeBlock->getConstant(src);
 870         if (!value.isNumber())
 871             move(TrustedImmPtr(JSValue::encode(value)), dst);
 872         else
 873             move(ImmPtr(JSValue::encode(value)), dst);
 874         killLastResultRegister();
 875         return;
 876     }
 877
 878     if (src == m_lastResultBytecodeRegister && m_codeBlock->isTemporaryRegisterIndex(src) && !atJumpTarget()) {
 879         // The argument we want is already stored in eax
 880         if (dst != cachedResultRegister)
 881             move(cachedResultRegister, dst);
 882         killLastResultRegister();
 883         return;
 884     }
 885
 886     loadPtr(Address(callFrameRegister, src * sizeof(Register)), dst);
 887     killLastResultRegister();
 888 }
 889
 890 ALWAYS_INLINE void JIT::emitGetVirtualRegisters(int src1, RegisterID dst1, int src2, RegisterID dst2)
 891 {
 892     if (src2 == m_lastResultBytecodeRegister) {
 893         emitGetVirtualRegister(src2, dst2);
 894         emitGetVirtualRegister(src1, dst1);
 895     } else {
 896         emitGetVirtualRegister(src1, dst1);
 897         emitGetVirtualRegister(src2, dst2);
 898     }
 899 }
 900
 901 ALWAYS_INLINE int32_t JIT::getConstantOperandImmediateInt(unsigned src)
 902 {
 903     return getConstantOperand(src).asInt32();
 904 }
 905
 906 ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(unsigned src)
 907 {
 908     return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isInt32();
 909 }
 910
 911 ALWAYS_INLINE void JIT::emitPutVirtualRegister(unsigned dst, RegisterID from)
 912 {
 913     storePtr(from, Address(callFrameRegister, dst * sizeof(Register)));
 914     m_lastResultBytecodeRegister = (from == cachedResultRegister) ? static_cast<int>(dst) : std::numeric_limits<int>::max();
 915 }
 916
 917 ALWAYS_INLINE void JIT::emitInitRegister(unsigned dst)
 918 {
 919     storePtr(TrustedImmPtr(JSValue::encode(jsUndefined())), Address(callFrameRegister, dst * sizeof(Register)));
 920 }
 921
 922 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfJSCell(RegisterID reg)
 923 {
 924 #if USE(JSVALUE64)
 925     return branchTestPtr(Zero, reg, tagMaskRegister);
 926 #else
 927     return branchTest32(Zero, reg, TrustedImm32(TagMask));
 928 #endif
 929 }
 930
 931 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfBothJSCells(RegisterID reg1, RegisterID reg2, RegisterID scratch)
 932 {
 933     move(reg1, scratch);
 934     orPtr(reg2, scratch);
 935     return emitJumpIfJSCell(scratch);
 936 }
 937
 938 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfJSCell(RegisterID reg)
 939 {
 940     addSlowCase(emitJumpIfJSCell(reg));
 941 }
 942
 943 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotJSCell(RegisterID reg)
 944 {
 945 #if USE(JSVALUE64)
 946     return branchTestPtr(NonZero, reg, tagMaskRegister);
 947 #else
 948     return branchTest32(NonZero, reg, TrustedImm32(TagMask));
 949 #endif
 950 }
 951
 952 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg)
 953 {
 954     addSlowCase(emitJumpIfNotJSCell(reg));
 955 }
 956
 957 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg, int vReg)
 958 {
 959     if (!m_codeBlock->isKnownNotImmediate(vReg))
 960         emitJumpSlowCaseIfNotJSCell(reg);
 961 }
 962
 963 #if USE(JSVALUE64)
 964
 965 inline void JIT::emitLoadDouble(int index, FPRegisterID value)
 966 {
 967     if (m_codeBlock->isConstantRegisterIndex(index)) {
 968         WriteBarrier<Unknown>& inConstantPool = m_codeBlock->constantRegister(index);
 969         loadDouble(&inConstantPool, value);
 970     } else
 971         loadDouble(addressFor(index), value);
 972 }
 973
 974 inline void JIT::emitLoadInt32ToDouble(int index, FPRegisterID value)
 975 {
 976     if (m_codeBlock->isConstantRegisterIndex(index)) {
 977         ASSERT(isOperandConstantImmediateInt(index));
 978         convertInt32ToDouble(Imm32(getConstantOperand(index).asInt32()), value);
 979     } else
 980         convertInt32ToDouble(addressFor(index), value);
 981 }
 982 #endif
 983
 984 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfImmediateInteger(RegisterID reg)
 985 {
 986 #if USE(JSVALUE64)
 987     return branchPtr(AboveOrEqual, reg, tagTypeNumberRegister);
 988 #else
 989     return branchTest32(NonZero, reg, TrustedImm32(TagTypeNumber));
 990 #endif
 991 }
 992
 993 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotImmediateInteger(RegisterID reg)
 994 {
 995 #if USE(JSVALUE64)
 996     return branchPtr(Below, reg, tagTypeNumberRegister);
 997 #else
 998     return branchTest32(Zero, reg, TrustedImm32(TagTypeNumber));
 999 #endif
1000 }
1001
1002 ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotImmediateIntegers(RegisterID reg1, RegisterID reg2, RegisterID scratch)
1003 {
1004     move(reg1, scratch);
1005     andPtr(reg2, scratch);
1006     return emitJumpIfNotImmediateInteger(scratch);
1007 }
1008
1009 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateInteger(RegisterID reg)
1010 {
1011     addSlowCase(emitJumpIfNotImmediateInteger(reg));
1012 }
1013
1014 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateIntegers(RegisterID reg1, RegisterID reg2, RegisterID scratch)
1015 {
1016     addSlowCase(emitJumpIfNotImmediateIntegers(reg1, reg2, scratch));
1017 }
1018
1019 ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateNumber(RegisterID reg)
1020 {
1021     addSlowCase(emitJumpIfNotImmediateNumber(reg));
1022 }
1023
1024 #if USE(JSVALUE32_64)
1025 ALWAYS_INLINE void JIT::emitFastArithDeTagImmediate(RegisterID reg)
1026 {
1027     subPtr(TrustedImm32(TagTypeNumber), reg);
1028 }
1029
1030 ALWAYS_INLINE JIT::Jump JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
1031 {
1032     return branchSubPtr(Zero, TrustedImm32(TagTypeNumber), reg);
1033 }
1034 #endif
1035
1036 ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID src, RegisterID dest)
1037 {
1038 #if USE(JSVALUE64)
1039     emitFastArithIntToImmNoCheck(src, dest);
1040 #else
1041     if (src != dest)
1042         move(src, dest);
1043     addPtr(TrustedImm32(TagTypeNumber), dest);
1044 #endif
1045 }
1046
1047 // operand is int32_t, must have been zero-extended if register is 64-bit.
1048 ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest)
1049 {
1050 #if USE(JSVALUE64)
1051     if (src != dest)
1052         move(src, dest);
1053     orPtr(tagTypeNumberRegister, dest);
1054 #else
1055     signExtend32ToPtr(src, dest);
1056     addPtr(dest, dest);
1057     emitFastArithReTagImmediate(dest, dest);
1058 #endif
1059 }
1060
1061 ALWAYS_INLINE void JIT::emitTagAsBoolImmediate(RegisterID reg)
1062 {
1063     or32(TrustedImm32(static_cast<int32_t>(ValueFalse)), reg);
1064 }
1065
1066 #endif // USE(JSVALUE32_64)
1067
1068 } // namespace JSC
1069
1070 #endif // ENABLE(JIT)
1071
1072 #endif