1/* 2 * Copyright (C) 2013 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 FTLAbstractHeapRepository_h 27#define FTLAbstractHeapRepository_h 28 29#if ENABLE(FTL_JIT) 30 31#include "DFGArrayMode.h" 32#include "FTLAbstractHeap.h" 33#include "IndexingType.h" 34 35namespace JSC { namespace FTL { 36 37#define FOR_EACH_ABSTRACT_HEAP(macro) \ 38 macro(length) \ 39 macro(structureTable) \ 40 macro(typedArrayProperties) \ 41 macro(WriteBarrierBuffer_bufferContents) 42 43#define FOR_EACH_ABSTRACT_FIELD(macro) \ 44 macro(ArrayBuffer_data, ArrayBuffer::offsetOfData()) \ 45 macro(Butterfly_arrayBuffer, Butterfly::offsetOfArrayBuffer()) \ 46 macro(Butterfly_publicLength, Butterfly::offsetOfPublicLength()) \ 47 macro(Butterfly_vectorLength, Butterfly::offsetOfVectorLength()) \ 48 macro(CallFrame_callerFrame, CallFrame::callerFrameOffset()) \ 49 macro(JSArrayBufferView_length, JSArrayBufferView::offsetOfLength()) \ 50 macro(JSArrayBufferView_mode, JSArrayBufferView::offsetOfMode()) \ 51 macro(JSArrayBufferView_vector, JSArrayBufferView::offsetOfVector()) \ 52 macro(JSCell_structureID, JSCell::structureIDOffset()) \ 53 macro(JSCell_typeInfoFlags, JSCell::typeInfoFlagsOffset()) \ 54 macro(JSCell_typeInfoType, JSCell::typeInfoTypeOffset()) \ 55 macro(JSCell_indexingType, JSCell::indexingTypeOffset()) \ 56 macro(JSCell_gcData, JSCell::gcDataOffset()) \ 57 macro(JSFunction_executable, JSFunction::offsetOfExecutable()) \ 58 macro(JSFunction_scope, JSFunction::offsetOfScopeChain()) \ 59 macro(JSObject_butterfly, JSObject::butterflyOffset()) \ 60 macro(JSScope_next, JSScope::offsetOfNext()) \ 61 macro(JSString_flags, JSString::offsetOfFlags()) \ 62 macro(JSString_length, JSString::offsetOfLength()) \ 63 macro(JSString_value, JSString::offsetOfValue()) \ 64 macro(JSVariableObject_registers, JSVariableObject::offsetOfRegisters()) \ 65 macro(JSWrapperObject_internalValue, JSWrapperObject::internalValueOffset()) \ 66 macro(MarkedAllocator_freeListHead, MarkedAllocator::offsetOfFreeListHead()) \ 67 macro(MarkedBlock_markBits, MarkedBlock::offsetOfMarks()) \ 68 macro(StringImpl_data, StringImpl::dataOffset()) \ 69 macro(StringImpl_hashAndFlags, StringImpl::flagsOffset()) \ 70 macro(Structure_classInfo, Structure::classInfoOffset()) \ 71 macro(Structure_globalObject, Structure::globalObjectOffset()) \ 72 macro(Structure_prototype, Structure::prototypeOffset()) \ 73 macro(Structure_structureID, Structure::structureIDOffset()) 74 75#define FOR_EACH_INDEXED_ABSTRACT_HEAP(macro) \ 76 macro(JSRopeString_fibers, JSRopeString::offsetOfFibers(), sizeof(WriteBarrier<JSString>)) \ 77 macro(characters8, 0, sizeof(LChar)) \ 78 macro(characters16, 0, sizeof(UChar)) \ 79 macro(indexedInt32Properties, 0, sizeof(EncodedJSValue)) \ 80 macro(indexedDoubleProperties, 0, sizeof(double)) \ 81 macro(indexedContiguousProperties, 0, sizeof(EncodedJSValue)) \ 82 macro(indexedArrayStorageProperties, 0, sizeof(EncodedJSValue)) \ 83 macro(singleCharacterStrings, 0, sizeof(JSString*)) \ 84 macro(variables, 0, sizeof(Register)) 85 86#define FOR_EACH_NUMBERED_ABSTRACT_HEAP(macro) \ 87 macro(properties) 88 89// This class is meant to be cacheable between compilations, but it doesn't have to be. 90// Doing so saves on creation of nodes. But clearing it will save memory. 91 92class AbstractHeapRepository { 93 WTF_MAKE_NONCOPYABLE(AbstractHeapRepository); 94public: 95 AbstractHeapRepository(LContext); 96 ~AbstractHeapRepository(); 97 98 AbstractHeap root; 99 100#define ABSTRACT_HEAP_DECLARATION(name) AbstractHeap name; 101 FOR_EACH_ABSTRACT_HEAP(ABSTRACT_HEAP_DECLARATION) 102#undef ABSTRACT_HEAP_DECLARATION 103 104#define ABSTRACT_FIELD_DECLARATION(name, offset) AbstractField name; 105 FOR_EACH_ABSTRACT_FIELD(ABSTRACT_FIELD_DECLARATION) 106#undef ABSTRACT_FIELD_DECLARATION 107 108 AbstractField& JSCell_freeListNext; 109 110#define INDEXED_ABSTRACT_HEAP_DECLARATION(name, offset, size) IndexedAbstractHeap name; 111 FOR_EACH_INDEXED_ABSTRACT_HEAP(INDEXED_ABSTRACT_HEAP_DECLARATION) 112#undef INDEXED_ABSTRACT_HEAP_DECLARATION 113 114#define NUMBERED_ABSTRACT_HEAP_DECLARATION(name) NumberedAbstractHeap name; 115 FOR_EACH_NUMBERED_ABSTRACT_HEAP(NUMBERED_ABSTRACT_HEAP_DECLARATION) 116#undef NUMBERED_ABSTRACT_HEAP_DECLARATION 117 118 AbsoluteAbstractHeap absolute; 119 120 IndexedAbstractHeap* forIndexingType(IndexingType indexingType) 121 { 122 switch (indexingType) { 123 case ALL_BLANK_INDEXING_TYPES: 124 case ALL_UNDECIDED_INDEXING_TYPES: 125 return 0; 126 127 case ALL_INT32_INDEXING_TYPES: 128 return &indexedInt32Properties; 129 130 case ALL_DOUBLE_INDEXING_TYPES: 131 return &indexedDoubleProperties; 132 133 case ALL_CONTIGUOUS_INDEXING_TYPES: 134 return &indexedContiguousProperties; 135 136 case ALL_ARRAY_STORAGE_INDEXING_TYPES: 137 return &indexedArrayStorageProperties; 138 139 default: 140 RELEASE_ASSERT_NOT_REACHED(); 141 return 0; 142 } 143 } 144 145 IndexedAbstractHeap& forArrayType(DFG::Array::Type type) 146 { 147 switch (type) { 148 case DFG::Array::Int32: 149 return indexedInt32Properties; 150 case DFG::Array::Double: 151 return indexedDoubleProperties; 152 case DFG::Array::Contiguous: 153 return indexedContiguousProperties; 154 case DFG::Array::ArrayStorage: 155 case DFG::Array::SlowPutArrayStorage: 156 return indexedArrayStorageProperties; 157 default: 158 RELEASE_ASSERT_NOT_REACHED(); 159 return indexedInt32Properties; 160 } 161 } 162 163private: 164 friend class AbstractHeap; 165 166 LContext m_context; 167 unsigned m_tbaaKind; 168}; 169 170} } // namespace JSC::FTL 171 172#endif // ENABLE(FTL_JIT) 173 174#endif // FTLAbstractHeapRepository_h 175 176