git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

5 *

6 * This library is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Library General Public

8 * License as published by the Free Software Foundation; either

9 * version 2 of the License, or (at your option) any later version.

10 *

11 * This library is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Library General Public License for more details.

15 *

16 * You should have received a copy of the GNU Library General Public License

17 * along with this library; see the file COPYING.LIB. If not, write to

18 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

19 * Boston, MA 02110-1301, USA.

20 *

21 */

23 #ifndef JSObject_h

24 #define JSObject_h

26 #include "ArgList.h"

27 #include "ArrayConventions.h"

28 #include "ArrayStorage.h"

29 #include "Butterfly.h"

30 #include "CallFrame.h"

31 #include "ClassInfo.h"

32 #include "CommonIdentifiers.h"

33 #include "CopyWriteBarrier.h"

34 #include "CustomGetterSetter.h"

35 #include "DeferGC.h"

36 #include "Heap.h"

37 #include "HeapInlines.h"

38 #include "IndexingHeaderInlines.h"

39 #include "JSCell.h"

40 #include "PropertySlot.h"

41 #include "PropertyStorage.h"

42 #include "PutDirectIndexMode.h"

43 #include "PutPropertySlot.h"

45 #include "Structure.h"

46 #include "VM.h"

47 #include "JSString.h"

48 #include "SparseArrayValueMap.h"

49 #include <wtf/StdLibExtras.h>

51 namespace JSC {

 inline JSCell* getJSFunction(JSValue value)

54 {

     if (value.isCell() && (value.asCell()->type() == JSFunctionType))

56 return value.asCell();

57 return 0;

58 }

60 class GetterSetter;

61 class InternalFunction;

62 class JSFunction;

63 class LLIntOffsetsExtractor;

64 class MarkedBlock;

65 class PropertyDescriptor;

66 class PropertyNameArray;

67 class Structure;

68 struct HashTable;

69 struct HashTableValue;

 JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*, const String&);

72 extern JS_EXPORTDATA const char* StrictModeReadonlyPropertyWriteError;

 COMPILE_ASSERT(None < FirstInternalAttribute, None_is_below_FirstInternalAttribute);

 COMPILE_ASSERT(ReadOnly < FirstInternalAttribute, ReadOnly_is_below_FirstInternalAttribute);

 COMPILE_ASSERT(DontEnum < FirstInternalAttribute, DontEnum_is_below_FirstInternalAttribute);

 COMPILE_ASSERT(DontDelete < FirstInternalAttribute, DontDelete_is_below_FirstInternalAttribute);

 COMPILE_ASSERT(Function < FirstInternalAttribute, Function_is_below_FirstInternalAttribute);

 COMPILE_ASSERT(Accessor < FirstInternalAttribute, Accessor_is_below_FirstInternalAttribute);

81 class JSFinalObject;

83 class JSObject : public JSCell {

84 friend class BatchedTransitionOptimizer;

85 friend class JIT;

86 friend class JSCell;

87 friend class JSFinalObject;

88 friend class MarkedBlock;

     JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashTableValue*, JSObject*, PropertyName, PropertySlot&);

91 enum PutMode {

92 PutModePut,

93 PutModeDefineOwnProperty,

94 };

96 public:

97 typedef JSCell Base;

     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);

     JS_EXPORT_PRIVATE static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);

101

     JS_EXPORT_PRIVATE static String className(const JSObject*);

103 JS_EXPORT_PRIVATE static String calculatedClassName(JSObject*);

104

105 JSValue prototype() const;

     JS_EXPORT_PRIVATE void setPrototype(VM&, JSValue prototype);

     JS_EXPORT_PRIVATE bool setPrototypeWithCycleCheck(ExecState*, JSValue prototype);

108

109 bool mayInterceptIndexedAccesses()

110 {

         return structure()->mayInterceptIndexedAccesses();

112 }

113

     JSValue get(ExecState*, PropertyName) const;

     JSValue get(ExecState*, unsigned propertyName) const;

116

     bool fastGetOwnPropertySlot(ExecState*, VM&, Structure&, PropertyName, PropertySlot&);

     bool getPropertySlot(ExecState*, PropertyName, PropertySlot&);

     bool getPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);

120

     static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);

     JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndex(JSObject*, ExecState*, unsigned propertyName, PropertySlot&);

123

124 // The key difference between this and getOwnPropertySlot is that getOwnPropertySlot

125 // currently returns incorrect results for the DOM window (with non-own properties)

126 // being returned. Once this is fixed we should migrate code & remove this method.

     JS_EXPORT_PRIVATE bool getOwnPropertyDescriptor(ExecState*, PropertyName, PropertyDescriptor&);

128

129 JS_EXPORT_PRIVATE bool allowsAccessFrom(ExecState*);

130

131 unsigned getArrayLength() const

132 {

         if (!hasIndexedProperties(indexingType()))

134 return 0;

135 return m_butterfly->publicLength();

136 }

137

138 unsigned getVectorLength()

139 {

         if (!hasIndexedProperties(indexingType()))

141 return 0;

142 return m_butterfly->vectorLength();

143 }

144

     JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);

     JS_EXPORT_PRIVATE static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);

147

     ALWAYS_INLINE void putByIndexInline(ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow)

149 {

         if (canSetIndexQuickly(propertyName)) {

             setIndexQuickly(exec->vm(), propertyName, value);

152 return;

153 }

         methodTable(exec->vm())->putByIndex(this, exec, propertyName, value, shouldThrow);

155 }

156

157 // This is similar to the putDirect* methods:

158 // - the prototype chain is not consulted

159 // - accessors are not called.

160 // - it will ignore extensibility and read-only properties if PutDirectIndexLikePutDirect is passed as the mode (the default).

161 // This method creates a property with attributes writable, enumerable and configurable all set to true.

     bool putDirectIndex(ExecState* exec, unsigned propertyName, JSValue value, unsigned attributes, PutDirectIndexMode mode)

163 {

         if (!attributes && canSetIndexQuicklyForPutDirect(propertyName)) {

             setIndexQuickly(exec->vm(), propertyName, value);

166 return true;

167 }

         return putDirectIndexBeyondVectorLength(exec, propertyName, value, attributes, mode);

169 }

     bool putDirectIndex(ExecState* exec, unsigned propertyName, JSValue value)

171 {

         return putDirectIndex(exec, propertyName, value, 0, PutDirectIndexLikePutDirect);

173 }

174

175 // A non-throwing version of putDirect and putDirectIndex.

     JS_EXPORT_PRIVATE void putDirectMayBeIndex(ExecState*, PropertyName, JSValue);

177

178 bool hasIndexingHeader() const

179 {

         return structure()->hasIndexingHeader(this);

181 }

182

     bool canGetIndexQuickly(unsigned i)

184 {

185 switch (indexingType()) {

186 case ALL_BLANK_INDEXING_TYPES:

187 case ALL_UNDECIDED_INDEXING_TYPES:

188 return false;

189 case ALL_INT32_INDEXING_TYPES:

190 case ALL_CONTIGUOUS_INDEXING_TYPES:

             return i < m_butterfly->vectorLength() && m_butterfly->contiguous()[i];

192 case ALL_DOUBLE_INDEXING_TYPES: {

             if (i >= m_butterfly->vectorLength())

194 return false;

             double value = m_butterfly->contiguousDouble()[i];

196 if (value != value)

197 return false;

198 return true;

199 }

200 case ALL_ARRAY_STORAGE_INDEXING_TYPES:

             return i < m_butterfly->arrayStorage()->vectorLength() && m_butterfly->arrayStorage()->m_vector[i];

202 default:

203 RELEASE_ASSERT_NOT_REACHED();

204 return false;

205 }

206 }

