Remove m_subclassData from JSArray, move the attribute to subclass as needed
[WebKit-https.git] / 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