/*
- * Copyright (C) 2008, 2012, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2012, 2013, 2014 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
#if ENABLE(JIT)
-// Verbose logging of code generation
-#define ENABLE_JIT_VERBOSE 0
-// Verbose logging for OSR-related code.
-#define ENABLE_JIT_VERBOSE_OSR 0
-
// We've run into some problems where changing the size of the class JIT leads to
// performance fluctuations. Try forcing alignment in an attempt to stabalize this.
#if COMPILER(GCC)
#include "CompactJITCodeMap.h"
#include "Interpreter.h"
#include "JITDisassembler.h"
+#include "JITInlineCacheGenerator.h"
#include "JSInterfaceJIT.h"
#include "LegacyProfiler.h"
#include "Opcode.h"
#include "ResultType.h"
+#include "SamplingTool.h"
#include "UnusedPointer.h"
-#include <bytecode/SamplingTool.h>
namespace JSC {
+ class ArrayAllocationProfile;
class CodeBlock;
class FunctionExecutable;
class JIT;
class JSPropertyNameIterator;
+ class Identifier;
class Interpreter;
class JSScope;
class JSStack;
}
};
- enum PropertyStubGetById_T { PropertyStubGetById };
- enum PropertyStubPutById_T { PropertyStubPutById };
-
- struct PropertyStubCompilationInfo {
- enum Type { GetById, PutById } m_type;
-
- unsigned bytecodeIndex;
- MacroAssembler::Call callReturnLocation;
- MacroAssembler::Label hotPathBegin;
- MacroAssembler::DataLabelPtr getStructureToCompare;
- MacroAssembler::PatchableJump getStructureCheck;
- MacroAssembler::ConvertibleLoadLabel propertyStorageLoad;
-#if USE(JSVALUE64)
- MacroAssembler::DataLabelCompact getDisplacementLabel;
-#else
- MacroAssembler::DataLabelCompact getDisplacementLabel1;
- MacroAssembler::DataLabelCompact getDisplacementLabel2;
-#endif
- MacroAssembler::Label getPutResult;
- MacroAssembler::Label getColdPathBegin;
- MacroAssembler::DataLabelPtr putStructureToCompare;
-#if USE(JSVALUE64)
- MacroAssembler::DataLabel32 putDisplacementLabel;
-#else
- MacroAssembler::DataLabel32 putDisplacementLabel1;
- MacroAssembler::DataLabel32 putDisplacementLabel2;
-#endif
-
-#if !ASSERT_DISABLED
- PropertyStubCompilationInfo()
- : bytecodeIndex(std::numeric_limits<unsigned>::max())
- {
- }
-#endif
-
-
- PropertyStubCompilationInfo(
- PropertyStubGetById_T, unsigned bytecodeIndex, MacroAssembler::Label hotPathBegin,
- MacroAssembler::DataLabelPtr structureToCompare,
- MacroAssembler::PatchableJump structureCheck,
- MacroAssembler::ConvertibleLoadLabel propertyStorageLoad,
-#if USE(JSVALUE64)
- MacroAssembler::DataLabelCompact displacementLabel,
-#else
- MacroAssembler::DataLabelCompact displacementLabel1,
- MacroAssembler::DataLabelCompact displacementLabel2,
-#endif
- MacroAssembler::Label putResult)
- : m_type(GetById)
- , bytecodeIndex(bytecodeIndex)
- , hotPathBegin(hotPathBegin)
- , getStructureToCompare(structureToCompare)
- , getStructureCheck(structureCheck)
- , propertyStorageLoad(propertyStorageLoad)
-#if USE(JSVALUE64)
- , getDisplacementLabel(displacementLabel)
-#else
- , getDisplacementLabel1(displacementLabel1)
- , getDisplacementLabel2(displacementLabel2)
-#endif
- , getPutResult(putResult)
- {
- }
-
- PropertyStubCompilationInfo(
- PropertyStubPutById_T, unsigned bytecodeIndex, MacroAssembler::Label hotPathBegin,
- MacroAssembler::DataLabelPtr structureToCompare,
- MacroAssembler::ConvertibleLoadLabel propertyStorageLoad,
-#if USE(JSVALUE64)
- MacroAssembler::DataLabel32 displacementLabel
-#else
- MacroAssembler::DataLabel32 displacementLabel1,
- MacroAssembler::DataLabel32 displacementLabel2
-#endif
- )
- : m_type(PutById)
- , bytecodeIndex(bytecodeIndex)
- , hotPathBegin(hotPathBegin)
- , propertyStorageLoad(propertyStorageLoad)
- , putStructureToCompare(structureToCompare)
-#if USE(JSVALUE64)
- , putDisplacementLabel(displacementLabel)
-#else
- , putDisplacementLabel1(displacementLabel1)
- , putDisplacementLabel2(displacementLabel2)
-#endif
- {
- }
-
- void slowCaseInfo(PropertyStubGetById_T, MacroAssembler::Label coldPathBegin, MacroAssembler::Call call)
- {
- ASSERT(m_type == GetById);
- callReturnLocation = call;
- getColdPathBegin = coldPathBegin;
- }
-
- void slowCaseInfo(PropertyStubPutById_T, MacroAssembler::Call call)
- {
- ASSERT(m_type == PutById);
- callReturnLocation = call;
- }
-
- void copyToStubInfo(StructureStubInfo& info, LinkBuffer &patchBuffer);
- };
-
struct ByValCompilationInfo {
ByValCompilationInfo() { }
MacroAssembler::Call returnAddress;
};
- struct StructureStubCompilationInfo {
+ struct CallCompilationInfo {
MacroAssembler::DataLabelPtr hotPathBegin;
MacroAssembler::Call hotPathOther;
MacroAssembler::Call callReturnLocation;
- CallLinkInfo::CallType callType;
- unsigned bytecodeIndex;
+ CallLinkInfo* callLinkInfo;
};
// Near calls can only be patched to other JIT code, regular calls can be patched to JIT code or relinked to stub functions.
void ctiPatchCallByReturnAddress(CodeBlock* codeblock, ReturnAddressPtr returnAddress, FunctionPtr newCalleeFunction);
class JIT : private JSInterfaceJIT {
+ friend class JITSlowPathCall;
friend class JITStubCall;
- friend struct PropertyStubCompilationInfo;
using MacroAssembler::Jump;
using MacroAssembler::JumpList;
static const int patchPutByIdDefaultOffset = 256;
public:
- static JITCode compile(VM* vm, CodeBlock* codeBlock, JITCompilationEffort effort, CodePtr* functionEntryArityCheck = 0)
+ static CompilationResult compile(VM* vm, CodeBlock* codeBlock, JITCompilationEffort effort)
{
- return JIT(vm, codeBlock).privateCompile(functionEntryArityCheck, effort);
+ return JIT(vm, codeBlock).privateCompile(effort);
}
static void compileClosureCall(VM* vm, CallLinkInfo* callLinkInfo, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, Structure* expectedStructure, ExecutableBase* expectedExecutable, MacroAssemblerCodePtr codePtr)
jit.privateCompileClosureCall(callLinkInfo, calleeCodeBlock, expectedStructure, expectedExecutable, codePtr);
}
- static void compileGetByIdProto(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress)
- {
- JIT jit(vm, codeBlock);
- jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
- jit.privateCompileGetByIdProto(stubInfo, structure, prototypeStructure, ident, slot, cachedOffset, returnAddress, callFrame);
- }
-
- static void compileGetByIdSelfList(VM* vm, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* polymorphicStructures, int currentIndex, Structure* structure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
- {
- JIT jit(vm, codeBlock);
- jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
- jit.privateCompileGetByIdSelfList(stubInfo, polymorphicStructures, currentIndex, structure, ident, slot, cachedOffset);
- }
- static void compileGetByIdProtoList(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
- {
- JIT jit(vm, codeBlock);
- jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
- jit.privateCompileGetByIdProtoList(stubInfo, prototypeStructureList, currentIndex, structure, prototypeStructure, ident, slot, cachedOffset, callFrame);
- }
- static void compileGetByIdChainList(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
- {
- JIT jit(vm, codeBlock);
- jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
- jit.privateCompileGetByIdChainList(stubInfo, prototypeStructureList, currentIndex, structure, chain, count, ident, slot, cachedOffset, callFrame);
- }
-
- static void compileGetByIdChain(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress)
- {
- JIT jit(vm, codeBlock);
- jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
- jit.privateCompileGetByIdChain(stubInfo, structure, chain, count, ident, slot, cachedOffset, returnAddress, callFrame);
- }
-
- static void compilePutByIdTransition(VM* vm, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* oldStructure, Structure* newStructure, PropertyOffset cachedOffset, StructureChain* chain, ReturnAddressPtr returnAddress, bool direct)
- {
- JIT jit(vm, codeBlock);
- jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
- jit.privateCompilePutByIdTransition(stubInfo, oldStructure, newStructure, cachedOffset, chain, returnAddress, direct);
- }
-
static void compileGetByVal(VM* vm, CodeBlock* codeBlock, ByValInfo* byValInfo, ReturnAddressPtr returnAddress, JITArrayMode arrayMode)
{
JIT jit(vm, codeBlock);
jit.m_bytecodeOffset = byValInfo->bytecodeIndex;
jit.privateCompilePutByVal(byValInfo, returnAddress, arrayMode);
}
+
+ static void compileDirectPutByVal(VM* vm, CodeBlock* codeBlock, ByValInfo* byValInfo, ReturnAddressPtr returnAddress, JITArrayMode arrayMode)
+ {
+ JIT jit(vm, codeBlock);
+ jit.m_bytecodeOffset = byValInfo->bytecodeIndex;
+ jit.privateCompilePutByVal(byValInfo, returnAddress, arrayMode);
+ }
static CodeRef compileCTINativeCall(VM* vm, NativeFunction func)
{
if (!vm->canUseJIT()) {
-#if ENABLE(LLINT)
return CodeRef::createLLIntCodeRef(llint_native_call_trampoline);
-#else
- return CodeRef();
-#endif
}
JIT jit(vm, 0);
return jit.privateCompileCTINativeCall(vm, func);
}
- static void resetPatchGetById(RepatchBuffer&, StructureStubInfo*);
- static void resetPatchPutById(RepatchBuffer&, StructureStubInfo*);
- static void patchGetByIdSelf(CodeBlock*, StructureStubInfo*, Structure*, PropertyOffset cachedOffset, ReturnAddressPtr);
- static void patchPutByIdReplace(CodeBlock*, StructureStubInfo*, Structure*, PropertyOffset cachedOffset, ReturnAddressPtr, bool direct);
-
- static void compilePatchGetArrayLength(VM* vm, CodeBlock* codeBlock, ReturnAddressPtr returnAddress)
- {
- JIT jit(vm, codeBlock);
-#if ENABLE(DFG_JIT)
- // Force profiling to be enabled during stub generation.
- jit.m_canBeOptimized = true;
- jit.m_canBeOptimizedOrInlined = true;
- jit.m_shouldEmitProfiling = true;
-#endif // ENABLE(DFG_JIT)
- return jit.privateCompilePatchGetArrayLength(returnAddress);
- }
-
- static void linkFor(JSFunction* callee, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, CodePtr, CallLinkInfo*, VM*, CodeSpecializationKind);
- static void linkSlowCall(CodeBlock* callerCodeBlock, CallLinkInfo*);
+ static unsigned frameRegisterCountFor(CodeBlock*);
+ static int stackPointerOffsetFor(CodeBlock*);
private:
JIT(VM*, CodeBlock* = 0);
void privateCompileMainPass();
void privateCompileLinkPass();
void privateCompileSlowCases();
- JITCode privateCompile(CodePtr* functionEntryArityCheck, JITCompilationEffort);
+ CompilationResult privateCompile(JITCompilationEffort);
void privateCompileClosureCall(CallLinkInfo*, CodeBlock* calleeCodeBlock, Structure*, ExecutableBase*, MacroAssemblerCodePtr);
- void privateCompileGetByIdProto(StructureStubInfo*, Structure*, Structure* prototypeStructure, const Identifier&, const PropertySlot&, PropertyOffset cachedOffset, ReturnAddressPtr, CallFrame*);
- void privateCompileGetByIdSelfList(StructureStubInfo*, PolymorphicAccessStructureList*, int, Structure*, const Identifier&, const PropertySlot&, PropertyOffset cachedOffset);
- void privateCompileGetByIdProtoList(StructureStubInfo*, PolymorphicAccessStructureList*, int, Structure*, Structure* prototypeStructure, const Identifier&, const PropertySlot&, PropertyOffset cachedOffset, CallFrame*);
- void privateCompileGetByIdChainList(StructureStubInfo*, PolymorphicAccessStructureList*, int, Structure*, StructureChain*, size_t count, const Identifier&, const PropertySlot&, PropertyOffset cachedOffset, CallFrame*);
- void privateCompileGetByIdChain(StructureStubInfo*, Structure*, StructureChain*, size_t count, const Identifier&, const PropertySlot&, PropertyOffset cachedOffset, ReturnAddressPtr, CallFrame*);
- void privateCompilePutByIdTransition(StructureStubInfo*, Structure*, Structure*, PropertyOffset cachedOffset, StructureChain*, ReturnAddressPtr, bool direct);
-
void privateCompileGetByVal(ByValInfo*, ReturnAddressPtr, JITArrayMode);
void privateCompilePutByVal(ByValInfo*, ReturnAddressPtr, JITArrayMode);
CodeRef privateCompileCTINativeCall(VM*, NativeFunction);
void privateCompilePatchGetArrayLength(ReturnAddressPtr returnAddress);
- static bool isDirectPutById(StructureStubInfo*);
+ // Add a call out from JIT code, without an exception check.
+ Call appendCall(const FunctionPtr& function)
+ {
+ Call functionCall = call();
+ m_calls.append(CallRecord(functionCall, m_bytecodeOffset, function.value()));
+ return functionCall;
+ }
+
+#if OS(WINDOWS) && CPU(X86_64)
+ Call appendCallWithSlowPathReturnType(const FunctionPtr& function)
+ {
+ Call functionCall = callWithSlowPathReturnType();
+ m_calls.append(CallRecord(functionCall, m_bytecodeOffset, function.value()));
+ return functionCall;
+ }
+#endif
+
+ void exceptionCheck(Jump jumpToHandler)
+ {
+ m_exceptionChecks.append(jumpToHandler);
+ }
+
+ void exceptionCheck()
+ {
+ m_exceptionChecks.append(emitExceptionCheck());
+ }
+
+ void exceptionCheckWithCallFrameRollback()
+ {
+ m_exceptionChecksWithCallFrameRollback.append(emitExceptionCheck());
+ }
+
+ void privateCompileExceptionHandlers();
void addSlowCase(Jump);
void addSlowCase(JumpList);
void compileOpCall(OpcodeID, Instruction*, unsigned callLinkInfoIndex);
void compileOpCallSlowCase(OpcodeID, Instruction*, Vector<SlowCaseEntry>::iterator&, unsigned callLinkInfoIndex);
void compileLoadVarargs(Instruction*);
- void compileCallEval();
- void compileCallEvalSlowCase(Vector<SlowCaseEntry>::iterator&);
+ void compileCallEval(Instruction*);
+ void compileCallEvalSlowCase(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitPutCallResult(Instruction*);
enum CompileOpStrictEqType { OpStrictEq, OpNStrictEq };
void compileOpStrictEq(Instruction* instruction, CompileOpStrictEqType type);
- bool isOperandConstantImmediateDouble(unsigned src);
+ bool isOperandConstantImmediateDouble(int src);
void emitLoadDouble(int index, FPRegisterID value);
void emitLoadInt32ToDouble(int index, FPRegisterID value);
- Jump emitJumpIfNotObject(RegisterID structureReg);
-
- Jump addStructureTransitionCheck(JSCell*, Structure*, StructureStubInfo*, RegisterID scratch);
- void addStructureTransitionCheck(JSCell*, Structure*, StructureStubInfo*, JumpList& failureCases, RegisterID scratch);
- void testPrototype(JSValue, JumpList& failureCases, StructureStubInfo*);
+ Jump emitJumpIfCellNotObject(RegisterID cellReg);
- enum WriteBarrierMode { UnconditionalWriteBarrier, ShouldFilterImmediates };
+ enum WriteBarrierMode { UnconditionalWriteBarrier, ShouldFilterBase, ShouldFilterValue, ShouldFilterBaseAndValue };
// value register in write barrier is used before any scratch registers
// so may safely be the same as either of the scratch registers.
- void emitWriteBarrier(RegisterID owner, RegisterID valueTag, RegisterID scratch, RegisterID scratch2, WriteBarrierMode, WriteBarrierUseKind);
- void emitWriteBarrier(JSCell* owner, RegisterID value, RegisterID scratch, WriteBarrierMode, WriteBarrierUseKind);
+ void emitWriteBarrier(unsigned owner, unsigned value, WriteBarrierMode);
+ void emitWriteBarrier(JSCell* owner, unsigned value, WriteBarrierMode);
+ void emitWriteBarrier(JSCell* owner);
template<typename StructureType> // StructureType can be RegisterID or ImmPtr.
void emitAllocateJSObject(RegisterID allocator, StructureType, RegisterID result, RegisterID scratch);
-#if ENABLE(VALUE_PROFILER)
// This assumes that the value to profile is in regT0 and that regT3 is available for
// scratch.
void emitValueProfilingSite(ValueProfile*);
void emitValueProfilingSite(unsigned bytecodeOffset);
void emitValueProfilingSite();
-#else
- void emitValueProfilingSite(unsigned) { }
- void emitValueProfilingSite() { }
-#endif
- void emitArrayProfilingSite(RegisterID structureAndIndexingType, RegisterID scratch, ArrayProfile*);
- void emitArrayProfilingSiteForBytecodeIndex(RegisterID structureAndIndexingType, RegisterID scratch, unsigned bytecodeIndex);
+ void emitArrayProfilingSiteWithCell(RegisterID cell, RegisterID indexingType, ArrayProfile*);
+ void emitArrayProfilingSiteForBytecodeIndexWithCell(RegisterID cell, RegisterID indexingType, unsigned bytecodeIndex);
void emitArrayProfileStoreToHoleSpecialCase(ArrayProfile*);
void emitArrayProfileOutOfBoundsSpecialCase(ArrayProfile*);
JumpList emitDoubleGetByVal(Instruction*, PatchableJump& badType);
JumpList emitContiguousGetByVal(Instruction*, PatchableJump& badType, IndexingType expectedShape = ContiguousShape);
JumpList emitArrayStorageGetByVal(Instruction*, PatchableJump& badType);
- JumpList emitIntTypedArrayGetByVal(Instruction*, PatchableJump& badType, const TypedArrayDescriptor&, size_t elementSize, TypedArraySignedness);
- JumpList emitFloatTypedArrayGetByVal(Instruction*, PatchableJump& badType, const TypedArrayDescriptor&, size_t elementSize);
+ JumpList emitIntTypedArrayGetByVal(Instruction*, PatchableJump& badType, TypedArrayType);
+ JumpList emitFloatTypedArrayGetByVal(Instruction*, PatchableJump& badType, TypedArrayType);
// Property is in regT0, base is in regT0. regT2 contains indecing type.
// The value to store is not yet loaded. Property is int-checked and
}
JumpList emitGenericContiguousPutByVal(Instruction*, PatchableJump& badType, IndexingType indexingShape = ContiguousShape);
JumpList emitArrayStoragePutByVal(Instruction*, PatchableJump& badType);
- JumpList emitIntTypedArrayPutByVal(Instruction*, PatchableJump& badType, const TypedArrayDescriptor&, size_t elementSize, TypedArraySignedness, TypedArrayRounding);
- JumpList emitFloatTypedArrayPutByVal(Instruction*, PatchableJump& badType, const TypedArrayDescriptor&, size_t elementSize);
+ JumpList emitIntTypedArrayPutByVal(Instruction*, PatchableJump& badType, TypedArrayType);
+ JumpList emitFloatTypedArrayPutByVal(Instruction*, PatchableJump& badType, TypedArrayType);
enum FinalObjectMode { MayBeFinal, KnownNotFinal };
+ template <typename T> Jump branchStructure(RelationalCondition, T leftHandSide, Structure*);
+
#if USE(JSVALUE32_64)
- bool getOperandConstantImmediateInt(unsigned op1, unsigned op2, unsigned& op, int32_t& constant);
+ bool getOperandConstantImmediateInt(int op1, int op2, int& op, int32_t& constant);
void emitLoadTag(int index, RegisterID tag);
void emitLoadPayload(int index, RegisterID payload);
void emitStore(int index, const JSValue constant, RegisterID base = callFrameRegister);
void emitStoreInt32(int index, RegisterID payload, bool indexIsInt32 = false);
void emitStoreInt32(int index, TrustedImm32 payload, bool indexIsInt32 = false);
- void emitStoreAndMapInt32(int index, RegisterID tag, RegisterID payload, bool indexIsInt32, size_t opcodeLength);
void emitStoreCell(int index, RegisterID payload, bool indexIsCell = false);
void emitStoreBool(int index, RegisterID payload, bool indexIsBool = false);
void emitStoreDouble(int index, FPRegisterID value);
- bool isLabeled(unsigned bytecodeOffset);
- void map(unsigned bytecodeOffset, int virtualRegisterIndex, RegisterID tag, RegisterID payload);
- void unmap(RegisterID);
- void unmap();
- bool isMapped(int virtualRegisterIndex);
- bool getMappedPayload(int virtualRegisterIndex, RegisterID& payload);
- bool getMappedTag(int virtualRegisterIndex, RegisterID& tag);
-
void emitJumpSlowCaseIfNotJSCell(int virtualRegisterIndex);
void emitJumpSlowCaseIfNotJSCell(int virtualRegisterIndex, RegisterID tag);
- void compileGetByIdHotPath(Identifier*);
- void compileGetByIdSlowCase(int resultVReg, int baseVReg, Identifier*, Vector<SlowCaseEntry>::iterator&);
+ void compileGetByIdHotPath(const Identifier*);
void compileGetDirectOffset(RegisterID base, RegisterID resultTag, RegisterID resultPayload, PropertyOffset cachedOffset);
void compileGetDirectOffset(JSObject* base, RegisterID resultTag, RegisterID resultPayload, PropertyOffset cachedOffset);
void compileGetDirectOffset(RegisterID base, RegisterID resultTag, RegisterID resultPayload, RegisterID offset, FinalObjectMode = MayBeFinal);
void compilePutDirectOffset(RegisterID base, RegisterID valueTag, RegisterID valuePayload, PropertyOffset cachedOffset);
// Arithmetic opcode helpers
- void emitAdd32Constant(unsigned dst, unsigned op, int32_t constant, ResultType opType);
- void emitSub32Constant(unsigned dst, unsigned op, int32_t constant, ResultType opType);
- void emitBinaryDoubleOp(OpcodeID, unsigned dst, unsigned op1, unsigned op2, OperandTypes, JumpList& notInt32Op1, JumpList& notInt32Op2, bool op1IsInRegisters = true, bool op2IsInRegisters = true);
-
-#if CPU(ARM_TRADITIONAL)
- // sequenceOpCall
- static const int sequenceOpCallInstructionSpace = 12;
- static const int sequenceOpCallConstantSpace = 2;
- // sequenceGetByIdHotPath
- static const int sequenceGetByIdHotPathInstructionSpace = 36;
- static const int sequenceGetByIdHotPathConstantSpace = 4;
- // sequenceGetByIdSlowCase
- static const int sequenceGetByIdSlowCaseInstructionSpace = 80;
- static const int sequenceGetByIdSlowCaseConstantSpace = 4;
- // sequencePutById
- static const int sequencePutByIdInstructionSpace = 36;
- static const int sequencePutByIdConstantSpace = 4;
-#elif CPU(SH4)
- // sequenceOpCall
- static const int sequenceOpCallInstructionSpace = 12;
- static const int sequenceOpCallConstantSpace = 2;
- // sequenceGetByIdHotPath
- static const int sequenceGetByIdHotPathInstructionSpace = 36;
- static const int sequenceGetByIdHotPathConstantSpace = 5;
- // sequenceGetByIdSlowCase
- static const int sequenceGetByIdSlowCaseInstructionSpace = 38;
- static const int sequenceGetByIdSlowCaseConstantSpace = 4;
- // sequencePutById
- static const int sequencePutByIdInstructionSpace = 36;
- static const int sequencePutByIdConstantSpace = 5;
-#endif
+ void emitAdd32Constant(int dst, int op, int32_t constant, ResultType opType);
+ void emitSub32Constant(int dst, int op, int32_t constant, ResultType opType);
+ void emitBinaryDoubleOp(OpcodeID, int dst, int op1, int op2, OperandTypes, JumpList& notInt32Op1, JumpList& notInt32Op2, bool op1IsInRegisters = true, bool op2IsInRegisters = true);
#else // USE(JSVALUE32_64)
- /* This function is deprecated. */
- void emitGetJITStubArg(unsigned argumentNumber, RegisterID dst);
-
void emitGetVirtualRegister(int src, RegisterID dst);
+ void emitGetVirtualRegister(VirtualRegister src, RegisterID dst);
void emitGetVirtualRegisters(int src1, RegisterID dst1, int src2, RegisterID dst2);
- void emitPutVirtualRegister(unsigned dst, RegisterID from = regT0);
- void emitStoreCell(unsigned dst, RegisterID payload, bool /* only used in JSValue32_64 */ = false)
+ void emitGetVirtualRegisters(VirtualRegister src1, RegisterID dst1, VirtualRegister src2, RegisterID dst2);
+ void emitPutVirtualRegister(int dst, RegisterID from = regT0);
+ void emitPutVirtualRegister(VirtualRegister dst, RegisterID from = regT0);
+ void emitStoreCell(int dst, RegisterID payload, bool /* only used in JSValue32_64 */ = false)
+ {
+ emitPutVirtualRegister(dst, payload);
+ }
+ void emitStoreCell(VirtualRegister dst, RegisterID payload)
{
emitPutVirtualRegister(dst, payload);
}
- int32_t getConstantOperandImmediateInt(unsigned src);
-
- void killLastResultRegister();
+ int32_t getConstantOperandImmediateInt(int src);
Jump emitJumpIfJSCell(RegisterID);
Jump emitJumpIfBothJSCells(RegisterID, RegisterID, RegisterID);
void emitFastArithReTagImmediate(RegisterID src, RegisterID dest);
void emitTagAsBoolImmediate(RegisterID reg);
- void compileBinaryArithOp(OpcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi);
- void compileBinaryArithOpSlowCase(OpcodeID, Vector<SlowCaseEntry>::iterator&, unsigned dst, unsigned src1, unsigned src2, OperandTypes, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase);
+ void compileBinaryArithOp(OpcodeID, int dst, int src1, int src2, OperandTypes opi);
+ void compileBinaryArithOpSlowCase(Instruction*, OpcodeID, Vector<SlowCaseEntry>::iterator&, int dst, int src1, int src2, OperandTypes, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase);
- void compileGetByIdHotPath(int baseVReg, Identifier*);
- void compileGetByIdSlowCase(int resultVReg, int baseVReg, Identifier*, Vector<SlowCaseEntry>::iterator&);
+ void compileGetByIdHotPath(int baseVReg, const Identifier*);
void compileGetDirectOffset(RegisterID base, RegisterID result, PropertyOffset cachedOffset);
void compileGetDirectOffset(JSObject* base, RegisterID result, PropertyOffset cachedOffset);
void compileGetDirectOffset(RegisterID base, RegisterID result, RegisterID offset, RegisterID scratch, FinalObjectMode = MayBeFinal);
#endif // USE(JSVALUE32_64)
-#if (defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL)
-#define BEGIN_UNINTERRUPTED_SEQUENCE(name) do { beginUninterruptedSequence(name ## InstructionSpace, name ## ConstantSpace); } while (false)
-#define END_UNINTERRUPTED_SEQUENCE_FOR_PUT(name, dst) do { endUninterruptedSequence(name ## InstructionSpace, name ## ConstantSpace, dst); } while (false)
-#define END_UNINTERRUPTED_SEQUENCE(name) END_UNINTERRUPTED_SEQUENCE_FOR_PUT(name, 0)
-
- void beginUninterruptedSequence(int, int);
- void endUninterruptedSequence(int, int, int);
-
-#else
-#define BEGIN_UNINTERRUPTED_SEQUENCE(name)
-#define END_UNINTERRUPTED_SEQUENCE(name)
-#define END_UNINTERRUPTED_SEQUENCE_FOR_PUT(name, dst)
-#endif
-
- void emit_compareAndJump(OpcodeID, unsigned op1, unsigned op2, unsigned target, RelationalCondition);
- void emit_compareAndJumpSlow(unsigned op1, unsigned op2, unsigned target, DoubleCondition, int (JIT_STUB *stub)(STUB_ARGS_DECLARATION), bool invert, Vector<SlowCaseEntry>::iterator&);
+ void emit_compareAndJump(OpcodeID, int op1, int op2, unsigned target, RelationalCondition);
+ void emit_compareAndJumpSlow(int op1, int op2, unsigned target, DoubleCondition, size_t (JIT_OPERATION *operation)(ExecState*, EncodedJSValue, EncodedJSValue), bool invert, Vector<SlowCaseEntry>::iterator&);
+ void emit_op_touch_entry(Instruction*);
void emit_op_add(Instruction*);
void emit_op_bitand(Instruction*);
void emit_op_bitor(Instruction*);
void emit_op_call(Instruction*);
void emit_op_call_eval(Instruction*);
void emit_op_call_varargs(Instruction*);
- void emit_op_call_put_result(Instruction*);
+ void emit_op_construct_varargs(Instruction*);
+ void emit_op_captured_mov(Instruction*);
void emit_op_catch(Instruction*);
void emit_op_construct(Instruction*);
void emit_op_get_callee(Instruction*);
void emit_op_create_this(Instruction*);
- void emit_op_convert_this(Instruction*);
+ void emit_op_to_this(Instruction*);
void emit_op_create_arguments(Instruction*);
void emit_op_debug(Instruction*);
void emit_op_del_by_id(Instruction*);
void emit_op_new_array_with_size(Instruction*);
void emit_op_new_array_buffer(Instruction*);
void emit_op_new_func(Instruction*);
+ void emit_op_new_captured_func(Instruction*);
void emit_op_new_func_exp(Instruction*);
void emit_op_new_object(Instruction*);
void emit_op_new_regexp(Instruction*);
void emit_op_put_by_val(Instruction*);
void emit_op_put_getter_setter(Instruction*);
void emit_op_init_global_const(Instruction*);
- void emit_op_init_global_const_check(Instruction*);
- void emit_resolve_operations(ResolveOperations*, const int* base, const int* value);
- void emitSlow_link_resolve_operations(ResolveOperations*, Vector<SlowCaseEntry>::iterator&);
- void emit_op_resolve(Instruction*);
- void emit_op_resolve_base(Instruction*);
- void emit_op_resolve_with_base(Instruction*);
- void emit_op_resolve_with_this(Instruction*);
- void emit_op_put_to_base(Instruction*);
void emit_op_ret(Instruction*);
void emit_op_ret_object_or_this(Instruction*);
void emit_op_rshift(Instruction*);
void emit_op_to_number(Instruction*);
void emit_op_to_primitive(Instruction*);
void emit_op_unexpected_load(Instruction*);
+ void emit_op_unsigned(Instruction*);
void emit_op_urshift(Instruction*);
- void emit_op_get_scoped_var(Instruction*);
- void emit_op_put_scoped_var(Instruction*);
void emitSlow_op_add(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_bitand(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_call(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_call_eval(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_call_varargs(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitSlow_op_construct_varargs(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitSlow_op_captured_mov(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_construct(Instruction*, Vector<SlowCaseEntry>::iterator&);
- void emitSlow_op_convert_this(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitSlow_op_to_this(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_create_this(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_div(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_eq(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitSlow_op_get_callee(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_get_by_id(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_get_arguments_length(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_get_by_val(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_inc(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_put_by_id(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_put_by_val(Instruction*, Vector<SlowCaseEntry>::iterator&);
- void emitSlow_op_init_global_const_check(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_rshift(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_stricteq(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_sub(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_to_number(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_to_primitive(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitSlow_op_unsigned(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitSlow_op_urshift(Instruction*, Vector<SlowCaseEntry>::iterator&);
- void emitSlow_op_resolve(Instruction*, Vector<SlowCaseEntry>::iterator&);
- void emitSlow_op_resolve_base(Instruction*, Vector<SlowCaseEntry>::iterator&);
- void emitSlow_op_resolve_with_base(Instruction*, Vector<SlowCaseEntry>::iterator&);
- void emitSlow_op_resolve_with_this(Instruction*, Vector<SlowCaseEntry>::iterator&);
- void emitSlow_op_put_to_base(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emit_op_resolve_scope(Instruction*);
+ void emit_op_get_from_scope(Instruction*);
+ void emit_op_put_to_scope(Instruction*);
+ void emitSlow_op_resolve_scope(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitSlow_op_get_from_scope(Instruction*, Vector<SlowCaseEntry>::iterator&);
+ void emitSlow_op_put_to_scope(Instruction*, Vector<SlowCaseEntry>::iterator&);
void emitRightShift(Instruction*, bool isUnsigned);
void emitRightShiftSlowCase(Instruction*, Vector<SlowCaseEntry>::iterator&, bool isUnsigned);
- void emitInitRegister(unsigned dst);
+ void emitVarInjectionCheck(bool needsVarInjectionChecks);
+ void emitResolveClosure(int dst, bool needsVarInjectionChecks, unsigned depth);
+ void emitLoadWithStructureCheck(int scope, Structure** structureSlot);
+ void emitGetGlobalProperty(uintptr_t* operandSlot);
+ void emitGetGlobalVar(uintptr_t operand);
+ void emitGetClosureVar(int scope, uintptr_t operand);
+ void emitPutGlobalProperty(uintptr_t* operandSlot, int value);
+#if USE(JSVALUE64)
+ void emitNotifyWrite(RegisterID value, RegisterID scratch, VariableWatchpointSet*);
+#else
+ void emitNotifyWrite(RegisterID tag, RegisterID payload, RegisterID scratch, VariableWatchpointSet*);
+#endif
+ void emitPutGlobalVar(uintptr_t operand, int value, VariableWatchpointSet*);
+ void emitPutClosureVar(int scope, uintptr_t operand, int value);
+
+ void emitInitRegister(int dst);
void emitPutIntToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry);
void emitGetFromCallFrameHeaderPtr(JSStack::CallFrameHeaderEntry, RegisterID to, RegisterID from = callFrameRegister);
void emitGetFromCallFrameHeader64(JSStack::CallFrameHeaderEntry, RegisterID to, RegisterID from = callFrameRegister);
#endif
- JSValue getConstantOperand(unsigned src);
- bool isOperandConstantImmediateInt(unsigned src);
- bool isOperandConstantImmediateChar(unsigned src);
-
- bool atJumpTarget();
+ JSValue getConstantOperand(int src);
+ bool isOperandConstantImmediateInt(int src);
+ bool isOperandConstantImmediateChar(int src);
Jump getSlowCase(Vector<SlowCaseEntry>::iterator& iter)
{
}
void linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator&, int virtualRegisterIndex);
+ MacroAssembler::Call appendCallWithExceptionCheck(const FunctionPtr&);
+#if OS(WINDOWS) && CPU(X86_64)
+ MacroAssembler::Call appendCallWithExceptionCheckAndSlowPathReturnType(const FunctionPtr&);
+#endif
+ MacroAssembler::Call appendCallWithCallFrameRollbackOnException(const FunctionPtr&);
+ MacroAssembler::Call appendCallWithExceptionCheckSetJSValueResult(const FunctionPtr&, int);
+ MacroAssembler::Call appendCallWithExceptionCheckSetJSValueResultWithProfile(const FunctionPtr&, int);
+
+ enum WithProfileTag { WithProfile };
+
+ MacroAssembler::Call callOperation(C_JITOperation_E);
+ MacroAssembler::Call callOperation(C_JITOperation_EO, GPRReg);
+ MacroAssembler::Call callOperation(C_JITOperation_ESt, Structure*);
+ MacroAssembler::Call callOperation(C_JITOperation_EZ, int32_t);
+ MacroAssembler::Call callOperation(F_JITOperation_EJZZ, GPRReg, int32_t, int32_t);
+ MacroAssembler::Call callOperation(J_JITOperation_E, int);
+ MacroAssembler::Call callOperation(J_JITOperation_EAapJ, int, ArrayAllocationProfile*, GPRReg);
+ MacroAssembler::Call callOperation(J_JITOperation_EAapJcpZ, int, ArrayAllocationProfile*, GPRReg, int32_t);
+ MacroAssembler::Call callOperation(J_JITOperation_EAapJcpZ, int, ArrayAllocationProfile*, const JSValue*, int32_t);
+ MacroAssembler::Call callOperation(J_JITOperation_EC, int, JSCell*);
+ MacroAssembler::Call callOperation(V_JITOperation_EC, JSCell*);
+ MacroAssembler::Call callOperation(J_JITOperation_EJ, int, GPRReg);
+#if USE(JSVALUE64)
+ MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_ESsiJI, int, StructureStubInfo*, GPRReg, StringImpl*);
+#else
+ MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_ESsiJI, int, StructureStubInfo*, GPRReg, GPRReg, StringImpl*);
+#endif
+ MacroAssembler::Call callOperation(J_JITOperation_EJIdc, int, GPRReg, const Identifier*);
+ MacroAssembler::Call callOperation(J_JITOperation_EJJ, int, GPRReg, GPRReg);
+#if USE(JSVALUE64)
+ MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_EJJ, int, GPRReg, GPRReg);
+#else
+ MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_EJJ, int, GPRReg, GPRReg, GPRReg, GPRReg);
+#endif
+ MacroAssembler::Call callOperation(J_JITOperation_EP, int, void*);
+ MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_EPc, int, Instruction*);
+ MacroAssembler::Call callOperation(J_JITOperation_EZ, int, int32_t);
+ MacroAssembler::Call callOperation(P_JITOperation_EJS, GPRReg, size_t);
+ MacroAssembler::Call callOperation(S_JITOperation_ECC, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(S_JITOperation_EJ, RegisterID);
+ MacroAssembler::Call callOperation(S_JITOperation_EJJ, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(S_JITOperation_EOJss, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(Sprt_JITOperation_EZ, int32_t);
+ MacroAssembler::Call callOperation(V_JITOperation_E);
+ MacroAssembler::Call callOperation(V_JITOperation_EC, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_ECC, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_ECICC, RegisterID, const Identifier*, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_EIdJZ, const Identifier*, RegisterID, int32_t);
+ MacroAssembler::Call callOperation(V_JITOperation_EJ, RegisterID);
+#if USE(JSVALUE64)
+ MacroAssembler::Call callOperationNoExceptionCheck(V_JITOperation_EJ, RegisterID);
+#else
+ MacroAssembler::Call callOperationNoExceptionCheck(V_JITOperation_EJ, RegisterID, RegisterID);
+#endif
+ MacroAssembler::Call callOperation(V_JITOperation_EJIdJJ, RegisterID, const Identifier*, RegisterID, RegisterID);
+#if USE(JSVALUE64)
+ MacroAssembler::Call callOperation(F_JITOperation_EFJJZ, RegisterID, RegisterID, RegisterID, int32_t);
+ MacroAssembler::Call callOperation(V_JITOperation_ESsiJJI, StructureStubInfo*, RegisterID, RegisterID, StringImpl*);
+#else
+ MacroAssembler::Call callOperation(V_JITOperation_ESsiJJI, StructureStubInfo*, RegisterID, RegisterID, RegisterID, RegisterID, StringImpl*);
+#endif
+ MacroAssembler::Call callOperation(V_JITOperation_EJJJ, RegisterID, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_EJZJ, RegisterID, int32_t, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_EJZ, RegisterID, int32_t);
+ MacroAssembler::Call callOperation(V_JITOperation_EPc, Instruction*);
+ MacroAssembler::Call callOperation(V_JITOperation_EZ, int32_t);
+ MacroAssembler::Call callOperationWithCallFrameRollbackOnException(J_JITOperation_E);
+ MacroAssembler::Call callOperationNoExceptionCheck(J_JITOperation_EE, RegisterID);
+ MacroAssembler::Call callOperationWithCallFrameRollbackOnException(V_JITOperation_ECb, CodeBlock*);
+ MacroAssembler::Call callOperationWithCallFrameRollbackOnException(Z_JITOperation_E);
+#if USE(JSVALUE32_64)
+ MacroAssembler::Call callOperation(F_JITOperation_EFJJZ, RegisterID, RegisterID, RegisterID, RegisterID, RegisterID, int32_t);
+ MacroAssembler::Call callOperation(F_JITOperation_EJZZ, GPRReg, GPRReg, int32_t, int32_t);
+ MacroAssembler::Call callOperation(J_JITOperation_EAapJ, int, ArrayAllocationProfile*, GPRReg, GPRReg);
+ MacroAssembler::Call callOperation(J_JITOperation_EJ, int, GPRReg, GPRReg);
+ MacroAssembler::Call callOperation(J_JITOperation_EJIdc, int, GPRReg, GPRReg, const Identifier*);
+ MacroAssembler::Call callOperation(J_JITOperation_EJJ, int, GPRReg, GPRReg, GPRReg, GPRReg);
+ MacroAssembler::Call callOperation(P_JITOperation_EJS, GPRReg, GPRReg, size_t);
+ MacroAssembler::Call callOperation(S_JITOperation_EJ, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(S_JITOperation_EJJ, RegisterID, RegisterID, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_EIdJZ, const Identifier*, RegisterID, RegisterID, int32_t);
+ MacroAssembler::Call callOperation(V_JITOperation_EJ, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_EJJJ, RegisterID, RegisterID, RegisterID, RegisterID, RegisterID, RegisterID);
+ MacroAssembler::Call callOperation(V_JITOperation_EJZ, RegisterID, RegisterID, int32_t);
+ MacroAssembler::Call callOperation(V_JITOperation_EJZJ, RegisterID, RegisterID, int32_t, RegisterID, RegisterID);
+#endif
+
Jump checkStructure(RegisterID reg, Structure* structure);
- void restoreArgumentReferenceForTrampoline();
void updateTopCallFrame();
Call emitNakedCall(CodePtr function = CodePtr());
#endif
#ifndef NDEBUG
- void printBytecodeOperandTypes(unsigned src1, unsigned src2);
+ void printBytecodeOperandTypes(int src1, int src2);
#endif
#if ENABLE(SAMPLING_FLAGS)
#endif
Interpreter* m_interpreter;
- VM* m_vm;
- CodeBlock* m_codeBlock;
Vector<CallRecord> m_calls;
Vector<Label> m_labels;
- Vector<PropertyStubCompilationInfo> m_propertyAccessCompilationInfo;
+ Vector<JITGetByIdGenerator> m_getByIds;
+ Vector<JITPutByIdGenerator> m_putByIds;
Vector<ByValCompilationInfo> m_byValCompilationInfo;
- Vector<StructureStubCompilationInfo> m_callStructureStubCompilationInfo;
+ Vector<CallCompilationInfo> m_callCompilationInfo;
Vector<JumpTable> m_jmpTable;
unsigned m_bytecodeOffset;
Vector<SlowCaseEntry> m_slowCases;
Vector<SwitchRecord> m_switches;
- unsigned m_propertyAccessInstructionIndex;
+ JumpList m_exceptionChecks;
+ JumpList m_exceptionChecksWithCallFrameRollback;
+
+ unsigned m_getByIdIndex;
+ unsigned m_putByIdIndex;
unsigned m_byValInstructionIndex;
- unsigned m_globalResolveInfoIndex;
unsigned m_callLinkInfoIndex;
-#if USE(JSVALUE32_64)
- unsigned m_jumpTargetIndex;
- unsigned m_mappedBytecodeOffset;
- int m_mappedVirtualRegisterIndex;
- RegisterID m_mappedTag;
- RegisterID m_mappedPayload;
-#else
- int m_lastResultBytecodeRegister;
-#endif
- unsigned m_jumpTargetsPosition;
-
-#ifndef NDEBUG
-#if defined(ASSEMBLER_HAS_CONSTANT_POOL) && ASSEMBLER_HAS_CONSTANT_POOL
- Label m_uninterruptedInstructionSequenceBegin;
- int m_uninterruptedConstantSequenceBegin;
-#endif
-#endif
OwnPtr<JITDisassembler> m_disassembler;
RefPtr<Profiler::Compilation> m_compilation;
WeakRandom m_randomGenerator;
static CodeRef stringGetByValStubGenerator(VM*);
-#if ENABLE(VALUE_PROFILER)
bool m_canBeOptimized;
bool m_canBeOptimizedOrInlined;
bool m_shouldEmitProfiling;
-#endif
} JIT_CLASS_ALIGNMENT;
} // namespace JSC
projects / apple / javascriptcore.git / blobdiff