207

208 JSValue getIndexQuickly(unsigned i)

209 {

210 switch (indexingType()) {

211 case ALL_INT32_INDEXING_TYPES:

             return jsNumber(m_butterfly->contiguous()[i].get().asInt32());

213 case ALL_CONTIGUOUS_INDEXING_TYPES:

             return m_butterfly->contiguous()[i].get();

215 case ALL_DOUBLE_INDEXING_TYPES:

             return JSValue(JSValue::EncodeAsDouble, m_butterfly->contiguousDouble()[i]);

217 case ALL_ARRAY_STORAGE_INDEXING_TYPES:

             return m_butterfly->arrayStorage()->m_vector[i].get();

219 default:

220 RELEASE_ASSERT_NOT_REACHED();

221 return JSValue();

222 }

223 }

224

225 JSValue tryGetIndexQuickly(unsigned i)

226 {

227 switch (indexingType()) {

228 case ALL_BLANK_INDEXING_TYPES:

229 case ALL_UNDECIDED_INDEXING_TYPES:

230 break;

231 case ALL_INT32_INDEXING_TYPES:

             if (i < m_butterfly->publicLength()) {

                 JSValue result = m_butterfly->contiguous()[i].get();

                 ASSERT(result.isInt32() || !result);

235 return result;

236 }

237 break;

238 case ALL_CONTIGUOUS_INDEXING_TYPES:

             if (i < m_butterfly->publicLength())

                 return m_butterfly->contiguous()[i].get();

241 break;

242 case ALL_DOUBLE_INDEXING_TYPES: {

             if (i >= m_butterfly->publicLength())

244 break;

             double result = m_butterfly->contiguousDouble()[i];

246 if (result != result)

247 break;

             return JSValue(JSValue::EncodeAsDouble, result);

249 }

250 case ALL_ARRAY_STORAGE_INDEXING_TYPES:

             if (i < m_butterfly->arrayStorage()->vectorLength())

                 return m_butterfly->arrayStorage()->m_vector[i].get();

253 break;

254 default:

255 RELEASE_ASSERT_NOT_REACHED();

256 break;

257 }

258 return JSValue();

259 }

260

     JSValue getDirectIndex(ExecState* exec, unsigned i)

262 {

         if (JSValue result = tryGetIndexQuickly(i))

264 return result;

265 PropertySlot slot(this);

         if (methodTable(exec->vm())->getOwnPropertySlotByIndex(this, exec, i, slot))

             return slot.getValue(exec, i);

268 return JSValue();

269 }

270

     JSValue getIndex(ExecState* exec, unsigned i)

272 {

         if (JSValue result = tryGetIndexQuickly(i))

274 return result;

         return get(exec, i);

276 }

277

     bool canSetIndexQuickly(unsigned i)

279 {

280 switch (indexingType()) {

281 case ALL_BLANK_INDEXING_TYPES:

282 case ALL_UNDECIDED_INDEXING_TYPES:

283 return false;

284 case ALL_INT32_INDEXING_TYPES:

285 case ALL_DOUBLE_INDEXING_TYPES:

286 case ALL_CONTIGUOUS_INDEXING_TYPES:

287 case NonArrayWithArrayStorage:

288 case ArrayWithArrayStorage:

             return i < m_butterfly->vectorLength();

290 case NonArrayWithSlowPutArrayStorage:

291 case ArrayWithSlowPutArrayStorage:

             return i < m_butterfly->arrayStorage()->vectorLength()

                 && !!m_butterfly->arrayStorage()->m_vector[i];

294 default:

295 RELEASE_ASSERT_NOT_REACHED();

296 return false;

297 }

298 }

299

     bool canSetIndexQuicklyForPutDirect(unsigned i)

301 {

302 switch (indexingType()) {

303 case ALL_BLANK_INDEXING_TYPES:

304 case ALL_UNDECIDED_INDEXING_TYPES:

305 return false;

306 case ALL_INT32_INDEXING_TYPES:

307 case ALL_DOUBLE_INDEXING_TYPES:

308 case ALL_CONTIGUOUS_INDEXING_TYPES:

309 case ALL_ARRAY_STORAGE_INDEXING_TYPES:

             return i < m_butterfly->vectorLength();

311 default:

312 RELEASE_ASSERT_NOT_REACHED();

313 return false;

314 }

315 }

316

     void setIndexQuickly(VM& vm, unsigned i, JSValue v)

318 {

319 switch (indexingType()) {

320 case ALL_INT32_INDEXING_TYPES: {

             ASSERT(i < m_butterfly->vectorLength());

             if (!v.isInt32()) {

                 convertInt32ToDoubleOrContiguousWhilePerformingSetIndex(vm, i, v);

324 return;

325 }

326 FALLTHROUGH;

327 }

328 case ALL_CONTIGUOUS_INDEXING_TYPES: {

             ASSERT(i < m_butterfly->vectorLength());

             m_butterfly->contiguous()[i].set(vm, this, v);

             if (i >= m_butterfly->publicLength())

                 m_butterfly->setPublicLength(i + 1);

333 break;

334 }

335 case ALL_DOUBLE_INDEXING_TYPES: {

             ASSERT(i < m_butterfly->vectorLength());

             if (!v.isNumber()) {

                 convertDoubleToContiguousWhilePerformingSetIndex(vm, i, v);

339 return;

340 }

             double value = v.asNumber();

342 if (value != value) {

                 convertDoubleToContiguousWhilePerformingSetIndex(vm, i, v);

344 return;

345 }

             m_butterfly->contiguousDouble()[i] = value;

             if (i >= m_butterfly->publicLength())

                 m_butterfly->setPublicLength(i + 1);

349 break;

350 }

351 case ALL_ARRAY_STORAGE_INDEXING_TYPES: {

             ArrayStorage* storage = m_butterfly->arrayStorage();

             WriteBarrier<Unknown>& x = storage->m_vector[i];

354 JSValue old = x.get();

             x.set(vm, this, v);

356 if (!old) {

357 ++storage->m_numValuesInVector;

                 if (i >= storage->length())

                     storage->setLength(i + 1);

360 }

361 break;

362 }

363 default:

364 RELEASE_ASSERT_NOT_REACHED();

365 }

366 }

367

     void initializeIndex(VM& vm, unsigned i, JSValue v)

369 {

         initializeIndex(vm, i, v, indexingType());

371 }

372

     void initializeIndex(VM& vm, unsigned i, JSValue v, IndexingType indexingType)

374 {

375 switch (indexingType) {

376 case ALL_UNDECIDED_INDEXING_TYPES: {

             setIndexQuicklyToUndecided(vm, i, v);

378 break;

379 }

380 case ALL_INT32_INDEXING_TYPES: {

             ASSERT(i < m_butterfly->publicLength());

             ASSERT(i < m_butterfly->vectorLength());

             if (!v.isInt32()) {

                 convertInt32ToDoubleOrContiguousWhilePerformingSetIndex(vm, i, v);

385 break;

386 }

387 FALLTHROUGH;

388 }

389 case ALL_CONTIGUOUS_INDEXING_TYPES: {

             ASSERT(i < m_butterfly->publicLength());

             ASSERT(i < m_butterfly->vectorLength());

             m_butterfly->contiguous()[i].set(vm, this, v);

393 break;

394 }

395 case ALL_DOUBLE_INDEXING_TYPES: {

             ASSERT(i < m_butterfly->publicLength());

             ASSERT(i < m_butterfly->vectorLength());

             if (!v.isNumber()) {

                 convertDoubleToContiguousWhilePerformingSetIndex(vm, i, v);

400 return;

401 }

             double value = v.asNumber();

403 if (value != value) {

                 convertDoubleToContiguousWhilePerformingSetIndex(vm, i, v);

405 return;

406 }

             m_butterfly->contiguousDouble()[i] = value;

408 break;

409 }

410 case ALL_ARRAY_STORAGE_INDEXING_TYPES: {

             ArrayStorage* storage = m_butterfly->arrayStorage();

             ASSERT(i < storage->length());

             ASSERT(i < storage->m_numValuesInVector);

             storage->m_vector[i].set(vm, this, v);

415 break;

416 }

417 default:

418 RELEASE_ASSERT_NOT_REACHED();

419 }

420 }

