bytecode/Instruction.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  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef Instruction_h
  30 #define Instruction_h
  31
  32 #include "MacroAssembler.h"
  33 #include "Opcode.h"
  34 #include "PropertySlot.h"
  35 #include "Structure.h"
  36 #include "StructureChain.h"
  37 #include <wtf/VectorTraits.h>
  38
  39 #define POLYMORPHIC_LIST_CACHE_SIZE 8
  40
  41 namespace JSC {
  42
  43     // *Sigh*, If the JIT is enabled we need to track the stubRountine (of type CodeLocationLabel),
  44     // 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
  45     // curently actually use PolymorphicAccessStructureLists, which we should).  Anyway, this seems like the best
  46     // solution for now - will need to something smarter if/when we actually want mixed-mode operation.
  47
  48     class JSCell;
  49     class Structure;
  50     class StructureChain;
  51     struct LLIntCallLinkInfo;
  52     struct ValueProfile;
  53
  54 #if ENABLE(JIT)
  55     typedef MacroAssemblerCodeRef PolymorphicAccessStructureListStubRoutineType;
  56
  57     // 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.
  58     struct PolymorphicAccessStructureList {
  59         WTF_MAKE_FAST_ALLOCATED;
  60     public:
  61         struct PolymorphicStubInfo {
  62             bool isChain;
  63             bool isDirect;
  64             PolymorphicAccessStructureListStubRoutineType stubRoutine;
  65             WriteBarrier<Structure> base;
  66             union {
  67                 WriteBarrierBase<Structure> proto;
  68                 WriteBarrierBase<StructureChain> chain;
  69             } u;
  70
  71             PolymorphicStubInfo()
  72             {
  73                 u.proto.clear();
  74             }
  75
  76             void set(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType _stubRoutine, Structure* _base, bool isDirect)
  77             {
  78                 stubRoutine = _stubRoutine;
  79                 base.set(globalData, owner, _base);
  80                 u.proto.clear();
  81                 isChain = false;
  82                 this->isDirect = isDirect;
  83             }
  84
  85             void set(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType _stubRoutine, Structure* _base, Structure* _proto, bool isDirect)
  86             {
  87                 stubRoutine = _stubRoutine;
  88                 base.set(globalData, owner, _base);
  89                 u.proto.set(globalData, owner, _proto);
  90                 isChain = false;
  91                 this->isDirect = isDirect;
  92             }
  93
  94             void set(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType _stubRoutine, Structure* _base, StructureChain* _chain, bool isDirect)
  95             {
  96                 stubRoutine = _stubRoutine;
  97                 base.set(globalData, owner, _base);
  98                 u.chain.set(globalData, owner, _chain);
  99                 isChain = true;
 100                 this->isDirect = isDirect;
 101             }
 102         } list[POLYMORPHIC_LIST_CACHE_SIZE];
 103
 104         PolymorphicAccessStructureList()
 105         {
 106         }
 107
 108         PolymorphicAccessStructureList(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType stubRoutine, Structure* firstBase, bool isDirect)
 109         {
 110             list[0].set(globalData, owner, stubRoutine, firstBase, isDirect);
 111         }
 112
 113         PolymorphicAccessStructureList(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType stubRoutine, Structure* firstBase, Structure* firstProto, bool isDirect)
 114         {
 115             list[0].set(globalData, owner, stubRoutine, firstBase, firstProto, isDirect);
 116         }
 117
 118         PolymorphicAccessStructureList(JSGlobalData& globalData, JSCell* owner, PolymorphicAccessStructureListStubRoutineType stubRoutine, Structure* firstBase, StructureChain* firstChain, bool isDirect)
 119         {
 120             list[0].set(globalData, owner, stubRoutine, firstBase, firstChain, isDirect);
 121         }
 122
 123         bool visitWeak(int count)
 124         {
 125             for (int i = 0; i < count; ++i) {
 126                 PolymorphicStubInfo& info = list[i];
 127                 if (!info.base) {
 128                     // We're being marked during initialisation of an entry
 129                     ASSERT(!info.u.proto);
 130                     continue;
 131                 }
 132
 133                 if (!Heap::isMarked(info.base.get()))
 134                     return false;
 135                 if (info.u.proto && !info.isChain
 136                     && !Heap::isMarked(info.u.proto.get()))
 137                     return false;
 138                 if (info.u.chain && info.isChain
 139                     && !Heap::isMarked(info.u.chain.get()))
 140                     return false;
 141             }
 142
 143             return true;
 144         }
 145     };
 146
 147 #endif
 148
 149     struct Instruction {
 150         Instruction()
 151         {
 152             u.jsCell.clear();
 153         }
 154
 155         Instruction(Opcode opcode)
 156         {
 157 #if !ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER)
 158             // We have to initialize one of the pointer members to ensure that
 159             // the entire struct is initialized, when opcode is not a pointer.
 160             u.jsCell.clear();
 161 #endif
 162             u.opcode = opcode;
 163         }
 164
 165         Instruction(int operand)
 166         {
 167             // We have to initialize one of the pointer members to ensure that
 168             // the entire struct is initialized in 64-bit.
 169             u.jsCell.clear();
 170             u.operand = operand;
 171         }
 172
 173         Instruction(JSGlobalData& globalData, JSCell* owner, Structure* structure)
 174         {
 175             u.structure.clear();
 176             u.structure.set(globalData, owner, structure);
 177         }
 178         Instruction(JSGlobalData& globalData, JSCell* owner, StructureChain* structureChain)
 179         {
 180             u.structureChain.clear();
 181             u.structureChain.set(globalData, owner, structureChain);
 182         }
 183         Instruction(JSGlobalData& globalData, JSCell* owner, JSCell* jsCell)
 184         {
 185             u.jsCell.clear();
 186             u.jsCell.set(globalData, owner, jsCell);
 187         }
 188
 189         Instruction(PropertySlot::GetValueFunc getterFunc) { u.getterFunc = getterFunc; }
 190
 191         Instruction(LLIntCallLinkInfo* callLinkInfo) { u.callLinkInfo = callLinkInfo; }
 192
 193         Instruction(ValueProfile* profile) { u.profile = profile; }
 194
 195         union {
 196             Opcode opcode;
 197             int operand;
 198             WriteBarrierBase<Structure> structure;
 199             WriteBarrierBase<StructureChain> structureChain;
 200             WriteBarrierBase<JSCell> jsCell;
 201             PropertySlot::GetValueFunc getterFunc;
 202             LLIntCallLinkInfo* callLinkInfo;
 203             ValueProfile* profile;
 204             void* pointer;
 205         } u;
 206
 207     private:
 208         Instruction(StructureChain*);
 209         Instruction(Structure*);
 210     };
 211
 212 } // namespace JSC
 213
 214 namespace WTF {
 215
 216     template<> struct VectorTraits<JSC::Instruction> : VectorTraitsBase<true, JSC::Instruction> { };
 217
 218 } // namespace WTF
 219
 220 #endif // Instruction_h