X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/14957cd040308e3eeec43d26bae5d76da13fcd85..93a3786624b2768d89bfa27e46598dc64e2fb70a:/bytecode/Instruction.h?ds=sidebyside diff --git a/bytecode/Instruction.h b/bytecode/Instruction.h index b3bb5b7..988b1dd 100644 --- a/bytecode/Instruction.h +++ b/bytecode/Instruction.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 Apple Inc. All rights reserved. + * Copyright (C) 2008, 2012, 2013 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -32,162 +32,105 @@ #include "MacroAssembler.h" #include "Opcode.h" #include "PropertySlot.h" +#include "ResolveOperation.h" +#include "SpecialPointer.h" #include "Structure.h" #include "StructureChain.h" #include -#define POLYMORPHIC_LIST_CACHE_SIZE 8 - namespace JSC { - // *Sigh*, If the JIT is enabled we need to track the stubRountine (of type CodeLocationLabel), - // If the JIT is not in use we don't actually need the variable (that said, if the JIT is not in use we don't - // curently actually use PolymorphicAccessStructureLists, which we should). Anyway, this seems like the best - // solution for now - will need to something smarter if/when we actually want mixed-mode operation. -#if ENABLE(JIT) - typedef CodeLocationLabel PolymorphicAccessStructureListStubRoutineType; -#else - typedef void* PolymorphicAccessStructureListStubRoutineType; -#endif - - class JSCell; - class Structure; - class StructureChain; - - // Structure used by op_get_by_id_self_list and op_get_by_id_proto_list instruction to hold data off the main opcode stream. - struct PolymorphicAccessStructureList { - WTF_MAKE_FAST_ALLOCATED; - public: - struct PolymorphicStubInfo { - bool isChain; - PolymorphicAccessStructureListStubRoutineType stubRoutine; - WriteBarrier base; - union { - WriteBarrierBase proto; - WriteBarrierBase chain; - } u; - - PolymorphicStubInfo() - { - u.proto.clear(); - } - - void set(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType _stubRoutine, Structure* _base) - { - stubRoutine = _stubRoutine; - base.set(globalData, owner, _base); - u.proto.clear(); - isChain = false; - } - - void set(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType _stubRoutine, Structure* _base, Structure* _proto) - { - stubRoutine = _stubRoutine; - base.set(globalData, owner, _base); - u.proto.set(globalData, owner, _proto); - isChain = false; - } - - void set(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType _stubRoutine, Structure* _base, StructureChain* _chain) - { - stubRoutine = _stubRoutine; - base.set(globalData, owner, _base); - u.chain.set(globalData, owner, _chain); - isChain = true; - } - } list[POLYMORPHIC_LIST_CACHE_SIZE]; +class ArrayAllocationProfile; +class ArrayProfile; +class ObjectAllocationProfile; +struct LLIntCallLinkInfo; +struct ValueProfile; + +struct Instruction { + Instruction() + { + u.jsCell.clear(); + } - PolymorphicAccessStructureList(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType stubRoutine, Structure* firstBase) - { - list[0].set(globalData, owner, stubRoutine, firstBase); - } - - PolymorphicAccessStructureList(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType stubRoutine, Structure* firstBase, Structure* firstProto) - { - list[0].set(globalData, owner, stubRoutine, firstBase, firstProto); - } - - PolymorphicAccessStructureList(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType stubRoutine, Structure* firstBase, StructureChain* firstChain) - { - list[0].set(globalData, owner, stubRoutine, firstBase, firstChain); - } - - void visitAggregate(SlotVisitor& visitor, int count) - { - for (int i = 0; i < count; ++i) { - PolymorphicStubInfo& info = list[i]; - if (!info.base) { - // We're being marked during initialisation of an entry - ASSERT(!info.u.proto); - continue; - } - - visitor.append(&info.base); - if (info.u.proto && !info.isChain) - visitor.append(&info.u.proto); - if (info.u.chain && info.isChain) - visitor.append(&info.u.chain); - } - } - }; - - struct Instruction { - Instruction(Opcode opcode) - { -#if !ENABLE(COMPUTED_GOTO_INTERPRETER) - // We have to initialize one of the pointer members to ensure that - // the entire struct is initialized, when opcode is not a pointer. - u.jsCell.clear(); + Instruction(Opcode opcode) + { +#if !ENABLE(COMPUTED_GOTO_OPCODES) + // We have to initialize one of the pointer members to ensure that + // the entire struct is initialized, when opcode is not a pointer. + u.jsCell.clear(); #endif - u.opcode = opcode; - } - - Instruction(int operand) - { - // We have to initialize one of the pointer members to ensure that - // the entire struct is initialized in 64-bit. - u.jsCell.clear(); - u.operand = operand; - } - - Instruction(JSGlobalData& globalData, JSCell* owner, Structure* structure) - { - u.structure.clear(); - u.structure.set(globalData, owner, structure); - } - Instruction(JSGlobalData& globalData, JSCell* owner, StructureChain* structureChain) - { - u.structureChain.clear(); - u.structureChain.set(globalData, owner, structureChain); - } - Instruction(JSGlobalData& globalData, JSCell* owner, JSCell* jsCell) - { - u.jsCell.clear(); - u.jsCell.set(globalData, owner, jsCell); - } - Instruction(PolymorphicAccessStructureList* polymorphicStructures) { u.polymorphicStructures = polymorphicStructures; } - Instruction(PropertySlot::GetValueFunc getterFunc) { u.getterFunc = getterFunc; } - - union { - Opcode opcode; - int operand; - WriteBarrierBase structure; - WriteBarrierBase structureChain; - WriteBarrierBase jsCell; - PolymorphicAccessStructureList* polymorphicStructures; - PropertySlot::GetValueFunc getterFunc; - } u; + u.opcode = opcode; + } + + Instruction(int operand) + { + // We have to initialize one of the pointer members to ensure that + // the entire struct is initialized in 64-bit. + u.jsCell.clear(); + u.operand = operand; + } + + Instruction(VM& vm, JSCell* owner, Structure* structure) + { + u.structure.clear(); + u.structure.set(vm, owner, structure); + } + Instruction(VM& vm, JSCell* owner, StructureChain* structureChain) + { + u.structureChain.clear(); + u.structureChain.set(vm, owner, structureChain); + } + Instruction(VM& vm, JSCell* owner, JSCell* jsCell) + { + u.jsCell.clear(); + u.jsCell.set(vm, owner, jsCell); + } + + Instruction(PropertySlot::GetValueFunc getterFunc) { u.getterFunc = getterFunc; } + + Instruction(LLIntCallLinkInfo* callLinkInfo) { u.callLinkInfo = callLinkInfo; } + + Instruction(ValueProfile* profile) { u.profile = profile; } + Instruction(ArrayProfile* profile) { u.arrayProfile = profile; } + Instruction(ArrayAllocationProfile* profile) { u.arrayAllocationProfile = profile; } + Instruction(ObjectAllocationProfile* profile) { u.objectAllocationProfile = profile; } + + Instruction(WriteBarrier* registerPointer) { u.registerPointer = registerPointer; } + + Instruction(Special::Pointer pointer) { u.specialPointer = pointer; } + + Instruction(bool* predicatePointer) { u.predicatePointer = predicatePointer; } + + union { + Opcode opcode; + int operand; + WriteBarrierBase structure; + WriteBarrierBase structureChain; + WriteBarrierBase jsCell; + WriteBarrier* registerPointer; + Special::Pointer specialPointer; + PropertySlot::GetValueFunc getterFunc; + LLIntCallLinkInfo* callLinkInfo; + ValueProfile* profile; + ArrayProfile* arrayProfile; + ArrayAllocationProfile* arrayAllocationProfile; + ObjectAllocationProfile* objectAllocationProfile; + void* pointer; + bool* predicatePointer; + ResolveOperations* resolveOperations; + PutToBaseOperation* putToBaseOperation; + } u; - private: - Instruction(StructureChain*); - Instruction(Structure*); - }; +private: + Instruction(StructureChain*); + Instruction(Structure*); +}; } // namespace JSC namespace WTF { - template<> struct VectorTraits : VectorTraitsBase { }; +template<> struct VectorTraits : VectorTraitsBase { }; } // namespace WTF