421

422 bool hasSparseMap()

423 {

424 switch (indexingType()) {

425 case ALL_BLANK_INDEXING_TYPES:

426 case ALL_UNDECIDED_INDEXING_TYPES:

427 case ALL_INT32_INDEXING_TYPES:

428 case ALL_DOUBLE_INDEXING_TYPES:

429 case ALL_CONTIGUOUS_INDEXING_TYPES:

430 return false;

431 case ALL_ARRAY_STORAGE_INDEXING_TYPES:

             return !!m_butterfly->arrayStorage()->m_sparseMap;

433 default:

434 RELEASE_ASSERT_NOT_REACHED();

435 return false;

436 }

437 }

438

439 bool inSparseIndexingMode()

440 {

441 switch (indexingType()) {

442 case ALL_BLANK_INDEXING_TYPES:

443 case ALL_UNDECIDED_INDEXING_TYPES:

444 case ALL_INT32_INDEXING_TYPES:

445 case ALL_DOUBLE_INDEXING_TYPES:

446 case ALL_CONTIGUOUS_INDEXING_TYPES:

447 return false;

448 case ALL_ARRAY_STORAGE_INDEXING_TYPES:

             return m_butterfly->arrayStorage()->inSparseMode();

450 default:

451 RELEASE_ASSERT_NOT_REACHED();

452 return false;

453 }

454 }

455

456 void enterDictionaryIndexingMode(VM&);

457

458 // putDirect is effectively an unchecked vesion of 'defineOwnProperty':

459 // - the prototype chain is not consulted

460 // - accessors are not called.

461 // - attributes will be respected (after the call the property will exist with the given attributes)

462 // - the property name is assumed to not be an index.

     void putDirect(VM&, PropertyName, JSValue, unsigned attributes = 0);

     void putDirect(VM&, PropertyName, JSValue, PutPropertySlot&);

     void putDirectWithoutTransition(VM&, PropertyName, JSValue, unsigned attributes = 0);

     void putDirectNonIndexAccessor(VM&, PropertyName, JSValue, unsigned attributes);

     void putDirectAccessor(ExecState*, PropertyName, JSValue, unsigned attributes);

     JS_EXPORT_PRIVATE void putDirectCustomAccessor(VM&, PropertyName, JSValue, unsigned attributes);

469

     void putGetter(ExecState*, PropertyName, JSValue);

     void putSetter(ExecState*, PropertyName, JSValue);

472

     JS_EXPORT_PRIVATE bool hasProperty(ExecState*, PropertyName) const;

     JS_EXPORT_PRIVATE bool hasProperty(ExecState*, unsigned propertyName) const;

     bool hasOwnProperty(ExecState*, PropertyName) const;

     bool hasOwnProperty(ExecState*, unsigned) const;

477

     JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, PropertyName);

     JS_EXPORT_PRIVATE static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);

480

     JS_EXPORT_PRIVATE static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);

482

     bool hasInstance(ExecState*, JSValue);

     static bool defaultHasInstance(ExecState*, JSValue, JSValue prototypeProperty);

485

     JS_EXPORT_PRIVATE static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);

     JS_EXPORT_PRIVATE static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);

     JS_EXPORT_PRIVATE static void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);

489

     JS_EXPORT_PRIVATE static uint32_t getEnumerableLength(ExecState*, JSObject*);

     JS_EXPORT_PRIVATE static void getStructurePropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);

     JS_EXPORT_PRIVATE static void getGenericPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);

493

     JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;

     bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;

     JS_EXPORT_PRIVATE double toNumber(ExecState*) const;

     JS_EXPORT_PRIVATE JSString* toString(ExecState*) const;

498

     JS_EXPORT_PRIVATE static JSValue toThis(JSCell*, ExecState*, ECMAMode);

500

501 // This get function only looks at the property map.

     JSValue getDirect(VM& vm, PropertyName propertyName) const

503 {

         Structure* structure = this->structure(vm);

         PropertyOffset offset = structure->get(vm, propertyName);

         checkOffset(offset, structure->inlineCapacity());

         return offset != invalidOffset ? getDirect(offset) : JSValue();

508 }

509

     JSValue getDirect(VM& vm, PropertyName propertyName, unsigned& attributes) const

511 {

         Structure* structure = this->structure(vm);

         PropertyOffset offset = structure->get(vm, propertyName, attributes);

         checkOffset(offset, structure->inlineCapacity());

         return offset != invalidOffset ? getDirect(offset) : JSValue();

516 }

517

     PropertyOffset getDirectOffset(VM& vm, PropertyName propertyName)

519 {

         Structure* structure = this->structure(vm);

         PropertyOffset offset = structure->get(vm, propertyName);

         checkOffset(offset, structure->inlineCapacity());

523 return offset;

524 }

525

     PropertyOffset getDirectOffset(VM& vm, PropertyName propertyName, unsigned& attributes)

527 {

         Structure* structure = this->structure(vm);

         PropertyOffset offset = structure->get(vm, propertyName, attributes);

         checkOffset(offset, structure->inlineCapacity());

531 return offset;

532 }

533

     bool hasInlineStorage() const { return structure()->hasInlineStorage(); }

535 ConstPropertyStorage inlineStorageUnsafe() const

536 {

         return bitwise_cast<ConstPropertyStorage>(this + 1);

538 }

539 PropertyStorage inlineStorageUnsafe()

540 {

         return bitwise_cast<PropertyStorage>(this + 1);

542 }

543 ConstPropertyStorage inlineStorage() const

544 {

545 ASSERT(hasInlineStorage());

546 return inlineStorageUnsafe();

547 }

548 PropertyStorage inlineStorage()

549 {

550 ASSERT(hasInlineStorage());

551 return inlineStorageUnsafe();

552 }

553

     const Butterfly* butterfly() const { return m_butterfly.get(); }

     Butterfly* butterfly() { return m_butterfly.get(); }

556

     ConstPropertyStorage outOfLineStorage() const { return m_butterfly->propertyStorage(); }

     PropertyStorage outOfLineStorage() { return m_butterfly->propertyStorage(); }

559

     const WriteBarrierBase<Unknown>* locationForOffset(PropertyOffset offset) const

561 {

         if (isInlineOffset(offset))

             return &inlineStorage()[offsetInInlineStorage(offset)];

         return &outOfLineStorage()[offsetInOutOfLineStorage(offset)];

565 }

566

     WriteBarrierBase<Unknown>* locationForOffset(PropertyOffset offset)

568 {

         if (isInlineOffset(offset))

             return &inlineStorage()[offsetInInlineStorage(offset)];

         return &outOfLineStorage()[offsetInOutOfLineStorage(offset)];

572 }

573

     void transitionTo(VM&, Structure*);

575

     JS_EXPORT_PRIVATE bool removeDirect(VM&, PropertyName); // Return true if anything is removed.

     bool hasCustomProperties() { return structure()->didTransition(); }

     bool hasGetterSetterProperties() { return structure()->hasGetterSetterProperties(); }

     bool hasCustomGetterSetterProperties() { return structure()->hasCustomGetterSetterProperties(); }

580

581 // putOwnDataProperty has 'put' like semantics, however this method:

582 // - assumes the object contains no own getter/setter properties.

583 // - provides no special handling for __proto__

584 // - does not walk the prototype chain (to check for accessors or non-writable properties).

585 // This is used by JSLexicalEnvironment.

     bool putOwnDataProperty(VM&, PropertyName, JSValue, PutPropertySlot&);

587

588 // Fast access to known property offsets.

     JSValue getDirect(PropertyOffset offset) const { return locationForOffset(offset)->get(); }

     void putDirect(VM& vm, PropertyOffset offset, JSValue value) { locationForOffset(offset)->set(vm, this, value); }

     void putDirectUndefined(PropertyOffset offset) { locationForOffset(offset)->setUndefined(); }

592

     JS_EXPORT_PRIVATE void putDirectNativeFunction(VM&, JSGlobalObject*, const PropertyName&, unsigned functionLength, NativeFunction, Intrinsic, unsigned attributes);

     JS_EXPORT_PRIVATE JSFunction* putDirectBuiltinFunction(VM&, JSGlobalObject*, const PropertyName&, FunctionExecutable*, unsigned attributes);

     JSFunction* putDirectBuiltinFunctionWithoutTransition(VM&, JSGlobalObject*, const PropertyName&, FunctionExecutable*, unsigned attributes);

     JS_EXPORT_PRIVATE void putDirectNativeFunctionWithoutTransition(VM&, JSGlobalObject*, const PropertyName&, unsigned functionLength, NativeFunction, Intrinsic, unsigned attributes);

597

     JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);

599

     bool isGlobalObject() const;

     bool isVariableObject() const;

     bool isStaticScopeObject() const;

     bool isNameScopeObject() const;

     bool isCatchScopeObject() const;

     bool isFunctionNameScopeObject() const;

     bool isActivationObject() const;

     bool isErrorInstance() const;

     bool isWithScope() const;

609

610 JS_EXPORT_PRIVATE void seal(VM&);

611 JS_EXPORT_PRIVATE void freeze(VM&);

612 JS_EXPORT_PRIVATE void preventExtensions(VM&);

     bool isSealed(VM& vm) { return structure(vm)->isSealed(vm); }

     bool isFrozen(VM& vm) { return structure(vm)->isFrozen(vm); }

     bool isExtensible() { return structure()->isExtensible(); }

616 bool indexingShouldBeSparse()

617 {

618 return !isExtensible()

             || structure()->typeInfo().interceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero();

620 }

621

     bool staticFunctionsReified() { return structure()->staticFunctionsReified(); }

     void reifyStaticFunctionsForDelete(ExecState* exec);

624

     JS_EXPORT_PRIVATE Butterfly* growOutOfLineStorage(VM&, size_t oldSize, size_t newSize);

     void setButterflyWithoutChangingStructure(VM&, Butterfly*);

627

     void setStructure(VM&, Structure*);

     void setStructureAndButterfly(VM&, Structure*, Butterfly*);

     void setStructureAndReallocateStorageIfNecessary(VM&, unsigned oldCapacity, Structure*);

     void setStructureAndReallocateStorageIfNecessary(VM&, Structure*);

632

     void convertToDictionary(VM& vm)

634 {

         setStructure(vm, Structure::toCacheableDictionaryTransition(vm, structure(vm)));

636 }

637

     void flattenDictionaryObject(VM& vm)

639 {

         structure(vm)->flattenDictionaryStructure(vm, this);

641 }

     void shiftButterflyAfterFlattening(VM&, size_t outOfLineCapacityBefore, size_t outOfLineCapacityAfter);

643

644 JSGlobalObject* globalObject() const

645 {

         ASSERT(structure()->globalObject());

         ASSERT(!isGlobalObject() || ((JSObject*)structure()->globalObject()) == this);

         return structure()->globalObject();

649 }

650

651 void switchToSlowPutArrayStorage(VM&);

652

653 // The receiver is the prototype in this case. The following:

654 //

655 // asObject(foo->structure()->storedPrototype())->attemptToInterceptPutByIndexOnHoleForPrototype(...)

656 //

657 // is equivalent to:

658 //

659 // foo->attemptToInterceptPutByIndexOnHole(...);

     bool attemptToInterceptPutByIndexOnHoleForPrototype(ExecState*, JSValue thisValue, unsigned propertyName, JSValue, bool shouldThrow);

661

662 // Returns 0 if int32 storage cannot be created - either because

663 // indexing should be sparse, we're having a bad time, or because

664 // we already have a more general form of storage (double,

665 // contiguous, array storage).

666 ContiguousJSValues ensureInt32(VM& vm)

667 {

         if (LIKELY(hasInt32(indexingType())))

669 return m_butterfly->contiguousInt32();

670

671 return ensureInt32Slow(vm);

672 }

673

674 // Returns 0 if double storage cannot be created - either because

675 // indexing should be sparse, we're having a bad time, or because

676 // we already have a more general form of storage (contiguous,

677 // or array storage).

678 ContiguousDoubles ensureDouble(VM& vm)

679 {

         if (LIKELY(hasDouble(indexingType())))

681 return m_butterfly->contiguousDouble();

682

683 return ensureDoubleSlow(vm);

684 }

685

686 // Returns 0 if contiguous storage cannot be created - either because

687 // indexing should be sparse or because we're having a bad time.

688 ContiguousJSValues ensureContiguous(VM& vm)

689 {

         if (LIKELY(hasContiguous(indexingType())))

691 return m_butterfly->contiguous();

692

693 return ensureContiguousSlow(vm);

694 }

695

696 // Ensure that the object is in a mode where it has array storage. Use

697 // this if you're about to perform actions that would have required the

698 // object to be converted to have array storage, if it didn't have it

699 // already.

     ArrayStorage* ensureArrayStorage(VM& vm)

701 {

         if (LIKELY(hasAnyArrayStorage(indexingType())))

703 return m_butterfly->arrayStorage();

704

705 return ensureArrayStorageSlow(vm);

706 }

707

708 static size_t offsetOfInlineStorage();

709

710 static ptrdiff_t butterflyOffset()

711 {

         return OBJECT_OFFSETOF(JSObject, m_butterfly);

713 }

714

715 void* butterflyAddress()

716 {

717 return &m_butterfly;

718 }

719

720 DECLARE_EXPORT_INFO;

721

722 protected:

     void finishCreation(VM& vm)

724 {

         Base::finishCreation(vm);

         ASSERT(inherits(info()));

         ASSERT(prototype().isNull() || Heap::heap(this) == Heap::heap(prototype()));

         ASSERT(structure()->isObject());

729 ASSERT(classInfo());

730 }

731

     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)

733 {

         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());

735 }

736

737 // To instantiate objects you likely want JSFinalObject, below.

738 // To create derived types you likely want JSNonFinalObject, below.

     JSObject(VM&, Structure*, Butterfly* = 0);

740

     void visitButterfly(SlotVisitor&, Butterfly*, size_t storageSize);

     void copyButterfly(CopyVisitor&, Butterfly*, size_t storageSize);

743

744 // Call this if you know that the object is in a mode where it has array

745 // storage. This will assert otherwise.

746 ArrayStorage* arrayStorage()

747 {

         ASSERT(hasAnyArrayStorage(indexingType()));

749 return m_butterfly->arrayStorage();

750 }

751

752 // Call this if you want to predicate some actions on whether or not the

753 // object is in a mode where it has array storage.

754 ArrayStorage* arrayStorageOrNull()

755 {

756 switch (indexingType()) {

757 case ALL_ARRAY_STORAGE_INDEXING_TYPES:

758 return m_butterfly->arrayStorage();

759

760 default:

761 return 0;

762 }

763 }

764

765 size_t butterflyTotalSize();

766 size_t butterflyPreCapacity();

767

     Butterfly* createInitialUndecided(VM&, unsigned length);

     ContiguousJSValues createInitialInt32(VM&, unsigned length);

     ContiguousDoubles createInitialDouble(VM&, unsigned length);

     ContiguousJSValues createInitialContiguous(VM&, unsigned length);

772

     void convertUndecidedForValue(VM&, JSValue);

     void createInitialForValueAndSet(VM&, unsigned index, JSValue);

     void convertInt32ForValue(VM&, JSValue);

776

     ArrayStorage* createArrayStorage(VM&, unsigned length, unsigned vectorLength);

778 ArrayStorage* createInitialArrayStorage(VM&);

779

780 ContiguousJSValues convertUndecidedToInt32(VM&);

781 ContiguousDoubles convertUndecidedToDouble(VM&);

782 ContiguousJSValues convertUndecidedToContiguous(VM&);

     ArrayStorage* convertUndecidedToArrayStorage(VM&, NonPropertyTransition);

784 ArrayStorage* convertUndecidedToArrayStorage(VM&);

785

786 ContiguousDoubles convertInt32ToDouble(VM&);

787 ContiguousJSValues convertInt32ToContiguous(VM&);

     ArrayStorage* convertInt32ToArrayStorage(VM&, NonPropertyTransition);

789 ArrayStorage* convertInt32ToArrayStorage(VM&);

790

791 ContiguousJSValues convertDoubleToContiguous(VM&);

     ArrayStorage* convertDoubleToArrayStorage(VM&, NonPropertyTransition);

793 ArrayStorage* convertDoubleToArrayStorage(VM&);

794

     ArrayStorage* convertContiguousToArrayStorage(VM&, NonPropertyTransition);

796 ArrayStorage* convertContiguousToArrayStorage(VM&);

797

798

799 ArrayStorage* ensureArrayStorageExistsAndEnterDictionaryIndexingMode(VM&);

800

     bool defineOwnNonIndexProperty(ExecState*, PropertyName, const PropertyDescriptor&, bool throwException);

802

803 template<IndexingType indexingShape>

     void putByIndexBeyondVectorLengthWithoutAttributes(ExecState*, unsigned propertyName, JSValue);

     void putByIndexBeyondVectorLengthWithArrayStorage(ExecState*, unsigned propertyName, JSValue, bool shouldThrow, ArrayStorage*);

806

     bool increaseVectorLength(VM&, unsigned newLength);

808 void deallocateSparseIndexMap();

     bool defineOwnIndexedProperty(ExecState*, unsigned, const PropertyDescriptor&, bool throwException);

810 SparseArrayValueMap* allocateSparseIndexMap(VM&);

811

812 void notifyPresenceOfIndexedAccessors(VM&);

813

     bool attemptToInterceptPutByIndexOnHole(ExecState*, unsigned index, JSValue, bool shouldThrow);

815

816 // Call this if you want setIndexQuickly to succeed and you're sure that

817 // the array is contiguous.

     void ensureLength(VM& vm, unsigned length)

819 {

820 ASSERT(length < MAX_ARRAY_INDEX);

         ASSERT(hasContiguous(indexingType()) || hasInt32(indexingType()) || hasDouble(indexingType()) || hasUndecided(indexingType()));

822

         if (m_butterfly->vectorLength() < length)

824 ensureLengthSlow(vm, length);

825

         if (m_butterfly->publicLength() < length)

827 m_butterfly->setPublicLength(length);

828 }

829

830 // Call this if you want to shrink the butterfly backing store, and you're

831 // sure that the array is contiguous.

     void reallocateAndShrinkButterfly(VM&, unsigned length);

833

834 template<IndexingType indexingShape>

835 unsigned countElements(Butterfly*);

836

837 // This is relevant to undecided, int32, double, and contiguous.

838 unsigned countElements();

839

840 private:

841 friend class LLIntOffsetsExtractor;

842

843 // Nobody should ever ask any of these questions on something already known to be a JSObject.

844 using JSCell::isAPIValueWrapper;

845 using JSCell::isGetterSetter;

846 void getObject();

     void getString(ExecState* exec);

848 void isObject();

849 void isString();

850

     Butterfly* createInitialIndexedStorage(VM&, unsigned length, size_t elementSize);

852

     ArrayStorage* enterDictionaryIndexingModeWhenArrayStorageAlreadyExists(VM&, ArrayStorage*);

854

855 template<PutMode>

     bool putDirectInternal(VM&, PropertyName, JSValue, unsigned attr, PutPropertySlot&);

857

     bool inlineGetOwnPropertySlot(VM&, Structure&, PropertyName, PropertySlot&);

     JS_EXPORT_PRIVATE void fillGetterPropertySlot(PropertySlot&, JSValue, unsigned, PropertyOffset);

     void fillCustomGetterPropertySlot(PropertySlot&, JSValue, unsigned, Structure&);

861

     const HashTableValue* findPropertyHashEntry(PropertyName) const;

863

     void putIndexedDescriptor(ExecState*, SparseArrayEntry*, const PropertyDescriptor&, PropertyDescriptor& old);

865

     void putByIndexBeyondVectorLength(ExecState*, unsigned propertyName, JSValue, bool shouldThrow);

     bool putDirectIndexBeyondVectorLengthWithArrayStorage(ExecState*, unsigned propertyName, JSValue, unsigned attributes, PutDirectIndexMode, ArrayStorage*);

     JS_EXPORT_PRIVATE bool putDirectIndexBeyondVectorLength(ExecState*, unsigned propertyName, JSValue, unsigned attributes, PutDirectIndexMode);

869

     unsigned getNewVectorLength(unsigned currentVectorLength, unsigned currentLength, unsigned desiredLength);

     unsigned getNewVectorLength(unsigned desiredLength);

872

     ArrayStorage* constructConvertedArrayStorageWithoutCopyingElements(VM&, unsigned neededLength);

874

     JS_EXPORT_PRIVATE void setIndexQuicklyToUndecided(VM&, unsigned index, JSValue);

     JS_EXPORT_PRIVATE void convertInt32ToDoubleOrContiguousWhilePerformingSetIndex(VM&, unsigned index, JSValue);

     JS_EXPORT_PRIVATE void convertDoubleToContiguousWhilePerformingSetIndex(VM&, unsigned index, JSValue);

878

     void ensureLengthSlow(VM&, unsigned length);

880

881 ContiguousJSValues ensureInt32Slow(VM&);

882 ContiguousDoubles ensureDoubleSlow(VM&);

883 ContiguousJSValues ensureContiguousSlow(VM&);

884 JS_EXPORT_PRIVATE ArrayStorage* ensureArrayStorageSlow(VM&);

885

886 protected:

887 CopyWriteBarrier<Butterfly> m_butterfly;

888 #if USE(JSVALUE32_64)

889 private:

890 uint32_t m_padding;

891 #endif

892 };

893

894 // JSNonFinalObject is a type of JSObject that has some internal storage,

895 // but also preserves some space in the collector cell for additional

896 // data members in derived types.

897 class JSNonFinalObject : public JSObject {

898 friend class JSObject;

899

900 public:

901 typedef JSObject Base;

902

     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)

904 {

         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());

906 }

907

908 protected:

     explicit JSNonFinalObject(VM& vm, Structure* structure, Butterfly* butterfly = 0)

         : JSObject(vm, structure, butterfly)

911 {

912 }

913

     void finishCreation(VM& vm)

915 {

         Base::finishCreation(vm);

         ASSERT(!this->structure()->hasInlineStorage());

918 ASSERT(classInfo());

919 }

920 };

921

922 class JSFinalObject;

923

924 // JSFinalObject is a type of JSObject that contains sufficent internal

925 // storage to fully make use of the colloctor cell containing it.

926 class JSFinalObject : public JSObject {

927 friend class JSObject;

928

929 public:

930 typedef JSObject Base;

     static const unsigned StructureFlags = Base::StructureFlags;

932

     static size_t allocationSize(size_t inlineCapacity)

934 {

         return sizeof(JSObject) + inlineCapacity * sizeof(WriteBarrierBase<Unknown>);

936 }

937

938 static const unsigned defaultSize = 64;

     static inline unsigned defaultInlineCapacity()

940 {

         return (defaultSize - allocationSize(0)) / sizeof(WriteBarrier<Unknown>);

942 }

943

944 static const unsigned maxSize = 512;

     static inline unsigned maxInlineCapacity()

946 {

         return (maxSize - allocationSize(0)) / sizeof(WriteBarrier<Unknown>);

948 }

949

     static JSFinalObject* create(ExecState*, Structure*, Butterfly* = nullptr);

     static JSFinalObject* create(VM&, Structure*);

     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype, unsigned inlineCapacity)

953 {

         return Structure::create(vm, globalObject, prototype, TypeInfo(FinalObjectType, StructureFlags), info(), NonArray, inlineCapacity);

955 }

956

     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);

958

959 DECLARE_EXPORT_INFO;

960

961 protected:

962 void visitChildrenCommon(SlotVisitor&);

963

     void finishCreation(VM& vm)

965 {

         Base::finishCreation(vm);

         ASSERT(structure()->totalStorageCapacity() == structure()->inlineCapacity());

968 ASSERT(classInfo());

969 }

970

971 private:

972 friend class LLIntOffsetsExtractor;

973

     explicit JSFinalObject(VM& vm, Structure* structure, Butterfly* butterfly = nullptr)

         : JSObject(vm, structure, butterfly)

976 {

977 }

978 };

979

 inline JSFinalObject* JSFinalObject::create(

     ExecState* exec, Structure* structure, Butterfly* butterfly)

982 {

983 JSFinalObject* finalObject = new (

984 NotNull,

985 allocateCell<JSFinalObject>(

986 *exec->heap(),

             allocationSize(structure->inlineCapacity())

988 )

     ) JSFinalObject(exec->vm(), structure, butterfly);

     finalObject->finishCreation(exec->vm());

991 return finalObject;

992 }

993

 inline JSFinalObject* JSFinalObject::create(VM& vm, Structure* structure)

995 {

     JSFinalObject* finalObject = new (NotNull, allocateCell<JSFinalObject>(vm.heap, allocationSize(structure->inlineCapacity()))) JSFinalObject(vm, structure);

997 finalObject->finishCreation(vm);

998 return finalObject;

999 }

1000

 inline bool isJSFinalObject(JSCell* cell)

1002 {

     return cell->classInfo() == JSFinalObject::info();

1004 }

1005

 inline bool isJSFinalObject(JSValue value)

1007 {

     return value.isCell() && isJSFinalObject(value.asCell());

1009 }

1010

 inline size_t JSObject::offsetOfInlineStorage()

1012 {

1013 return sizeof(JSObject);

1014 }

1015

 inline bool JSObject::isGlobalObject() const

1017 {

1018 return type() == GlobalObjectType;

1019 }

1020

 inline bool JSObject::isVariableObject() const

1022 {

     return type() == GlobalObjectType || type() == ActivationObjectType;

1024 }

1025

 inline bool JSObject::isStaticScopeObject() const

1027 {

     JSType type = this->type();

     return type == NameScopeObjectType || type == ActivationObjectType;

1030 }

1031

 inline bool JSObject::isNameScopeObject() const

1033 {

1034 return type() == NameScopeObjectType;

1035 }

1036

 inline bool JSObject::isActivationObject() const

1038 {

1039 return type() == ActivationObjectType;

1040 }

1041

 inline bool JSObject::isErrorInstance() const

1043 {

1044 return type() == ErrorInstanceType;

1045 }

1046

 inline bool JSObject::isWithScope() const

1048 {

1049 return type() == WithScopeType;

1050 }

1051

 inline void JSObject::setStructureAndButterfly(VM& vm, Structure* structure, Butterfly* butterfly)

1053 {

1054 ASSERT(structure);

     ASSERT(!butterfly == (!structure->outOfLineCapacity() && !structure->hasIndexingHeader(this)));

     m_butterfly.set(vm, this, butterfly);

1057 setStructure(vm, structure);

1058 }

1059

 inline void JSObject::setStructure(VM& vm, Structure* structure)

1061 {

1062 ASSERT(structure);

     ASSERT(!m_butterfly == !(structure->outOfLineCapacity() || structure->hasIndexingHeader(this)));

     JSCell::setStructure(vm, structure);

1065 }

1066

 inline void JSObject::setButterflyWithoutChangingStructure(VM& vm, Butterfly* butterfly)

1068 {

     m_butterfly.set(vm, this, butterfly);

1070 }

1071

 inline CallType getCallData(JSValue value, CallData& callData)

1073 {

     CallType result = value.isCell() ? value.asCell()->methodTable()->getCallData(value.asCell(), callData) : CallTypeNone;

     ASSERT(result == CallTypeNone || value.isValidCallee());

1076 return result;

1077 }

1078

 inline ConstructType getConstructData(JSValue value, ConstructData& constructData)

1080 {

     ConstructType result = value.isCell() ? value.asCell()->methodTable()->getConstructData(value.asCell(), constructData) : ConstructTypeNone;

     ASSERT(result == ConstructTypeNone || value.isValidCallee());

1083 return result;

1084 }

1085

 inline JSObject* asObject(JSCell* cell)

1087 {

     ASSERT(cell->isObject());

1089 return jsCast<JSObject*>(cell);

1090 }

1091

 inline JSObject* asObject(JSValue value)

1093 {

     return asObject(value.asCell());

1095 }

1096

 inline JSObject::JSObject(VM& vm, Structure* structure, Butterfly* butterfly)

     : JSCell(vm, structure)

     , m_butterfly(vm, this, butterfly)

1100 {

     vm.heap.ascribeOwner(this, butterfly);

1102 }

1103

 inline JSValue JSObject::prototype() const

1105 {

     return structure()->storedPrototype();

1107 }

1108

 ALWAYS_INLINE bool JSObject::inlineGetOwnPropertySlot(VM& vm, Structure& structure, PropertyName propertyName, PropertySlot& slot)

1110 {

1111 unsigned attributes;

     PropertyOffset offset = structure.get(vm, propertyName, attributes);

     if (!isValidOffset(offset))

1114 return false;

1115

1116 JSValue value = getDirect(offset);

     if (structure.hasGetterSetterProperties() && value.isGetterSetter())

         fillGetterPropertySlot(slot, value, attributes, offset);

     else if (structure.hasCustomGetterSetterProperties() && value.isCustomGetterSetter())

         fillCustomGetterPropertySlot(slot, value, attributes, structure);

1121 else

         slot.setValue(this, attributes, value, offset);

1123

1124 return true;

1125 }

1126

 ALWAYS_INLINE void JSObject::fillCustomGetterPropertySlot(PropertySlot& slot, JSValue customGetterSetter, unsigned attributes, Structure& structure)

1128 {

     if (structure.isDictionary()) {

         slot.setCustom(this, attributes, jsCast<CustomGetterSetter*>(customGetterSetter)->getter());

1131 return;

1132 }

     slot.setCacheableCustom(this, attributes, jsCast<CustomGetterSetter*>(customGetterSetter)->getter());

1134 }

1135

1136 // It may seem crazy to inline a function this large, especially a virtual function,

1137 // but it makes a big difference to property lookup that derived classes can inline their

1138 // base class call to this.

 ALWAYS_INLINE bool JSObject::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)

1140 {

     VM& vm = exec->vm();

     Structure& structure = *object->structure(vm);

     if (object->inlineGetOwnPropertySlot(vm, structure, propertyName, slot))

1144 return true;

     if (Optional<uint32_t> index = parseIndex(propertyName))

         return getOwnPropertySlotByIndex(object, exec, index.value(), slot);

1147 return false;

1148 }

1149

 ALWAYS_INLINE bool JSObject::fastGetOwnPropertySlot(ExecState* exec, VM& vm, Structure& structure, PropertyName propertyName, PropertySlot& slot)

1151 {

     if (LIKELY(!TypeInfo::overridesGetOwnPropertySlot(inlineTypeFlags())))

         return inlineGetOwnPropertySlot(vm, structure, propertyName, slot);

     return structure.classInfo()->methodTable.getOwnPropertySlot(this, exec, propertyName, slot);

1155 }

1156

1157 // It may seem crazy to inline a function this large but it makes a big difference

1158 // since this is function very hot in variable lookup

 ALWAYS_INLINE bool JSObject::getPropertySlot(ExecState* exec, PropertyName propertyName, PropertySlot& slot)

1160 {

     VM& vm = exec->vm();

     auto& structureIDTable = vm.heap.structureIDTable();

1163 JSObject* object = this;

1164 while (true) {

         Structure& structure = *structureIDTable.get(object->structureID());

         if (object->fastGetOwnPropertySlot(exec, vm, structure, propertyName, slot))

1167 return true;

1168 JSValue prototype = structure.storedPrototype();

         if (!prototype.isObject())

1170 break;

1171 object = asObject(prototype);

1172 }

1173

     if (Optional<uint32_t> index = parseIndex(propertyName))

         return getPropertySlot(exec, index.value(), slot);

1176 return false;

1177 }

1178

 ALWAYS_INLINE bool JSObject::getPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot)

1180 {

     VM& vm = exec->vm();

     auto& structureIDTable = vm.heap.structureIDTable();

1183 JSObject* object = this;

1184 while (true) {

         Structure& structure = *structureIDTable.get(object->structureID());

         if (structure.classInfo()->methodTable.getOwnPropertySlotByIndex(object, exec, propertyName, slot))

1187 return true;

1188 JSValue prototype = structure.storedPrototype();

         if (!prototype.isObject())

1190 return false;

1191 object = asObject(prototype);

1192 }

1193 }

1194

 inline JSValue JSObject::get(ExecState* exec, PropertyName propertyName) const

1196 {

1197 PropertySlot slot(this);

     if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))

         return slot.getValue(exec, propertyName);

1200

1201 return jsUndefined();

1202 }

1203

 inline JSValue JSObject::get(ExecState* exec, unsigned propertyName) const

1205 {

1206 PropertySlot slot(this);

     if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))

         return slot.getValue(exec, propertyName);

1209

1210 return jsUndefined();

1211 }

1212

 template<JSObject::PutMode mode>

 inline bool JSObject::putDirectInternal(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes, PutPropertySlot& slot)

1215 {

1216 ASSERT(value);

     ASSERT(value.isGetterSetter() == !!(attributes & Accessor));

     ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));

     ASSERT(!parseIndex(propertyName));

1220

     Structure* structure = this->structure(vm);

     if (structure->isDictionary()) {

1223 unsigned currentAttributes;

         PropertyOffset offset = structure->get(vm, propertyName, currentAttributes);

1225 if (offset != invalidOffset) {

             if ((mode == PutModePut) && currentAttributes & ReadOnly)

1227 return false;

1228

             putDirect(vm, offset, value);

1230 structure->didReplaceProperty(offset);

             slot.setExistingProperty(this, offset);

1232

             if ((attributes & Accessor) != (currentAttributes & Accessor)) {

1234 ASSERT(!(attributes & ReadOnly));

                 setStructure(vm, Structure::attributeChangeTransition(vm, structure, propertyName, attributes));

1236 }

1237 return true;

1238 }

1239

         if ((mode == PutModePut) && !isExtensible())

1241 return false;

1242

1243 DeferGC deferGC(vm.heap);

1244 Butterfly* newButterfly = butterfly();

         if (this->structure()->putWillGrowOutOfLineStorage())

             newButterfly = growOutOfLineStorage(vm, this->structure()->outOfLineCapacity(), this->structure()->suggestedNewOutOfLineStorageCapacity());

         offset = this->structure()->addPropertyWithoutTransition(vm, propertyName, attributes);

         setStructureAndButterfly(vm, this->structure(), newButterfly);

1249

1250 validateOffset(offset);

         ASSERT(this->structure()->isValidOffset(offset));

         putDirect(vm, offset, value);

         slot.setNewProperty(this, offset);

1254 if (attributes & ReadOnly)

             this->structure()->setContainsReadOnlyProperties();

1256 return true;

1257 }

1258

1259 PropertyOffset offset;

     size_t currentCapacity = this->structure()->outOfLineCapacity();

     if (Structure* structure = Structure::addPropertyTransitionToExistingStructure(this->structure(), propertyName, attributes, offset)) {

1262 DeferGC deferGC(vm.heap);

1263 Butterfly* newButterfly = butterfly();

         if (currentCapacity != structure->outOfLineCapacity()) {

             ASSERT(structure != this->structure());

             newButterfly = growOutOfLineStorage(vm, currentCapacity, structure->outOfLineCapacity());

1267 }

1268

1269 validateOffset(offset);

         ASSERT(structure->isValidOffset(offset));

         setStructureAndButterfly(vm, structure, newButterfly);

         putDirect(vm, offset, value);

         slot.setNewProperty(this, offset);

1274 return true;

1275 }

1276

1277 unsigned currentAttributes;

     offset = structure->get(vm, propertyName, currentAttributes);

1279 if (offset != invalidOffset) {

         if ((mode == PutModePut) && currentAttributes & ReadOnly)

1281 return false;

1282

1283 structure->didReplaceProperty(offset);

         slot.setExistingProperty(this, offset);

         putDirect(vm, offset, value);

1286

         if ((attributes & Accessor) != (currentAttributes & Accessor)) {

1288 ASSERT(!(attributes & ReadOnly));

             setStructure(vm, Structure::attributeChangeTransition(vm, structure, propertyName, attributes));

1290 }

1291 return true;

1292 }

1293

     if ((mode == PutModePut) && !isExtensible())

1295 return false;

1296

     structure = Structure::addPropertyTransition(vm, structure, propertyName, attributes, offset, slot.context());

1298

1299 validateOffset(offset);

     ASSERT(structure->isValidOffset(offset));

1301 setStructureAndReallocateStorageIfNecessary(vm, structure);

1302

     putDirect(vm, offset, value);

     slot.setNewProperty(this, offset);

1305 if (attributes & ReadOnly)

1306 structure->setContainsReadOnlyProperties();

1307 return true;

1308 }

1309

 inline void JSObject::setStructureAndReallocateStorageIfNecessary(VM& vm, unsigned oldCapacity, Structure* newStructure)

1311 {

     ASSERT(oldCapacity <= newStructure->outOfLineCapacity());

1313

     if (oldCapacity == newStructure->outOfLineCapacity()) {

1315 setStructure(vm, newStructure);

1316 return;

1317 }

1318

1319 DeferGC deferGC(vm.heap);

1320 Butterfly* newButterfly = growOutOfLineStorage(

         vm, oldCapacity, newStructure->outOfLineCapacity());

     setStructureAndButterfly(vm, newStructure, newButterfly);

1323 }

1324

 inline void JSObject::setStructureAndReallocateStorageIfNecessary(VM& vm, Structure* newStructure)

1326 {

1327 setStructureAndReallocateStorageIfNecessary(

         vm, structure(vm)->outOfLineCapacity(), newStructure);

1329 }

1330

 inline bool JSObject::putOwnDataProperty(VM& vm, PropertyName propertyName, JSValue value, PutPropertySlot& slot)

1332 {

1333 ASSERT(value);

     ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));

     ASSERT(!structure()->hasGetterSetterProperties());

     ASSERT(!structure()->hasCustomGetterSetterProperties());

1337

     return putDirectInternal<PutModePut>(vm, propertyName, value, 0, slot);

1339 }

1340

 inline void JSObject::putDirect(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes)

1342 {

     ASSERT(!value.isGetterSetter() && !(attributes & Accessor));

     ASSERT(!value.isCustomGetterSetter());

1345 PutPropertySlot slot(this);

     putDirectInternal<PutModeDefineOwnProperty>(vm, propertyName, value, attributes, slot);

1347 }

1348

 inline void JSObject::putDirect(VM& vm, PropertyName propertyName, JSValue value, PutPropertySlot& slot)

1350 {

     ASSERT(!value.isGetterSetter());

     ASSERT(!value.isCustomGetterSetter());

     putDirectInternal<PutModeDefineOwnProperty>(vm, propertyName, value, 0, slot);

1354 }

1355

 inline void JSObject::putDirectWithoutTransition(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes)

1357 {

1358 DeferGC deferGC(vm.heap);

     ASSERT(!value.isGetterSetter() && !(attributes & Accessor));

     ASSERT(!value.isCustomGetterSetter());

     Butterfly* newButterfly = m_butterfly.get();

     if (structure()->putWillGrowOutOfLineStorage())

         newButterfly = growOutOfLineStorage(vm, structure()->outOfLineCapacity(), structure()->suggestedNewOutOfLineStorageCapacity());

     PropertyOffset offset = structure()->addPropertyWithoutTransition(vm, propertyName, attributes);

     setStructureAndButterfly(vm, structure(), newButterfly);

     putDirect(vm, offset, value);

1367 }

1368

 inline JSValue JSObject::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const

1370 {

     return methodTable()->defaultValue(this, exec, preferredType);

1372 }

1373

 ALWAYS_INLINE JSObject* Register::object() const

1375 {

     return asObject(jsValue());

1377 }

1378

 ALWAYS_INLINE Register& Register::operator=(JSObject* object)

1380 {

     u.value = JSValue::encode(JSValue(object));

1382 return *this;

1383 }

1384

 inline size_t offsetInButterfly(PropertyOffset offset)

1386 {

     return offsetInOutOfLineStorage(offset) + Butterfly::indexOfPropertyStorage();

1388 }

1389

 inline size_t JSObject::butterflyPreCapacity()

1391 {

     if (UNLIKELY(hasIndexingHeader()))

         return butterfly()->indexingHeader()->preCapacity(structure());

1394 return 0;

1395 }

1396

 inline size_t JSObject::butterflyTotalSize()

1398 {

     Structure* structure = this->structure();

     Butterfly* butterfly = this->butterfly();

1401 size_t preCapacity;

1402 size_t indexingPayloadSizeInBytes;

     bool hasIndexingHeader = this->hasIndexingHeader();

1404

     if (UNLIKELY(hasIndexingHeader)) {

         preCapacity = butterfly->indexingHeader()->preCapacity(structure);

         indexingPayloadSizeInBytes = butterfly->indexingHeader()->indexingPayloadSizeInBytes(structure);

1408 } else {

1409 preCapacity = 0;

1410 indexingPayloadSizeInBytes = 0;

1411 }

1412

     return Butterfly::totalSize(preCapacity, structure->outOfLineCapacity(), hasIndexingHeader, indexingPayloadSizeInBytes);

1414 }

1415

1416 // Helpers for patching code where you want to emit a load or store and

1417 // the base is:

1418 // For inline offsets: a pointer to the out-of-line storage pointer.

1419 // For out-of-line offsets: the base of the out-of-line storage.

 inline size_t offsetRelativeToPatchedStorage(PropertyOffset offset)

1421 {

     if (isOutOfLineOffset(offset))

         return sizeof(EncodedJSValue) * offsetInButterfly(offset);

     return JSObject::offsetOfInlineStorage() - JSObject::butterflyOffset() + sizeof(EncodedJSValue) * offsetInInlineStorage(offset);

1425 }

1426

1427 // Returns the maximum offset (away from zero) a load instruction will encode.

 inline size_t maxOffsetRelativeToPatchedStorage(PropertyOffset offset)

1429 {

     ptrdiff_t addressOffset = static_cast<ptrdiff_t>(offsetRelativeToPatchedStorage(offset));

1431 #if USE(JSVALUE32_64)

     if (addressOffset >= 0)

         return static_cast<size_t>(addressOffset) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag);

1434 #endif

     return static_cast<size_t>(addressOffset);

1436 }

1437

 inline int indexRelativeToBase(PropertyOffset offset)

1439 {

     if (isOutOfLineOffset(offset))

         return offsetInOutOfLineStorage(offset) + Butterfly::indexOfPropertyStorage();

     ASSERT(!(JSObject::offsetOfInlineStorage() % sizeof(EncodedJSValue)));

     return JSObject::offsetOfInlineStorage() / sizeof(EncodedJSValue) + offsetInInlineStorage(offset);

1444 }

1445

 inline int offsetRelativeToBase(PropertyOffset offset)

1447 {

     if (isOutOfLineOffset(offset))

         return offsetInOutOfLineStorage(offset) * sizeof(EncodedJSValue) + Butterfly::offsetOfPropertyStorage();

     return JSObject::offsetOfInlineStorage() + offsetInInlineStorage(offset) * sizeof(EncodedJSValue);

1451 }

1452

 COMPILE_ASSERT(!(sizeof(JSObject) % sizeof(WriteBarrierBase<Unknown>)), JSObject_inline_storage_has_correct_alignment);

1454

 ALWAYS_INLINE Identifier makeIdentifier(VM& vm, const char* name)

1456 {

     return Identifier::fromString(&vm, name);

1458 }

1459

 ALWAYS_INLINE Identifier makeIdentifier(VM&, const Identifier& name)

1461 {

1462 return name;

1463 }

1464

1465 // Helper for defining native functions, if you're not using a static hash table.

1466 // Use this macro from within finishCreation() methods in prototypes. This assumes

1467 // you've defined variables called exec, globalObject, and vm, and they

1468 // have the expected meanings.

1469 #define JSC_NATIVE_INTRINSIC_FUNCTION(jsName, cppName, attributes, length, intrinsic) \

1470 putDirectNativeFunction(\

1471 vm, globalObject, makeIdentifier(vm, (jsName)), (length), cppName, \

1472 (intrinsic), (attributes))

1473

1474 // As above, but this assumes that the function you're defining doesn't have an

1475 // intrinsic.

1476 #define JSC_NATIVE_FUNCTION(jsName, cppName, attributes, length) \

1477 JSC_NATIVE_INTRINSIC_FUNCTION(jsName, cppName, (attributes), (length), NoIntrinsic)

1478

1479 // Identical helpers but for builtins. Note that currently, we don't support builtins that are

1480 // also intrinsics, but we probably will do that eventually.

1481 #define JSC_BUILTIN_FUNCTION(jsName, generatorName, attributes) \

1482 putDirectBuiltinFunction(\

1483 vm, globalObject, makeIdentifier(vm, (jsName)), (generatorName)(vm), (attributes))

1484

1485 } // namespace JSC

1486

1487 #endif // JSObject_h