LCOV - code coverage report
Current view: top level - src - objects-inl.h (source / functions) Hit Total Coverage
Test: app.info Lines: 2282 2394 95.3 %
Date: 2017-04-26 Functions: 750 838 89.5 %

          Line data    Source code
       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : //
       5             : // Review notes:
       6             : //
       7             : // - The use of macros in these inline functions may seem superfluous
       8             : // but it is absolutely needed to make sure gcc generates optimal
       9             : // code. gcc is not happy when attempting to inline too deep.
      10             : //
      11             : 
      12             : #ifndef V8_OBJECTS_INL_H_
      13             : #define V8_OBJECTS_INL_H_
      14             : 
      15             : #include "src/base/atomicops.h"
      16             : #include "src/base/bits.h"
      17             : #include "src/builtins/builtins.h"
      18             : #include "src/contexts-inl.h"
      19             : #include "src/conversions-inl.h"
      20             : #include "src/factory.h"
      21             : #include "src/feedback-vector-inl.h"
      22             : #include "src/field-index-inl.h"
      23             : #include "src/field-type.h"
      24             : #include "src/handles-inl.h"
      25             : #include "src/heap/heap-inl.h"
      26             : #include "src/heap/heap.h"
      27             : #include "src/isolate-inl.h"
      28             : #include "src/isolate.h"
      29             : #include "src/keys.h"
      30             : #include "src/layout-descriptor-inl.h"
      31             : #include "src/lookup-cache-inl.h"
      32             : #include "src/lookup.h"
      33             : #include "src/objects.h"
      34             : #include "src/objects/literal-objects.h"
      35             : #include "src/objects/module-info.h"
      36             : #include "src/objects/regexp-match-info.h"
      37             : #include "src/objects/scope-info.h"
      38             : #include "src/property.h"
      39             : #include "src/prototype.h"
      40             : #include "src/transitions-inl.h"
      41             : #include "src/v8memory.h"
      42             : 
      43             : // Has to be the last include (doesn't have include guards):
      44             : #include "src/objects/object-macros.h"
      45             : 
      46             : namespace v8 {
      47             : namespace internal {
      48             : 
      49           0 : PropertyDetails::PropertyDetails(Smi* smi) {
      50  3155947257 :   value_ = smi->value();
      51           0 : }
      52             : 
      53             : 
      54     5376023 : Smi* PropertyDetails::AsSmi() const {
      55             :   // Ensure the upper 2 bits have the same value by sign extending it. This is
      56             :   // necessary to be able to use the 31st bit of the property details.
      57   479332596 :   int value = value_ << 1;
      58   484708619 :   return Smi::FromInt(value >> 1);
      59             : }
      60             : 
      61             : 
      62       24292 : int PropertyDetails::field_width_in_words() const {
      63             :   DCHECK(location() == kField);
      64             :   if (!FLAG_unbox_double_fields) return 1;
      65             :   if (kDoubleSize == kPointerSize) return 1;
      66             :   return representation().IsDouble() ? kDoubleSize / kPointerSize : 1;
      67             : }
      68             : 
      69             : #define INT_ACCESSORS(holder, name, offset)                                   \
      70             :   int holder::name() const { return READ_INT_FIELD(this, offset); }           \
      71             :   void holder::set_##name(int value) { WRITE_INT_FIELD(this, offset, value); }
      72             : 
      73             : #define ACCESSORS_CHECKED2(holder, name, type, offset, get_condition, \
      74             :                            set_condition)                             \
      75             :   type* holder::name() const {                                        \
      76             :     DCHECK(get_condition);                                            \
      77             :     return type::cast(READ_FIELD(this, offset));                      \
      78             :   }                                                                   \
      79             :   void holder::set_##name(type* value, WriteBarrierMode mode) {       \
      80             :     DCHECK(set_condition);                                            \
      81             :     WRITE_FIELD(this, offset, value);                                 \
      82             :     CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode);  \
      83             :   }
      84             : #define ACCESSORS_CHECKED(holder, name, type, offset, condition) \
      85             :   ACCESSORS_CHECKED2(holder, name, type, offset, condition, condition)
      86             : 
      87             : #define ACCESSORS(holder, name, type, offset) \
      88             :   ACCESSORS_CHECKED(holder, name, type, offset, true)
      89             : 
      90             : // Getter that returns a Smi as an int and writes an int as a Smi.
      91             : #define SMI_ACCESSORS_CHECKED(holder, name, offset, condition) \
      92             :   int holder::name() const {                                   \
      93             :     DCHECK(condition);                                         \
      94             :     Object* value = READ_FIELD(this, offset);                  \
      95             :     return Smi::cast(value)->value();                          \
      96             :   }                                                            \
      97             :   void holder::set_##name(int value) {                         \
      98             :     DCHECK(condition);                                         \
      99             :     WRITE_FIELD(this, offset, Smi::FromInt(value));            \
     100             :   }
     101             : 
     102             : #define SMI_ACCESSORS(holder, name, offset) \
     103             :   SMI_ACCESSORS_CHECKED(holder, name, offset, true)
     104             : 
     105             : #define SYNCHRONIZED_SMI_ACCESSORS(holder, name, offset)    \
     106             :   int holder::synchronized_##name() const {                 \
     107             :     Object* value = ACQUIRE_READ_FIELD(this, offset);       \
     108             :     return Smi::cast(value)->value();                       \
     109             :   }                                                         \
     110             :   void holder::synchronized_set_##name(int value) {         \
     111             :     RELEASE_WRITE_FIELD(this, offset, Smi::FromInt(value)); \
     112             :   }
     113             : 
     114             : #define NOBARRIER_SMI_ACCESSORS(holder, name, offset)          \
     115             :   int holder::nobarrier_##name() const {                       \
     116             :     Object* value = NOBARRIER_READ_FIELD(this, offset);        \
     117             :     return Smi::cast(value)->value();                          \
     118             :   }                                                            \
     119             :   void holder::nobarrier_set_##name(int value) {               \
     120             :     NOBARRIER_WRITE_FIELD(this, offset, Smi::FromInt(value));  \
     121             :   }
     122             : 
     123             : #define BOOL_GETTER(holder, field, name, offset)           \
     124             :   bool holder::name() const {                              \
     125             :     return BooleanBit::get(field(), offset);               \
     126             :   }                                                        \
     127             : 
     128             : 
     129             : #define BOOL_ACCESSORS(holder, field, name, offset)        \
     130             :   bool holder::name() const {                              \
     131             :     return BooleanBit::get(field(), offset);               \
     132             :   }                                                        \
     133             :   void holder::set_##name(bool value) {                    \
     134             :     set_##field(BooleanBit::set(field(), offset, value));  \
     135             :   }
     136             : 
     137             : #define TYPE_CHECKER(type, instancetype)           \
     138             :   bool HeapObject::Is##type() const {              \
     139             :     return map()->instance_type() == instancetype; \
     140             :   }
     141             : 
     142        2010 : TYPE_CHECKER(BreakPointInfo, TUPLE2_TYPE)
     143    36808999 : TYPE_CHECKER(ByteArray, BYTE_ARRAY_TYPE)
     144    54655371 : TYPE_CHECKER(BytecodeArray, BYTECODE_ARRAY_TYPE)
     145      256140 : TYPE_CHECKER(CallHandlerInfo, TUPLE2_TYPE)
     146    17643174 : TYPE_CHECKER(Cell, CELL_TYPE)
     147  1492753715 : TYPE_CHECKER(Code, CODE_TYPE)
     148     1925922 : TYPE_CHECKER(ConstantElementsPair, TUPLE2_TYPE)
     149     2089235 : TYPE_CHECKER(FixedDoubleArray, FIXED_DOUBLE_ARRAY_TYPE)
     150       54140 : TYPE_CHECKER(Foreign, FOREIGN_TYPE)
     151      303534 : TYPE_CHECKER(FreeSpace, FREE_SPACE_TYPE)
     152   399290019 : TYPE_CHECKER(HeapNumber, HEAP_NUMBER_TYPE)
     153      414785 : TYPE_CHECKER(JSArgumentsObject, JS_ARGUMENTS_TYPE)
     154   381637936 : TYPE_CHECKER(JSArray, JS_ARRAY_TYPE)
     155     3783273 : TYPE_CHECKER(JSArrayBuffer, JS_ARRAY_BUFFER_TYPE)
     156    26853956 : TYPE_CHECKER(JSAsyncGeneratorObject, JS_ASYNC_GENERATOR_OBJECT_TYPE)
     157     7243491 : TYPE_CHECKER(JSBoundFunction, JS_BOUND_FUNCTION_TYPE)
     158     5805651 : TYPE_CHECKER(JSContextExtensionObject, JS_CONTEXT_EXTENSION_OBJECT_TYPE)
     159      205269 : TYPE_CHECKER(JSDataView, JS_DATA_VIEW_TYPE)
     160     1361614 : TYPE_CHECKER(JSDate, JS_DATE_TYPE)
     161    10171091 : TYPE_CHECKER(JSError, JS_ERROR_TYPE)
     162   498931743 : TYPE_CHECKER(JSFunction, JS_FUNCTION_TYPE)
     163   357894061 : TYPE_CHECKER(JSGlobalObject, JS_GLOBAL_OBJECT_TYPE)
     164     1851229 : TYPE_CHECKER(JSMap, JS_MAP_TYPE)
     165    10392549 : TYPE_CHECKER(JSMapIterator, JS_MAP_ITERATOR_TYPE)
     166             : TYPE_CHECKER(JSMessageObject, JS_MESSAGE_OBJECT_TYPE)
     167             : TYPE_CHECKER(JSModuleNamespace, JS_MODULE_NAMESPACE_TYPE)
     168             : TYPE_CHECKER(JSPromiseCapability, JS_PROMISE_CAPABILITY_TYPE)
     169    10633626 : TYPE_CHECKER(JSPromise, JS_PROMISE_TYPE)
     170    17749199 : TYPE_CHECKER(JSRegExp, JS_REGEXP_TYPE)
     171     1734562 : TYPE_CHECKER(JSSet, JS_SET_TYPE)
     172    10395224 : TYPE_CHECKER(JSSetIterator, JS_SET_ITERATOR_TYPE)
     173             : TYPE_CHECKER(JSAsyncFromSyncIterator, JS_ASYNC_FROM_SYNC_ITERATOR_TYPE)
     174             : TYPE_CHECKER(JSStringIterator, JS_STRING_ITERATOR_TYPE)
     175   567626685 : TYPE_CHECKER(JSTypedArray, JS_TYPED_ARRAY_TYPE)
     176     6678541 : TYPE_CHECKER(JSValue, JS_VALUE_TYPE)
     177      736901 : TYPE_CHECKER(JSWeakMap, JS_WEAK_MAP_TYPE)
     178      667923 : TYPE_CHECKER(JSWeakSet, JS_WEAK_SET_TYPE)
     179   774990240 : TYPE_CHECKER(Map, MAP_TYPE)
     180      201320 : TYPE_CHECKER(MutableHeapNumber, MUTABLE_HEAP_NUMBER_TYPE)
     181   100664959 : TYPE_CHECKER(Oddball, ODDBALL_TYPE)
     182    13653924 : TYPE_CHECKER(PropertyCell, PROPERTY_CELL_TYPE)
     183    84441701 : TYPE_CHECKER(SharedFunctionInfo, SHARED_FUNCTION_INFO_TYPE)
     184       56561 : TYPE_CHECKER(SourcePositionTableWithFrameCache, TUPLE2_TYPE)
     185   495119109 : TYPE_CHECKER(Symbol, SYMBOL_TYPE)
     186    30787465 : TYPE_CHECKER(TransitionArray, TRANSITION_ARRAY_TYPE)
     187      925741 : TYPE_CHECKER(TypeFeedbackInfo, TUPLE3_TYPE)
     188   182965056 : TYPE_CHECKER(WeakCell, WEAK_CELL_TYPE)
     189    13697892 : TYPE_CHECKER(WeakFixedArray, FIXED_ARRAY_TYPE)
     190             : 
     191             : #define TYPED_ARRAY_TYPE_CHECKER(Type, type, TYPE, ctype, size) \
     192             :   TYPE_CHECKER(Fixed##Type##Array, FIXED_##TYPE##_ARRAY_TYPE)
     193             : TYPED_ARRAYS(TYPED_ARRAY_TYPE_CHECKER)
     194             : #undef TYPED_ARRAY_TYPE_CHECKER
     195             : 
     196             : #undef TYPE_CHECKER
     197             : 
     198             : bool HeapObject::IsFixedArrayBase() const {
     199             :   return IsFixedArray() || IsFixedDoubleArray() || IsFixedTypedArrayBase();
     200             : }
     201             : 
     202             : bool HeapObject::IsFixedArray() const {
     203   105566131 :   InstanceType instance_type = map()->instance_type();
     204    87126646 :   return instance_type == FIXED_ARRAY_TYPE ||
     205        9260 :          instance_type == TRANSITION_ARRAY_TYPE;
     206             : }
     207             : 
     208             : bool HeapObject::IsSloppyArgumentsElements() const { return IsFixedArray(); }
     209             : 
     210             : bool HeapObject::IsJSSloppyArgumentsObject() const {
     211             :   return IsJSArgumentsObject();
     212             : }
     213             : 
     214             : bool HeapObject::IsJSGeneratorObject() const {
     215    53935050 :   return map()->instance_type() == JS_GENERATOR_OBJECT_TYPE ||
     216             :          IsJSAsyncGeneratorObject();
     217             : }
     218             : 
     219             : bool HeapObject::IsBoilerplateDescription() const { return IsFixedArray(); }
     220             : 
     221             : // External objects are not extensible, so the map check is enough.
     222             : bool HeapObject::IsExternal() const {
     223           6 :   return map() == GetHeap()->external_map();
     224             : }
     225             : 
     226             : #define IS_TYPE_FUNCTION_DEF(type_)                               \
     227             :   bool Object::Is##type_() const {                                \
     228             :     return IsHeapObject() && HeapObject::cast(this)->Is##type_(); \
     229             :   }
     230  8745258574 : HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DEF)
     231             : #undef IS_TYPE_FUNCTION_DEF
     232             : 
     233             : #define IS_TYPE_FUNCTION_DEF(Type, Value)             \
     234             :   bool Object::Is##Type(Isolate* isolate) const {     \
     235             :     return this == isolate->heap()->Value();          \
     236             :   }                                                   \
     237             :   bool HeapObject::Is##Type(Isolate* isolate) const { \
     238             :     return this == isolate->heap()->Value();          \
     239             :   }
     240  2388900449 : ODDBALL_LIST(IS_TYPE_FUNCTION_DEF)
     241             : #undef IS_TYPE_FUNCTION_DEF
     242             : 
     243             : bool Object::IsNullOrUndefined(Isolate* isolate) const {
     244   146369441 :   Heap* heap = isolate->heap();
     245   146383789 :   return this == heap->null_value() || this == heap->undefined_value();
     246             : }
     247             : 
     248             : bool HeapObject::IsNullOrUndefined(Isolate* isolate) const {
     249             :   Heap* heap = isolate->heap();
     250             :   return this == heap->null_value() || this == heap->undefined_value();
     251             : }
     252             : 
     253             : bool HeapObject::IsString() const {
     254  1854387899 :   return map()->instance_type() < FIRST_NONSTRING_TYPE;
     255             : }
     256             : 
     257             : bool HeapObject::IsName() const {
     258   221732305 :   return map()->instance_type() <= LAST_NAME_TYPE;
     259             : }
     260             : 
     261             : bool HeapObject::IsUniqueName() const {
     262     3686694 :   return IsInternalizedString() || IsSymbol();
     263             : }
     264             : 
     265      317969 : bool Name::IsUniqueName() const {
     266             :   uint32_t type = map()->instance_type();
     267   391052587 :   return (type & (kIsNotStringMask | kIsNotInternalizedMask)) !=
     268      317969 :          (kStringTag | kNotInternalizedTag);
     269             : }
     270             : 
     271             : bool HeapObject::IsFunction() const {
     272             :   STATIC_ASSERT(LAST_FUNCTION_TYPE == LAST_TYPE);
     273    66778071 :   return map()->instance_type() >= FIRST_FUNCTION_TYPE;
     274             : }
     275             : 
     276    26152841 : bool HeapObject::IsCallable() const { return map()->is_callable(); }
     277             : 
     278      167294 : bool HeapObject::IsConstructor() const { return map()->is_constructor(); }
     279             : 
     280             : bool HeapObject::IsTemplateInfo() const {
     281     1108362 :   return IsObjectTemplateInfo() || IsFunctionTemplateInfo();
     282             : }
     283             : 
     284             : bool HeapObject::IsInternalizedString() const {
     285   276708392 :   uint32_t type = map()->instance_type();
     286             :   STATIC_ASSERT(kNotInternalizedTag != 0);
     287   276708391 :   return (type & (kIsNotStringMask | kIsNotInternalizedMask)) ==
     288         956 :       (kStringTag | kInternalizedTag);
     289             : }
     290             : 
     291             : bool HeapObject::IsConsString() const {
     292   120232343 :   if (!IsString()) return false;
     293   119963302 :   return StringShape(String::cast(this)).IsCons();
     294             : }
     295             : 
     296             : bool HeapObject::IsThinString() const {
     297   318912019 :   if (!IsString()) return false;
     298   318912020 :   return StringShape(String::cast(this)).IsThin();
     299             : }
     300             : 
     301             : bool HeapObject::IsSlicedString() const {
     302    18415929 :   if (!IsString()) return false;
     303    18415929 :   return StringShape(String::cast(this)).IsSliced();
     304             : }
     305             : 
     306             : bool HeapObject::IsSeqString() const {
     307         301 :   if (!IsString()) return false;
     308         301 :   return StringShape(String::cast(this)).IsSequential();
     309             : }
     310             : 
     311             : bool HeapObject::IsSeqOneByteString() const {
     312   121848066 :   if (!IsString()) return false;
     313   235318159 :   return StringShape(String::cast(this)).IsSequential() &&
     314   113470095 :          String::cast(this)->IsOneByteRepresentation();
     315             : }
     316             : 
     317             : bool HeapObject::IsSeqTwoByteString() const {
     318      110317 :   if (!IsString()) return false;
     319      220449 :   return StringShape(String::cast(this)).IsSequential() &&
     320      110132 :          String::cast(this)->IsTwoByteRepresentation();
     321             : }
     322             : 
     323             : bool HeapObject::IsExternalString() const {
     324    26036428 :   if (!IsString()) return false;
     325    24593956 :   return StringShape(String::cast(this)).IsExternal();
     326             : }
     327             : 
     328             : bool HeapObject::IsExternalOneByteString() const {
     329   563474787 :   if (!IsString()) return false;
     330    84704563 :   return StringShape(String::cast(this)).IsExternal() &&
     331     1435381 :          String::cast(this)->IsOneByteRepresentation();
     332             : }
     333             : 
     334             : bool HeapObject::IsExternalTwoByteString() const {
     335     5267563 :   if (!IsString()) return false;
     336     5267657 :   return StringShape(String::cast(this)).IsExternal() &&
     337          95 :          String::cast(this)->IsTwoByteRepresentation();
     338             : }
     339             : 
     340   509871775 : bool Object::IsNumber() const { return IsSmi() || IsHeapNumber(); }
     341             : 
     342             : bool HeapObject::IsFiller() const {
     343   545617233 :   InstanceType instance_type = map()->instance_type();
     344   545617233 :   return instance_type == FREE_SPACE_TYPE || instance_type == FILLER_TYPE;
     345             : }
     346             : 
     347             : bool HeapObject::IsFixedTypedArrayBase() const {
     348    18131340 :   InstanceType instance_type = map()->instance_type();
     349    18131342 :   return (instance_type >= FIRST_FIXED_TYPED_ARRAY_TYPE &&
     350             :           instance_type <= LAST_FIXED_TYPED_ARRAY_TYPE);
     351             : }
     352             : 
     353             : bool HeapObject::IsJSReceiver() const {
     354             :   STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
     355   393912414 :   return map()->instance_type() >= FIRST_JS_RECEIVER_TYPE;
     356             : }
     357             : 
     358             : bool HeapObject::IsJSObject() const {
     359             :   STATIC_ASSERT(LAST_JS_OBJECT_TYPE == LAST_TYPE);
     360   413327166 :   return map()->IsJSObjectMap();
     361             : }
     362             : 
     363   108997282 : bool HeapObject::IsJSProxy() const { return map()->IsJSProxyMap(); }
     364             : 
     365             : bool HeapObject::IsJSArrayIterator() const {
     366             :   InstanceType instance_type = map()->instance_type();
     367             :   return (instance_type >= FIRST_ARRAY_ITERATOR_TYPE &&
     368             :           instance_type <= LAST_ARRAY_ITERATOR_TYPE);
     369             : }
     370             : 
     371             : bool HeapObject::IsJSWeakCollection() const {
     372      411218 :   return IsJSWeakMap() || IsJSWeakSet();
     373             : }
     374             : 
     375           0 : bool HeapObject::IsJSCollection() const { return IsJSMap() || IsJSSet(); }
     376             : 
     377             : bool HeapObject::IsDescriptorArray() const { return IsFixedArray(); }
     378             : 
     379             : bool HeapObject::IsFrameArray() const { return IsFixedArray(); }
     380             : 
     381             : bool HeapObject::IsArrayList() const { return IsFixedArray(); }
     382             : 
     383             : bool HeapObject::IsRegExpMatchInfo() const { return IsFixedArray(); }
     384             : 
     385             : bool Object::IsLayoutDescriptor() const {
     386             :   return IsSmi() || IsFixedTypedArrayBase();
     387             : }
     388             : 
     389             : bool HeapObject::IsFeedbackVector() const {
     390    17731163 :   return map() == GetHeap()->feedback_vector_map();
     391             : }
     392             : 
     393             : bool HeapObject::IsFeedbackMetadata() const { return IsFixedArray(); }
     394             : 
     395             : bool HeapObject::IsDeoptimizationInputData() const {
     396             :   // Must be a fixed array.
     397             :   if (!IsFixedArray()) return false;
     398             : 
     399             :   // There's no sure way to detect the difference between a fixed array and
     400             :   // a deoptimization data array.  Since this is used for asserts we can
     401             :   // check that the length is zero or else the fixed size plus a multiple of
     402             :   // the entry size.
     403             :   int length = FixedArray::cast(this)->length();
     404             :   if (length == 0) return true;
     405             : 
     406             :   length -= DeoptimizationInputData::kFirstDeoptEntryIndex;
     407             :   return length >= 0 && length % DeoptimizationInputData::kDeoptEntrySize == 0;
     408             : }
     409             : 
     410             : bool HeapObject::IsDeoptimizationOutputData() const {
     411             :   if (!IsFixedArray()) return false;
     412             :   // There's actually no way to see the difference between a fixed array and
     413             :   // a deoptimization data array.  Since this is used for asserts we can check
     414             :   // that the length is plausible though.
     415             :   if (FixedArray::cast(this)->length() % 2 != 0) return false;
     416             :   return true;
     417             : }
     418             : 
     419             : bool HeapObject::IsHandlerTable() const {
     420             :   if (!IsFixedArray()) return false;
     421             :   // There's actually no way to see the difference between a fixed array and
     422             :   // a handler table array.
     423             :   return true;
     424             : }
     425             : 
     426             : bool HeapObject::IsTemplateList() const {
     427             :   if (!IsFixedArray()) return false;
     428             :   // There's actually no way to see the difference between a fixed array and
     429             :   // a template list.
     430             :   if (FixedArray::cast(this)->length() < 1) return false;
     431             :   return true;
     432             : }
     433             : 
     434             : bool HeapObject::IsDependentCode() const {
     435     1050332 :   if (!IsFixedArray()) return false;
     436             :   // There's actually no way to see the difference between a fixed array and
     437             :   // a dependent codes array.
     438             :   return true;
     439             : }
     440             : 
     441             : bool HeapObject::IsContext() const {
     442    47818623 :   Map* map = this->map();
     443    47818624 :   Heap* heap = GetHeap();
     444             :   return (
     445   117837909 :       map == heap->function_context_map() || map == heap->catch_context_map() ||
     446    81784430 :       map == heap->with_context_map() || map == heap->native_context_map() ||
     447    35036482 :       map == heap->block_context_map() || map == heap->module_context_map() ||
     448    82238931 :       map == heap->eval_context_map() || map == heap->script_context_map() ||
     449    11194752 :       map == heap->debug_evaluate_context_map());
     450             : }
     451             : 
     452             : bool HeapObject::IsNativeContext() const {
     453     3134528 :   return map() == GetHeap()->native_context_map();
     454             : }
     455             : 
     456             : bool HeapObject::IsScriptContextTable() const {
     457             :   return map() == GetHeap()->script_context_table_map();
     458             : }
     459             : 
     460             : bool HeapObject::IsScopeInfo() const {
     461     2151237 :   return map() == GetHeap()->scope_info_map();
     462             : }
     463             : 
     464             : bool HeapObject::IsModuleInfo() const {
     465        7405 :   return map() == GetHeap()->module_info_map();
     466             : }
     467             : 
     468             : template <>
     469             : inline bool Is<JSFunction>(Object* obj) {
     470             :   return obj->IsJSFunction();
     471             : }
     472             : 
     473             : bool HeapObject::IsAbstractCode() const {
     474    88243955 :   return IsBytecodeArray() || IsCode();
     475             : }
     476             : 
     477             : bool HeapObject::IsStringWrapper() const {
     478     4672952 :   return IsJSValue() && JSValue::cast(this)->value()->IsString();
     479             : }
     480             : 
     481             : bool HeapObject::IsBoolean() const {
     482    73691882 :   return IsOddball() &&
     483    17935570 :          ((Oddball::cast(this)->kind() & Oddball::kNotBooleanMask) == 0);
     484             : }
     485             : 
     486             : bool HeapObject::IsJSArrayBufferView() const {
     487      364934 :   return IsJSDataView() || IsJSTypedArray();
     488             : }
     489             : 
     490             : template <>
     491             : inline bool Is<JSArray>(Object* obj) {
     492             :   return obj->IsJSArray();
     493             : }
     494             : 
     495             : bool HeapObject::IsHashTable() const {
     496   300700319 :   return map() == GetHeap()->hash_table_map();
     497             : }
     498             : 
     499             : bool HeapObject::IsWeakHashTable() const { return IsHashTable(); }
     500             : 
     501             : bool HeapObject::IsDictionary() const {
     502   300631147 :   return IsHashTable() && this != GetHeap()->string_table();
     503             : }
     504             : 
     505             : bool Object::IsNameDictionary() const { return IsDictionary(); }
     506             : 
     507             : bool Object::IsGlobalDictionary() const { return IsDictionary(); }
     508             : 
     509             : bool Object::IsSeededNumberDictionary() const { return IsDictionary(); }
     510             : 
     511             : bool HeapObject::IsUnseededNumberDictionary() const {
     512       41117 :   return map() == GetHeap()->unseeded_number_dictionary_map();
     513             : }
     514             : 
     515             : bool HeapObject::IsStringTable() const { return IsHashTable(); }
     516             : 
     517             : bool HeapObject::IsStringSet() const { return IsHashTable(); }
     518             : 
     519             : bool HeapObject::IsObjectHashSet() const { return IsHashTable(); }
     520             : 
     521             : bool HeapObject::IsNormalizedMapCache() const {
     522             :   return NormalizedMapCache::IsNormalizedMapCache(this);
     523             : }
     524             : 
     525             : int NormalizedMapCache::GetIndex(Handle<Map> map) {
     526     1413271 :   return map->Hash() % NormalizedMapCache::kEntries;
     527             : }
     528             : 
     529             : bool NormalizedMapCache::IsNormalizedMapCache(const HeapObject* obj) {
     530             :   if (!obj->IsFixedArray()) return false;
     531             :   if (FixedArray::cast(obj)->length() != NormalizedMapCache::kEntries) {
     532             :     return false;
     533             :   }
     534             : #ifdef VERIFY_HEAP
     535             :   if (FLAG_verify_heap) {
     536             :     reinterpret_cast<NormalizedMapCache*>(const_cast<HeapObject*>(obj))
     537             :         ->NormalizedMapCacheVerify();
     538             :   }
     539             : #endif
     540             :   return true;
     541             : }
     542             : 
     543             : bool HeapObject::IsCompilationCacheTable() const { return IsHashTable(); }
     544             : 
     545             : bool HeapObject::IsCodeCacheHashTable() const { return IsHashTable(); }
     546             : 
     547             : bool HeapObject::IsMapCache() const { return IsHashTable(); }
     548             : 
     549             : bool HeapObject::IsObjectHashTable() const { return IsHashTable(); }
     550             : 
     551             : bool HeapObject::IsOrderedHashTable() const {
     552             :   return map() == GetHeap()->ordered_hash_table_map();
     553             : }
     554             : 
     555             : bool Object::IsOrderedHashSet() const { return IsOrderedHashTable(); }
     556             : 
     557             : bool Object::IsOrderedHashMap() const { return IsOrderedHashTable(); }
     558             : 
     559             : bool Object::IsPrimitive() const {
     560    15483296 :   return IsSmi() || HeapObject::cast(this)->map()->IsPrimitiveMap();
     561             : }
     562             : 
     563             : bool HeapObject::IsJSGlobalProxy() const {
     564   259758238 :   bool result = map()->instance_type() == JS_GLOBAL_PROXY_TYPE;
     565             :   DCHECK(!result || map()->is_access_check_needed());
     566             :   return result;
     567             : }
     568             : 
     569     4720176 : bool HeapObject::IsUndetectable() const { return map()->is_undetectable(); }
     570             : 
     571             : bool HeapObject::IsAccessCheckNeeded() const {
     572    65796405 :   if (IsJSGlobalProxy()) {
     573             :     const JSGlobalProxy* proxy = JSGlobalProxy::cast(this);
     574      130716 :     JSGlobalObject* global = proxy->GetIsolate()->context()->global_object();
     575      130716 :     return proxy->IsDetachedFrom(global);
     576             :   }
     577    65665689 :   return map()->is_access_check_needed();
     578             : }
     579             : 
     580             : bool HeapObject::IsStruct() const {
     581             :   switch (map()->instance_type()) {
     582             : #define MAKE_STRUCT_CASE(NAME, Name, name) \
     583             :   case NAME##_TYPE:                        \
     584             :     return true;
     585             :     STRUCT_LIST(MAKE_STRUCT_CASE)
     586             : #undef MAKE_STRUCT_CASE
     587             :     default:
     588             :       return false;
     589             :   }
     590             : }
     591             : 
     592             : #define MAKE_STRUCT_PREDICATE(NAME, Name, name)                  \
     593             :   bool Object::Is##Name() const {                                \
     594             :     return IsHeapObject() && HeapObject::cast(this)->Is##Name(); \
     595             :   }                                                              \
     596             :   bool HeapObject::Is##Name() const {                            \
     597             :     return map()->instance_type() == NAME##_TYPE;                \
     598             :   }
     599  1521245107 : STRUCT_LIST(MAKE_STRUCT_PREDICATE)
     600             : #undef MAKE_STRUCT_PREDICATE
     601             : 
     602     2126394 : double Object::Number() const {
     603             :   DCHECK(IsNumber());
     604             :   return IsSmi()
     605             :              ? static_cast<double>(reinterpret_cast<const Smi*>(this)->value())
     606   448893954 :              : reinterpret_cast<const HeapNumber*>(this)->value();
     607             : }
     608             : 
     609             : bool Object::IsNaN() const {
     610        9314 :   return this->IsHeapNumber() && std::isnan(HeapNumber::cast(this)->value());
     611             : }
     612             : 
     613             : bool Object::IsMinusZero() const {
     614        9012 :   return this->IsHeapNumber() &&
     615        4273 :          i::IsMinusZero(HeapNumber::cast(this)->value());
     616             : }
     617             : 
     618             : // ------------------------------------
     619             : // Cast operations
     620             : 
     621             : CAST_ACCESSOR(AbstractCode)
     622             : CAST_ACCESSOR(ArrayList)
     623             : CAST_ACCESSOR(BoilerplateDescription)
     624             : CAST_ACCESSOR(BreakPointInfo)
     625             : CAST_ACCESSOR(ByteArray)
     626             : CAST_ACCESSOR(BytecodeArray)
     627             : CAST_ACCESSOR(CallHandlerInfo)
     628             : CAST_ACCESSOR(Cell)
     629             : CAST_ACCESSOR(Code)
     630             : CAST_ACCESSOR(ConsString)
     631             : CAST_ACCESSOR(ConstantElementsPair)
     632             : CAST_ACCESSOR(DeoptimizationInputData)
     633             : CAST_ACCESSOR(DeoptimizationOutputData)
     634             : CAST_ACCESSOR(DependentCode)
     635             : CAST_ACCESSOR(DescriptorArray)
     636             : CAST_ACCESSOR(ExternalOneByteString)
     637             : CAST_ACCESSOR(ExternalString)
     638             : CAST_ACCESSOR(ExternalTwoByteString)
     639             : CAST_ACCESSOR(FixedArray)
     640             : CAST_ACCESSOR(FixedArrayBase)
     641             : CAST_ACCESSOR(FixedDoubleArray)
     642             : CAST_ACCESSOR(FixedTypedArrayBase)
     643             : CAST_ACCESSOR(Foreign)
     644             : CAST_ACCESSOR(GlobalDictionary)
     645             : CAST_ACCESSOR(HandlerTable)
     646             : CAST_ACCESSOR(HeapObject)
     647             : CAST_ACCESSOR(JSArgumentsObject);
     648             : CAST_ACCESSOR(JSArray)
     649             : CAST_ACCESSOR(JSArrayBuffer)
     650             : CAST_ACCESSOR(JSArrayBufferView)
     651             : CAST_ACCESSOR(JSBoundFunction)
     652             : CAST_ACCESSOR(JSDataView)
     653             : CAST_ACCESSOR(JSDate)
     654             : CAST_ACCESSOR(JSFunction)
     655             : CAST_ACCESSOR(JSGeneratorObject)
     656             : CAST_ACCESSOR(JSAsyncGeneratorObject)
     657             : CAST_ACCESSOR(JSGlobalObject)
     658             : CAST_ACCESSOR(JSGlobalProxy)
     659             : CAST_ACCESSOR(JSMap)
     660             : CAST_ACCESSOR(JSMapIterator)
     661             : CAST_ACCESSOR(JSMessageObject)
     662             : CAST_ACCESSOR(JSModuleNamespace)
     663             : CAST_ACCESSOR(JSObject)
     664             : CAST_ACCESSOR(JSProxy)
     665             : CAST_ACCESSOR(JSReceiver)
     666             : CAST_ACCESSOR(JSRegExp)
     667             : CAST_ACCESSOR(JSPromiseCapability)
     668             : CAST_ACCESSOR(JSPromise)
     669             : CAST_ACCESSOR(JSSet)
     670             : CAST_ACCESSOR(JSSetIterator)
     671             : CAST_ACCESSOR(JSSloppyArgumentsObject)
     672             : CAST_ACCESSOR(JSAsyncFromSyncIterator)
     673             : CAST_ACCESSOR(JSStringIterator)
     674             : CAST_ACCESSOR(JSArrayIterator)
     675             : CAST_ACCESSOR(JSTypedArray)
     676             : CAST_ACCESSOR(JSValue)
     677             : CAST_ACCESSOR(JSWeakCollection)
     678             : CAST_ACCESSOR(JSWeakMap)
     679             : CAST_ACCESSOR(JSWeakSet)
     680             : CAST_ACCESSOR(LayoutDescriptor)
     681             : CAST_ACCESSOR(Map)
     682             : CAST_ACCESSOR(ModuleInfo)
     683             : CAST_ACCESSOR(Name)
     684             : CAST_ACCESSOR(NameDictionary)
     685             : CAST_ACCESSOR(NormalizedMapCache)
     686             : CAST_ACCESSOR(Object)
     687             : CAST_ACCESSOR(ObjectHashTable)
     688             : CAST_ACCESSOR(ObjectHashSet)
     689             : CAST_ACCESSOR(Oddball)
     690             : CAST_ACCESSOR(OrderedHashMap)
     691             : CAST_ACCESSOR(OrderedHashSet)
     692             : CAST_ACCESSOR(PropertyCell)
     693             : CAST_ACCESSOR(TemplateList)
     694             : CAST_ACCESSOR(RegExpMatchInfo)
     695             : CAST_ACCESSOR(ScopeInfo)
     696             : CAST_ACCESSOR(SeededNumberDictionary)
     697             : CAST_ACCESSOR(SeqOneByteString)
     698             : CAST_ACCESSOR(SeqString)
     699             : CAST_ACCESSOR(SeqTwoByteString)
     700             : CAST_ACCESSOR(SharedFunctionInfo)
     701             : CAST_ACCESSOR(SourcePositionTableWithFrameCache)
     702             : CAST_ACCESSOR(SlicedString)
     703             : CAST_ACCESSOR(SloppyArgumentsElements)
     704             : CAST_ACCESSOR(Smi)
     705             : CAST_ACCESSOR(String)
     706             : CAST_ACCESSOR(StringSet)
     707             : CAST_ACCESSOR(StringTable)
     708             : CAST_ACCESSOR(Struct)
     709             : CAST_ACCESSOR(Symbol)
     710             : CAST_ACCESSOR(TemplateInfo)
     711             : CAST_ACCESSOR(ThinString)
     712             : CAST_ACCESSOR(TypeFeedbackInfo)
     713             : CAST_ACCESSOR(UnseededNumberDictionary)
     714             : CAST_ACCESSOR(WeakCell)
     715             : CAST_ACCESSOR(WeakFixedArray)
     716             : CAST_ACCESSOR(WeakHashTable)
     717             : 
     718             : #define MAKE_STRUCT_CAST(NAME, Name, name) CAST_ACCESSOR(Name)
     719             : STRUCT_LIST(MAKE_STRUCT_CAST)
     720             : #undef MAKE_STRUCT_CAST
     721             : 
     722             : #undef CAST_ACCESSOR
     723             : 
     724             : bool Object::HasValidElements() {
     725             :   // Dictionary is covered under FixedArray.
     726             :   return IsFixedArray() || IsFixedDoubleArray() || IsFixedTypedArrayBase();
     727             : }
     728             : 
     729             : bool Object::KeyEquals(Object* second) {
     730             :   Object* first = this;
     731             :   if (second->IsNumber()) {
     732             :     if (first->IsNumber()) return first->Number() == second->Number();
     733             :     Object* temp = first;
     734             :     first = second;
     735             :     second = temp;
     736             :   }
     737             :   if (first->IsNumber()) {
     738             :     DCHECK_LE(0, first->Number());
     739             :     uint32_t expected = static_cast<uint32_t>(first->Number());
     740             :     uint32_t index;
     741             :     return Name::cast(second)->AsArrayIndex(&index) && index == expected;
     742             :   }
     743             :   return Name::cast(first)->Equals(Name::cast(second));
     744             : }
     745             : 
     746    18292697 : bool Object::FilterKey(PropertyFilter filter) {
     747    18292697 :   if (IsSymbol()) {
     748      117093 :     if (filter & SKIP_SYMBOLS) return true;
     749       38964 :     if (Symbol::cast(this)->is_private()) return true;
     750             :   } else {
     751    18175604 :     if (filter & SKIP_STRINGS) return true;
     752             :   }
     753    14776368 :   return false;
     754             : }
     755             : 
     756    15780871 : Handle<Object> Object::NewStorageFor(Isolate* isolate, Handle<Object> object,
     757             :                                      Representation representation) {
     758    15780871 :   if (!representation.IsDouble()) return object;
     759        2849 :   Handle<HeapNumber> result = isolate->factory()->NewHeapNumber(MUTABLE);
     760        2849 :   if (object->IsUninitialized(isolate)) {
     761             :     result->set_value_as_bits(kHoleNanInt64);
     762        1819 :   } else if (object->IsMutableHeapNumber()) {
     763             :     // Ensure that all bits of the double value are preserved.
     764             :     result->set_value_as_bits(HeapNumber::cast(*object)->value_as_bits());
     765             :   } else {
     766             :     result->set_value(object->Number());
     767             :   }
     768        2849 :   return result;
     769             : }
     770             : 
     771    58148416 : Handle<Object> Object::WrapForRead(Isolate* isolate, Handle<Object> object,
     772             :                                    Representation representation) {
     773             :   DCHECK(!object->IsUninitialized(isolate));
     774    58148416 :   if (!representation.IsDouble()) {
     775             :     DCHECK(object->FitsRepresentation(representation));
     776    58138789 :     return object;
     777             :   }
     778        9627 :   return isolate->factory()->NewHeapNumber(HeapNumber::cast(*object)->value());
     779             : }
     780             : 
     781  1404264801 : StringShape::StringShape(const String* str)
     782  1404264801 :     : type_(str->map()->instance_type()) {
     783             :   set_valid();
     784             :   DCHECK((type_ & kIsNotStringMask) == kStringTag);
     785  1404264801 : }
     786             : 
     787             : StringShape::StringShape(Map* map) : type_(map->instance_type()) {
     788             :   set_valid();
     789             :   DCHECK((type_ & kIsNotStringMask) == kStringTag);
     790             : }
     791             : 
     792             : StringShape::StringShape(InstanceType t) : type_(static_cast<uint32_t>(t)) {
     793             :   set_valid();
     794             :   DCHECK((type_ & kIsNotStringMask) == kStringTag);
     795             : }
     796             : 
     797             : bool StringShape::IsInternalized() {
     798             :   DCHECK(valid());
     799             :   STATIC_ASSERT(kNotInternalizedTag != 0);
     800        8520 :   return (type_ & (kIsNotStringMask | kIsNotInternalizedMask)) ==
     801             :          (kStringTag | kInternalizedTag);
     802             : }
     803             : 
     804   114913639 : bool String::IsOneByteRepresentation() const {
     805             :   uint32_t type = map()->instance_type();
     806   259153545 :   return (type & kStringEncodingMask) == kOneByteStringTag;
     807             : }
     808             : 
     809      110227 : bool String::IsTwoByteRepresentation() const {
     810             :   uint32_t type = map()->instance_type();
     811      110255 :   return (type & kStringEncodingMask) == kTwoByteStringTag;
     812             : }
     813             : 
     814     6863007 : bool String::IsOneByteRepresentationUnderneath() {
     815             :   uint32_t type = map()->instance_type();
     816             :   STATIC_ASSERT(kIsIndirectStringTag != 0);
     817             :   STATIC_ASSERT((kIsIndirectStringMask & kStringEncodingMask) == 0);
     818             :   DCHECK(IsFlat());
     819     6863007 :   switch (type & (kIsIndirectStringMask | kStringEncodingMask)) {
     820             :     case kOneByteStringTag:
     821             :       return true;
     822             :     case kTwoByteStringTag:
     823     2579033 :       return false;
     824             :     default:  // Cons or sliced string.  Need to go deeper.
     825        2821 :       return GetUnderlying()->IsOneByteRepresentation();
     826             :   }
     827             : }
     828             : 
     829             : bool String::IsTwoByteRepresentationUnderneath() {
     830             :   uint32_t type = map()->instance_type();
     831             :   STATIC_ASSERT(kIsIndirectStringTag != 0);
     832             :   STATIC_ASSERT((kIsIndirectStringMask & kStringEncodingMask) == 0);
     833             :   DCHECK(IsFlat());
     834             :   switch (type & (kIsIndirectStringMask | kStringEncodingMask)) {
     835             :     case kOneByteStringTag:
     836             :       return false;
     837             :     case kTwoByteStringTag:
     838             :       return true;
     839             :     default:  // Cons or sliced string.  Need to go deeper.
     840             :       return GetUnderlying()->IsTwoByteRepresentation();
     841             :   }
     842             : }
     843             : 
     844    19309490 : bool String::HasOnlyOneByteChars() {
     845             :   uint32_t type = map()->instance_type();
     846    38618795 :   return (type & kOneByteDataHintMask) == kOneByteDataHintTag ||
     847    19309490 :          IsOneByteRepresentation();
     848             : }
     849             : 
     850             : bool StringShape::HasOnlyOneByteChars() {
     851       25653 :   return (type_ & kStringEncodingMask) == kOneByteStringTag ||
     852       25653 :          (type_ & kOneByteDataHintMask) == kOneByteDataHintTag;
     853             : }
     854             : 
     855   119963302 : bool StringShape::IsCons() {
     856   170327289 :   return (type_ & kStringRepresentationMask) == kConsStringTag;
     857             : }
     858             : 
     859   318912011 : bool StringShape::IsThin() {
     860   319612391 :   return (type_ & kStringRepresentationMask) == kThinStringTag;
     861             : }
     862             : 
     863    18415929 : bool StringShape::IsSliced() {
     864    19116309 :   return (type_ & kStringRepresentationMask) == kSlicedStringTag;
     865             : }
     866             : 
     867             : bool StringShape::IsIndirect() {
     868         926 :   return (type_ & kIsIndirectStringMask) == kIsIndirectStringTag;
     869             : }
     870             : 
     871   113130699 : bool StringShape::IsExternal() {
     872   113223545 :   return (type_ & kStringRepresentationMask) == kExternalStringTag;
     873             : }
     874             : 
     875   121958684 : bool StringShape::IsSequential() {
     876   121958684 :   return (type_ & kStringRepresentationMask) == kSeqStringTag;
     877             : }
     878             : 
     879             : StringRepresentationTag StringShape::representation_tag() {
     880   377546368 :   uint32_t tag = (type_ & kStringRepresentationMask);
     881             :   return static_cast<StringRepresentationTag>(tag);
     882             : }
     883             : 
     884   125899846 : uint32_t StringShape::encoding_tag() { return type_ & kStringEncodingMask; }
     885             : 
     886   711884275 : uint32_t StringShape::full_representation_tag() {
     887  1084356816 :   return (type_ & (kStringRepresentationMask | kStringEncodingMask));
     888             : }
     889             : 
     890             : STATIC_ASSERT((kStringRepresentationMask | kStringEncodingMask) ==
     891             :               Internals::kFullStringRepresentationMask);
     892             : 
     893             : STATIC_ASSERT(static_cast<uint32_t>(kStringEncodingMask) ==
     894             :               Internals::kStringEncodingMask);
     895             : 
     896             : bool StringShape::IsSequentialOneByte() {
     897             :   return full_representation_tag() == (kSeqStringTag | kOneByteStringTag);
     898             : }
     899             : 
     900             : bool StringShape::IsSequentialTwoByte() {
     901             :   return full_representation_tag() == (kSeqStringTag | kTwoByteStringTag);
     902             : }
     903             : 
     904             : bool StringShape::IsExternalOneByte() {
     905         116 :   return full_representation_tag() == (kExternalStringTag | kOneByteStringTag);
     906             : }
     907             : 
     908             : STATIC_ASSERT((kExternalStringTag | kOneByteStringTag) ==
     909             :               Internals::kExternalOneByteRepresentationTag);
     910             : 
     911             : STATIC_ASSERT(v8::String::ONE_BYTE_ENCODING == kOneByteStringTag);
     912             : 
     913             : bool StringShape::IsExternalTwoByte() {
     914         164 :   return full_representation_tag() == (kExternalStringTag | kTwoByteStringTag);
     915             : }
     916             : 
     917             : STATIC_ASSERT((kExternalStringTag | kTwoByteStringTag) ==
     918             :               Internals::kExternalTwoByteRepresentationTag);
     919             : 
     920             : STATIC_ASSERT(v8::String::TWO_BYTE_ENCODING == kTwoByteStringTag);
     921             : 
     922    15603730 : uc32 FlatStringReader::Get(int index) {
     923    15603730 :   if (is_one_byte_) {
     924    14739778 :     return Get<uint8_t>(index);
     925             :   } else {
     926      863952 :     return Get<uc16>(index);
     927             :   }
     928             : }
     929             : 
     930             : template <typename Char>
     931    38301209 : Char FlatStringReader::Get(int index) {
     932             :   DCHECK_EQ(is_one_byte_, sizeof(Char) == 1);
     933             :   DCHECK(0 <= index && index <= length_);
     934             :   if (sizeof(Char) == 1) {
     935    53023851 :     return static_cast<Char>(static_cast<const uint8_t*>(start_)[index]);
     936             :   } else {
     937      881088 :     return static_cast<Char>(static_cast<const uc16*>(start_)[index]);
     938             :   }
     939             : }
     940             : 
     941             : Handle<Object> StringTableShape::AsHandle(Isolate* isolate, HashTableKey* key) {
     942             :   return key->AsHandle(isolate);
     943             : }
     944             : 
     945             : template <typename Char>
     946           0 : class SequentialStringKey : public HashTableKey {
     947             :  public:
     948             :   explicit SequentialStringKey(Vector<const Char> string, uint32_t seed)
     949      206164 :       : string_(string), hash_field_(0), seed_(seed) {}
     950             : 
     951      261937 :   uint32_t Hash() override {
     952      261937 :     hash_field_ = StringHasher::HashSequentialString<Char>(
     953      261937 :         string_.start(), string_.length(), seed_);
     954             : 
     955      261937 :     uint32_t result = hash_field_ >> String::kHashShift;
     956             :     DCHECK(result != 0);  // Ensure that the hash value of 0 is never computed.
     957      261937 :     return result;
     958             :   }
     959             : 
     960      435600 :   uint32_t HashForObject(Object* other) override {
     961      435600 :     return String::cast(other)->Hash();
     962             :   }
     963             : 
     964             :   Vector<const Char> string_;
     965             :   uint32_t hash_field_;
     966             :   uint32_t seed_;
     967             : };
     968             : 
     969           0 : class OneByteStringKey : public SequentialStringKey<uint8_t> {
     970             :  public:
     971             :   OneByteStringKey(Vector<const uint8_t> str, uint32_t seed)
     972      206164 :       : SequentialStringKey<uint8_t>(str, seed) {}
     973             : 
     974      400281 :   bool IsMatch(Object* string) override {
     975      400281 :     return String::cast(string)->IsOneByteEqualTo(string_);
     976             :   }
     977             : 
     978             :   Handle<Object> AsHandle(Isolate* isolate) override;
     979             : };
     980             : 
     981           0 : class SeqOneByteSubStringKey : public HashTableKey {
     982             :  public:
     983             :   SeqOneByteSubStringKey(Handle<SeqOneByteString> string, int from, int length)
     984      115049 :       : string_(string), from_(from), length_(length) {
     985             :     DCHECK(string_->IsSeqOneByteString());
     986             :   }
     987             : 
     988             : // VS 2017 on official builds gives this spurious warning:
     989             : // warning C4789: buffer 'key' of size 16 bytes will be overrun; 4 bytes will
     990             : // be written starting at offset 16
     991             : // https://bugs.chromium.org/p/v8/issues/detail?id=6068
     992             : #if defined(V8_CC_MSVC)
     993             : #pragma warning(push)
     994             : #pragma warning(disable : 4789)
     995             : #endif
     996      230098 :   uint32_t Hash() override {
     997             :     DCHECK(length_ >= 0);
     998             :     DCHECK(from_ + length_ <= string_->length());
     999      230098 :     const uint8_t* chars = string_->GetChars() + from_;
    1000             :     hash_field_ = StringHasher::HashSequentialString(
    1001      230098 :         chars, length_, string_->GetHeap()->HashSeed());
    1002      230098 :     uint32_t result = hash_field_ >> String::kHashShift;
    1003             :     DCHECK(result != 0);  // Ensure that the hash value of 0 is never computed.
    1004      230098 :     return result;
    1005             :   }
    1006             : #if defined(V8_CC_MSVC)
    1007             : #pragma warning(pop)
    1008             : #endif
    1009             : 
    1010       62703 :   uint32_t HashForObject(Object* other) override {
    1011       62703 :     return String::cast(other)->Hash();
    1012             :   }
    1013             : 
    1014             :   bool IsMatch(Object* string) override;
    1015             :   Handle<Object> AsHandle(Isolate* isolate) override;
    1016             : 
    1017             :  private:
    1018             :   Handle<SeqOneByteString> string_;
    1019             :   int from_;
    1020             :   int length_;
    1021             :   uint32_t hash_field_;
    1022             : };
    1023             : 
    1024           0 : class TwoByteStringKey : public SequentialStringKey<uc16> {
    1025             :  public:
    1026             :   explicit TwoByteStringKey(Vector<const uc16> str, uint32_t seed)
    1027           0 :       : SequentialStringKey<uc16>(str, seed) {}
    1028             : 
    1029           0 :   bool IsMatch(Object* string) override {
    1030           0 :     return String::cast(string)->IsTwoByteEqualTo(string_);
    1031             :   }
    1032             : 
    1033             :   Handle<Object> AsHandle(Isolate* isolate) override;
    1034             : };
    1035             : 
    1036             : // Utf8StringKey carries a vector of chars as key.
    1037           0 : class Utf8StringKey : public HashTableKey {
    1038             :  public:
    1039             :   explicit Utf8StringKey(Vector<const char> string, uint32_t seed)
    1040    24522791 :       : string_(string), hash_field_(0), seed_(seed) {}
    1041             : 
    1042    57783168 :   bool IsMatch(Object* string) override {
    1043    57783168 :     return String::cast(string)->IsUtf8EqualTo(string_);
    1044             :   }
    1045             : 
    1046    24691642 :   uint32_t Hash() override {
    1047    24691642 :     if (hash_field_ != 0) return hash_field_ >> String::kHashShift;
    1048    24522791 :     hash_field_ = StringHasher::ComputeUtf8Hash(string_, seed_, &chars_);
    1049    24522789 :     uint32_t result = hash_field_ >> String::kHashShift;
    1050             :     DCHECK(result != 0);  // Ensure that the hash value of 0 is never computed.
    1051    24522789 :     return result;
    1052             :   }
    1053             : 
    1054       56401 :   uint32_t HashForObject(Object* other) override {
    1055       56401 :     return String::cast(other)->Hash();
    1056             :   }
    1057             : 
    1058      168851 :   Handle<Object> AsHandle(Isolate* isolate) override {
    1059      168851 :     if (hash_field_ == 0) Hash();
    1060             :     return isolate->factory()->NewInternalizedStringFromUtf8(string_, chars_,
    1061      168851 :                                                              hash_field_);
    1062             :   }
    1063             : 
    1064             :   Vector<const char> string_;
    1065             :   uint32_t hash_field_;
    1066             :   int chars_;  // Caches the number of characters when computing the hash code.
    1067             :   uint32_t seed_;
    1068             : };
    1069             : 
    1070    18511529 : Representation Object::OptimalRepresentation() {
    1071    18511529 :   if (!FLAG_track_fields) return Representation::Tagged();
    1072    18511529 :   if (IsSmi()) {
    1073             :     return Representation::Smi();
    1074    27441497 :   } else if (FLAG_track_double_fields && IsHeapNumber()) {
    1075             :     return Representation::Double();
    1076    27435436 :   } else if (FLAG_track_computed_fields &&
    1077             :              IsUninitialized(HeapObject::cast(this)->GetIsolate())) {
    1078             :     return Representation::None();
    1079    13277637 :   } else if (FLAG_track_heap_object_fields) {
    1080             :     DCHECK(IsHeapObject());
    1081             :     return Representation::HeapObject();
    1082             :   } else {
    1083             :     return Representation::Tagged();
    1084             :   }
    1085             : }
    1086             : 
    1087             : 
    1088    15233959 : ElementsKind Object::OptimalElementsKind() {
    1089    15233959 :   if (IsSmi()) return FAST_SMI_ELEMENTS;
    1090     3558656 :   if (IsNumber()) return FAST_DOUBLE_ELEMENTS;
    1091     1269899 :   return FAST_ELEMENTS;
    1092             : }
    1093             : 
    1094             : 
    1095    67630556 : bool Object::FitsRepresentation(Representation representation) {
    1096    67630556 :   if (FLAG_track_fields && representation.IsSmi()) {
    1097     6783629 :     return IsSmi();
    1098    60846927 :   } else if (FLAG_track_double_fields && representation.IsDouble()) {
    1099      120016 :     return IsMutableHeapNumber() || IsNumber();
    1100    60786919 :   } else if (FLAG_track_heap_object_fields && representation.IsHeapObject()) {
    1101    56319440 :     return IsHeapObject();
    1102     4467479 :   } else if (FLAG_track_fields && representation.IsNone()) {
    1103             :     return false;
    1104             :   }
    1105     4062543 :   return true;
    1106             : }
    1107             : 
    1108   147403590 : bool Object::ToUint32(uint32_t* value) {
    1109   147403590 :   if (IsSmi()) {
    1110             :     int num = Smi::cast(this)->value();
    1111    47649636 :     if (num < 0) return false;
    1112    47584912 :     *value = static_cast<uint32_t>(num);
    1113    47584912 :     return true;
    1114             :   }
    1115    99753955 :   if (IsHeapNumber()) {
    1116             :     double num = HeapNumber::cast(this)->value();
    1117       87792 :     return DoubleToUint32IfEqualToSelf(num, value);
    1118             :   }
    1119             :   return false;
    1120             : }
    1121             : 
    1122             : // static
    1123    14370959 : MaybeHandle<JSReceiver> Object::ToObject(Isolate* isolate,
    1124             :                                          Handle<Object> object,
    1125             :                                          const char* method_name) {
    1126    14370959 :   if (object->IsJSReceiver()) return Handle<JSReceiver>::cast(object);
    1127        9181 :   return ToObject(isolate, object, isolate->native_context(), method_name);
    1128             : }
    1129             : 
    1130             : 
    1131             : // static
    1132    92268675 : MaybeHandle<Name> Object::ToName(Isolate* isolate, Handle<Object> input) {
    1133    92268674 :   if (input->IsName()) return Handle<Name>::cast(input);
    1134     4574502 :   return ConvertToName(isolate, input);
    1135             : }
    1136             : 
    1137             : // static
    1138      337341 : MaybeHandle<Object> Object::ToPropertyKey(Isolate* isolate,
    1139             :                                           Handle<Object> value) {
    1140      592941 :   if (value->IsSmi() || HeapObject::cast(*value)->IsName()) return value;
    1141         744 :   return ConvertToPropertyKey(isolate, value);
    1142             : }
    1143             : 
    1144             : // static
    1145     5143633 : MaybeHandle<Object> Object::ToPrimitive(Handle<Object> input,
    1146             :                                         ToPrimitiveHint hint) {
    1147     5143633 :   if (input->IsPrimitive()) return input;
    1148     4513791 :   return JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(input), hint);
    1149             : }
    1150             : 
    1151             : // static
    1152    20517910 : MaybeHandle<Object> Object::ToNumber(Handle<Object> input) {
    1153    20517910 :   if (input->IsNumber()) return input;
    1154     2890892 :   return ConvertToNumber(HeapObject::cast(*input)->GetIsolate(), input);
    1155             : }
    1156             : 
    1157             : // static
    1158       11216 : MaybeHandle<Object> Object::ToInteger(Isolate* isolate, Handle<Object> input) {
    1159    17339574 :   if (input->IsSmi()) return input;
    1160       29747 :   return ConvertToInteger(isolate, input);
    1161             : }
    1162             : 
    1163             : // static
    1164             : MaybeHandle<Object> Object::ToInt32(Isolate* isolate, Handle<Object> input) {
    1165       10635 :   if (input->IsSmi()) return input;
    1166        1232 :   return ConvertToInt32(isolate, input);
    1167             : }
    1168             : 
    1169             : // static
    1170      533162 : MaybeHandle<Object> Object::ToUint32(Isolate* isolate, Handle<Object> input) {
    1171      533162 :   if (input->IsSmi()) return handle(Smi::cast(*input)->ToUint32Smi(), isolate);
    1172      533104 :   return ConvertToUint32(isolate, input);
    1173             : }
    1174             : 
    1175             : // static
    1176    29682983 : MaybeHandle<String> Object::ToString(Isolate* isolate, Handle<Object> input) {
    1177    29682983 :   if (input->IsString()) return Handle<String>::cast(input);
    1178     8539968 :   return ConvertToString(isolate, input);
    1179             : }
    1180             : 
    1181             : // static
    1182       72668 : MaybeHandle<Object> Object::ToLength(Isolate* isolate, Handle<Object> input) {
    1183       72668 :   if (input->IsSmi()) {
    1184      214830 :     int value = std::max(Smi::cast(*input)->value(), 0);
    1185             :     return handle(Smi::FromInt(value), isolate);
    1186             :   }
    1187        1058 :   return ConvertToLength(isolate, input);
    1188             : }
    1189             : 
    1190             : // static
    1191       24570 : MaybeHandle<Object> Object::ToIndex(Isolate* isolate, Handle<Object> input,
    1192             :                                     MessageTemplate::Template error_index) {
    1193       44537 :   if (input->IsSmi() && Smi::cast(*input)->value() >= 0) return input;
    1194        5303 :   return ConvertToIndex(isolate, input, error_index);
    1195             : }
    1196             : 
    1197    61270978 : bool Object::HasSpecificClassOf(String* name) {
    1198    61270978 :   return this->IsJSObject() && (JSObject::cast(this)->class_name() == name);
    1199             : }
    1200             : 
    1201     1731166 : MaybeHandle<Object> Object::GetProperty(Handle<Object> object,
    1202             :                                         Handle<Name> name) {
    1203     1731166 :   LookupIterator it(object, name);
    1204     1731166 :   if (!it.IsFound()) return it.factory()->undefined_value();
    1205     1574254 :   return GetProperty(&it);
    1206             : }
    1207             : 
    1208    39946317 : MaybeHandle<Object> JSReceiver::GetProperty(Handle<JSReceiver> receiver,
    1209             :                                             Handle<Name> name) {
    1210    39946317 :   LookupIterator it(receiver, name, receiver);
    1211    39946318 :   if (!it.IsFound()) return it.factory()->undefined_value();
    1212    23169480 :   return Object::GetProperty(&it);
    1213             : }
    1214             : 
    1215        3656 : MaybeHandle<Object> Object::GetElement(Isolate* isolate, Handle<Object> object,
    1216             :                                        uint32_t index) {
    1217        3656 :   LookupIterator it(isolate, object, index);
    1218        3656 :   if (!it.IsFound()) return it.factory()->undefined_value();
    1219        3626 :   return GetProperty(&it);
    1220             : }
    1221             : 
    1222   150446481 : MaybeHandle<Object> JSReceiver::GetElement(Isolate* isolate,
    1223             :                                            Handle<JSReceiver> receiver,
    1224             :                                            uint32_t index) {
    1225             :   LookupIterator it(isolate, receiver, index, receiver);
    1226   150446481 :   if (!it.IsFound()) return it.factory()->undefined_value();
    1227    72334441 :   return Object::GetProperty(&it);
    1228             : }
    1229             : 
    1230     8350945 : Handle<Object> JSReceiver::GetDataProperty(Handle<JSReceiver> object,
    1231             :                                            Handle<Name> name) {
    1232             :   LookupIterator it(object, name, object,
    1233     8350945 :                     LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
    1234    13519827 :   if (!it.IsFound()) return it.factory()->undefined_value();
    1235     3182063 :   return GetDataProperty(&it);
    1236             : }
    1237             : 
    1238      292728 : MaybeHandle<Object> Object::SetElement(Isolate* isolate, Handle<Object> object,
    1239             :                                        uint32_t index, Handle<Object> value,
    1240             :                                        LanguageMode language_mode) {
    1241      292728 :   LookupIterator it(isolate, object, index);
    1242      292728 :   MAYBE_RETURN_NULL(
    1243             :       SetProperty(&it, value, language_mode, MAY_BE_STORE_FROM_KEYED));
    1244             :   return value;
    1245             : }
    1246             : 
    1247     5040576 : MaybeHandle<Object> JSReceiver::GetPrototype(Isolate* isolate,
    1248             :                                              Handle<JSReceiver> receiver) {
    1249             :   // We don't expect access checks to be needed on JSProxy objects.
    1250             :   DCHECK(!receiver->IsAccessCheckNeeded() || receiver->IsJSObject());
    1251             :   PrototypeIterator iter(isolate, receiver, kStartAtReceiver,
    1252     5040576 :                          PrototypeIterator::END_AT_NON_HIDDEN);
    1253     5072017 :   do {
    1254     5072073 :     if (!iter.AdvanceFollowingProxies()) return MaybeHandle<Object>();
    1255     5072017 :   } while (!iter.IsAtEnd());
    1256             :   return PrototypeIterator::GetCurrent(iter);
    1257             : }
    1258             : 
    1259      201835 : MaybeHandle<Object> JSReceiver::GetProperty(Isolate* isolate,
    1260             :                                             Handle<JSReceiver> receiver,
    1261             :                                             const char* name) {
    1262      201835 :   Handle<String> str = isolate->factory()->InternalizeUtf8String(name);
    1263      201835 :   return GetProperty(receiver, str);
    1264             : }
    1265             : 
    1266             : // static
    1267        1529 : MUST_USE_RESULT MaybeHandle<FixedArray> JSReceiver::OwnPropertyKeys(
    1268             :     Handle<JSReceiver> object) {
    1269             :   return KeyAccumulator::GetKeys(object, KeyCollectionMode::kOwnOnly,
    1270             :                                  ALL_PROPERTIES,
    1271        3832 :                                  GetKeysConversion::kConvertToString);
    1272             : }
    1273             : 
    1274     2359753 : bool JSObject::PrototypeHasNoElements(Isolate* isolate, JSObject* object) {
    1275             :   DisallowHeapAllocation no_gc;
    1276             :   HeapObject* prototype = HeapObject::cast(object->map()->prototype());
    1277     2359753 :   HeapObject* null = isolate->heap()->null_value();
    1278     2359753 :   HeapObject* empty = isolate->heap()->empty_fixed_array();
    1279     9398657 :   while (prototype != null) {
    1280             :     Map* map = prototype->map();
    1281     4700041 :     if (map->instance_type() <= LAST_CUSTOM_ELEMENTS_RECEIVER) return false;
    1282     4696385 :     if (JSObject::cast(prototype)->elements() != empty) return false;
    1283             :     prototype = HeapObject::cast(map->prototype());
    1284             :   }
    1285             :   return true;
    1286             : }
    1287             : 
    1288             : #define ACQUIRE_READ_FIELD(p, offset)           \
    1289             :   reinterpret_cast<Object*>(base::Acquire_Load( \
    1290             :       reinterpret_cast<const base::AtomicWord*>(FIELD_ADDR_CONST(p, offset))))
    1291             : 
    1292             : #define NOBARRIER_READ_FIELD(p, offset)           \
    1293             :   reinterpret_cast<Object*>(base::NoBarrier_Load( \
    1294             :       reinterpret_cast<const base::AtomicWord*>(FIELD_ADDR_CONST(p, offset))))
    1295             : 
    1296             : #define RELEASE_WRITE_FIELD(p, offset, value)                     \
    1297             :   base::Release_Store(                                            \
    1298             :       reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \
    1299             :       reinterpret_cast<base::AtomicWord>(value));
    1300             : 
    1301             : #define NOBARRIER_WRITE_FIELD(p, offset, value)                   \
    1302             :   base::NoBarrier_Store(                                          \
    1303             :       reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \
    1304             :       reinterpret_cast<base::AtomicWord>(value));
    1305             : 
    1306             : #define WRITE_BARRIER(heap, object, offset, value)          \
    1307             :   heap->incremental_marking()->RecordWrite(                 \
    1308             :       object, HeapObject::RawField(object, offset), value); \
    1309             :   heap->RecordWrite(object, offset, value);
    1310             : 
    1311             : #define FIXED_ARRAY_ELEMENTS_WRITE_BARRIER(heap, array, start, length) \
    1312             :   do {                                                                 \
    1313             :     heap->RecordFixedArrayElements(array, start, length);              \
    1314             :     heap->incremental_marking()->IterateBlackObject(array);            \
    1315             :   } while (false)
    1316             : 
    1317             : #define CONDITIONAL_WRITE_BARRIER(heap, object, offset, value, mode) \
    1318             :   if (mode != SKIP_WRITE_BARRIER) {                                  \
    1319             :     if (mode == UPDATE_WRITE_BARRIER) {                              \
    1320             :       heap->incremental_marking()->RecordWrite(                      \
    1321             :           object, HeapObject::RawField(object, offset), value);      \
    1322             :     }                                                                \
    1323             :     heap->RecordWrite(object, offset, value);                        \
    1324             :   }
    1325             : 
    1326             : #define READ_DOUBLE_FIELD(p, offset) \
    1327             :   ReadDoubleValue(FIELD_ADDR_CONST(p, offset))
    1328             : 
    1329             : #define WRITE_DOUBLE_FIELD(p, offset, value) \
    1330             :   WriteDoubleValue(FIELD_ADDR(p, offset), value)
    1331             : 
    1332             : #define READ_INT_FIELD(p, offset) \
    1333             :   (*reinterpret_cast<const int*>(FIELD_ADDR_CONST(p, offset)))
    1334             : 
    1335             : #define WRITE_INT_FIELD(p, offset, value) \
    1336             :   (*reinterpret_cast<int*>(FIELD_ADDR(p, offset)) = value)
    1337             : 
    1338             : #define READ_INTPTR_FIELD(p, offset) \
    1339             :   (*reinterpret_cast<const intptr_t*>(FIELD_ADDR_CONST(p, offset)))
    1340             : 
    1341             : #define WRITE_INTPTR_FIELD(p, offset, value) \
    1342             :   (*reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset)) = value)
    1343             : 
    1344             : #define READ_UINT8_FIELD(p, offset) \
    1345             :   (*reinterpret_cast<const uint8_t*>(FIELD_ADDR_CONST(p, offset)))
    1346             : 
    1347             : #define WRITE_UINT8_FIELD(p, offset, value) \
    1348             :   (*reinterpret_cast<uint8_t*>(FIELD_ADDR(p, offset)) = value)
    1349             : 
    1350             : #define READ_INT8_FIELD(p, offset) \
    1351             :   (*reinterpret_cast<const int8_t*>(FIELD_ADDR_CONST(p, offset)))
    1352             : 
    1353             : #define WRITE_INT8_FIELD(p, offset, value) \
    1354             :   (*reinterpret_cast<int8_t*>(FIELD_ADDR(p, offset)) = value)
    1355             : 
    1356             : #define READ_UINT16_FIELD(p, offset) \
    1357             :   (*reinterpret_cast<const uint16_t*>(FIELD_ADDR_CONST(p, offset)))
    1358             : 
    1359             : #define WRITE_UINT16_FIELD(p, offset, value) \
    1360             :   (*reinterpret_cast<uint16_t*>(FIELD_ADDR(p, offset)) = value)
    1361             : 
    1362             : #define READ_INT16_FIELD(p, offset) \
    1363             :   (*reinterpret_cast<const int16_t*>(FIELD_ADDR_CONST(p, offset)))
    1364             : 
    1365             : #define WRITE_INT16_FIELD(p, offset, value) \
    1366             :   (*reinterpret_cast<int16_t*>(FIELD_ADDR(p, offset)) = value)
    1367             : 
    1368             : #define READ_UINT32_FIELD(p, offset) \
    1369             :   (*reinterpret_cast<const uint32_t*>(FIELD_ADDR_CONST(p, offset)))
    1370             : 
    1371             : #define WRITE_UINT32_FIELD(p, offset, value) \
    1372             :   (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset)) = value)
    1373             : 
    1374             : #define READ_INT32_FIELD(p, offset) \
    1375             :   (*reinterpret_cast<const int32_t*>(FIELD_ADDR_CONST(p, offset)))
    1376             : 
    1377             : #define WRITE_INT32_FIELD(p, offset, value) \
    1378             :   (*reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset)) = value)
    1379             : 
    1380             : #define READ_FLOAT_FIELD(p, offset) \
    1381             :   (*reinterpret_cast<const float*>(FIELD_ADDR_CONST(p, offset)))
    1382             : 
    1383             : #define WRITE_FLOAT_FIELD(p, offset, value) \
    1384             :   (*reinterpret_cast<float*>(FIELD_ADDR(p, offset)) = value)
    1385             : 
    1386             : #define READ_UINT64_FIELD(p, offset) \
    1387             :   (*reinterpret_cast<const uint64_t*>(FIELD_ADDR_CONST(p, offset)))
    1388             : 
    1389             : #define WRITE_UINT64_FIELD(p, offset, value) \
    1390             :   (*reinterpret_cast<uint64_t*>(FIELD_ADDR(p, offset)) = value)
    1391             : 
    1392             : #define READ_INT64_FIELD(p, offset) \
    1393             :   (*reinterpret_cast<const int64_t*>(FIELD_ADDR_CONST(p, offset)))
    1394             : 
    1395             : #define WRITE_INT64_FIELD(p, offset, value) \
    1396             :   (*reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset)) = value)
    1397             : 
    1398             : #define READ_BYTE_FIELD(p, offset) \
    1399             :   (*reinterpret_cast<const byte*>(FIELD_ADDR_CONST(p, offset)))
    1400             : 
    1401             : #define NOBARRIER_READ_BYTE_FIELD(p, offset) \
    1402             :   static_cast<byte>(base::NoBarrier_Load(    \
    1403             :       reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset))))
    1404             : 
    1405             : #define WRITE_BYTE_FIELD(p, offset, value) \
    1406             :   (*reinterpret_cast<byte*>(FIELD_ADDR(p, offset)) = value)
    1407             : 
    1408             : #define NOBARRIER_WRITE_BYTE_FIELD(p, offset, value)           \
    1409             :   base::NoBarrier_Store(                                       \
    1410             :       reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \
    1411             :       static_cast<base::Atomic8>(value));
    1412             : 
    1413    42136153 : Object** HeapObject::RawField(HeapObject* obj, int byte_offset) {
    1414   671123484 :   return reinterpret_cast<Object**>(FIELD_ADDR(obj, byte_offset));
    1415             : }
    1416             : 
    1417             : 
    1418             : MapWord MapWord::FromMap(const Map* map) {
    1419   856172372 :   return MapWord(reinterpret_cast<uintptr_t>(map));
    1420             : }
    1421             : 
    1422             : 
    1423             : Map* MapWord::ToMap() {
    1424 44683731997 :   return reinterpret_cast<Map*>(value_);
    1425             : }
    1426             : 
    1427         179 : bool MapWord::IsForwardingAddress() const {
    1428   634488324 :   return HAS_SMI_TAG(reinterpret_cast<Object*>(value_));
    1429             : }
    1430             : 
    1431             : 
    1432   116355462 : MapWord MapWord::FromForwardingAddress(HeapObject* object) {
    1433   117565725 :   Address raw = reinterpret_cast<Address>(object) - kHeapObjectTag;
    1434   117565725 :   return MapWord(reinterpret_cast<uintptr_t>(raw));
    1435             : }
    1436             : 
    1437             : 
    1438          88 : HeapObject* MapWord::ToForwardingAddress() {
    1439             :   DCHECK(IsForwardingAddress());
    1440   115207098 :   return HeapObject::FromAddress(reinterpret_cast<Address>(value_));
    1441             : }
    1442             : 
    1443             : 
    1444             : #ifdef VERIFY_HEAP
    1445             : void HeapObject::VerifyObjectField(int offset) {
    1446             :   VerifyPointer(READ_FIELD(this, offset));
    1447             : }
    1448             : 
    1449             : void HeapObject::VerifySmiField(int offset) {
    1450             :   CHECK(READ_FIELD(this, offset)->IsSmi());
    1451             : }
    1452             : #endif
    1453             : 
    1454             : 
    1455   968853525 : Heap* HeapObject::GetHeap() const {
    1456             :   Heap* heap = MemoryChunk::FromAddress(
    1457             :                    reinterpret_cast<Address>(const_cast<HeapObject*>(this)))
    1458 12164385575 :                    ->heap();
    1459             :   SLOW_DCHECK(heap != NULL);
    1460   968853525 :   return heap;
    1461             : }
    1462             : 
    1463             : 
    1464   838978413 : Isolate* HeapObject::GetIsolate() const {
    1465   838978413 :   return GetHeap()->isolate();
    1466             : }
    1467             : 
    1468             : 
    1469 12111299830 : Map* HeapObject::map() const {
    1470 12111299830 :   return map_word().ToMap();
    1471             : }
    1472             : 
    1473             : 
    1474    20959499 : void HeapObject::set_map(Map* value) {
    1475             :   set_map_word(MapWord::FromMap(value));
    1476    20959499 :   if (value != nullptr) {
    1477             :     // TODO(1600) We are passing NULL as a slot because maps can never be on
    1478             :     // evacuation candidate.
    1479    20959460 :     value->GetHeap()->incremental_marking()->RecordWrite(this, nullptr, value);
    1480             : #ifdef VERIFY_HEAP
    1481             :     value->GetHeap()->VerifyObjectLayoutChange(this, value);
    1482             : #endif
    1483             :   }
    1484    20959502 : }
    1485             : 
    1486             : 
    1487             : Map* HeapObject::synchronized_map() {
    1488             :   return synchronized_map_word().ToMap();
    1489             : }
    1490             : 
    1491             : 
    1492    64489136 : void HeapObject::synchronized_set_map(Map* value) {
    1493             :   synchronized_set_map_word(MapWord::FromMap(value));
    1494    64489136 :   if (value != nullptr) {
    1495             :     // TODO(1600) We are passing NULL as a slot because maps can never be on
    1496             :     // evacuation candidate.
    1497    64489140 :     value->GetHeap()->incremental_marking()->RecordWrite(this, nullptr, value);
    1498             : #ifdef VERIFY_HEAP
    1499             :     value->GetHeap()->VerifyObjectLayoutChange(this, value);
    1500             : #endif
    1501             :   }
    1502    64489132 : }
    1503             : 
    1504             : 
    1505             : void HeapObject::synchronized_set_map_no_write_barrier(Map* value) {
    1506             :   synchronized_set_map_word(MapWord::FromMap(value));
    1507             : }
    1508             : 
    1509             : 
    1510             : // Unsafe accessor omitting write barrier.
    1511             : void HeapObject::set_map_no_write_barrier(Map* value) {
    1512             :   set_map_word(MapWord::FromMap(value));
    1513             : }
    1514             : 
    1515             : 
    1516         179 : MapWord HeapObject::map_word() const {
    1517             :   return MapWord(
    1518 44525254310 :       reinterpret_cast<uintptr_t>(NOBARRIER_READ_FIELD(this, kMapOffset)));
    1519             : }
    1520             : 
    1521             : 
    1522   116355462 : void HeapObject::set_map_word(MapWord map_word) {
    1523   774594098 :   NOBARRIER_WRITE_FIELD(
    1524             :       this, kMapOffset, reinterpret_cast<Object*>(map_word.value_));
    1525   116355462 : }
    1526             : 
    1527             : 
    1528             : MapWord HeapObject::synchronized_map_word() const {
    1529             :   return MapWord(
    1530   633537834 :       reinterpret_cast<uintptr_t>(ACQUIRE_READ_FIELD(this, kMapOffset)));
    1531             : }
    1532             : 
    1533             : 
    1534             : void HeapObject::synchronized_set_map_word(MapWord map_word) {
    1535    64489136 :   RELEASE_WRITE_FIELD(
    1536             :       this, kMapOffset, reinterpret_cast<Object*>(map_word.value_));
    1537             : }
    1538             : 
    1539             : 
    1540  1140898422 : int HeapObject::Size() {
    1541  1140898422 :   return SizeFromMap(map());
    1542             : }
    1543             : 
    1544             : 
    1545        8364 : double HeapNumber::value() const {
    1546        8364 :   return READ_DOUBLE_FIELD(this, kValueOffset);
    1547             : }
    1548             : 
    1549             : 
    1550             : void HeapNumber::set_value(double value) {
    1551             :   WRITE_DOUBLE_FIELD(this, kValueOffset, value);
    1552             : }
    1553             : 
    1554             : uint64_t HeapNumber::value_as_bits() const {
    1555      108666 :   return READ_UINT64_FIELD(this, kValueOffset);
    1556             : }
    1557             : 
    1558             : void HeapNumber::set_value_as_bits(uint64_t bits) {
    1559       62708 :   WRITE_UINT64_FIELD(this, kValueOffset, bits);
    1560             : }
    1561             : 
    1562             : int HeapNumber::get_exponent() {
    1563             :   return ((READ_INT_FIELD(this, kExponentOffset) & kExponentMask) >>
    1564             :           kExponentShift) - kExponentBias;
    1565             : }
    1566             : 
    1567             : 
    1568             : int HeapNumber::get_sign() {
    1569             :   return READ_INT_FIELD(this, kExponentOffset) & kSignMask;
    1570             : }
    1571             : 
    1572   874466302 : ACCESSORS(JSReceiver, properties, FixedArray, kPropertiesOffset)
    1573             : 
    1574             : 
    1575             : Object** FixedArray::GetFirstElementAddress() {
    1576             :   return reinterpret_cast<Object**>(FIELD_ADDR(this, OffsetOfElementAt(0)));
    1577             : }
    1578             : 
    1579             : 
    1580             : bool FixedArray::ContainsOnlySmisOrHoles() {
    1581             :   Object* the_hole = GetHeap()->the_hole_value();
    1582             :   Object** current = GetFirstElementAddress();
    1583             :   for (int i = 0; i < length(); ++i) {
    1584             :     Object* candidate = *current++;
    1585             :     if (!candidate->IsSmi() && candidate != the_hole) return false;
    1586             :   }
    1587             :   return true;
    1588             : }
    1589             : 
    1590             : 
    1591     1549515 : FixedArrayBase* JSObject::elements() const {
    1592   594986650 :   Object* array = READ_FIELD(this, kElementsOffset);
    1593     1549515 :   return static_cast<FixedArrayBase*>(array);
    1594             : }
    1595             : 
    1596             : Context* SloppyArgumentsElements::context() {
    1597             :   return Context::cast(get(kContextIndex));
    1598             : }
    1599             : 
    1600             : FixedArray* SloppyArgumentsElements::arguments() {
    1601             :   return FixedArray::cast(get(kArgumentsIndex));
    1602             : }
    1603             : 
    1604             : void SloppyArgumentsElements::set_arguments(FixedArray* arguments) {
    1605       34062 :   set(kArgumentsIndex, arguments);
    1606             : }
    1607             : 
    1608             : uint32_t SloppyArgumentsElements::parameter_map_length() {
    1609      924771 :   return length() - kParameterMapStart;
    1610             : }
    1611             : 
    1612             : Object* SloppyArgumentsElements::get_mapped_entry(uint32_t entry) {
    1613      161202 :   return get(entry + kParameterMapStart);
    1614             : }
    1615             : 
    1616             : void SloppyArgumentsElements::set_mapped_entry(uint32_t entry, Object* object) {
    1617         834 :   set(entry + kParameterMapStart, object);
    1618             : }
    1619             : 
    1620     1601164 : void AllocationSite::Initialize() {
    1621     1601164 :   set_transition_info(Smi::kZero);
    1622     1601164 :   SetElementsKind(GetInitialFastElementsKind());
    1623     1601164 :   set_nested_site(Smi::kZero);
    1624             :   set_pretenure_data(0);
    1625             :   set_pretenure_create_count(0);
    1626     1601164 :   set_dependent_code(DependentCode::cast(GetHeap()->empty_fixed_array()),
    1627     1601164 :                      SKIP_WRITE_BARRIER);
    1628     1601164 : }
    1629             : 
    1630             : 
    1631             : bool AllocationSite::IsZombie() { return pretenure_decision() == kZombie; }
    1632             : 
    1633             : 
    1634             : bool AllocationSite::IsMaybeTenure() {
    1635             :   return pretenure_decision() == kMaybeTenure;
    1636             : }
    1637             : 
    1638             : 
    1639             : bool AllocationSite::PretenuringDecisionMade() {
    1640             :   return pretenure_decision() != kUndecided;
    1641             : }
    1642             : 
    1643             : 
    1644             : void AllocationSite::MarkZombie() {
    1645             :   DCHECK(!IsZombie());
    1646      328902 :   Initialize();
    1647             :   set_pretenure_decision(kZombie);
    1648             : }
    1649             : 
    1650             : 
    1651             : ElementsKind AllocationSite::GetElementsKind() {
    1652             :   DCHECK(!SitePointsToLiteral());
    1653             :   int value = Smi::cast(transition_info())->value();
    1654     1090771 :   return ElementsKindBits::decode(value);
    1655             : }
    1656             : 
    1657             : 
    1658     1624795 : void AllocationSite::SetElementsKind(ElementsKind kind) {
    1659             :   int value = Smi::cast(transition_info())->value();
    1660     3249590 :   set_transition_info(Smi::FromInt(ElementsKindBits::update(value, kind)),
    1661     1624795 :                       SKIP_WRITE_BARRIER);
    1662     1624795 : }
    1663             : 
    1664             : 
    1665             : bool AllocationSite::CanInlineCall() {
    1666             :   int value = Smi::cast(transition_info())->value();
    1667        1358 :   return DoNotInlineBit::decode(value) == 0;
    1668             : }
    1669             : 
    1670             : 
    1671        3674 : void AllocationSite::SetDoNotInlineCall() {
    1672             :   int value = Smi::cast(transition_info())->value();
    1673        7348 :   set_transition_info(Smi::FromInt(DoNotInlineBit::update(value, true)),
    1674        3674 :                       SKIP_WRITE_BARRIER);
    1675        3674 : }
    1676             : 
    1677             : 
    1678      651685 : bool AllocationSite::SitePointsToLiteral() {
    1679             :   // If transition_info is a smi, then it represents an ElementsKind
    1680             :   // for a constructed array. Otherwise, it must be a boilerplate
    1681             :   // for an object or array literal.
    1682      686453 :   return transition_info()->IsJSArray() || transition_info()->IsJSObject();
    1683             : }
    1684             : 
    1685             : 
    1686             : // Heuristic: We only need to create allocation site info if the boilerplate
    1687             : // elements kind is the initial elements kind.
    1688             : AllocationSiteMode AllocationSite::GetMode(
    1689             :     ElementsKind boilerplate_elements_kind) {
    1690     1534425 :   if (IsFastSmiElementsKind(boilerplate_elements_kind)) {
    1691             :     return TRACK_ALLOCATION_SITE;
    1692             :   }
    1693             : 
    1694             :   return DONT_TRACK_ALLOCATION_SITE;
    1695             : }
    1696             : 
    1697   152227118 : inline bool AllocationSite::CanTrack(InstanceType type) {
    1698   152227118 :   if (FLAG_turbo) {
    1699             :     // TurboFan doesn't care at all about String pretenuring feedback,
    1700             :     // so don't bother even trying to track that.
    1701    92973138 :     return type == JS_ARRAY_TYPE || type == JS_OBJECT_TYPE;
    1702             :   }
    1703    59253980 :   if (FLAG_allocation_site_pretenuring) {
    1704   118507960 :     return type == JS_ARRAY_TYPE ||
    1705   169661645 :         type == JS_OBJECT_TYPE ||
    1706   110407665 :         type < FIRST_NONSTRING_TYPE;
    1707             :   }
    1708           0 :   return type == JS_ARRAY_TYPE;
    1709             : }
    1710             : 
    1711             : 
    1712             : AllocationSite::PretenureDecision AllocationSite::pretenure_decision() {
    1713             :   int value = pretenure_data();
    1714     7720620 :   return PretenureDecisionBits::decode(value);
    1715             : }
    1716             : 
    1717             : 
    1718             : void AllocationSite::set_pretenure_decision(PretenureDecision decision) {
    1719             :   int value = pretenure_data();
    1720      663634 :   set_pretenure_data(PretenureDecisionBits::update(value, decision));
    1721             : }
    1722             : 
    1723             : 
    1724             : bool AllocationSite::deopt_dependent_code() {
    1725             :   int value = pretenure_data();
    1726        1021 :   return DeoptDependentCodeBit::decode(value);
    1727             : }
    1728             : 
    1729             : 
    1730             : void AllocationSite::set_deopt_dependent_code(bool deopt) {
    1731             :   int value = pretenure_data();
    1732         720 :   set_pretenure_data(DeoptDependentCodeBit::update(value, deopt));
    1733             : }
    1734             : 
    1735             : 
    1736             : int AllocationSite::memento_found_count() {
    1737             :   int value = pretenure_data();
    1738             :   return MementoFoundCountBits::decode(value);
    1739             : }
    1740             : 
    1741             : 
    1742             : inline void AllocationSite::set_memento_found_count(int count) {
    1743             :   int value = pretenure_data();
    1744             :   // Verify that we can count more mementos than we can possibly find in one
    1745             :   // new space collection.
    1746             :   DCHECK((GetHeap()->MaxSemiSpaceSize() /
    1747             :           (Heap::kMinObjectSizeInWords * kPointerSize +
    1748             :            AllocationMemento::kSize)) < MementoFoundCountBits::kMax);
    1749             :   DCHECK(count < MementoFoundCountBits::kMax);
    1750     3226311 :   set_pretenure_data(MementoFoundCountBits::update(value, count));
    1751             : }
    1752             : 
    1753             : 
    1754             : int AllocationSite::memento_create_count() { return pretenure_create_count(); }
    1755             : 
    1756             : 
    1757             : void AllocationSite::set_memento_create_count(int count) {
    1758             :   set_pretenure_create_count(count);
    1759             : }
    1760             : 
    1761             : 
    1762             : bool AllocationSite::IncrementMementoFoundCount(int increment) {
    1763     3218597 :   if (IsZombie()) return false;
    1764             : 
    1765             :   int value = memento_found_count();
    1766     3218597 :   set_memento_found_count(value + increment);
    1767     3218597 :   return memento_found_count() >= kPretenureMinimumCreated;
    1768             : }
    1769             : 
    1770             : 
    1771             : inline void AllocationSite::IncrementMementoCreateCount() {
    1772             :   DCHECK(FLAG_allocation_site_pretenuring);
    1773             :   int value = memento_create_count();
    1774     7485930 :   set_memento_create_count(value + 1);
    1775             : }
    1776             : 
    1777             : 
    1778        3857 : inline bool AllocationSite::MakePretenureDecision(
    1779             :     PretenureDecision current_decision,
    1780             :     double ratio,
    1781             :     bool maximum_size_scavenge) {
    1782             :   // Here we just allow state transitions from undecided or maybe tenure
    1783             :   // to don't tenure, maybe tenure, or tenure.
    1784        3857 :   if ((current_decision == kUndecided || current_decision == kMaybeTenure)) {
    1785        2915 :     if (ratio >= kPretenureRatio) {
    1786             :       // We just transition into tenure state when the semi-space was at
    1787             :       // maximum capacity.
    1788        2143 :       if (maximum_size_scavenge) {
    1789             :         set_deopt_dependent_code(true);
    1790             :         set_pretenure_decision(kTenure);
    1791             :         // Currently we just need to deopt when we make a state transition to
    1792             :         // tenure.
    1793         136 :         return true;
    1794             :       }
    1795             :       set_pretenure_decision(kMaybeTenure);
    1796             :     } else {
    1797             :       set_pretenure_decision(kDontTenure);
    1798             :     }
    1799             :   }
    1800             :   return false;
    1801             : }
    1802             : 
    1803             : 
    1804        3857 : inline bool AllocationSite::DigestPretenuringFeedback(
    1805             :     bool maximum_size_scavenge) {
    1806             :   bool deopt = false;
    1807             :   int create_count = memento_create_count();
    1808             :   int found_count = memento_found_count();
    1809        3857 :   bool minimum_mementos_created = create_count >= kPretenureMinimumCreated;
    1810             :   double ratio =
    1811           0 :       minimum_mementos_created || FLAG_trace_pretenuring_statistics ?
    1812        7714 :           static_cast<double>(found_count) / create_count : 0.0;
    1813             :   PretenureDecision current_decision = pretenure_decision();
    1814             : 
    1815        3857 :   if (minimum_mementos_created) {
    1816             :     deopt = MakePretenureDecision(
    1817        3857 :         current_decision, ratio, maximum_size_scavenge);
    1818             :   }
    1819             : 
    1820        3857 :   if (FLAG_trace_pretenuring_statistics) {
    1821             :     PrintIsolate(GetIsolate(),
    1822             :                  "pretenuring: AllocationSite(%p): (created, found, ratio) "
    1823             :                  "(%d, %d, %f) %s => %s\n",
    1824             :                  static_cast<void*>(this), create_count, found_count, ratio,
    1825             :                  PretenureDecisionName(current_decision),
    1826           0 :                  PretenureDecisionName(pretenure_decision()));
    1827             :   }
    1828             : 
    1829             :   // Clear feedback calculation fields until the next gc.
    1830             :   set_memento_found_count(0);
    1831             :   set_memento_create_count(0);
    1832        3857 :   return deopt;
    1833             : }
    1834             : 
    1835             : 
    1836     3625210 : bool AllocationMemento::IsValid() {
    1837     7250420 :   return allocation_site()->IsAllocationSite() &&
    1838     3625210 :          !AllocationSite::cast(allocation_site())->IsZombie();
    1839             : }
    1840             : 
    1841             : 
    1842             : AllocationSite* AllocationMemento::GetAllocationSite() {
    1843             :   DCHECK(IsValid());
    1844             :   return AllocationSite::cast(allocation_site());
    1845             : }
    1846             : 
    1847             : Address AllocationMemento::GetAllocationSiteUnchecked() {
    1848             :   return reinterpret_cast<Address>(allocation_site());
    1849             : }
    1850             : 
    1851      189268 : void JSObject::EnsureCanContainHeapObjectElements(Handle<JSObject> object) {
    1852      189268 :   JSObject::ValidateElements(object);
    1853             :   ElementsKind elements_kind = object->map()->elements_kind();
    1854      189268 :   if (!IsFastObjectElementsKind(elements_kind)) {
    1855           0 :     if (IsFastHoleyElementsKind(elements_kind)) {
    1856           0 :       TransitionElementsKind(object, FAST_HOLEY_ELEMENTS);
    1857             :     } else {
    1858           0 :       TransitionElementsKind(object, FAST_ELEMENTS);
    1859             :     }
    1860             :   }
    1861      189268 : }
    1862             : 
    1863             : 
    1864     1305287 : void JSObject::EnsureCanContainElements(Handle<JSObject> object,
    1865             :                                         Object** objects,
    1866             :                                         uint32_t count,
    1867             :                                         EnsureElementsMode mode) {
    1868             :   ElementsKind current_kind = object->GetElementsKind();
    1869             :   ElementsKind target_kind = current_kind;
    1870             :   {
    1871             :     DisallowHeapAllocation no_allocation;
    1872             :     DCHECK(mode != ALLOW_COPIED_DOUBLE_ELEMENTS);
    1873             :     bool is_holey = IsFastHoleyElementsKind(current_kind);
    1874     2610574 :     if (current_kind == FAST_HOLEY_ELEMENTS) return;
    1875     1305287 :     Object* the_hole = object->GetHeap()->the_hole_value();
    1876    28081506 :     for (uint32_t i = 0; i < count; ++i) {
    1877    26776219 :       Object* current = *objects++;
    1878    26776219 :       if (current == the_hole) {
    1879             :         is_holey = true;
    1880             :         target_kind = GetHoleyElementsKind(target_kind);
    1881    24500699 :       } else if (!current->IsSmi()) {
    1882    13736928 :         if (mode == ALLOW_CONVERTED_DOUBLE_ELEMENTS && current->IsNumber()) {
    1883     1400641 :           if (IsFastSmiElementsKind(target_kind)) {
    1884         126 :             if (is_holey) {
    1885             :               target_kind = FAST_HOLEY_DOUBLE_ELEMENTS;
    1886             :             } else {
    1887             :               target_kind = FAST_DOUBLE_ELEMENTS;
    1888             :             }
    1889             :           }
    1890     5763221 :         } else if (is_holey) {
    1891             :           target_kind = FAST_HOLEY_ELEMENTS;
    1892             :           break;
    1893             :         } else {
    1894             :           target_kind = FAST_ELEMENTS;
    1895             :         }
    1896             :       }
    1897             :     }
    1898             :   }
    1899     1305287 :   if (target_kind != current_kind) {
    1900      142604 :     TransitionElementsKind(object, target_kind);
    1901             :   }
    1902             : }
    1903             : 
    1904             : 
    1905      141370 : void JSObject::EnsureCanContainElements(Handle<JSObject> object,
    1906             :                                         Handle<FixedArrayBase> elements,
    1907             :                                         uint32_t length,
    1908             :                                         EnsureElementsMode mode) {
    1909      141370 :   Heap* heap = object->GetHeap();
    1910      141370 :   if (elements->map() != heap->fixed_double_array_map()) {
    1911             :     DCHECK(elements->map() == heap->fixed_array_map() ||
    1912             :            elements->map() == heap->fixed_cow_array_map());
    1913      141370 :     if (mode == ALLOW_COPIED_DOUBLE_ELEMENTS) {
    1914             :       mode = DONT_ALLOW_DOUBLE_ELEMENTS;
    1915             :     }
    1916             :     Object** objects =
    1917      141370 :         Handle<FixedArray>::cast(elements)->GetFirstElementAddress();
    1918      141370 :     EnsureCanContainElements(object, objects, length, mode);
    1919      141370 :     return;
    1920             :   }
    1921             : 
    1922             :   DCHECK(mode == ALLOW_COPIED_DOUBLE_ELEMENTS);
    1923           0 :   if (object->GetElementsKind() == FAST_HOLEY_SMI_ELEMENTS) {
    1924           0 :     TransitionElementsKind(object, FAST_HOLEY_DOUBLE_ELEMENTS);
    1925           0 :   } else if (object->GetElementsKind() == FAST_SMI_ELEMENTS) {
    1926             :     Handle<FixedDoubleArray> double_array =
    1927             :         Handle<FixedDoubleArray>::cast(elements);
    1928           0 :     for (uint32_t i = 0; i < length; ++i) {
    1929           0 :       if (double_array->is_the_hole(i)) {
    1930           0 :         TransitionElementsKind(object, FAST_HOLEY_DOUBLE_ELEMENTS);
    1931             :         return;
    1932             :       }
    1933             :     }
    1934           0 :     TransitionElementsKind(object, FAST_DOUBLE_ELEMENTS);
    1935             :   }
    1936             : }
    1937             : 
    1938             : 
    1939     1284602 : void JSObject::SetMapAndElements(Handle<JSObject> object,
    1940             :                                  Handle<Map> new_map,
    1941             :                                  Handle<FixedArrayBase> value) {
    1942     1284602 :   JSObject::MigrateToMap(object, new_map);
    1943             :   DCHECK((object->map()->has_fast_smi_or_object_elements() ||
    1944             :           (*value == object->GetHeap()->empty_fixed_array()) ||
    1945             :           object->map()->has_fast_string_wrapper_elements()) ==
    1946             :          (value->map() == object->GetHeap()->fixed_array_map() ||
    1947             :           value->map() == object->GetHeap()->fixed_cow_array_map()));
    1948             :   DCHECK((*value == object->GetHeap()->empty_fixed_array()) ||
    1949             :          (object->map()->has_fast_double_elements() ==
    1950             :           value->IsFixedDoubleArray()));
    1951     1284602 :   object->set_elements(*value);
    1952     1284602 : }
    1953             : 
    1954             : 
    1955    31091120 : void JSObject::set_elements(FixedArrayBase* value, WriteBarrierMode mode) {
    1956    31091120 :   WRITE_FIELD(this, kElementsOffset, value);
    1957    86662529 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kElementsOffset, value, mode);
    1958    31091119 : }
    1959             : 
    1960             : 
    1961    75752317 : void JSObject::initialize_elements() {
    1962    75752317 :   FixedArrayBase* elements = map()->GetInitialElements();
    1963    75752320 :   WRITE_FIELD(this, kElementsOffset, elements);
    1964    75752320 : }
    1965             : 
    1966             : 
    1967      723347 : InterceptorInfo* JSObject::GetIndexedInterceptor() {
    1968      723347 :   return map()->GetIndexedInterceptor();
    1969             : }
    1970             : 
    1971     1796121 : InterceptorInfo* JSObject::GetNamedInterceptor() {
    1972     1796121 :   return map()->GetNamedInterceptor();
    1973             : }
    1974             : 
    1975             : InterceptorInfo* Map::GetNamedInterceptor() {
    1976             :   DCHECK(has_named_interceptor());
    1977     1796121 :   FunctionTemplateInfo* info = GetFunctionTemplateInfo();
    1978             :   return InterceptorInfo::cast(info->named_property_handler());
    1979             : }
    1980             : 
    1981             : InterceptorInfo* Map::GetIndexedInterceptor() {
    1982             :   DCHECK(has_indexed_interceptor());
    1983      723569 :   FunctionTemplateInfo* info = GetFunctionTemplateInfo();
    1984             :   return InterceptorInfo::cast(info->indexed_property_handler());
    1985             : }
    1986             : 
    1987             : double Oddball::to_number_raw() const {
    1988             :   return READ_DOUBLE_FIELD(this, kToNumberRawOffset);
    1989             : }
    1990             : 
    1991             : void Oddball::set_to_number_raw(double value) {
    1992             :   WRITE_DOUBLE_FIELD(this, kToNumberRawOffset, value);
    1993             : }
    1994             : 
    1995             : void Oddball::set_to_number_raw_as_bits(uint64_t bits) {
    1996          86 :   WRITE_UINT64_FIELD(this, kToNumberRawOffset, bits);
    1997             : }
    1998             : 
    1999     2565605 : ACCESSORS(Oddball, to_string, String, kToStringOffset)
    2000     3335952 : ACCESSORS(Oddball, to_number, Object, kToNumberOffset)
    2001        3572 : ACCESSORS(Oddball, type_of, String, kTypeOfOffset)
    2002             : 
    2003             : 
    2004    17935568 : byte Oddball::kind() const {
    2005    68025540 :   return Smi::cast(READ_FIELD(this, kKindOffset))->value();
    2006             : }
    2007             : 
    2008             : 
    2009             : void Oddball::set_kind(byte value) {
    2010         688 :   WRITE_FIELD(this, kKindOffset, Smi::FromInt(value));
    2011             : }
    2012             : 
    2013             : 
    2014             : // static
    2015     3334533 : Handle<Object> Oddball::ToNumber(Handle<Oddball> input) {
    2016     3334533 :   return handle(input->to_number(), input->GetIsolate());
    2017             : }
    2018             : 
    2019             : 
    2020    92400901 : ACCESSORS(Cell, value, Object, kValueOffset)
    2021    12677007 : ACCESSORS(PropertyCell, dependent_code, DependentCode, kDependentCodeOffset)
    2022   285471243 : ACCESSORS(PropertyCell, property_details_raw, Object, kDetailsOffset)
    2023   122708442 : ACCESSORS(PropertyCell, value, Object, kValueOffset)
    2024             : 
    2025             : 
    2026             : PropertyDetails PropertyCell::property_details() {
    2027             :   return PropertyDetails(Smi::cast(property_details_raw()));
    2028             : }
    2029             : 
    2030             : 
    2031             : void PropertyCell::set_property_details(PropertyDetails details) {
    2032    29668633 :   set_property_details_raw(details.AsSmi());
    2033             : }
    2034             : 
    2035             : 
    2036   539618432 : Object* WeakCell::value() const { return READ_FIELD(this, kValueOffset); }
    2037             : 
    2038             : 
    2039             : void WeakCell::clear() {
    2040             :   // Either the garbage collector is clearing the cell or we are simply
    2041             :   // initializing the root empty weak cell.
    2042             :   DCHECK(GetHeap()->gc_state() == Heap::MARK_COMPACT ||
    2043             :          this == GetHeap()->empty_weak_cell());
    2044     2544885 :   WRITE_FIELD(this, kValueOffset, Smi::kZero);
    2045             : }
    2046             : 
    2047             : 
    2048    39367624 : void WeakCell::initialize(HeapObject* val) {
    2049    39367624 :   WRITE_FIELD(this, kValueOffset, val);
    2050             :   // We just have to execute the generational barrier here because we never
    2051             :   // mark through a weak cell and collect evacuation candidates when we process
    2052             :   // all weak cells.
    2053             :   WriteBarrierMode mode =
    2054             :       ObjectMarking::IsBlack(this, MarkingState::Internal(this))
    2055             :           ? UPDATE_WRITE_BARRIER
    2056    39367627 :           : UPDATE_WEAK_WRITE_BARRIER;
    2057    78853349 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kValueOffset, val, mode);
    2058    39367622 : }
    2059             : 
    2060   180847148 : bool WeakCell::cleared() const { return value() == Smi::kZero; }
    2061             : 
    2062   146885795 : Object* WeakCell::next() const { return READ_FIELD(this, kNextOffset); }
    2063             : 
    2064             : 
    2065   149269707 : void WeakCell::set_next(Object* val, WriteBarrierMode mode) {
    2066   149269707 :   WRITE_FIELD(this, kNextOffset, val);
    2067   149269707 :   if (mode == UPDATE_WRITE_BARRIER) {
    2068     3053880 :     WRITE_BARRIER(GetHeap(), this, kNextOffset, val);
    2069             :   }
    2070   149269707 : }
    2071             : 
    2072             : 
    2073             : void WeakCell::clear_next(Object* the_hole_value) {
    2074             :   DCHECK_EQ(GetHeap()->the_hole_value(), the_hole_value);
    2075    93809593 :   set_next(the_hole_value, SKIP_WRITE_BARRIER);
    2076             : }
    2077             : 
    2078   180847147 : bool WeakCell::next_cleared() { return next()->IsTheHole(GetIsolate()); }
    2079             : 
    2080    38682580 : int JSObject::GetHeaderSize() { return GetHeaderSize(map()->instance_type()); }
    2081             : 
    2082             : 
    2083    22565346 : int JSObject::GetHeaderSize(InstanceType type) {
    2084             :   // Check for the most common kind of JavaScript object before
    2085             :   // falling into the generic switch. This speeds up the internal
    2086             :   // field operations considerably on average.
    2087    22565346 :   if (type == JS_OBJECT_TYPE) return JSObject::kHeaderSize;
    2088     3542329 :   switch (type) {
    2089             :     case JS_API_OBJECT_TYPE:
    2090             :     case JS_SPECIAL_API_OBJECT_TYPE:
    2091             :       return JSObject::kHeaderSize;
    2092             :     case JS_GENERATOR_OBJECT_TYPE:
    2093       18006 :       return JSGeneratorObject::kSize;
    2094             :     case JS_ASYNC_GENERATOR_OBJECT_TYPE:
    2095        1736 :       return JSAsyncGeneratorObject::kSize;
    2096             :     case JS_GLOBAL_PROXY_TYPE:
    2097          12 :       return JSGlobalProxy::kSize;
    2098             :     case JS_GLOBAL_OBJECT_TYPE:
    2099         667 :       return JSGlobalObject::kSize;
    2100             :     case JS_BOUND_FUNCTION_TYPE:
    2101          18 :       return JSBoundFunction::kSize;
    2102             :     case JS_FUNCTION_TYPE:
    2103     1303743 :       return JSFunction::kSize;
    2104             :     case JS_VALUE_TYPE:
    2105        6530 :       return JSValue::kSize;
    2106             :     case JS_DATE_TYPE:
    2107        1304 :       return JSDate::kSize;
    2108             :     case JS_ARRAY_TYPE:
    2109      100752 :       return JSArray::kSize;
    2110             :     case JS_ARRAY_BUFFER_TYPE:
    2111      269010 :       return JSArrayBuffer::kSize;
    2112             :     case JS_TYPED_ARRAY_TYPE:
    2113       10200 :       return JSTypedArray::kSize;
    2114             :     case JS_DATA_VIEW_TYPE:
    2115       11442 :       return JSDataView::kSize;
    2116             :     case JS_SET_TYPE:
    2117        1461 :       return JSSet::kSize;
    2118             :     case JS_MAP_TYPE:
    2119        2035 :       return JSMap::kSize;
    2120             :     case JS_SET_ITERATOR_TYPE:
    2121           0 :       return JSSetIterator::kSize;
    2122             :     case JS_MAP_ITERATOR_TYPE:
    2123           0 :       return JSMapIterator::kSize;
    2124             :     case JS_WEAK_MAP_TYPE:
    2125        1390 :       return JSWeakMap::kSize;
    2126             :     case JS_WEAK_SET_TYPE:
    2127         628 :       return JSWeakSet::kSize;
    2128             :     case JS_PROMISE_CAPABILITY_TYPE:
    2129           0 :       return JSPromiseCapability::kSize;
    2130             :     case JS_PROMISE_TYPE:
    2131         320 :       return JSPromise::kSize;
    2132             :     case JS_REGEXP_TYPE:
    2133      121430 :       return JSRegExp::kSize;
    2134             :     case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
    2135             :       return JSObject::kHeaderSize;
    2136             :     case JS_MESSAGE_OBJECT_TYPE:
    2137           0 :       return JSMessageObject::kSize;
    2138             :     case JS_ARGUMENTS_TYPE:
    2139        3090 :       return JSArgumentsObject::kHeaderSize;
    2140             :     case JS_ERROR_TYPE:
    2141             :       return JSObject::kHeaderSize;
    2142             :     case JS_STRING_ITERATOR_TYPE:
    2143           0 :       return JSStringIterator::kSize;
    2144             :     case JS_MODULE_NAMESPACE_TYPE:
    2145         172 :       return JSModuleNamespace::kHeaderSize;
    2146             :     default:
    2147          30 :       if (type >= FIRST_ARRAY_ITERATOR_TYPE &&
    2148             :           type <= LAST_ARRAY_ITERATOR_TYPE) {
    2149             :         return JSArrayIterator::kSize;
    2150             :       }
    2151           0 :       UNREACHABLE();
    2152             :       return 0;
    2153             :   }
    2154             : }
    2155             : 
    2156             : inline bool IsSpecialReceiverInstanceType(InstanceType instance_type) {
    2157   832677097 :   return instance_type <= LAST_SPECIAL_RECEIVER_TYPE;
    2158             : }
    2159             : 
    2160     2513887 : int JSObject::GetEmbedderFieldCount(Map* map) {
    2161             :   int instance_size = map->instance_size();
    2162     2513887 :   if (instance_size == kVariableSizeSentinel) return 0;
    2163             :   InstanceType instance_type = map->instance_type();
    2164     2513887 :   return ((instance_size - GetHeaderSize(instance_type)) >> kPointerSizeLog2) -
    2165     2513885 :          map->GetInObjectProperties();
    2166             : }
    2167             : 
    2168     1572754 : int JSObject::GetEmbedderFieldCount() { return GetEmbedderFieldCount(map()); }
    2169             : 
    2170             : int JSObject::GetEmbedderFieldOffset(int index) {
    2171             :   DCHECK(index < GetEmbedderFieldCount() && index >= 0);
    2172         120 :   return GetHeaderSize() + (kPointerSize * index);
    2173             : }
    2174             : 
    2175             : Object* JSObject::GetEmbedderField(int index) {
    2176             :   DCHECK(index < GetEmbedderFieldCount() && index >= 0);
    2177             :   // Internal objects do follow immediately after the header, whereas in-object
    2178             :   // properties are at the end of the object. Therefore there is no need
    2179             :   // to adjust the index here.
    2180    18329612 :   return READ_FIELD(this, GetHeaderSize() + (kPointerSize * index));
    2181             : }
    2182             : 
    2183      460436 : void JSObject::SetEmbedderField(int index, Object* value) {
    2184             :   DCHECK(index < GetEmbedderFieldCount() && index >= 0);
    2185             :   // Internal objects do follow immediately after the header, whereas in-object
    2186             :   // properties are at the end of the object. Therefore there is no need
    2187             :   // to adjust the index here.
    2188      460436 :   int offset = GetHeaderSize() + (kPointerSize * index);
    2189      460436 :   WRITE_FIELD(this, offset, value);
    2190      920872 :   WRITE_BARRIER(GetHeap(), this, offset, value);
    2191      460436 : }
    2192             : 
    2193             : void JSObject::SetEmbedderField(int index, Smi* value) {
    2194             :   DCHECK(index < GetEmbedderFieldCount() && index >= 0);
    2195             :   // Internal objects do follow immediately after the header, whereas in-object
    2196             :   // properties are at the end of the object. Therefore there is no need
    2197             :   // to adjust the index here.
    2198      551122 :   int offset = GetHeaderSize() + (kPointerSize * index);
    2199      551122 :   WRITE_FIELD(this, offset, value);
    2200             : }
    2201             : 
    2202             : 
    2203   159585822 : bool JSObject::IsUnboxedDoubleField(FieldIndex index) {
    2204             :   if (!FLAG_unbox_double_fields) return false;
    2205   159585822 :   return map()->IsUnboxedDoubleField(index);
    2206             : }
    2207             : 
    2208             : 
    2209   194021000 : bool Map::IsUnboxedDoubleField(FieldIndex index) {
    2210             :   if (!FLAG_unbox_double_fields) return false;
    2211   388042020 :   if (index.is_hidden_field() || !index.is_inobject()) return false;
    2212   117112536 :   return !layout_descriptor()->IsTagged(index.property_index());
    2213             : }
    2214             : 
    2215             : 
    2216             : // Access fast-case object properties at index. The use of these routines
    2217             : // is needed to correctly distinguish between properties stored in-object and
    2218             : // properties stored in the properties array.
    2219   143185706 : Object* JSObject::RawFastPropertyAt(FieldIndex index) {
    2220             :   DCHECK(!IsUnboxedDoubleField(index));
    2221   143185706 :   if (index.is_inobject()) {
    2222    65614713 :     return READ_FIELD(this, index.offset());
    2223             :   } else {
    2224    77570993 :     return properties()->get(index.outobject_array_index());
    2225             :   }
    2226             : }
    2227             : 
    2228             : 
    2229             : double JSObject::RawFastDoublePropertyAt(FieldIndex index) {
    2230             :   DCHECK(IsUnboxedDoubleField(index));
    2231       79717 :   return READ_DOUBLE_FIELD(this, index.offset());
    2232             : }
    2233             : 
    2234             : uint64_t JSObject::RawFastDoublePropertyAsBitsAt(FieldIndex index) {
    2235             :   DCHECK(IsUnboxedDoubleField(index));
    2236      154997 :   return READ_UINT64_FIELD(this, index.offset());
    2237             : }
    2238             : 
    2239   131217574 : void JSObject::RawFastPropertyAtPut(FieldIndex index, Object* value) {
    2240   131217574 :   if (index.is_inobject()) {
    2241             :     int offset = index.offset();
    2242   105249686 :     WRITE_FIELD(this, offset, value);
    2243   210499372 :     WRITE_BARRIER(GetHeap(), this, offset, value);
    2244             :   } else {
    2245    25967888 :     properties()->set(index.outobject_array_index(), value);
    2246             :   }
    2247   131217579 : }
    2248             : 
    2249             : void JSObject::RawFastDoublePropertyAsBitsAtPut(FieldIndex index,
    2250             :                                                 uint64_t bits) {
    2251      255921 :   WRITE_UINT64_FIELD(this, index.offset(), bits);
    2252             : }
    2253             : 
    2254    16426148 : void JSObject::FastPropertyAtPut(FieldIndex index, Object* value) {
    2255    16426148 :   if (IsUnboxedDoubleField(index)) {
    2256             :     DCHECK(value->IsMutableHeapNumber());
    2257             :     // Ensure that all bits of the double value are preserved.
    2258             :     RawFastDoublePropertyAsBitsAtPut(index,
    2259             :                                      HeapNumber::cast(value)->value_as_bits());
    2260             :   } else {
    2261    16426152 :     RawFastPropertyAtPut(index, value);
    2262             :   }
    2263    16426153 : }
    2264             : 
    2265    76633742 : void JSObject::WriteToField(int descriptor, PropertyDetails details,
    2266             :                             Object* value) {
    2267             :   DCHECK_EQ(kField, details.location());
    2268             :   DCHECK_EQ(kData, details.kind());
    2269             :   DisallowHeapAllocation no_gc;
    2270    76633742 :   FieldIndex index = FieldIndex::ForDescriptor(map(), descriptor);
    2271    76633746 :   if (details.representation().IsDouble()) {
    2272             :     // Nothing more to be done.
    2273       79276 :     if (value->IsUninitialized(this->GetIsolate())) {
    2274         850 :       return;
    2275             :     }
    2276             :     // Manipulating the signaling NaN used for the hole and uninitialized
    2277             :     // double field sentinel in C++, e.g. with bit_cast or value()/set_value(),
    2278             :     // will change its value on ia32 (the x87 stack is used to return values
    2279             :     // and stores to the stack silently clear the signalling bit).
    2280             :     uint64_t bits;
    2281       78426 :     if (value->IsSmi()) {
    2282        9361 :       bits = bit_cast<uint64_t>(static_cast<double>(Smi::cast(value)->value()));
    2283             :     } else {
    2284             :       DCHECK(value->IsHeapNumber());
    2285             :       bits = HeapNumber::cast(value)->value_as_bits();
    2286             :     }
    2287       78426 :     if (IsUnboxedDoubleField(index)) {
    2288             :       RawFastDoublePropertyAsBitsAtPut(index, bits);
    2289             :     } else {
    2290       12134 :       HeapNumber* box = HeapNumber::cast(RawFastPropertyAt(index));
    2291             :       DCHECK(box->IsMutableHeapNumber());
    2292             :       box->set_value_as_bits(bits);
    2293             :     }
    2294             :   } else {
    2295    76554470 :     RawFastPropertyAtPut(index, value);
    2296             :   }
    2297             : }
    2298             : 
    2299    15576962 : int JSObject::GetInObjectPropertyOffset(int index) {
    2300    15576962 :   return map()->GetInObjectPropertyOffset(index);
    2301             : }
    2302             : 
    2303             : 
    2304             : Object* JSObject::InObjectPropertyAt(int index) {
    2305      420363 :   int offset = GetInObjectPropertyOffset(index);
    2306      420363 :   return READ_FIELD(this, offset);
    2307             : }
    2308             : 
    2309             : 
    2310    15153108 : Object* JSObject::InObjectPropertyAtPut(int index,
    2311             :                                         Object* value,
    2312             :                                         WriteBarrierMode mode) {
    2313             :   // Adjust for the number of properties stored in the object.
    2314    15153108 :   int offset = GetInObjectPropertyOffset(index);
    2315    15153108 :   WRITE_FIELD(this, offset, value);
    2316    44027068 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode);
    2317    15153108 :   return value;
    2318             : }
    2319             : 
    2320             : 
    2321    45730477 : void JSObject::InitializeBody(Map* map, int start_offset,
    2322             :                               Object* pre_allocated_value,
    2323             :                               Object* filler_value) {
    2324             :   DCHECK(!filler_value->IsHeapObject() ||
    2325             :          !GetHeap()->InNewSpace(filler_value));
    2326             :   DCHECK(!pre_allocated_value->IsHeapObject() ||
    2327             :          !GetHeap()->InNewSpace(pre_allocated_value));
    2328             :   int size = map->instance_size();
    2329             :   int offset = start_offset;
    2330    45730477 :   if (filler_value != pre_allocated_value) {
    2331             :     int end_of_pre_allocated_offset =
    2332      408109 :         size - (map->unused_property_fields() * kPointerSize);
    2333             :     DCHECK_LE(kHeaderSize, end_of_pre_allocated_offset);
    2334     1059946 :     while (offset < end_of_pre_allocated_offset) {
    2335      243728 :       WRITE_FIELD(this, offset, pre_allocated_value);
    2336      243728 :       offset += kPointerSize;
    2337             :     }
    2338             :   }
    2339   159778779 :   while (offset < size) {
    2340   114048302 :     WRITE_FIELD(this, offset, filler_value);
    2341   114048302 :     offset += kPointerSize;
    2342             :   }
    2343    45730477 : }
    2344             : 
    2345             : 
    2346     9127260 : bool Map::TooManyFastProperties(StoreFromKeyed store_mode) {
    2347     9127260 :   if (unused_property_fields() != 0) return false;
    2348     2657362 :   if (is_prototype_map()) return false;
    2349     1839473 :   int minimum = store_mode == CERTAINLY_NOT_STORE_FROM_KEYED ? 128 : 12;
    2350             :   int limit = Max(minimum, GetInObjectProperties());
    2351     3678946 :   int external = NumberOfFields() - GetInObjectProperties();
    2352     1839473 :   return external > limit;
    2353             : }
    2354             : 
    2355             : 
    2356             : void Struct::InitializeBody(int object_size) {
    2357    16537277 :   Object* value = GetHeap()->undefined_value();
    2358   138790293 :   for (int offset = kHeaderSize; offset < object_size; offset += kPointerSize) {
    2359   138790293 :     WRITE_FIELD(this, offset, value);
    2360             :   }
    2361             : }
    2362             : 
    2363     7371061 : bool Object::ToArrayLength(uint32_t* index) { return Object::ToUint32(index); }
    2364             : 
    2365             : 
    2366      115041 : bool Object::ToArrayIndex(uint32_t* index) {
    2367   139584463 :   return Object::ToUint32(index) && *index != kMaxUInt32;
    2368             : }
    2369             : 
    2370             : 
    2371             : void Object::VerifyApiCallResultType() {
    2372             : #if DEBUG
    2373             :   if (IsSmi()) return;
    2374             :   DCHECK(IsHeapObject());
    2375             :   Isolate* isolate = HeapObject::cast(this)->GetIsolate();
    2376             :   if (!(IsString() || IsSymbol() || IsJSReceiver() || IsHeapNumber() ||
    2377             :         IsUndefined(isolate) || IsTrue(isolate) || IsFalse(isolate) ||
    2378             :         IsNull(isolate))) {
    2379             :     FATAL("API call returned invalid object");
    2380             :   }
    2381             : #endif  // DEBUG
    2382             : }
    2383             : 
    2384             : 
    2385   135385520 : Object* FixedArray::get(int index) const {
    2386             :   SLOW_DCHECK(index >= 0 && index < this->length());
    2387 23466094969 :   return NOBARRIER_READ_FIELD(this, kHeaderSize + index * kPointerSize);
    2388             : }
    2389             : 
    2390    13135713 : Handle<Object> FixedArray::get(FixedArray* array, int index, Isolate* isolate) {
    2391    13135714 :   return handle(array->get(index), isolate);
    2392             : }
    2393             : 
    2394             : template <class T>
    2395     4882075 : MaybeHandle<T> FixedArray::GetValue(Isolate* isolate, int index) const {
    2396             :   Object* obj = get(index);
    2397     4882079 :   if (obj->IsUndefined(isolate)) return MaybeHandle<T>();
    2398             :   return Handle<T>(T::cast(obj), isolate);
    2399             : }
    2400             : 
    2401             : template <class T>
    2402      331820 : Handle<T> FixedArray::GetValueChecked(Isolate* isolate, int index) const {
    2403             :   Object* obj = get(index);
    2404      331820 :   CHECK(!obj->IsUndefined(isolate));
    2405      331820 :   return Handle<T>(T::cast(obj), isolate);
    2406             : }
    2407   636029439 : bool FixedArray::is_the_hole(Isolate* isolate, int index) {
    2408   636029439 :   return get(index)->IsTheHole(isolate);
    2409             : }
    2410             : 
    2411     6294309 : void FixedArray::set(int index, Smi* value) {
    2412             :   DCHECK(map() != GetHeap()->fixed_cow_array_map());
    2413             :   DCHECK(index >= 0 && index < this->length());
    2414             :   DCHECK(reinterpret_cast<Object*>(value)->IsSmi());
    2415   927414047 :   int offset = kHeaderSize + index * kPointerSize;
    2416  1210139051 :   NOBARRIER_WRITE_FIELD(this, offset, value);
    2417     6294309 : }
    2418             : 
    2419             : 
    2420  1267402652 : void FixedArray::set(int index, Object* value) {
    2421             :   DCHECK_NE(GetHeap()->fixed_cow_array_map(), map());
    2422             :   DCHECK(IsFixedArray());
    2423             :   DCHECK_GE(index, 0);
    2424             :   DCHECK_LT(index, this->length());
    2425  1267402652 :   int offset = kHeaderSize + index * kPointerSize;
    2426  1267402652 :   NOBARRIER_WRITE_FIELD(this, offset, value);
    2427  2534805332 :   WRITE_BARRIER(GetHeap(), this, offset, value);
    2428  1267402638 : }
    2429             : 
    2430             : 
    2431     1088004 : double FixedDoubleArray::get_scalar(int index) {
    2432             :   DCHECK(map() != GetHeap()->fixed_cow_array_map() &&
    2433             :          map() != GetHeap()->fixed_array_map());
    2434             :   DCHECK(index >= 0 && index < this->length());
    2435             :   DCHECK(!is_the_hole(index));
    2436    15461556 :   return READ_DOUBLE_FIELD(this, kHeaderSize + index * kDoubleSize);
    2437             : }
    2438             : 
    2439             : 
    2440             : uint64_t FixedDoubleArray::get_representation(int index) {
    2441             :   DCHECK(map() != GetHeap()->fixed_cow_array_map() &&
    2442             :          map() != GetHeap()->fixed_array_map());
    2443             :   DCHECK(index >= 0 && index < this->length());
    2444    28953458 :   int offset = kHeaderSize + index * kDoubleSize;
    2445    28953458 :   return READ_UINT64_FIELD(this, offset);
    2446             : }
    2447             : 
    2448    14439798 : Handle<Object> FixedDoubleArray::get(FixedDoubleArray* array, int index,
    2449             :                                      Isolate* isolate) {
    2450    14439798 :   if (array->is_the_hole(index)) {
    2451     1306236 :     return isolate->factory()->the_hole_value();
    2452             :   } else {
    2453    13133562 :     return isolate->factory()->NewNumber(array->get_scalar(index));
    2454             :   }
    2455             : }
    2456             : 
    2457             : 
    2458    34897920 : void FixedDoubleArray::set(int index, double value) {
    2459             :   DCHECK(map() != GetHeap()->fixed_cow_array_map() &&
    2460             :          map() != GetHeap()->fixed_array_map());
    2461    46341632 :   int offset = kHeaderSize + index * kDoubleSize;
    2462    46341632 :   if (std::isnan(value)) {
    2463      183640 :     WRITE_DOUBLE_FIELD(this, offset, std::numeric_limits<double>::quiet_NaN());
    2464             :   } else {
    2465    46157992 :     WRITE_DOUBLE_FIELD(this, offset, value);
    2466             :   }
    2467             :   DCHECK(!is_the_hole(index));
    2468    34897920 : }
    2469             : 
    2470             : void FixedDoubleArray::set_the_hole(Isolate* isolate, int index) {
    2471             :   set_the_hole(index);
    2472             : }
    2473             : 
    2474             : void FixedDoubleArray::set_the_hole(int index) {
    2475             :   DCHECK(map() != GetHeap()->fixed_cow_array_map() &&
    2476             :          map() != GetHeap()->fixed_array_map());
    2477    47257346 :   int offset = kHeaderSize + index * kDoubleSize;
    2478    47257346 :   WRITE_UINT64_FIELD(this, offset, kHoleNanInt64);
    2479             : }
    2480             : 
    2481             : bool FixedDoubleArray::is_the_hole(Isolate* isolate, int index) {
    2482             :   return is_the_hole(index);
    2483             : }
    2484             : 
    2485             : bool FixedDoubleArray::is_the_hole(int index) {
    2486             :   return get_representation(index) == kHoleNanInt64;
    2487             : }
    2488             : 
    2489             : 
    2490             : double* FixedDoubleArray::data_start() {
    2491             :   return reinterpret_cast<double*>(FIELD_ADDR(this, kHeaderSize));
    2492             : }
    2493             : 
    2494             : 
    2495             : void FixedDoubleArray::FillWithHoles(int from, int to) {
    2496     1089217 :   for (int i = from; i < to; i++) {
    2497             :     set_the_hole(i);
    2498             :   }
    2499             : }
    2500             : 
    2501             : 
    2502    81463437 : Object* WeakFixedArray::Get(int index) const {
    2503    81463437 :   Object* raw = FixedArray::cast(this)->get(index + kFirstIndex);
    2504    81463437 :   if (raw->IsSmi()) return raw;
    2505             :   DCHECK(raw->IsWeakCell());
    2506    67406353 :   return WeakCell::cast(raw)->value();
    2507             : }
    2508             : 
    2509             : 
    2510             : bool WeakFixedArray::IsEmptySlot(int index) const {
    2511             :   DCHECK(index < Length());
    2512    57574813 :   return Get(index)->IsSmi();
    2513             : }
    2514             : 
    2515             : 
    2516             : void WeakFixedArray::Clear(int index) {
    2517             :   FixedArray::cast(this)->set(index + kFirstIndex, Smi::kZero);
    2518             : }
    2519             : 
    2520             : 
    2521             : int WeakFixedArray::Length() const {
    2522    31130118 :   return FixedArray::cast(this)->length() - kFirstIndex;
    2523             : }
    2524             : 
    2525             : 
    2526             : int WeakFixedArray::last_used_index() const {
    2527             :   return Smi::cast(FixedArray::cast(this)->get(kLastUsedIndexIndex))->value();
    2528             : }
    2529             : 
    2530             : 
    2531             : void WeakFixedArray::set_last_used_index(int index) {
    2532             :   FixedArray::cast(this)->set(kLastUsedIndexIndex, Smi::FromInt(index));
    2533             : }
    2534             : 
    2535             : 
    2536             : template <class T>
    2537    23791470 : T* WeakFixedArray::Iterator::Next() {
    2538    23791470 :   if (list_ != NULL) {
    2539             :     // Assert that list did not change during iteration.
    2540             :     DCHECK_EQ(last_used_index_, list_->last_used_index());
    2541    34547286 :     while (index_ < list_->Length()) {
    2542    17053117 :       Object* item = list_->Get(index_++);
    2543    17053117 :       if (item != Empty()) return T::cast(item);
    2544             :     }
    2545      220526 :     list_ = NULL;
    2546             :   }
    2547             :   return NULL;
    2548             : }
    2549             : 
    2550     2074374 : int ArrayList::Length() const {
    2551     2074374 :   if (FixedArray::cast(this)->length() == 0) return 0;
    2552     2056532 :   return Smi::cast(FixedArray::cast(this)->get(kLengthIndex))->value();
    2553             : }
    2554             : 
    2555             : 
    2556             : void ArrayList::SetLength(int length) {
    2557             :   return FixedArray::cast(this)->set(kLengthIndex, Smi::FromInt(length));
    2558             : }
    2559             : 
    2560             : Object* ArrayList::Get(int index) const {
    2561     1984721 :   return FixedArray::cast(this)->get(kFirstIndex + index);
    2562             : }
    2563             : 
    2564             : 
    2565             : Object** ArrayList::Slot(int index) {
    2566     1339666 :   return data_start() + kFirstIndex + index;
    2567             : }
    2568             : 
    2569             : void ArrayList::Set(int index, Object* obj, WriteBarrierMode mode) {
    2570     3273145 :   FixedArray::cast(this)->set(kFirstIndex + index, obj, mode);
    2571             : }
    2572             : 
    2573             : 
    2574             : void ArrayList::Clear(int index, Object* undefined) {
    2575             :   DCHECK(undefined->IsUndefined(GetIsolate()));
    2576             :   FixedArray::cast(this)
    2577       13598 :       ->set(kFirstIndex + index, undefined, SKIP_WRITE_BARRIER);
    2578             : }
    2579             : 
    2580         445 : int RegExpMatchInfo::NumberOfCaptureRegisters() {
    2581             :   DCHECK_GE(length(), kLastMatchOverhead);
    2582             :   Object* obj = get(kNumberOfCapturesIndex);
    2583         445 :   return Smi::cast(obj)->value();
    2584             : }
    2585             : 
    2586             : void RegExpMatchInfo::SetNumberOfCaptureRegisters(int value) {
    2587             :   DCHECK_GE(length(), kLastMatchOverhead);
    2588             :   set(kNumberOfCapturesIndex, Smi::FromInt(value));
    2589             : }
    2590             : 
    2591             : String* RegExpMatchInfo::LastSubject() {
    2592             :   DCHECK_GE(length(), kLastMatchOverhead);
    2593             :   Object* obj = get(kLastSubjectIndex);
    2594             :   return String::cast(obj);
    2595             : }
    2596             : 
    2597             : void RegExpMatchInfo::SetLastSubject(String* value) {
    2598             :   DCHECK_GE(length(), kLastMatchOverhead);
    2599      590141 :   set(kLastSubjectIndex, value);
    2600             : }
    2601             : 
    2602             : Object* RegExpMatchInfo::LastInput() {
    2603             :   DCHECK_GE(length(), kLastMatchOverhead);
    2604             :   return get(kLastInputIndex);
    2605             : }
    2606             : 
    2607             : void RegExpMatchInfo::SetLastInput(Object* value) {
    2608             :   DCHECK_GE(length(), kLastMatchOverhead);
    2609      590212 :   set(kLastInputIndex, value);
    2610             : }
    2611             : 
    2612         890 : int RegExpMatchInfo::Capture(int i) {
    2613             :   DCHECK_LT(i, NumberOfCaptureRegisters());
    2614      844228 :   Object* obj = get(kFirstCaptureIndex + i);
    2615         890 :   return Smi::cast(obj)->value();
    2616             : }
    2617             : 
    2618             : void RegExpMatchInfo::SetCapture(int i, int value) {
    2619             :   DCHECK_LT(i, NumberOfCaptureRegisters());
    2620             :   set(kFirstCaptureIndex + i, Smi::FromInt(value));
    2621             : }
    2622             : 
    2623    84547900 : WriteBarrierMode HeapObject::GetWriteBarrierMode(
    2624             :     const DisallowHeapAllocation& promise) {
    2625    84547900 :   Heap* heap = GetHeap();
    2626    84547907 :   if (heap->incremental_marking()->IsMarking()) return UPDATE_WRITE_BARRIER;
    2627    81754264 :   if (heap->InNewSpace(this)) return SKIP_WRITE_BARRIER;
    2628             :   return UPDATE_WRITE_BARRIER;
    2629             : }
    2630             : 
    2631             : 
    2632             : AllocationAlignment HeapObject::RequiredAlignment() {
    2633             : #ifdef V8_HOST_ARCH_32_BIT
    2634             :   if ((IsFixedFloat64Array() || IsFixedDoubleArray()) &&
    2635             :       FixedArrayBase::cast(this)->length() != 0) {
    2636             :     return kDoubleAligned;
    2637             :   }
    2638             :   if (IsHeapNumber()) return kDoubleUnaligned;
    2639             : #endif  // V8_HOST_ARCH_32_BIT
    2640             :   return kWordAligned;
    2641             : }
    2642             : 
    2643             : 
    2644  1464816528 : void FixedArray::set(int index,
    2645             :                      Object* value,
    2646             :                      WriteBarrierMode mode) {
    2647             :   DCHECK_NE(map(), GetHeap()->fixed_cow_array_map());
    2648             :   DCHECK_GE(index, 0);
    2649             :   DCHECK_LT(index, this->length());
    2650  1464816528 :   int offset = kHeaderSize + index * kPointerSize;
    2651  1464816528 :   NOBARRIER_WRITE_FIELD(this, offset, value);
    2652  2340261225 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode);
    2653  1464816541 : }
    2654             : 
    2655             : 
    2656             : void FixedArray::NoWriteBarrierSet(FixedArray* array,
    2657             :                                    int index,
    2658             :                                    Object* value) {
    2659             :   DCHECK_NE(array->map(), array->GetHeap()->fixed_cow_array_map());
    2660             :   DCHECK_GE(index, 0);
    2661             :   DCHECK_LT(index, array->length());
    2662             :   DCHECK(!array->GetHeap()->InNewSpace(value));
    2663   368244307 :   NOBARRIER_WRITE_FIELD(array, kHeaderSize + index * kPointerSize, value);
    2664             : }
    2665             : 
    2666   343690133 : void FixedArray::set_undefined(int index) {
    2667             :   set_undefined(GetIsolate(), index);
    2668   343690133 : }
    2669             : 
    2670             : void FixedArray::set_undefined(Isolate* isolate, int index) {
    2671             :   FixedArray::NoWriteBarrierSet(this, index,
    2672   343692460 :                                 isolate->heap()->undefined_value());
    2673             : }
    2674             : 
    2675        1642 : void FixedArray::set_null(int index) { set_null(GetIsolate(), index); }
    2676             : 
    2677             : void FixedArray::set_null(Isolate* isolate, int index) {
    2678         821 :   FixedArray::NoWriteBarrierSet(this, index, isolate->heap()->null_value());
    2679             : }
    2680             : 
    2681         972 : void FixedArray::set_the_hole(int index) { set_the_hole(GetIsolate(), index); }
    2682             : 
    2683             : void FixedArray::set_the_hole(Isolate* isolate, int index) {
    2684    24536977 :   FixedArray::NoWriteBarrierSet(this, index, isolate->heap()->the_hole_value());
    2685             : }
    2686             : 
    2687     1582049 : void FixedArray::FillWithHoles(int from, int to) {
    2688             :   Isolate* isolate = GetIsolate();
    2689    13278545 :   for (int i = from; i < to; i++) {
    2690             :     set_the_hole(isolate, i);
    2691             :   }
    2692     1582049 : }
    2693             : 
    2694             : 
    2695           0 : Object** FixedArray::data_start() {
    2696           0 :   return HeapObject::RawField(this, kHeaderSize);
    2697             : }
    2698             : 
    2699             : 
    2700             : Object** FixedArray::RawFieldOfElementAt(int index) {
    2701             :   return HeapObject::RawField(this, OffsetOfElementAt(index));
    2702             : }
    2703             : 
    2704             : bool DescriptorArray::IsEmpty() {
    2705             :   DCHECK(length() >= kFirstIndex ||
    2706             :          this == GetHeap()->empty_descriptor_array());
    2707             :   return length() < kFirstIndex;
    2708             : }
    2709             : 
    2710             : 
    2711   125999356 : int DescriptorArray::number_of_descriptors() {
    2712             :   DCHECK(length() >= kFirstIndex || IsEmpty());
    2713             :   int len = length();
    2714   251998712 :   return len == 0 ? 0 : Smi::cast(get(kDescriptorLengthIndex))->value();
    2715             : }
    2716             : 
    2717             : 
    2718             : int DescriptorArray::number_of_descriptors_storage() {
    2719             :   int len = length();
    2720    15376286 :   return len == 0 ? 0 : (len - kFirstIndex) / kEntrySize;
    2721             : }
    2722             : 
    2723             : 
    2724    15361513 : int DescriptorArray::NumberOfSlackDescriptors() {
    2725    15361513 :   return number_of_descriptors_storage() - number_of_descriptors();
    2726             : }
    2727             : 
    2728             : 
    2729             : void DescriptorArray::SetNumberOfDescriptors(int number_of_descriptors) {
    2730             :   WRITE_FIELD(
    2731    14275674 :       this, kDescriptorLengthOffset, Smi::FromInt(number_of_descriptors));
    2732             : }
    2733             : 
    2734             : 
    2735             : inline int DescriptorArray::number_of_entries() {
    2736    33042169 :   return number_of_descriptors();
    2737             : }
    2738             : 
    2739             : 
    2740    22036671 : bool DescriptorArray::HasEnumCache() {
    2741    42631030 :   return !IsEmpty() && !get(kEnumCacheIndex)->IsSmi();
    2742             : }
    2743             : 
    2744             : 
    2745       36845 : void DescriptorArray::CopyEnumCacheFrom(DescriptorArray* array) {
    2746       36845 :   set(kEnumCacheIndex, array->get(kEnumCacheIndex));
    2747       36845 : }
    2748             : 
    2749             : 
    2750    14716029 : FixedArray* DescriptorArray::GetEnumCache() {
    2751             :   DCHECK(HasEnumCache());
    2752             :   FixedArray* bridge = FixedArray::cast(get(kEnumCacheIndex));
    2753    14716029 :   return FixedArray::cast(bridge->get(kEnumCacheBridgeCacheIndex));
    2754             : }
    2755             : 
    2756             : 
    2757       12128 : bool DescriptorArray::HasEnumIndicesCache() {
    2758       12128 :   if (IsEmpty()) return false;
    2759             :   Object* object = get(kEnumCacheIndex);
    2760       12128 :   if (object->IsSmi()) return false;
    2761             :   FixedArray* bridge = FixedArray::cast(object);
    2762       12128 :   return !bridge->get(kEnumCacheBridgeIndicesCacheIndex)->IsSmi();
    2763             : }
    2764             : 
    2765             : 
    2766       12121 : FixedArray* DescriptorArray::GetEnumIndicesCache() {
    2767             :   DCHECK(HasEnumIndicesCache());
    2768             :   FixedArray* bridge = FixedArray::cast(get(kEnumCacheIndex));
    2769       12121 :   return FixedArray::cast(bridge->get(kEnumCacheBridgeIndicesCacheIndex));
    2770             : }
    2771             : 
    2772             : 
    2773             : Object** DescriptorArray::GetEnumCacheSlot() {
    2774             :   DCHECK(HasEnumCache());
    2775             :   return HeapObject::RawField(reinterpret_cast<HeapObject*>(this),
    2776             :                               kEnumCacheOffset);
    2777             : }
    2778             : 
    2779             : // Perform a binary search in a fixed array.
    2780             : template <SearchMode search_mode, typename T>
    2781    43415927 : int BinarySearch(T* array, Name* name, int valid_entries,
    2782             :                  int* out_insertion_index) {
    2783             :   DCHECK(search_mode == ALL_ENTRIES || out_insertion_index == NULL);
    2784             :   int low = 0;
    2785    43415933 :   int high = array->number_of_entries() - 1;
    2786             :   uint32_t hash = name->hash_field();
    2787             :   int limit = high;
    2788             : 
    2789             :   DCHECK(low <= high);
    2790             : 
    2791   273941791 :   while (low != high) {
    2792   187109931 :     int mid = low + (high - low) / 2;
    2793   143294394 :     Name* mid_name = array->GetSortedKey(mid);
    2794             :     uint32_t mid_hash = mid_name->hash_field();
    2795             : 
    2796   187109925 :     if (mid_hash >= hash) {
    2797             :       high = mid;
    2798             :     } else {
    2799    97073216 :       low = mid + 1;
    2800             :     }
    2801             :   }
    2802             : 
    2803           0 :   for (; low <= limit; ++low) {
    2804             :     int sort_index = array->GetSortedKeyIndex(low);
    2805             :     Name* entry = array->GetKey(sort_index);
    2806             :     uint32_t current_hash = entry->hash_field();
    2807    43415927 :     if (current_hash != hash) {
    2808      299759 :       if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) {
    2809      131760 :         *out_insertion_index = sort_index + (current_hash > hash ? 0 : 1);
    2810             :       }
    2811             :       return T::kNotFound;
    2812             :     }
    2813    26567263 :     if (entry == name) {
    2814    16493264 :       if (search_mode == ALL_ENTRIES || sort_index < valid_entries) {
    2815    16049466 :         return sort_index;
    2816             :       }
    2817             :       return T::kNotFound;
    2818             :     }
    2819             :   }
    2820             : 
    2821           0 :   if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) {
    2822           0 :     *out_insertion_index = limit + 1;
    2823             :   }
    2824             :   return T::kNotFound;
    2825             : }
    2826             : 
    2827             : 
    2828             : // Perform a linear search in this fixed array. len is the number of entry
    2829             : // indices that are valid.
    2830             : template <SearchMode search_mode, typename T>
    2831    88030890 : int LinearSearch(T* array, Name* name, int valid_entries,
    2832             :                  int* out_insertion_index) {
    2833    14269614 :   if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) {
    2834             :     uint32_t hash = name->hash_field();
    2835             :     int len = array->number_of_entries();
    2836     1883620 :     for (int number = 0; number < len; number++) {
    2837             :       int sorted_index = array->GetSortedKeyIndex(number);
    2838             :       Name* entry = array->GetKey(sorted_index);
    2839             :       uint32_t current_hash = entry->hash_field();
    2840     1698742 :       if (current_hash > hash) {
    2841      318923 :         *out_insertion_index = sorted_index;
    2842      318923 :         return T::kNotFound;
    2843             :       }
    2844     1379819 :       if (entry == name) return sorted_index;
    2845             :     }
    2846      184878 :     *out_insertion_index = len;
    2847      184878 :     return T::kNotFound;
    2848             :   } else {
    2849             :     DCHECK_LE(valid_entries, array->number_of_entries());
    2850             :     DCHECK_NULL(out_insertion_index);  // Not supported here.
    2851   205167066 :     for (int number = 0; number < valid_entries; number++) {
    2852   252904345 :       if (array->GetKey(number) == name) return number;
    2853             :     }
    2854             :     return T::kNotFound;
    2855             :   }
    2856             : }
    2857             : 
    2858             : 
    2859             : template <SearchMode search_mode, typename T>
    2860   132968263 : int Search(T* array, Name* name, int valid_entries, int* out_insertion_index) {
    2861             :   SLOW_DCHECK(array->IsSortedNoDuplicates());
    2862             : 
    2863   132968263 :   if (valid_entries == 0) {
    2864      191448 :     if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) {
    2865      188093 :       *out_insertion_index = 0;
    2866             :     }
    2867             :     return T::kNotFound;
    2868             :   }
    2869             : 
    2870             :   // Fast case: do linear search for small arrays.
    2871             :   const int kMaxElementsForLinearSearch = 8;
    2872   132776829 :   if (valid_entries <= kMaxElementsForLinearSearch) {
    2873             :     return LinearSearch<search_mode>(array, name, valid_entries,
    2874    88030891 :                                      out_insertion_index);
    2875             :   }
    2876             : 
    2877             :   // Slow case: perform binary search.
    2878             :   return BinarySearch<search_mode>(array, name, valid_entries,
    2879    44745938 :                                    out_insertion_index);
    2880             : }
    2881             : 
    2882             : 
    2883             : int DescriptorArray::Search(Name* name, int valid_descriptors) {
    2884             :   DCHECK(name->IsUniqueName());
    2885   108133443 :   return internal::Search<VALID_ENTRIES>(this, name, valid_descriptors, NULL);
    2886             : }
    2887             : 
    2888   299935168 : int DescriptorArray::SearchWithCache(Isolate* isolate, Name* name, Map* map) {
    2889             :   DCHECK(name->IsUniqueName());
    2890   327914137 :   int number_of_own_descriptors = map->NumberOfOwnDescriptors();
    2891   327914170 :   if (number_of_own_descriptors == 0) return kNotFound;
    2892             : 
    2893   299935168 :   DescriptorLookupCache* cache = isolate->descriptor_lookup_cache();
    2894   299935173 :   int number = cache->Lookup(map, name);
    2895             : 
    2896   299935171 :   if (number == DescriptorLookupCache::kAbsent) {
    2897             :     number = Search(name, number_of_own_descriptors);
    2898   108133427 :     cache->Update(map, name, number);
    2899             :   }
    2900             : 
    2901             :   return number;
    2902             : }
    2903             : 
    2904             : PropertyDetails Map::GetLastDescriptorDetails() {
    2905   135427884 :   return instance_descriptors()->GetDetails(LastAdded());
    2906             : }
    2907             : 
    2908             : 
    2909             : int Map::LastAdded() {
    2910             :   int number_of_own_descriptors = NumberOfOwnDescriptors();
    2911             :   DCHECK(number_of_own_descriptors > 0);
    2912   237843085 :   return number_of_own_descriptors - 1;
    2913             : }
    2914             : 
    2915             : 
    2916   329578767 : int Map::NumberOfOwnDescriptors() {
    2917   329578767 :   return NumberOfOwnDescriptorsBits::decode(bit_field3());
    2918             : }
    2919             : 
    2920             : 
    2921             : void Map::SetNumberOfOwnDescriptors(int number) {
    2922             :   DCHECK(number <= instance_descriptors()->number_of_descriptors());
    2923             :   set_bit_field3(NumberOfOwnDescriptorsBits::update(bit_field3(), number));
    2924             : }
    2925             : 
    2926             : 
    2927       19870 : int Map::EnumLength() { return EnumLengthBits::decode(bit_field3()); }
    2928             : 
    2929             : 
    2930             : void Map::SetEnumLength(int length) {
    2931             :   if (length != kInvalidEnumCacheSentinel) {
    2932             :     DCHECK(length >= 0);
    2933             :     DCHECK(length == 0 || instance_descriptors()->HasEnumCache());
    2934             :     DCHECK(length <= NumberOfOwnDescriptors());
    2935             :   }
    2936             :   set_bit_field3(EnumLengthBits::update(bit_field3(), length));
    2937             : }
    2938             : 
    2939             : 
    2940    75754321 : FixedArrayBase* Map::GetInitialElements() {
    2941             :   FixedArrayBase* result = nullptr;
    2942    75754321 :   if (has_fast_elements() || has_fast_string_wrapper_elements()) {
    2943    75750435 :     result = GetHeap()->empty_fixed_array();
    2944        3886 :   } else if (has_fast_sloppy_arguments_elements()) {
    2945           0 :     result = GetHeap()->empty_sloppy_arguments_elements();
    2946        3886 :   } else if (has_fixed_typed_array_elements()) {
    2947           0 :     result = GetHeap()->EmptyFixedTypedArrayForMap(this);
    2948             :   } else {
    2949           0 :     UNREACHABLE();
    2950             :   }
    2951             :   DCHECK(!GetHeap()->InNewSpace(result));
    2952    75754321 :   return result;
    2953             : }
    2954             : 
    2955             : Object** DescriptorArray::GetKeySlot(int descriptor_number) {
    2956             :   DCHECK(descriptor_number < number_of_descriptors());
    2957             :   return RawFieldOfElementAt(ToKeyIndex(descriptor_number));
    2958             : }
    2959             : 
    2960             : 
    2961             : Object** DescriptorArray::GetDescriptorStartSlot(int descriptor_number) {
    2962             :   return GetKeySlot(descriptor_number);
    2963             : }
    2964             : 
    2965             : 
    2966             : Object** DescriptorArray::GetDescriptorEndSlot(int descriptor_number) {
    2967    22332733 :   return GetValueSlot(descriptor_number - 1) + 1;
    2968             : }
    2969             : 
    2970             : 
    2971     1139128 : Name* DescriptorArray::GetKey(int descriptor_number) {
    2972             :   DCHECK(descriptor_number < number_of_descriptors());
    2973     1139128 :   return Name::cast(get(ToKeyIndex(descriptor_number)));
    2974             : }
    2975             : 
    2976             : 
    2977             : int DescriptorArray::GetSortedKeyIndex(int descriptor_number) {
    2978  1101834646 :   return GetDetails(descriptor_number).pointer();
    2979             : }
    2980             : 
    2981             : 
    2982   336985680 : Name* DescriptorArray::GetSortedKey(int descriptor_number) {
    2983   336985683 :   return GetKey(GetSortedKeyIndex(descriptor_number));
    2984             : }
    2985             : 
    2986             : 
    2987   202034643 : void DescriptorArray::SetSortedKey(int descriptor_index, int pointer) {
    2988   202034643 :   PropertyDetails details = GetDetails(descriptor_index);
    2989             :   set(ToDetailsIndex(descriptor_index), details.set_pointer(pointer).AsSmi());
    2990   202034643 : }
    2991             : 
    2992             : 
    2993             : Object** DescriptorArray::GetValueSlot(int descriptor_number) {
    2994             :   DCHECK(descriptor_number < number_of_descriptors());
    2995             :   return RawFieldOfElementAt(ToValueIndex(descriptor_number));
    2996             : }
    2997             : 
    2998             : 
    2999             : int DescriptorArray::GetValueOffset(int descriptor_number) {
    3000             :   return OffsetOfElementAt(ToValueIndex(descriptor_number));
    3001             : }
    3002             : 
    3003             : 
    3004             : Object* DescriptorArray::GetValue(int descriptor_number) {
    3005             :   DCHECK(descriptor_number < number_of_descriptors());
    3006             :   return get(ToValueIndex(descriptor_number));
    3007             : }
    3008             : 
    3009             : 
    3010             : void DescriptorArray::SetValue(int descriptor_index, Object* value) {
    3011     5113417 :   set(ToValueIndex(descriptor_index), value);
    3012             : }
    3013             : 
    3014             : 
    3015  2799428620 : PropertyDetails DescriptorArray::GetDetails(int descriptor_number) {
    3016             :   DCHECK(descriptor_number < number_of_descriptors());
    3017             :   Object* details = get(ToDetailsIndex(descriptor_number));
    3018  2799428620 :   return PropertyDetails(Smi::cast(details));
    3019             : }
    3020             : 
    3021             : int DescriptorArray::GetFieldIndex(int descriptor_number) {
    3022             :   DCHECK(GetDetails(descriptor_number).location() == kField);
    3023   219174010 :   return GetDetails(descriptor_number).field_index();
    3024             : }
    3025             : 
    3026    67468751 : FieldType* DescriptorArray::GetFieldType(int descriptor_number) {
    3027             :   DCHECK(GetDetails(descriptor_number).location() == kField);
    3028             :   Object* wrapped_type = GetValue(descriptor_number);
    3029    67468751 :   return Map::UnwrapFieldType(wrapped_type);
    3030             : }
    3031             : 
    3032             : void DescriptorArray::Get(int descriptor_number, Descriptor* desc) {
    3033             :   desc->Init(handle(GetKey(descriptor_number), GetIsolate()),
    3034             :              handle(GetValue(descriptor_number), GetIsolate()),
    3035             :              GetDetails(descriptor_number));
    3036             : }
    3037             : 
    3038   175184432 : void DescriptorArray::Set(int descriptor_number, Name* key, Object* value,
    3039             :                           PropertyDetails details) {
    3040             :   // Range check.
    3041             :   DCHECK(descriptor_number < number_of_descriptors());
    3042   175184432 :   set(ToKeyIndex(descriptor_number), key);
    3043   175184439 :   set(ToValueIndex(descriptor_number), value);
    3044             :   set(ToDetailsIndex(descriptor_number), details.AsSmi());
    3045   175184437 : }
    3046             : 
    3047    20360095 : void DescriptorArray::Set(int descriptor_number, Descriptor* desc) {
    3048             :   Name* key = *desc->GetKey();
    3049             :   Object* value = *desc->GetValue();
    3050    20360095 :   Set(descriptor_number, key, value, desc->GetDetails());
    3051    20360098 : }
    3052             : 
    3053             : 
    3054    14261078 : void DescriptorArray::Append(Descriptor* desc) {
    3055             :   DisallowHeapAllocation no_gc;
    3056    14261078 :   int descriptor_number = number_of_descriptors();
    3057    14261082 :   SetNumberOfDescriptors(descriptor_number + 1);
    3058    14261082 :   Set(descriptor_number, desc);
    3059             : 
    3060             :   uint32_t hash = desc->GetKey()->Hash();
    3061             : 
    3062             :   int insertion;
    3063             : 
    3064   190250110 :   for (insertion = descriptor_number; insertion > 0; --insertion) {
    3065   171348672 :     Name* key = GetSortedKey(insertion - 1);
    3066   171348674 :     if (key->Hash() <= hash) break;
    3067   161727946 :     SetSortedKey(insertion, GetSortedKeyIndex(insertion - 1));
    3068             :   }
    3069             : 
    3070    14261083 :   SetSortedKey(insertion, descriptor_number);
    3071    14261082 : }
    3072             : 
    3073             : 
    3074    11109057 : void DescriptorArray::SwapSortedKeys(int first, int second) {
    3075             :   int first_key = GetSortedKeyIndex(first);
    3076    11109057 :   SetSortedKey(first, GetSortedKeyIndex(second));
    3077    11109057 :   SetSortedKey(second, first_key);
    3078    11109057 : }
    3079             : 
    3080             : 
    3081        1444 : int HashTableBase::NumberOfElements() {
    3082        1444 :   return Smi::cast(get(kNumberOfElementsIndex))->value();
    3083             : }
    3084             : 
    3085             : 
    3086             : int HashTableBase::NumberOfDeletedElements() {
    3087             :   return Smi::cast(get(kNumberOfDeletedElementsIndex))->value();
    3088             : }
    3089             : 
    3090             : 
    3091             : int HashTableBase::Capacity() {
    3092             :   return Smi::cast(get(kCapacityIndex))->value();
    3093             : }
    3094             : 
    3095             : 
    3096    69360167 : void HashTableBase::ElementAdded() {
    3097    69360167 :   SetNumberOfElements(NumberOfElements() + 1);
    3098    69360167 : }
    3099             : 
    3100             : 
    3101     6190531 : void HashTableBase::ElementRemoved() {
    3102     6190531 :   SetNumberOfElements(NumberOfElements() - 1);
    3103     6190531 :   SetNumberOfDeletedElements(NumberOfDeletedElements() + 1);
    3104     6190531 : }
    3105             : 
    3106             : 
    3107       53611 : void HashTableBase::ElementsRemoved(int n) {
    3108       53611 :   SetNumberOfElements(NumberOfElements() - n);
    3109       53611 :   SetNumberOfDeletedElements(NumberOfDeletedElements() + n);
    3110       53611 : }
    3111             : 
    3112             : 
    3113             : // static
    3114             : int HashTableBase::ComputeCapacity(int at_least_space_for) {
    3115             :   // Add 50% slack to make slot collisions sufficiently unlikely.
    3116             :   // See matching computation in HashTable::HasSufficientCapacityToAdd().
    3117             :   // Must be kept in sync with CodeStubAssembler::HashTableComputeCapacity().
    3118     8172602 :   int raw_cap = at_least_space_for + (at_least_space_for >> 1);
    3119     8172602 :   int capacity = base::bits::RoundUpToPowerOfTwo32(raw_cap);
    3120             :   return Max(capacity, kMinCapacity);
    3121             : }
    3122             : 
    3123        4531 : bool HashTableBase::IsKey(Isolate* isolate, Object* k) {
    3124   494835814 :   Heap* heap = isolate->heap();
    3125   494835814 :   return k != heap->the_hole_value() && k != heap->undefined_value();
    3126             : }
    3127             : 
    3128             : void HashTableBase::SetNumberOfElements(int nof) {
    3129             :   set(kNumberOfElementsIndex, Smi::FromInt(nof));
    3130             : }
    3131             : 
    3132             : 
    3133             : void HashTableBase::SetNumberOfDeletedElements(int nod) {
    3134             :   set(kNumberOfDeletedElementsIndex, Smi::FromInt(nod));
    3135             : }
    3136             : 
    3137             : template <typename Key>
    3138             : Map* BaseShape<Key>::GetMap(Isolate* isolate) {
    3139     7051348 :   return isolate->heap()->hash_table_map();
    3140             : }
    3141             : 
    3142             : template <typename Derived, typename Shape, typename Key>
    3143           0 : int HashTable<Derived, Shape, Key>::FindEntry(Key key) {
    3144   114374261 :   return FindEntry(GetIsolate(), key);
    3145             : }
    3146             : 
    3147             : 
    3148             : template<typename Derived, typename Shape, typename Key>
    3149   262503307 : int HashTable<Derived, Shape, Key>::FindEntry(Isolate* isolate, Key key) {
    3150   262503309 :   return FindEntry(isolate, key, HashTable::Hash(key));
    3151             : }
    3152             : 
    3153             : // Find entry for key otherwise return kNotFound.
    3154             : template <typename Derived, typename Shape, typename Key>
    3155   278595105 : int HashTable<Derived, Shape, Key>::FindEntry(Isolate* isolate, Key key,
    3156             :                                               int32_t hash) {
    3157   278595105 :   uint32_t capacity = Capacity();
    3158   278595105 :   uint32_t entry = FirstProbe(hash, capacity);
    3159             :   uint32_t count = 1;
    3160             :   // EnsureCapacity will guarantee the hash table is never full.
    3161   278595105 :   Object* undefined = isolate->heap()->undefined_value();
    3162   278595105 :   Object* the_hole = isolate->heap()->the_hole_value();
    3163             :   while (true) {
    3164   478398704 :     Object* element = KeyAt(entry);
    3165             :     // Empty entry. Uses raw unchecked accessors because it is called by the
    3166             :     // string table during bootstrapping.
    3167   478398704 :     if (element == undefined) break;
    3168   585119049 :     if (element != the_hole && Shape::IsMatch(key, element)) return entry;
    3169   199803599 :     entry = NextProbe(entry, count++, capacity);
    3170             :   }
    3171   199803599 :   return kNotFound;
    3172             : }
    3173             : 
    3174             : template <typename Derived, typename Shape, typename Key>
    3175        1818 : bool HashTable<Derived, Shape, Key>::Has(Key key) {
    3176        1818 :   return FindEntry(key) != kNotFound;
    3177             : }
    3178             : 
    3179             : template <typename Derived, typename Shape, typename Key>
    3180           0 : bool HashTable<Derived, Shape, Key>::Has(Isolate* isolate, Key key) {
    3181           0 :   return FindEntry(isolate, key) != kNotFound;
    3182             : }
    3183             : 
    3184             : bool ObjectHashSet::Has(Isolate* isolate, Handle<Object> key, int32_t hash) {
    3185    16034291 :   return FindEntry(isolate, key, hash) != kNotFound;
    3186             : }
    3187             : 
    3188       16135 : bool ObjectHashSet::Has(Isolate* isolate, Handle<Object> key) {
    3189       16135 :   Object* hash = key->GetHash();
    3190       16135 :   if (!hash->IsSmi()) return false;
    3191       16135 :   return FindEntry(isolate, key, Smi::cast(hash)->value()) != kNotFound;
    3192             : }
    3193             : 
    3194     2511675 : bool StringSetShape::IsMatch(String* key, Object* value) {
    3195     2511675 :   return value->IsString() && key->Equals(String::cast(value));
    3196             : }
    3197             : 
    3198             : uint32_t StringSetShape::Hash(String* key) { return key->Hash(); }
    3199             : 
    3200       24106 : uint32_t StringSetShape::HashForObject(String* key, Object* object) {
    3201       48212 :   return object->IsString() ? String::cast(object)->Hash() : 0;
    3202             : }
    3203             : 
    3204     8246987 : bool SeededNumberDictionary::requires_slow_elements() {
    3205             :   Object* max_index_object = get(kMaxNumberKeyIndex);
    3206     8246987 :   if (!max_index_object->IsSmi()) return false;
    3207             :   return 0 !=
    3208     7772696 :       (Smi::cast(max_index_object)->value() & kRequiresSlowElementsMask);
    3209             : }
    3210             : 
    3211             : 
    3212     6616350 : uint32_t SeededNumberDictionary::max_number_key() {
    3213             :   DCHECK(!requires_slow_elements());
    3214             :   Object* max_index_object = get(kMaxNumberKeyIndex);
    3215     6616350 :   if (!max_index_object->IsSmi()) return 0;
    3216     6612680 :   uint32_t value = static_cast<uint32_t>(Smi::cast(max_index_object)->value());
    3217     6612680 :   return value >> kRequiresSlowElementsTagSize;
    3218             : }
    3219             : 
    3220             : 
    3221             : void SeededNumberDictionary::set_requires_slow_elements() {
    3222             :   set(kMaxNumberKeyIndex, Smi::FromInt(kRequiresSlowElementsMask));
    3223             : }
    3224             : 
    3225             : 
    3226             : template <class T>
    3227             : PodArray<T>* PodArray<T>::cast(Object* object) {
    3228             :   SLOW_DCHECK(object->IsByteArray());
    3229             :   return reinterpret_cast<PodArray<T>*>(object);
    3230             : }
    3231             : template <class T>
    3232             : const PodArray<T>* PodArray<T>::cast(const Object* object) {
    3233             :   SLOW_DCHECK(object->IsByteArray());
    3234             :   return reinterpret_cast<const PodArray<T>*>(object);
    3235             : }
    3236             : 
    3237             : // static
    3238             : template <class T>
    3239             : Handle<PodArray<T>> PodArray<T>::New(Isolate* isolate, int length,
    3240             :                                      PretenureFlag pretenure) {
    3241             :   return Handle<PodArray<T>>::cast(
    3242       27524 :       isolate->factory()->NewByteArray(length * sizeof(T), pretenure));
    3243             : }
    3244             : 
    3245             : // static
    3246             : template <class Traits>
    3247             : STATIC_CONST_MEMBER_DEFINITION const InstanceType
    3248             :     FixedTypedArray<Traits>::kInstanceType;
    3249             : 
    3250             : 
    3251             : template <class Traits>
    3252             : FixedTypedArray<Traits>* FixedTypedArray<Traits>::cast(Object* object) {
    3253             :   SLOW_DCHECK(object->IsHeapObject() &&
    3254             :               HeapObject::cast(object)->map()->instance_type() ==
    3255             :               Traits::kInstanceType);
    3256             :   return reinterpret_cast<FixedTypedArray<Traits>*>(object);
    3257             : }
    3258             : 
    3259             : 
    3260             : template <class Traits>
    3261             : const FixedTypedArray<Traits>*
    3262             : FixedTypedArray<Traits>::cast(const Object* object) {
    3263             :   SLOW_DCHECK(object->IsHeapObject() &&
    3264             :               HeapObject::cast(object)->map()->instance_type() ==
    3265             :               Traits::kInstanceType);
    3266             :   return reinterpret_cast<FixedTypedArray<Traits>*>(object);
    3267             : }
    3268             : 
    3269             : 
    3270             : #define DEFINE_DEOPT_ELEMENT_ACCESSORS(name, type)       \
    3271             :   type* DeoptimizationInputData::name() {                \
    3272             :     return type::cast(get(k##name##Index));              \
    3273             :   }                                                      \
    3274             :   void DeoptimizationInputData::Set##name(type* value) { \
    3275             :     set(k##name##Index, value);                          \
    3276             :   }
    3277             : 
    3278      670855 : DEFINE_DEOPT_ELEMENT_ACCESSORS(TranslationByteArray, ByteArray)
    3279             : DEFINE_DEOPT_ELEMENT_ACCESSORS(InlinedFunctionCount, Smi)
    3280      670855 : DEFINE_DEOPT_ELEMENT_ACCESSORS(LiteralArray, FixedArray)
    3281             : DEFINE_DEOPT_ELEMENT_ACCESSORS(OsrAstId, Smi)
    3282       16786 : DEFINE_DEOPT_ELEMENT_ACCESSORS(OsrPcOffset, Smi)
    3283             : DEFINE_DEOPT_ELEMENT_ACCESSORS(OptimizationId, Smi)
    3284     1093020 : DEFINE_DEOPT_ELEMENT_ACCESSORS(SharedFunctionInfo, Object)
    3285      613072 : DEFINE_DEOPT_ELEMENT_ACCESSORS(WeakCellCache, Object)
    3286      670853 : DEFINE_DEOPT_ELEMENT_ACCESSORS(InliningPositions, PodArray<InliningPosition>)
    3287             : 
    3288             : #undef DEFINE_DEOPT_ELEMENT_ACCESSORS
    3289             : 
    3290             : 
    3291             : #define DEFINE_DEOPT_ENTRY_ACCESSORS(name, type)                \
    3292             :   type* DeoptimizationInputData::name(int i) {                  \
    3293             :     return type::cast(get(IndexForEntry(i) + k##name##Offset)); \
    3294             :   }                                                             \
    3295             :   void DeoptimizationInputData::Set##name(int i, type* value) { \
    3296             :     set(IndexForEntry(i) + k##name##Offset, value);             \
    3297             :   }
    3298             : 
    3299    13491850 : DEFINE_DEOPT_ENTRY_ACCESSORS(AstIdRaw, Smi)
    3300    18849367 : DEFINE_DEOPT_ENTRY_ACCESSORS(TranslationIndex, Smi)
    3301    13865590 : DEFINE_DEOPT_ENTRY_ACCESSORS(ArgumentsStackHeight, Smi)
    3302    36570290 : DEFINE_DEOPT_ENTRY_ACCESSORS(Pc, Smi)
    3303             : 
    3304             : #undef DEFINE_DEOPT_ENTRY_ACCESSORS
    3305             : 
    3306             : 
    3307      155604 : BailoutId DeoptimizationInputData::AstId(int i) {
    3308      155604 :   return BailoutId(AstIdRaw(i)->value());
    3309             : }
    3310             : 
    3311             : 
    3312             : void DeoptimizationInputData::SetAstId(int i, BailoutId value) {
    3313     6745924 :   SetAstIdRaw(i, Smi::FromInt(value.ToInt()));
    3314             : }
    3315             : 
    3316             : 
    3317             : int DeoptimizationInputData::DeoptCount() {
    3318     5129829 :   return (length() - kFirstDeoptEntryIndex) / kDeoptEntrySize;
    3319             : }
    3320             : 
    3321             : 
    3322      570503 : int DeoptimizationOutputData::DeoptPoints() { return length() / 2; }
    3323             : 
    3324             : 
    3325    24903103 : BailoutId DeoptimizationOutputData::AstId(int index) {
    3326    49806206 :   return BailoutId(Smi::cast(get(index * 2))->value());
    3327             : }
    3328             : 
    3329             : 
    3330     8420349 : void DeoptimizationOutputData::SetAstId(int index, BailoutId id) {
    3331     8420349 :   set(index * 2, Smi::FromInt(id.ToInt()));
    3332     8420349 : }
    3333             : 
    3334             : 
    3335             : Smi* DeoptimizationOutputData::PcAndState(int index) {
    3336      570503 :   return Smi::cast(get(1 + index * 2));
    3337             : }
    3338             : 
    3339             : 
    3340             : void DeoptimizationOutputData::SetPcAndState(int index, Smi* offset) {
    3341     8420349 :   set(1 + index * 2, offset);
    3342             : }
    3343             : 
    3344             : int HandlerTable::GetRangeStart(int index) const {
    3345     1522708 :   return Smi::cast(get(index * kRangeEntrySize + kRangeStartIndex))->value();
    3346             : }
    3347             : 
    3348       38737 : int HandlerTable::GetRangeEnd(int index) const {
    3349       77474 :   return Smi::cast(get(index * kRangeEntrySize + kRangeEndIndex))->value();
    3350             : }
    3351             : 
    3352       38737 : int HandlerTable::GetRangeHandler(int index) const {
    3353             :   return HandlerOffsetField::decode(
    3354      116211 :       Smi::cast(get(index * kRangeEntrySize + kRangeHandlerIndex))->value());
    3355             : }
    3356             : 
    3357       38737 : int HandlerTable::GetRangeData(int index) const {
    3358       77474 :   return Smi::cast(get(index * kRangeEntrySize + kRangeDataIndex))->value();
    3359             : }
    3360             : 
    3361      176509 : void HandlerTable::SetRangeStart(int index, int value) {
    3362      176509 :   set(index * kRangeEntrySize + kRangeStartIndex, Smi::FromInt(value));
    3363      176509 : }
    3364             : 
    3365             : 
    3366      176509 : void HandlerTable::SetRangeEnd(int index, int value) {
    3367      176509 :   set(index * kRangeEntrySize + kRangeEndIndex, Smi::FromInt(value));
    3368      176509 : }
    3369             : 
    3370             : 
    3371      176509 : void HandlerTable::SetRangeHandler(int index, int offset,
    3372             :                                    CatchPrediction prediction) {
    3373      176509 :   int value = HandlerOffsetField::encode(offset) |
    3374      176509 :               HandlerPredictionField::encode(prediction);
    3375      176509 :   set(index * kRangeEntrySize + kRangeHandlerIndex, Smi::FromInt(value));
    3376      176509 : }
    3377             : 
    3378      176509 : void HandlerTable::SetRangeData(int index, int value) {
    3379      176509 :   set(index * kRangeEntrySize + kRangeDataIndex, Smi::FromInt(value));
    3380      176509 : }
    3381             : 
    3382             : 
    3383      229725 : void HandlerTable::SetReturnOffset(int index, int value) {
    3384      229725 :   set(index * kReturnEntrySize + kReturnOffsetIndex, Smi::FromInt(value));
    3385      229725 : }
    3386             : 
    3387      229725 : void HandlerTable::SetReturnHandler(int index, int offset) {
    3388      229725 :   int value = HandlerOffsetField::encode(offset);
    3389      229725 :   set(index * kReturnEntrySize + kReturnHandlerIndex, Smi::FromInt(value));
    3390      229725 : }
    3391             : 
    3392             : int HandlerTable::NumberOfRangeEntries() const {
    3393    14329222 :   return length() / kRangeEntrySize;
    3394             : }
    3395             : 
    3396             : template <typename Derived, typename Shape, typename Key>
    3397             : HashTable<Derived, Shape, Key>*
    3398           0 : HashTable<Derived, Shape, Key>::cast(Object* obj) {
    3399             :   SLOW_DCHECK(obj->IsHashTable());
    3400           0 :   return reinterpret_cast<HashTable*>(obj);
    3401             : }
    3402             : 
    3403             : 
    3404             : template <typename Derived, typename Shape, typename Key>
    3405             : const HashTable<Derived, Shape, Key>*
    3406           0 : HashTable<Derived, Shape, Key>::cast(const Object* obj) {
    3407             :   SLOW_DCHECK(obj->IsHashTable());
    3408           0 :   return reinterpret_cast<const HashTable*>(obj);
    3409             : }
    3410             : 
    3411             : 
    3412  2045286580 : SMI_ACCESSORS(FixedArrayBase, length, kLengthOffset)
    3413   372133979 : SYNCHRONIZED_SMI_ACCESSORS(FixedArrayBase, length, kLengthOffset)
    3414             : 
    3415     2262765 : SMI_ACCESSORS(FreeSpace, size, kSizeOffset)
    3416   146411703 : NOBARRIER_SMI_ACCESSORS(FreeSpace, size, kSizeOffset)
    3417             : 
    3418 25747488476 : SMI_ACCESSORS(String, length, kLengthOffset)
    3419   469474131 : SYNCHRONIZED_SMI_ACCESSORS(String, length, kLengthOffset)
    3420             : 
    3421             : 
    3422             : int FreeSpace::Size() { return size(); }
    3423             : 
    3424             : 
    3425             : FreeSpace* FreeSpace::next() {
    3426             :   DCHECK(map() == GetHeap()->root(Heap::kFreeSpaceMapRootIndex) ||
    3427             :          (!GetHeap()->deserialization_complete() && map() == NULL));
    3428             :   DCHECK_LE(kNextOffset + kPointerSize, nobarrier_size());
    3429             :   return reinterpret_cast<FreeSpace*>(
    3430     2375857 :       Memory::Address_at(address() + kNextOffset));
    3431             : }
    3432             : 
    3433             : 
    3434             : void FreeSpace::set_next(FreeSpace* next) {
    3435             :   DCHECK(map() == GetHeap()->root(Heap::kFreeSpaceMapRootIndex) ||
    3436             :          (!GetHeap()->deserialization_complete() && map() == NULL));
    3437             :   DCHECK_LE(kNextOffset + kPointerSize, nobarrier_size());
    3438             :   base::NoBarrier_Store(
    3439             :       reinterpret_cast<base::AtomicWord*>(address() + kNextOffset),
    3440    35108610 :       reinterpret_cast<base::AtomicWord>(next));
    3441             : }
    3442             : 
    3443             : 
    3444        4198 : FreeSpace* FreeSpace::cast(HeapObject* o) {
    3445             :   SLOW_DCHECK(!o->GetHeap()->deserialization_complete() || o->IsFreeSpace());
    3446        4198 :   return reinterpret_cast<FreeSpace*>(o);
    3447             : }
    3448             : 
    3449             : 
    3450       66085 : uint32_t Name::hash_field() {
    3451  1546233852 :   return READ_UINT32_FIELD(this, kHashFieldOffset);
    3452             : }
    3453             : 
    3454             : 
    3455             : void Name::set_hash_field(uint32_t value) {
    3456   258543202 :   WRITE_UINT32_FIELD(this, kHashFieldOffset, value);
    3457             : #if V8_HOST_ARCH_64_BIT
    3458             : #if V8_TARGET_LITTLE_ENDIAN
    3459   258543202 :   WRITE_UINT32_FIELD(this, kHashFieldSlot + kIntSize, 0);
    3460             : #else
    3461             :   WRITE_UINT32_FIELD(this, kHashFieldSlot, 0);
    3462             : #endif
    3463             : #endif
    3464             : }
    3465             : 
    3466             : 
    3467      143793 : bool Name::Equals(Name* other) {
    3468      143793 :   if (other == this) return true;
    3469      188471 :   if ((this->IsInternalizedString() && other->IsInternalizedString()) ||
    3470       94567 :       this->IsSymbol() || other->IsSymbol()) {
    3471             :     return false;
    3472             :   }
    3473          15 :   return String::cast(this)->SlowEquals(String::cast(other));
    3474             : }
    3475             : 
    3476             : 
    3477     1401030 : bool Name::Equals(Handle<Name> one, Handle<Name> two) {
    3478     1401030 :   if (one.is_identical_to(two)) return true;
    3479     2284252 :   if ((one->IsInternalizedString() && two->IsInternalizedString()) ||
    3480     1142156 :       one->IsSymbol() || two->IsSymbol()) {
    3481             :     return false;
    3482             :   }
    3483             :   return String::SlowEquals(Handle<String>::cast(one),
    3484          30 :                             Handle<String>::cast(two));
    3485             : }
    3486             : 
    3487             : 
    3488     1505159 : ACCESSORS(Symbol, name, Object, kNameOffset)
    3489    42926480 : SMI_ACCESSORS(Symbol, flags, kFlagsOffset)
    3490        2240 : BOOL_ACCESSORS(Symbol, flags, is_private, kPrivateBit)
    3491             : BOOL_ACCESSORS(Symbol, flags, is_well_known_symbol, kWellKnownSymbolBit)
    3492             : BOOL_ACCESSORS(Symbol, flags, is_public, kPublicBit)
    3493             : 
    3494   132151924 : bool String::Equals(String* other) {
    3495   132151924 :   if (other == this) return true;
    3496   217702054 :   if (this->IsInternalizedString() && other->IsInternalizedString()) {
    3497             :     return false;
    3498             :   }
    3499    35260274 :   return SlowEquals(other);
    3500             : }
    3501             : 
    3502             : 
    3503     7223046 : bool String::Equals(Handle<String> one, Handle<String> two) {
    3504     7223046 :   if (one.is_identical_to(two)) return true;
    3505     7768020 :   if (one->IsInternalizedString() && two->IsInternalizedString()) {
    3506             :     return false;
    3507             :   }
    3508     6240760 :   return SlowEquals(one, two);
    3509             : }
    3510             : 
    3511             : 
    3512    81636753 : Handle<String> String::Flatten(Handle<String> string, PretenureFlag pretenure) {
    3513    81636752 :   if (string->IsConsString()) {
    3514             :     Handle<ConsString> cons = Handle<ConsString>::cast(string);
    3515     6153984 :     if (cons->IsFlat()) {
    3516             :       string = handle(cons->first());
    3517             :     } else {
    3518     5838673 :       return SlowFlatten(cons, pretenure);
    3519             :     }
    3520             :   }
    3521    75798072 :   if (string->IsThinString()) {
    3522             :     string = handle(Handle<ThinString>::cast(string)->actual());
    3523             :     DCHECK(!string->IsConsString());
    3524             :   }
    3525    75798072 :   return string;
    3526             : }
    3527             : 
    3528             : 
    3529             : uint16_t String::Get(int index) {
    3530             :   DCHECK(index >= 0 && index < length());
    3531   711884274 :   switch (StringShape(this).full_representation_tag()) {
    3532             :     case kSeqStringTag | kOneByteStringTag:
    3533   669062216 :       return SeqOneByteString::cast(this)->SeqOneByteStringGet(index);
    3534             :     case kSeqStringTag | kTwoByteStringTag:
    3535    32117543 :       return SeqTwoByteString::cast(this)->SeqTwoByteStringGet(index);
    3536             :     case kConsStringTag | kOneByteStringTag:
    3537             :     case kConsStringTag | kTwoByteStringTag:
    3538     4308780 :       return ConsString::cast(this)->ConsStringGet(index);
    3539             :     case kExternalStringTag | kOneByteStringTag:
    3540     4569721 :       return ExternalOneByteString::cast(this)->ExternalOneByteStringGet(index);
    3541             :     case kExternalStringTag | kTwoByteStringTag:
    3542        8878 :       return ExternalTwoByteString::cast(this)->ExternalTwoByteStringGet(index);
    3543             :     case kSlicedStringTag | kOneByteStringTag:
    3544             :     case kSlicedStringTag | kTwoByteStringTag:
    3545     1816876 :       return SlicedString::cast(this)->SlicedStringGet(index);
    3546             :     case kThinStringTag | kOneByteStringTag:
    3547             :     case kThinStringTag | kTwoByteStringTag:
    3548         258 :       return ThinString::cast(this)->ThinStringGet(index);
    3549             :     default:
    3550             :       break;
    3551             :   }
    3552             : 
    3553           0 :   UNREACHABLE();
    3554             :   return 0;
    3555             : }
    3556             : 
    3557             : 
    3558           0 : void String::Set(int index, uint16_t value) {
    3559             :   DCHECK(index >= 0 && index < length());
    3560             :   DCHECK(StringShape(this).IsSequential());
    3561             : 
    3562             :   return this->IsOneByteRepresentation()
    3563             :       ? SeqOneByteString::cast(this)->SeqOneByteStringSet(index, value)
    3564           0 :       : SeqTwoByteString::cast(this)->SeqTwoByteStringSet(index, value);
    3565             : }
    3566             : 
    3567             : 
    3568     6659596 : bool String::IsFlat() {
    3569     6659596 :   if (!StringShape(this).IsCons()) return true;
    3570     6628559 :   return ConsString::cast(this)->second()->length() == 0;
    3571             : }
    3572             : 
    3573             : 
    3574             : String* String::GetUnderlying() {
    3575             :   // Giving direct access to underlying string only makes sense if the
    3576             :   // wrapping string is already flattened.
    3577             :   DCHECK(this->IsFlat());
    3578             :   DCHECK(StringShape(this).IsIndirect());
    3579             :   STATIC_ASSERT(ConsString::kFirstOffset == SlicedString::kParentOffset);
    3580             :   STATIC_ASSERT(ConsString::kFirstOffset == ThinString::kActualOffset);
    3581             :   const int kUnderlyingOffset = SlicedString::kParentOffset;
    3582        2821 :   return String::cast(READ_FIELD(this, kUnderlyingOffset));
    3583             : }
    3584             : 
    3585             : 
    3586             : template<class Visitor>
    3587   134732640 : ConsString* String::VisitFlat(Visitor* visitor,
    3588             :                               String* string,
    3589             :                               const int offset) {
    3590             :   int slice_offset = offset;
    3591             :   const int length = string->length();
    3592             :   DCHECK(offset <= length);
    3593             :   while (true) {
    3594             :     int32_t type = string->map()->instance_type();
    3595   134919046 :     switch (type & (kStringRepresentationMask | kStringEncodingMask)) {
    3596             :       case kSeqStringTag | kOneByteStringTag:
    3597   227705888 :         visitor->VisitOneByteString(
    3598   113852944 :             SeqOneByteString::cast(string)->GetChars() + slice_offset,
    3599             :             length - offset);
    3600   113852949 :         return NULL;
    3601             : 
    3602             :       case kSeqStringTag | kTwoByteStringTag:
    3603    25559854 :         visitor->VisitTwoByteString(
    3604    12779927 :             SeqTwoByteString::cast(string)->GetChars() + slice_offset,
    3605             :             length - offset);
    3606    12779927 :         return NULL;
    3607             : 
    3608             :       case kExternalStringTag | kOneByteStringTag:
    3609        3836 :         visitor->VisitOneByteString(
    3610             :             ExternalOneByteString::cast(string)->GetChars() + slice_offset,
    3611             :             length - offset);
    3612        1918 :         return NULL;
    3613             : 
    3614             :       case kExternalStringTag | kTwoByteStringTag:
    3615       43114 :         visitor->VisitTwoByteString(
    3616             :             ExternalTwoByteString::cast(string)->GetChars() + slice_offset,
    3617             :             length - offset);
    3618       21557 :         return NULL;
    3619             : 
    3620             :       case kSlicedStringTag | kOneByteStringTag:
    3621             :       case kSlicedStringTag | kTwoByteStringTag: {
    3622             :         SlicedString* slicedString = SlicedString::cast(string);
    3623      179651 :         slice_offset += slicedString->offset();
    3624             :         string = slicedString->parent();
    3625      179651 :         continue;
    3626             :       }
    3627             : 
    3628             :       case kConsStringTag | kOneByteStringTag:
    3629             :       case kConsStringTag | kTwoByteStringTag:
    3630       47532 :         return ConsString::cast(string);
    3631             : 
    3632             :       case kThinStringTag | kOneByteStringTag:
    3633             :       case kThinStringTag | kTwoByteStringTag:
    3634             :         string = ThinString::cast(string)->actual();
    3635        6755 :         continue;
    3636             : 
    3637             :       default:
    3638           0 :         UNREACHABLE();
    3639             :         return NULL;
    3640             :     }
    3641             :   }
    3642             : }
    3643             : 
    3644             : 
    3645             : template <>
    3646             : inline Vector<const uint8_t> String::GetCharVector() {
    3647     2598676 :   String::FlatContent flat = GetFlatContent();
    3648             :   DCHECK(flat.IsOneByte());
    3649     2598676 :   return flat.ToOneByteVector();
    3650             : }
    3651             : 
    3652             : 
    3653             : template <>
    3654             : inline Vector<const uc16> String::GetCharVector() {
    3655     1320415 :   String::FlatContent flat = GetFlatContent();
    3656             :   DCHECK(flat.IsTwoByte());
    3657     1320415 :   return flat.ToUC16Vector();
    3658             : }
    3659             : 
    3660             : uint32_t String::ToValidIndex(Object* number) {
    3661        9854 :   uint32_t index = PositiveNumberToUint32(number);
    3662        9854 :   uint32_t length_value = static_cast<uint32_t>(length());
    3663        9854 :   if (index > length_value) return length_value;
    3664             :   return index;
    3665             : }
    3666             : 
    3667  2424700453 : uint16_t SeqOneByteString::SeqOneByteStringGet(int index) {
    3668             :   DCHECK(index >= 0 && index < length());
    3669  2514704483 :   return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
    3670             : }
    3671             : 
    3672             : 
    3673   303549731 : void SeqOneByteString::SeqOneByteStringSet(int index, uint16_t value) {
    3674             :   DCHECK(index >= 0 && index < length() && value <= kMaxOneByteCharCode);
    3675  1472850501 :   WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize,
    3676  1472850501 :                    static_cast<byte>(value));
    3677   303549731 : }
    3678             : 
    3679             : 
    3680             : Address SeqOneByteString::GetCharsAddress() {
    3681             :   return FIELD_ADDR(this, kHeaderSize);
    3682             : }
    3683             : 
    3684             : 
    3685       49538 : uint8_t* SeqOneByteString::GetChars() {
    3686       49538 :   return reinterpret_cast<uint8_t*>(GetCharsAddress());
    3687             : }
    3688             : 
    3689             : 
    3690             : Address SeqTwoByteString::GetCharsAddress() {
    3691             :   return FIELD_ADDR(this, kHeaderSize);
    3692             : }
    3693             : 
    3694             : 
    3695       91408 : uc16* SeqTwoByteString::GetChars() {
    3696       91408 :   return reinterpret_cast<uc16*>(FIELD_ADDR(this, kHeaderSize));
    3697             : }
    3698             : 
    3699             : 
    3700    32117543 : uint16_t SeqTwoByteString::SeqTwoByteStringGet(int index) {
    3701             :   DCHECK(index >= 0 && index < length());
    3702    32117543 :   return READ_UINT16_FIELD(this, kHeaderSize + index * kShortSize);
    3703             : }
    3704             : 
    3705             : 
    3706     2279171 : void SeqTwoByteString::SeqTwoByteStringSet(int index, uint16_t value) {
    3707             :   DCHECK(index >= 0 && index < length());
    3708    26025083 :   WRITE_UINT16_FIELD(this, kHeaderSize + index * kShortSize, value);
    3709     2279171 : }
    3710             : 
    3711             : 
    3712     6558695 : int SeqTwoByteString::SeqTwoByteStringSize(InstanceType instance_type) {
    3713     6558695 :   return SizeFor(length());
    3714             : }
    3715             : 
    3716             : 
    3717     8514287 : int SeqOneByteString::SeqOneByteStringSize(InstanceType instance_type) {
    3718     8514287 :   return SizeFor(length());
    3719             : }
    3720             : 
    3721             : 
    3722             : String* SlicedString::parent() {
    3723     5854608 :   return String::cast(READ_FIELD(this, kParentOffset));
    3724             : }
    3725             : 
    3726             : 
    3727     3593410 : void SlicedString::set_parent(String* parent, WriteBarrierMode mode) {
    3728             :   DCHECK(parent->IsSeqString() || parent->IsExternalString());
    3729     3593410 :   WRITE_FIELD(this, kParentOffset, parent);
    3730    10780230 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kParentOffset, parent, mode);
    3731     3593410 : }
    3732             : 
    3733             : 
    3734     9448012 : SMI_ACCESSORS(SlicedString, offset, kOffsetOffset)
    3735             : 
    3736             : 
    3737             : String* ConsString::first() {
    3738 23870927983 :   return String::cast(READ_FIELD(this, kFirstOffset));
    3739             : }
    3740             : 
    3741             : 
    3742             : Object* ConsString::unchecked_first() {
    3743      925906 :   return READ_FIELD(this, kFirstOffset);
    3744             : }
    3745             : 
    3746             : 
    3747    30771693 : void ConsString::set_first(String* value, WriteBarrierMode mode) {
    3748    30771693 :   WRITE_FIELD(this, kFirstOffset, value);
    3749    44532935 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kFirstOffset, value, mode);
    3750    30771693 : }
    3751             : 
    3752             : 
    3753             : String* ConsString::second() {
    3754   210726804 :   return String::cast(READ_FIELD(this, kSecondOffset));
    3755             : }
    3756             : 
    3757             : 
    3758             : Object* ConsString::unchecked_second() {
    3759    55049349 :   return READ_FIELD(this, kSecondOffset);
    3760             : }
    3761             : 
    3762             : 
    3763    30771693 : void ConsString::set_second(String* value, WriteBarrierMode mode) {
    3764    30771693 :   WRITE_FIELD(this, kSecondOffset, value);
    3765    44532935 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kSecondOffset, value, mode);
    3766    30771693 : }
    3767             : 
    3768    30084754 : ACCESSORS(ThinString, actual, String, kActualOffset);
    3769             : 
    3770             : bool ExternalString::is_short() {
    3771             :   InstanceType type = map()->instance_type();
    3772     1025442 :   return (type & kShortExternalStringMask) == kShortExternalStringTag;
    3773             : }
    3774             : 
    3775             : 
    3776             : const ExternalOneByteString::Resource* ExternalOneByteString::resource() {
    3777     6578069 :   return *reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset));
    3778             : }
    3779             : 
    3780             : 
    3781     1002272 : void ExternalOneByteString::update_data_cache() {
    3782     2004543 :   if (is_short()) return;
    3783             :   const char** data_field =
    3784             :       reinterpret_cast<const char**>(FIELD_ADDR(this, kResourceDataOffset));
    3785        8446 :   *data_field = resource()->data();
    3786             : }
    3787             : 
    3788             : 
    3789             : void ExternalOneByteString::set_resource(
    3790             :     const ExternalOneByteString::Resource* resource) {
    3791             :   DCHECK(IsAligned(reinterpret_cast<intptr_t>(resource), kPointerSize));
    3792             :   *reinterpret_cast<const Resource**>(
    3793     1002291 :       FIELD_ADDR(this, kResourceOffset)) = resource;
    3794     1002279 :   if (resource != NULL) update_data_cache();
    3795             : }
    3796             : 
    3797             : 
    3798             : const uint8_t* ExternalOneByteString::GetChars() {
    3799     5540291 :   return reinterpret_cast<const uint8_t*>(resource()->data());
    3800             : }
    3801             : 
    3802             : 
    3803     4569721 : uint16_t ExternalOneByteString::ExternalOneByteStringGet(int index) {
    3804             :   DCHECK(index >= 0 && index < length());
    3805     4569721 :   return GetChars()[index];
    3806             : }
    3807             : 
    3808             : 
    3809             : const ExternalTwoByteString::Resource* ExternalTwoByteString::resource() {
    3810      397390 :   return *reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset));
    3811             : }
    3812             : 
    3813             : 
    3814       23170 : void ExternalTwoByteString::update_data_cache() {
    3815       46340 :   if (is_short()) return;
    3816             :   const uint16_t** data_field =
    3817             :       reinterpret_cast<const uint16_t**>(FIELD_ADDR(this, kResourceDataOffset));
    3818       22993 :   *data_field = resource()->data();
    3819             : }
    3820             : 
    3821             : 
    3822             : void ExternalTwoByteString::set_resource(
    3823             :     const ExternalTwoByteString::Resource* resource) {
    3824             :   *reinterpret_cast<const Resource**>(
    3825       23170 :       FIELD_ADDR(this, kResourceOffset)) = resource;
    3826       23170 :   if (resource != NULL) update_data_cache();
    3827             : }
    3828             : 
    3829             : 
    3830             : const uint16_t* ExternalTwoByteString::GetChars() {
    3831      374345 :   return resource()->data();
    3832             : }
    3833             : 
    3834             : 
    3835        8878 : uint16_t ExternalTwoByteString::ExternalTwoByteStringGet(int index) {
    3836             :   DCHECK(index >= 0 && index < length());
    3837        8878 :   return GetChars()[index];
    3838             : }
    3839             : 
    3840             : 
    3841             : const uint16_t* ExternalTwoByteString::ExternalTwoByteStringGetData(
    3842             :       unsigned start) {
    3843          82 :   return GetChars() + start;
    3844             : }
    3845             : 
    3846             : 
    3847    69523438 : int ConsStringIterator::OffsetForDepth(int depth) { return depth & kDepthMask; }
    3848             : 
    3849             : 
    3850             : void ConsStringIterator::PushLeft(ConsString* string) {
    3851 23687723207 :   frames_[depth_++ & kDepthMask] = string;
    3852             : }
    3853             : 
    3854             : 
    3855             : void ConsStringIterator::PushRight(ConsString* string) {
    3856             :   // Inplace update.
    3857    15955258 :   frames_[(depth_-1) & kDepthMask] = string;
    3858             : }
    3859             : 
    3860             : 
    3861             : void ConsStringIterator::AdjustMaximumDepth() {
    3862    21185516 :   if (depth_ > maximum_depth_) maximum_depth_ = depth_;
    3863             : }
    3864             : 
    3865             : 
    3866             : void ConsStringIterator::Pop() {
    3867             :   DCHECK(depth_ > 0);
    3868             :   DCHECK(depth_ <= maximum_depth_);
    3869    55943140 :   depth_--;
    3870             : }
    3871             : 
    3872             : 
    3873    72203962 : uint16_t StringCharacterStream::GetNext() {
    3874             :   DCHECK(buffer8_ != NULL && end_ != NULL);
    3875             :   // Advance cursor if needed.
    3876    72203962 :   if (buffer8_ == end_) HasMore();
    3877             :   DCHECK(buffer8_ < end_);
    3878    72203962 :   return is_one_byte_ ? *buffer8_++ : *buffer16_++;
    3879             : }
    3880             : 
    3881             : 
    3882         162 : StringCharacterStream::StringCharacterStream(String* string, int offset)
    3883     5577423 :     : is_one_byte_(false) {
    3884     5577423 :   Reset(string, offset);
    3885         162 : }
    3886             : 
    3887             : 
    3888     3387190 : void StringCharacterStream::Reset(String* string, int offset) {
    3889     3387190 :   buffer8_ = NULL;
    3890     3387190 :   end_ = NULL;
    3891     3387190 :   ConsString* cons_string = String::VisitFlat(this, string, offset);
    3892     3387190 :   iter_.Reset(cons_string, offset);
    3893     3387190 :   if (cons_string != NULL) {
    3894       44928 :     string = iter_.Next(&offset);
    3895       44928 :     if (string != NULL) String::VisitFlat(this, string, offset);
    3896             :   }
    3897     3387190 : }
    3898             : 
    3899             : 
    3900    78002898 : bool StringCharacterStream::HasMore() {
    3901    78002898 :   if (buffer8_ != end_) return true;
    3902             :   int offset;
    3903     7564099 :   String* string = iter_.Next(&offset);
    3904             :   DCHECK_EQ(offset, 0);
    3905     7564099 :   if (string == NULL) return false;
    3906       99328 :   String::VisitFlat(this, string);
    3907             :   DCHECK(buffer8_ != end_);
    3908       99328 :   return true;
    3909             : }
    3910             : 
    3911             : 
    3912             : void StringCharacterStream::VisitOneByteString(
    3913             :     const uint8_t* chars, int length) {
    3914     3486473 :   is_one_byte_ = true;
    3915     3486473 :   buffer8_ = chars;
    3916     3486473 :   end_ = chars + length;
    3917             : }
    3918             : 
    3919             : 
    3920             : void StringCharacterStream::VisitTwoByteString(
    3921             :     const uint16_t* chars, int length) {
    3922          45 :   is_one_byte_ = false;
    3923          45 :   buffer16_ = chars;
    3924          45 :   end_ = reinterpret_cast<const uint8_t*>(chars + length);
    3925             : }
    3926             : 
    3927             : 
    3928     3775096 : int ByteArray::Size() { return RoundUp(length() + kHeaderSize, kPointerSize); }
    3929             : 
    3930             : byte ByteArray::get(int index) {
    3931             :   DCHECK(index >= 0 && index < this->length());
    3932   480004217 :   return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
    3933             : }
    3934             : 
    3935             : void ByteArray::set(int index, byte value) {
    3936             :   DCHECK(index >= 0 && index < this->length());
    3937     1698845 :   WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize, value);
    3938             : }
    3939             : 
    3940             : void ByteArray::copy_in(int index, const byte* buffer, int length) {
    3941             :   DCHECK(index >= 0 && length >= 0 && length <= kMaxInt - index &&
    3942             :          index + length <= this->length());
    3943      147787 :   byte* dst_addr = FIELD_ADDR(this, kHeaderSize + index * kCharSize);
    3944        3616 :   memcpy(dst_addr, buffer, length);
    3945             : }
    3946             : 
    3947             : void ByteArray::copy_out(int index, byte* buffer, int length) {
    3948             :   DCHECK(index >= 0 && length >= 0 && length <= kMaxInt - index &&
    3949             :          index + length <= this->length());
    3950        3310 :   const byte* src_addr = FIELD_ADDR(this, kHeaderSize + index * kCharSize);
    3951             :   memcpy(buffer, src_addr, length);
    3952             : }
    3953             : 
    3954             : int ByteArray::get_int(int index) {
    3955             :   DCHECK(index >= 0 && index < this->length() / kIntSize);
    3956        4829 :   return READ_INT_FIELD(this, kHeaderSize + index * kIntSize);
    3957             : }
    3958             : 
    3959             : void ByteArray::set_int(int index, int value) {
    3960             :   DCHECK(index >= 0 && index < this->length() / kIntSize);
    3961         951 :   WRITE_INT_FIELD(this, kHeaderSize + index * kIntSize, value);
    3962             : }
    3963             : 
    3964             : ByteArray* ByteArray::FromDataStartAddress(Address address) {
    3965             :   DCHECK_TAG_ALIGNED(address);
    3966             :   return reinterpret_cast<ByteArray*>(address - kHeaderSize + kHeapObjectTag);
    3967             : }
    3968             : 
    3969             : 
    3970       48426 : int ByteArray::ByteArraySize() { return SizeFor(this->length()); }
    3971             : 
    3972             : 
    3973             : Address ByteArray::GetDataStartAddress() {
    3974             :   return reinterpret_cast<Address>(this) - kHeapObjectTag + kHeaderSize;
    3975             : }
    3976             : 
    3977             : 
    3978       65553 : byte BytecodeArray::get(int index) {
    3979             :   DCHECK(index >= 0 && index < this->length());
    3980   232238932 :   return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
    3981             : }
    3982             : 
    3983             : 
    3984             : void BytecodeArray::set(int index, byte value) {
    3985             :   DCHECK(index >= 0 && index < this->length());
    3986    14671509 :   WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize, value);
    3987             : }
    3988             : 
    3989             : 
    3990             : void BytecodeArray::set_frame_size(int frame_size) {
    3991             :   DCHECK_GE(frame_size, 0);
    3992             :   DCHECK(IsAligned(frame_size, static_cast<unsigned>(kPointerSize)));
    3993     2113321 :   WRITE_INT_FIELD(this, kFrameSizeOffset, frame_size);
    3994             : }
    3995             : 
    3996             : 
    3997             : int BytecodeArray::frame_size() const {
    3998    19718860 :   return READ_INT_FIELD(this, kFrameSizeOffset);
    3999             : }
    4000             : 
    4001             : 
    4002       37547 : int BytecodeArray::register_count() const {
    4003    19709370 :   return frame_size() / kPointerSize;
    4004             : }
    4005             : 
    4006             : 
    4007             : void BytecodeArray::set_parameter_count(int number_of_parameters) {
    4008             :   DCHECK_GE(number_of_parameters, 0);
    4009             :   // Parameter count is stored as the size on stack of the parameters to allow
    4010             :   // it to be used directly by generated code.
    4011     2113321 :   WRITE_INT_FIELD(this, kParameterSizeOffset,
    4012     2113321 :                   (number_of_parameters << kPointerSizeLog2));
    4013             : }
    4014             : 
    4015             : int BytecodeArray::interrupt_budget() const {
    4016        9490 :   return READ_INT_FIELD(this, kInterruptBudgetOffset);
    4017             : }
    4018             : 
    4019             : void BytecodeArray::set_interrupt_budget(int interrupt_budget) {
    4020             :   DCHECK_GE(interrupt_budget, 0);
    4021     2113315 :   WRITE_INT_FIELD(this, kInterruptBudgetOffset, interrupt_budget);
    4022             : }
    4023             : 
    4024             : int BytecodeArray::osr_loop_nesting_level() const {
    4025       17921 :   return READ_INT8_FIELD(this, kOSRNestingLevelOffset);
    4026             : }
    4027             : 
    4028             : void BytecodeArray::set_osr_loop_nesting_level(int depth) {
    4029             :   DCHECK(0 <= depth && depth <= AbstractCode::kMaxLoopNestingMarker);
    4030             :   STATIC_ASSERT(AbstractCode::kMaxLoopNestingMarker < kMaxInt8);
    4031     2127582 :   WRITE_INT8_FIELD(this, kOSRNestingLevelOffset, depth);
    4032             : }
    4033             : 
    4034             : BytecodeArray::Age BytecodeArray::bytecode_age() const {
    4035     2200638 :   return static_cast<Age>(READ_INT8_FIELD(this, kBytecodeAgeOffset));
    4036             : }
    4037             : 
    4038             : void BytecodeArray::set_bytecode_age(BytecodeArray::Age age) {
    4039             :   DCHECK_GE(age, kFirstBytecodeAge);
    4040             :   DCHECK_LE(age, kLastBytecodeAge);
    4041             :   STATIC_ASSERT(kLastBytecodeAge <= kMaxInt8);
    4042     3518523 :   WRITE_INT8_FIELD(this, kBytecodeAgeOffset, static_cast<int8_t>(age));
    4043             : }
    4044             : 
    4045           0 : int BytecodeArray::parameter_count() const {
    4046             :   // Parameter count is stored as the size on stack of the parameters to allow
    4047             :   // it to be used directly by generated code.
    4048     1817083 :   return READ_INT_FIELD(this, kParameterSizeOffset) >> kPointerSizeLog2;
    4049             : }
    4050             : 
    4051    10704264 : ACCESSORS(BytecodeArray, constant_pool, FixedArray, kConstantPoolOffset)
    4052    25813134 : ACCESSORS(BytecodeArray, handler_table, FixedArray, kHandlerTableOffset)
    4053    18957677 : ACCESSORS(BytecodeArray, source_position_table, Object,
    4054             :           kSourcePositionTableOffset)
    4055             : 
    4056           0 : Address BytecodeArray::GetFirstBytecodeAddress() {
    4057           0 :   return reinterpret_cast<Address>(this) - kHeapObjectTag + kHeaderSize;
    4058             : }
    4059             : 
    4060     6224918 : ByteArray* BytecodeArray::SourcePositionTable() {
    4061             :   Object* maybe_table = source_position_table();
    4062     6224917 :   if (maybe_table->IsByteArray()) return ByteArray::cast(maybe_table);
    4063             :   DCHECK(maybe_table->IsSourcePositionTableWithFrameCache());
    4064             :   return SourcePositionTableWithFrameCache::cast(maybe_table)
    4065      218742 :       ->source_position_table();
    4066             : }
    4067             : 
    4068             : int BytecodeArray::BytecodeArraySize() { return SizeFor(this->length()); }
    4069             : 
    4070     2077423 : int BytecodeArray::SizeIncludingMetadata() {
    4071             :   int size = BytecodeArraySize();
    4072     2077423 :   size += constant_pool()->Size();
    4073     2077426 :   size += handler_table()->Size();
    4074     4154845 :   size += SourcePositionTable()->Size();
    4075     2077422 :   return size;
    4076             : }
    4077             : 
    4078     6977609 : ACCESSORS(FixedTypedArrayBase, base_pointer, Object, kBasePointerOffset)
    4079             : 
    4080             : 
    4081             : void* FixedTypedArrayBase::external_pointer() const {
    4082     4294373 :   intptr_t ptr = READ_INTPTR_FIELD(this, kExternalPointerOffset);
    4083             :   return reinterpret_cast<void*>(ptr);
    4084             : }
    4085             : 
    4086             : 
    4087             : void FixedTypedArrayBase::set_external_pointer(void* value,
    4088             :                                                WriteBarrierMode mode) {
    4089       16931 :   intptr_t ptr = reinterpret_cast<intptr_t>(value);
    4090       16931 :   WRITE_INTPTR_FIELD(this, kExternalPointerOffset, ptr);
    4091             : }
    4092             : 
    4093             : 
    4094         421 : void* FixedTypedArrayBase::DataPtr() {
    4095             :   return reinterpret_cast<void*>(
    4096     8561144 :       reinterpret_cast<intptr_t>(base_pointer()) +
    4097     4280572 :       reinterpret_cast<intptr_t>(external_pointer()));
    4098             : }
    4099             : 
    4100             : 
    4101     2004081 : int FixedTypedArrayBase::ElementSize(InstanceType type) {
    4102             :   int element_size;
    4103     2004081 :   switch (type) {
    4104             : #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size)                       \
    4105             :     case FIXED_##TYPE##_ARRAY_TYPE:                                           \
    4106             :       element_size = size;                                                    \
    4107             :       break;
    4108             : 
    4109      220476 :     TYPED_ARRAYS(TYPED_ARRAY_CASE)
    4110             : #undef TYPED_ARRAY_CASE
    4111             :     default:
    4112           0 :       UNREACHABLE();
    4113             :       return 0;
    4114             :   }
    4115             :   return element_size;
    4116             : }
    4117             : 
    4118             : 
    4119             : int FixedTypedArrayBase::DataSize(InstanceType type) {
    4120     2680106 :   if (base_pointer() == Smi::kZero) return 0;
    4121     2224910 :   return length() * ElementSize(type);
    4122             : }
    4123             : 
    4124             : 
    4125      915562 : int FixedTypedArrayBase::DataSize() {
    4126      915562 :   return DataSize(map()->instance_type());
    4127             : }
    4128             : 
    4129             : 
    4130             : int FixedTypedArrayBase::size() {
    4131      883727 :   return OBJECT_POINTER_ALIGN(kDataOffset + DataSize());
    4132             : }
    4133             : 
    4134             : 
    4135     1764544 : int FixedTypedArrayBase::TypedArraySize(InstanceType type) {
    4136     1764544 :   return OBJECT_POINTER_ALIGN(kDataOffset + DataSize(type));
    4137             : }
    4138             : 
    4139             : 
    4140             : int FixedTypedArrayBase::TypedArraySize(InstanceType type, int length) {
    4141         146 :   return OBJECT_POINTER_ALIGN(kDataOffset + length * ElementSize(type));
    4142             : }
    4143             : 
    4144             : 
    4145             : uint8_t Uint8ArrayTraits::defaultValue() { return 0; }
    4146             : 
    4147             : 
    4148             : uint8_t Uint8ClampedArrayTraits::defaultValue() { return 0; }
    4149             : 
    4150             : 
    4151             : int8_t Int8ArrayTraits::defaultValue() { return 0; }
    4152             : 
    4153             : 
    4154             : uint16_t Uint16ArrayTraits::defaultValue() { return 0; }
    4155             : 
    4156             : 
    4157             : int16_t Int16ArrayTraits::defaultValue() { return 0; }
    4158             : 
    4159             : 
    4160             : uint32_t Uint32ArrayTraits::defaultValue() { return 0; }
    4161             : 
    4162             : 
    4163             : int32_t Int32ArrayTraits::defaultValue() { return 0; }
    4164             : 
    4165             : 
    4166             : float Float32ArrayTraits::defaultValue() {
    4167             :   return std::numeric_limits<float>::quiet_NaN();
    4168             : }
    4169             : 
    4170             : 
    4171             : double Float64ArrayTraits::defaultValue() {
    4172             :   return std::numeric_limits<double>::quiet_NaN();
    4173             : }
    4174             : 
    4175             : 
    4176             : template <class Traits>
    4177      444734 : typename Traits::ElementType FixedTypedArray<Traits>::get_scalar(int index) {
    4178             :   DCHECK((index >= 0) && (index < this->length()));
    4179             :   ElementType* ptr = reinterpret_cast<ElementType*>(DataPtr());
    4180     1819662 :   return ptr[index];
    4181             : }
    4182             : 
    4183             : 
    4184             : template <class Traits>
    4185      209253 : void FixedTypedArray<Traits>::set(int index, ElementType value) {
    4186             :   DCHECK((index >= 0) && (index < this->length()));
    4187             :   ElementType* ptr = reinterpret_cast<ElementType*>(DataPtr());
    4188     2423824 :   ptr[index] = value;
    4189      209253 : }
    4190             : 
    4191             : template <class Traits>
    4192             : typename Traits::ElementType FixedTypedArray<Traits>::from(int value) {
    4193     1077724 :   return static_cast<ElementType>(value);
    4194             : }
    4195             : 
    4196             : template <>
    4197             : inline uint8_t FixedTypedArray<Uint8ClampedArrayTraits>::from(int value) {
    4198       37157 :   if (value < 0) return 0;
    4199       36940 :   if (value > 0xFF) return 0xFF;
    4200       36407 :   return static_cast<uint8_t>(value);
    4201             : }
    4202             : 
    4203             : template <class Traits>
    4204             : typename Traits::ElementType FixedTypedArray<Traits>::from(uint32_t value) {
    4205         672 :   return static_cast<ElementType>(value);
    4206             : }
    4207             : 
    4208             : template <>
    4209             : inline uint8_t FixedTypedArray<Uint8ClampedArrayTraits>::from(uint32_t value) {
    4210             :   // We need this special case for Uint32 -> Uint8Clamped, because the highest
    4211             :   // Uint32 values will be negative as an int, clamping to 0, rather than 255.
    4212         112 :   if (value > 0xFF) return 0xFF;
    4213          70 :   return static_cast<uint8_t>(value);
    4214             : }
    4215             : 
    4216             : template <class Traits>
    4217             : typename Traits::ElementType FixedTypedArray<Traits>::from(double value) {
    4218      484135 :   return static_cast<ElementType>(DoubleToInt32(value));
    4219             : }
    4220             : 
    4221             : template <>
    4222             : inline uint8_t FixedTypedArray<Uint8ClampedArrayTraits>::from(double value) {
    4223             :   // Handle NaNs and less than zero values which clamp to zero.
    4224      145131 :   if (!(value > 0)) return 0;
    4225      143603 :   if (value > 0xFF) return 0xFF;
    4226      142474 :   return static_cast<uint8_t>(lrint(value));
    4227             : }
    4228             : 
    4229             : template <>
    4230             : inline float FixedTypedArray<Float32ArrayTraits>::from(double value) {
    4231      176308 :   return static_cast<float>(value);
    4232             : }
    4233             : 
    4234             : template <>
    4235             : inline double FixedTypedArray<Float64ArrayTraits>::from(double value) {
    4236             :   return value;
    4237             : }
    4238             : 
    4239             : template <class Traits>
    4240      631785 : Handle<Object> FixedTypedArray<Traits>::get(FixedTypedArray<Traits>* array,
    4241             :                                             int index) {
    4242      901111 :   return Traits::ToHandle(array->GetIsolate(), array->get_scalar(index));
    4243             : }
    4244             : 
    4245             : 
    4246             : template <class Traits>
    4247     1432917 : void FixedTypedArray<Traits>::SetValue(uint32_t index, Object* value) {
    4248             :   ElementType cast_value = Traits::defaultValue();
    4249     1432917 :   if (value->IsSmi()) {
    4250             :     int int_value = Smi::cast(value)->value();
    4251             :     cast_value = from(int_value);
    4252      861872 :   } else if (value->IsHeapNumber()) {
    4253             :     double double_value = HeapNumber::cast(value)->value();
    4254             :     cast_value = from(double_value);
    4255             :   } else {
    4256             :     // Clamp undefined to the default value. All other types have been
    4257             :     // converted to a number type further up in the call chain.
    4258             :     DCHECK(value->IsUndefined(GetIsolate()));
    4259             :   }
    4260     1432917 :   set(index, cast_value);
    4261     1432917 : }
    4262             : 
    4263             : 
    4264      135118 : Handle<Object> Uint8ArrayTraits::ToHandle(Isolate* isolate, uint8_t scalar) {
    4265      135118 :   return handle(Smi::FromInt(scalar), isolate);
    4266             : }
    4267             : 
    4268             : 
    4269        3364 : Handle<Object> Uint8ClampedArrayTraits::ToHandle(Isolate* isolate,
    4270             :                                                  uint8_t scalar) {
    4271        3364 :   return handle(Smi::FromInt(scalar), isolate);
    4272             : }
    4273             : 
    4274             : 
    4275        7347 : Handle<Object> Int8ArrayTraits::ToHandle(Isolate* isolate, int8_t scalar) {
    4276        7347 :   return handle(Smi::FromInt(scalar), isolate);
    4277             : }
    4278             : 
    4279             : 
    4280      117732 : Handle<Object> Uint16ArrayTraits::ToHandle(Isolate* isolate, uint16_t scalar) {
    4281      117732 :   return handle(Smi::FromInt(scalar), isolate);
    4282             : }
    4283             : 
    4284             : 
    4285        5765 : Handle<Object> Int16ArrayTraits::ToHandle(Isolate* isolate, int16_t scalar) {
    4286        5765 :   return handle(Smi::FromInt(scalar), isolate);
    4287             : }
    4288             : 
    4289             : 
    4290             : Handle<Object> Uint32ArrayTraits::ToHandle(Isolate* isolate, uint32_t scalar) {
    4291      116823 :   return isolate->factory()->NewNumberFromUint(scalar);
    4292             : }
    4293             : 
    4294             : 
    4295             : Handle<Object> Int32ArrayTraits::ToHandle(Isolate* isolate, int32_t scalar) {
    4296       12622 :   return isolate->factory()->NewNumberFromInt(scalar);
    4297             : }
    4298             : 
    4299             : 
    4300             : Handle<Object> Float32ArrayTraits::ToHandle(Isolate* isolate, float scalar) {
    4301      117173 :   return isolate->factory()->NewNumber(scalar);
    4302             : }
    4303             : 
    4304             : 
    4305             : Handle<Object> Float64ArrayTraits::ToHandle(Isolate* isolate, double scalar) {
    4306      115841 :   return isolate->factory()->NewNumber(scalar);
    4307             : }
    4308             : 
    4309             : 
    4310             : int Map::visitor_id() {
    4311   887325107 :   return READ_BYTE_FIELD(this, kVisitorIdOffset);
    4312             : }
    4313             : 
    4314             : 
    4315             : void Map::set_visitor_id(int id) {
    4316             :   DCHECK(0 <= id && id < 256);
    4317    61099192 :   WRITE_BYTE_FIELD(this, kVisitorIdOffset, static_cast<byte>(id));
    4318             : }
    4319             : 
    4320             : 
    4321     2604818 : int Map::instance_size() {
    4322  3408723465 :   return NOBARRIER_READ_BYTE_FIELD(
    4323  3409086196 :       this, kInstanceSizeOffset) << kPointerSizeLog2;
    4324             : }
    4325             : 
    4326             : 
    4327             : int Map::inobject_properties_or_constructor_function_index() {
    4328   559917662 :   return READ_BYTE_FIELD(this,
    4329             :                          kInObjectPropertiesOrConstructorFunctionIndexOffset);
    4330             : }
    4331             : 
    4332             : 
    4333             : void Map::set_inobject_properties_or_constructor_function_index(int value) {
    4334             :   DCHECK(0 <= value && value < 256);
    4335             :   WRITE_BYTE_FIELD(this, kInObjectPropertiesOrConstructorFunctionIndexOffset,
    4336    58618581 :                    static_cast<byte>(value));
    4337             : }
    4338             : 
    4339             : 
    4340    10321328 : int Map::GetInObjectProperties() {
    4341             :   DCHECK(IsJSObjectMap());
    4342    10321328 :   return inobject_properties_or_constructor_function_index();
    4343             : }
    4344             : 
    4345             : 
    4346             : void Map::SetInObjectProperties(int value) {
    4347             :   DCHECK(IsJSObjectMap());
    4348             :   set_inobject_properties_or_constructor_function_index(value);
    4349             : }
    4350             : 
    4351             : 
    4352             : int Map::GetConstructorFunctionIndex() {
    4353             :   DCHECK(IsPrimitiveMap());
    4354             :   return inobject_properties_or_constructor_function_index();
    4355             : }
    4356             : 
    4357             : 
    4358             : void Map::SetConstructorFunctionIndex(int value) {
    4359             :   DCHECK(IsPrimitiveMap());
    4360             :   set_inobject_properties_or_constructor_function_index(value);
    4361             : }
    4362             : 
    4363             : 
    4364   174794440 : int Map::GetInObjectPropertyOffset(int index) {
    4365             :   // Adjust for the number of properties stored in the object.
    4366   174794440 :   index -= GetInObjectProperties();
    4367             :   DCHECK(index <= 0);
    4368   174794440 :   return instance_size() + (index * kPointerSize);
    4369             : }
    4370             : 
    4371             : 
    4372             : Handle<Map> Map::AddMissingTransitionsForTesting(
    4373             :     Handle<Map> split_map, Handle<DescriptorArray> descriptors,
    4374             :     Handle<LayoutDescriptor> full_layout_descriptor) {
    4375             :   return AddMissingTransitions(split_map, descriptors, full_layout_descriptor);
    4376             : }
    4377             : 
    4378             : 
    4379  2714915897 : int HeapObject::SizeFromMap(Map* map) {
    4380             :   int instance_size = map->instance_size();
    4381  2714915897 :   if (instance_size != kVariableSizeSentinel) return instance_size;
    4382             :   // Only inline the most frequent cases.
    4383             :   InstanceType instance_type = map->instance_type();
    4384  1393847819 :   if (instance_type == FIXED_ARRAY_TYPE ||
    4385             :       instance_type == TRANSITION_ARRAY_TYPE) {
    4386             :     return FixedArray::SizeFor(
    4387   341328652 :         reinterpret_cast<FixedArray*>(this)->synchronized_length());
    4388             :   }
    4389  2105038334 :   if (instance_type == ONE_BYTE_STRING_TYPE ||
    4390  1052519167 :       instance_type == ONE_BYTE_INTERNALIZED_STRING_TYPE) {
    4391             :     // Strings may get concurrently truncated, hence we have to access its
    4392             :     // length synchronized.
    4393             :     return SeqOneByteString::SizeFor(
    4394   366338010 :         reinterpret_cast<SeqOneByteString*>(this)->synchronized_length());
    4395             :   }
    4396   686181157 :   if (instance_type == BYTE_ARRAY_TYPE) {
    4397   289751578 :     return reinterpret_cast<ByteArray*>(this)->ByteArraySize();
    4398             :   }
    4399   396429579 :   if (instance_type == BYTECODE_ARRAY_TYPE) {
    4400     7819177 :     return reinterpret_cast<BytecodeArray*>(this)->BytecodeArraySize();
    4401             :   }
    4402   388610402 :   if (instance_type == FREE_SPACE_TYPE) {
    4403    21218654 :     return reinterpret_cast<FreeSpace*>(this)->nobarrier_size();
    4404             :   }
    4405   734783496 :   if (instance_type == STRING_TYPE ||
    4406   367391748 :       instance_type == INTERNALIZED_STRING_TYPE) {
    4407             :     // Strings may get concurrently truncated, hence we have to access its
    4408             :     // length synchronized.
    4409             :     return SeqTwoByteString::SizeFor(
    4410    75871721 :         reinterpret_cast<SeqTwoByteString*>(this)->synchronized_length());
    4411             :   }
    4412   291520027 :   if (instance_type == FIXED_DOUBLE_ARRAY_TYPE) {
    4413             :     return FixedDoubleArray::SizeFor(
    4414      208065 :         reinterpret_cast<FixedDoubleArray*>(this)->length());
    4415             :   }
    4416   291311962 :   if (instance_type >= FIRST_FIXED_TYPED_ARRAY_TYPE &&
    4417             :       instance_type <= LAST_FIXED_TYPED_ARRAY_TYPE) {
    4418             :     return reinterpret_cast<FixedTypedArrayBase*>(
    4419     1764544 :         this)->TypedArraySize(instance_type);
    4420             :   }
    4421             :   DCHECK(instance_type == CODE_TYPE);
    4422   289562819 :   return reinterpret_cast<Code*>(this)->CodeSize();
    4423             : }
    4424             : 
    4425             : 
    4426             : void Map::set_instance_size(int value) {
    4427             :   DCHECK_EQ(0, value & (kPointerSize - 1));
    4428    32314796 :   value >>= kPointerSizeLog2;
    4429             :   DCHECK(0 <= value && value < 256);
    4430    31977384 :   NOBARRIER_WRITE_BYTE_FIELD(
    4431             :       this, kInstanceSizeOffset, static_cast<byte>(value));
    4432             : }
    4433             : 
    4434             : 
    4435    31726576 : void Map::clear_unused() { WRITE_BYTE_FIELD(this, kUnusedOffset, 0); }
    4436             : 
    4437             : 
    4438 10915819079 : InstanceType Map::instance_type() {
    4439 40906609442 :   return static_cast<InstanceType>(READ_BYTE_FIELD(this, kInstanceTypeOffset));
    4440             : }
    4441             : 
    4442             : 
    4443             : void Map::set_instance_type(InstanceType value) {
    4444    32798022 :   WRITE_BYTE_FIELD(this, kInstanceTypeOffset, value);
    4445             : }
    4446             : 
    4447             : 
    4448             : int Map::unused_property_fields() {
    4449   105697117 :   return READ_BYTE_FIELD(this, kUnusedPropertyFieldsOffset);
    4450             : }
    4451             : 
    4452             : 
    4453             : void Map::set_unused_property_fields(int value) {
    4454    69830603 :   WRITE_BYTE_FIELD(this, kUnusedPropertyFieldsOffset, Min(value, 255));
    4455             : }
    4456             : 
    4457             : 
    4458   257476778 : byte Map::bit_field() const { return READ_BYTE_FIELD(this, kBitFieldOffset); }
    4459             : 
    4460             : 
    4461             : void Map::set_bit_field(byte value) {
    4462    58564475 :   WRITE_BYTE_FIELD(this, kBitFieldOffset, value);
    4463             : }
    4464             : 
    4465             : 
    4466  1124035688 : byte Map::bit_field2() const { return READ_BYTE_FIELD(this, kBitField2Offset); }
    4467             : 
    4468             : 
    4469             : void Map::set_bit_field2(byte value) {
    4470    96874979 :   WRITE_BYTE_FIELD(this, kBitField2Offset, value);
    4471             : }
    4472             : 
    4473             : 
    4474             : void Map::set_non_instance_prototype(bool value) {
    4475             :   if (value) {
    4476        6612 :     set_bit_field(bit_field() | (1 << kHasNonInstancePrototype));
    4477             :   } else {
    4478      689920 :     set_bit_field(bit_field() & ~(1 << kHasNonInstancePrototype));
    4479             :   }
    4480             : }
    4481             : 
    4482             : 
    4483             : bool Map::has_non_instance_prototype() {
    4484     5166388 :   return ((1 << kHasNonInstancePrototype) & bit_field()) != 0;
    4485             : }
    4486             : 
    4487             : 
    4488             : void Map::set_is_constructor(bool value) {
    4489         565 :   if (value) {
    4490         931 :     set_bit_field(bit_field() | (1 << kIsConstructor));
    4491             :   } else {
    4492         474 :     set_bit_field(bit_field() & ~(1 << kIsConstructor));
    4493             :   }
    4494             : }
    4495             : 
    4496             : 
    4497      167294 : bool Map::is_constructor() const {
    4498      774794 :   return ((1 << kIsConstructor) & bit_field()) != 0;
    4499             : }
    4500             : 
    4501             : void Map::set_has_hidden_prototype(bool value) {
    4502             :   set_bit_field3(HasHiddenPrototype::update(bit_field3(), value));
    4503             : }
    4504             : 
    4505         790 : bool Map::has_hidden_prototype() const {
    4506         790 :   return HasHiddenPrototype::decode(bit_field3());
    4507             : }
    4508             : 
    4509             : 
    4510             : void Map::set_has_indexed_interceptor() {
    4511         209 :   set_bit_field(bit_field() | (1 << kHasIndexedInterceptor));
    4512             : }
    4513             : 
    4514             : 
    4515         240 : bool Map::has_indexed_interceptor() {
    4516    16279991 :   return ((1 << kHasIndexedInterceptor) & bit_field()) != 0;
    4517             : }
    4518             : 
    4519             : 
    4520             : void Map::set_is_undetectable() {
    4521         309 :   set_bit_field(bit_field() | (1 << kIsUndetectable));
    4522             : }
    4523             : 
    4524             : 
    4525     4720176 : bool Map::is_undetectable() {
    4526    10077205 :   return ((1 << kIsUndetectable) & bit_field()) != 0;
    4527             : }
    4528             : 
    4529             : 
    4530             : void Map::set_has_named_interceptor() {
    4531        1268 :   set_bit_field(bit_field() | (1 << kHasNamedInterceptor));
    4532             : }
    4533             : 
    4534             : 
    4535         342 : bool Map::has_named_interceptor() {
    4536    46184187 :   return ((1 << kHasNamedInterceptor) & bit_field()) != 0;
    4537             : }
    4538             : 
    4539             : 
    4540             : void Map::set_is_access_check_needed(bool access_check_needed) {
    4541             :   if (access_check_needed) {
    4542      214566 :     set_bit_field(bit_field() | (1 << kIsAccessCheckNeeded));
    4543             :   } else {
    4544         293 :     set_bit_field(bit_field() & ~(1 << kIsAccessCheckNeeded));
    4545             :   }
    4546             : }
    4547             : 
    4548             : 
    4549    65665689 : bool Map::is_access_check_needed() {
    4550   120463265 :   return ((1 << kIsAccessCheckNeeded) & bit_field()) != 0;
    4551             : }
    4552             : 
    4553             : 
    4554             : void Map::set_is_extensible(bool value) {
    4555             :   if (value) {
    4556             :     set_bit_field2(bit_field2() | (1 << kIsExtensible));
    4557             :   } else {
    4558       52327 :     set_bit_field2(bit_field2() & ~(1 << kIsExtensible));
    4559             :   }
    4560             : }
    4561             : 
    4562             : bool Map::is_extensible() {
    4563    70035185 :   return ((1 << kIsExtensible) & bit_field2()) != 0;
    4564             : }
    4565             : 
    4566             : 
    4567             : void Map::set_is_prototype_map(bool value) {
    4568             :   set_bit_field2(IsPrototypeMapBits::update(bit_field2(), value));
    4569             : }
    4570             : 
    4571             : bool Map::is_prototype_map() const {
    4572             :   return IsPrototypeMapBits::decode(bit_field2());
    4573             : }
    4574             : 
    4575    34217892 : bool Map::should_be_fast_prototype_map() const {
    4576    34217894 :   if (!prototype_info()->IsPrototypeInfo()) return false;
    4577    28559896 :   return PrototypeInfo::cast(prototype_info())->should_be_fast_map();
    4578             : }
    4579             : 
    4580             : void Map::set_elements_kind(ElementsKind elements_kind) {
    4581             :   DCHECK(static_cast<int>(elements_kind) < kElementsKindCount);
    4582             :   DCHECK(kElementsKindCount <= (1 << Map::ElementsKindBits::kSize));
    4583     2274308 :   set_bit_field2(Map::ElementsKindBits::update(bit_field2(), elements_kind));
    4584             :   DCHECK(this->elements_kind() == elements_kind);
    4585             : }
    4586             : 
    4587             : 
    4588        7588 : ElementsKind Map::elements_kind() {
    4589        7588 :   return Map::ElementsKindBits::decode(bit_field2());
    4590             : }
    4591             : 
    4592             : 
    4593             : bool Map::has_fast_smi_elements() {
    4594             :   return IsFastSmiElementsKind(elements_kind());
    4595             : }
    4596             : 
    4597             : bool Map::has_fast_object_elements() {
    4598             :   return IsFastObjectElementsKind(elements_kind());
    4599             : }
    4600             : 
    4601             : bool Map::has_fast_smi_or_object_elements() {
    4602             :   return IsFastSmiOrObjectElementsKind(elements_kind());
    4603             : }
    4604             : 
    4605             : bool Map::has_fast_double_elements() {
    4606             :   return IsFastDoubleElementsKind(elements_kind());
    4607             : }
    4608             : 
    4609             : bool Map::has_fast_elements() { return IsFastElementsKind(elements_kind()); }
    4610             : 
    4611             : bool Map::has_sloppy_arguments_elements() {
    4612             :   return IsSloppyArgumentsElementsKind(elements_kind());
    4613             : }
    4614             : 
    4615             : bool Map::has_fast_sloppy_arguments_elements() {
    4616             :   return elements_kind() == FAST_SLOPPY_ARGUMENTS_ELEMENTS;
    4617             : }
    4618             : 
    4619             : bool Map::has_fast_string_wrapper_elements() {
    4620             :   return elements_kind() == FAST_STRING_WRAPPER_ELEMENTS;
    4621             : }
    4622             : 
    4623             : bool Map::has_fixed_typed_array_elements() {
    4624             :   return IsFixedTypedArrayElementsKind(elements_kind());
    4625             : }
    4626             : 
    4627             : bool Map::has_dictionary_elements() {
    4628             :   return IsDictionaryElementsKind(elements_kind());
    4629             : }
    4630             : 
    4631             : 
    4632             : void Map::set_dictionary_map(bool value) {
    4633             :   uint32_t new_bit_field3 = DictionaryMap::update(bit_field3(), value);
    4634             :   new_bit_field3 = IsUnstable::update(new_bit_field3, value);
    4635             :   set_bit_field3(new_bit_field3);
    4636             : }
    4637             : 
    4638             : 
    4639      189312 : bool Map::is_dictionary_map() {
    4640      189312 :   return DictionaryMap::decode(bit_field3());
    4641             : }
    4642             : 
    4643             : 
    4644             : Code::Flags Code::flags() {
    4645   356495647 :   return static_cast<Flags>(READ_INT_FIELD(this, kFlagsOffset));
    4646             : }
    4647             : 
    4648             : 
    4649             : void Map::set_owns_descriptors(bool owns_descriptors) {
    4650             :   set_bit_field3(OwnsDescriptors::update(bit_field3(), owns_descriptors));
    4651             : }
    4652             : 
    4653             : 
    4654             : bool Map::owns_descriptors() {
    4655             :   return OwnsDescriptors::decode(bit_field3());
    4656             : }
    4657             : 
    4658             : 
    4659        1089 : void Map::set_is_callable() { set_bit_field(bit_field() | (1 << kIsCallable)); }
    4660             : 
    4661             : 
    4662    26152841 : bool Map::is_callable() const {
    4663    31487873 :   return ((1 << kIsCallable) & bit_field()) != 0;
    4664             : }
    4665             : 
    4666             : 
    4667             : void Map::deprecate() {
    4668             :   set_bit_field3(Deprecated::update(bit_field3(), true));
    4669             : }
    4670             : 
    4671             : 
    4672     1500028 : bool Map::is_deprecated() {
    4673     1500028 :   return Deprecated::decode(bit_field3());
    4674             : }
    4675             : 
    4676             : 
    4677             : void Map::set_migration_target(bool value) {
    4678             :   set_bit_field3(IsMigrationTarget::update(bit_field3(), value));
    4679             : }
    4680             : 
    4681             : 
    4682             : bool Map::is_migration_target() {
    4683             :   return IsMigrationTarget::decode(bit_field3());
    4684             : }
    4685             : 
    4686             : void Map::set_immutable_proto(bool value) {
    4687             :   set_bit_field3(ImmutablePrototype::update(bit_field3(), value));
    4688             : }
    4689             : 
    4690             : bool Map::is_immutable_proto() {
    4691             :   return ImmutablePrototype::decode(bit_field3());
    4692             : }
    4693             : 
    4694             : void Map::set_new_target_is_base(bool value) {
    4695             :   set_bit_field3(NewTargetIsBase::update(bit_field3(), value));
    4696             : }
    4697             : 
    4698             : 
    4699             : bool Map::new_target_is_base() { return NewTargetIsBase::decode(bit_field3()); }
    4700             : 
    4701             : 
    4702             : void Map::set_construction_counter(int value) {
    4703             :   set_bit_field3(ConstructionCounter::update(bit_field3(), value));
    4704             : }
    4705             : 
    4706             : 
    4707             : int Map::construction_counter() {
    4708             :   return ConstructionCounter::decode(bit_field3());
    4709             : }
    4710             : 
    4711             : 
    4712             : void Map::mark_unstable() {
    4713             :   set_bit_field3(IsUnstable::update(bit_field3(), true));
    4714             : }
    4715             : 
    4716             : 
    4717             : bool Map::is_stable() {
    4718       23193 :   return !IsUnstable::decode(bit_field3());
    4719             : }
    4720             : 
    4721             : 
    4722             : bool Map::has_code_cache() {
    4723             :   // Code caches are always fixed arrays. The empty fixed array is used as a
    4724             :   // sentinel for an absent code cache.
    4725             :   return code_cache()->length() != 0;
    4726             : }
    4727             : 
    4728             : 
    4729       14201 : bool Map::CanBeDeprecated() {
    4730             :   int descriptor = LastAdded();
    4731       17747 :   for (int i = 0; i <= descriptor; i++) {
    4732       17488 :     PropertyDetails details = instance_descriptors()->GetDetails(i);
    4733       17488 :     if (details.representation().IsNone()) return true;
    4734       17488 :     if (details.representation().IsSmi()) return true;
    4735       13239 :     if (details.representation().IsDouble()) return true;
    4736       13030 :     if (details.representation().IsHeapObject()) return true;
    4737        6993 :     if (details.kind() == kData && details.location() == kDescriptor) {
    4738             :       return true;
    4739             :     }
    4740             :   }
    4741             :   return false;
    4742             : }
    4743             : 
    4744             : 
    4745    27694309 : void Map::NotifyLeafMapLayoutChange() {
    4746    27694309 :   if (is_stable()) {
    4747             :     mark_unstable();
    4748             :     dependent_code()->DeoptimizeDependentCodeGroup(
    4749             :         GetIsolate(),
    4750    17356254 :         DependentCode::kPrototypeCheckGroup);
    4751             :   }
    4752    27694308 : }
    4753             : 
    4754             : 
    4755    44622604 : bool Map::CanTransition() {
    4756             :   // Only JSObject and subtypes have map transitions and back pointers.
    4757             :   STATIC_ASSERT(LAST_TYPE == LAST_JS_OBJECT_TYPE);
    4758    45184498 :   return instance_type() >= FIRST_JS_OBJECT_TYPE;
    4759             : }
    4760             : 
    4761             : 
    4762      122057 : bool Map::IsBooleanMap() { return this == GetHeap()->boolean_map(); }
    4763    14930862 : bool Map::IsPrimitiveMap() {
    4764             :   STATIC_ASSERT(FIRST_PRIMITIVE_TYPE == FIRST_TYPE);
    4765    19459117 :   return instance_type() <= LAST_PRIMITIVE_TYPE;
    4766             : }
    4767             : bool Map::IsJSReceiverMap() {
    4768             :   STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
    4769    13522515 :   return instance_type() >= FIRST_JS_RECEIVER_TYPE;
    4770             : }
    4771   413326864 : bool Map::IsJSObjectMap() {
    4772             :   STATIC_ASSERT(LAST_JS_OBJECT_TYPE == LAST_TYPE);
    4773   441724957 :   return instance_type() >= FIRST_JS_OBJECT_TYPE;
    4774             : }
    4775             : bool Map::IsJSArrayMap() { return instance_type() == JS_ARRAY_TYPE; }
    4776             : bool Map::IsJSFunctionMap() { return instance_type() == JS_FUNCTION_TYPE; }
    4777      576224 : bool Map::IsStringMap() { return instance_type() < FIRST_NONSTRING_TYPE; }
    4778   217994564 : bool Map::IsJSProxyMap() { return instance_type() == JS_PROXY_TYPE; }
    4779             : bool Map::IsJSGlobalProxyMap() {
    4780             :   return instance_type() == JS_GLOBAL_PROXY_TYPE;
    4781             : }
    4782             : bool Map::IsJSGlobalObjectMap() {
    4783             :   return instance_type() == JS_GLOBAL_OBJECT_TYPE;
    4784             : }
    4785             : bool Map::IsJSTypedArrayMap() { return instance_type() == JS_TYPED_ARRAY_TYPE; }
    4786             : bool Map::IsJSDataViewMap() { return instance_type() == JS_DATA_VIEW_TYPE; }
    4787             : 
    4788       15150 : bool Map::IsSpecialReceiverMap() {
    4789             :   bool result = IsSpecialReceiverInstanceType(instance_type());
    4790             :   DCHECK_IMPLIES(!result,
    4791             :                  !has_named_interceptor() && !is_access_check_needed());
    4792       15150 :   return result;
    4793             : }
    4794             : 
    4795             : bool Map::CanOmitMapChecks() {
    4796             :   return is_stable() && FLAG_omit_map_checks_for_leaf_maps;
    4797             : }
    4798             : 
    4799             : 
    4800             : DependentCode* DependentCode::next_link() {
    4801             :   return DependentCode::cast(get(kNextLinkIndex));
    4802             : }
    4803             : 
    4804             : 
    4805             : void DependentCode::set_next_link(DependentCode* next) {
    4806      417557 :   set(kNextLinkIndex, next);
    4807             : }
    4808             : 
    4809             : 
    4810             : int DependentCode::flags() { return Smi::cast(get(kFlagsIndex))->value(); }
    4811             : 
    4812             : 
    4813             : void DependentCode::set_flags(int flags) {
    4814             :   set(kFlagsIndex, Smi::FromInt(flags));
    4815             : }
    4816             : 
    4817             : 
    4818     3802786 : int DependentCode::count() { return CountField::decode(flags()); }
    4819             : 
    4820     1029686 : void DependentCode::set_count(int value) {
    4821     2059372 :   set_flags(CountField::update(flags(), value));
    4822     1029686 : }
    4823             : 
    4824             : 
    4825             : DependentCode::DependencyGroup DependentCode::group() {
    4826       17404 :   return static_cast<DependencyGroup>(GroupField::decode(flags()));
    4827             : }
    4828             : 
    4829             : 
    4830             : void DependentCode::set_group(DependentCode::DependencyGroup group) {
    4831             :   set_flags(GroupField::update(flags(), static_cast<int>(group)));
    4832             : }
    4833             : 
    4834             : 
    4835             : void DependentCode::set_object_at(int i, Object* object) {
    4836     1580940 :   set(kCodesStartIndex + i, object);
    4837             : }
    4838             : 
    4839             : 
    4840             : Object* DependentCode::object_at(int i) {
    4841   259067510 :   return get(kCodesStartIndex + i);
    4842             : }
    4843             : 
    4844             : 
    4845             : void DependentCode::clear_at(int i) {
    4846      141616 :   set_undefined(kCodesStartIndex + i);
    4847             : }
    4848             : 
    4849             : 
    4850       13521 : void DependentCode::copy(int from, int to) {
    4851       27042 :   set(kCodesStartIndex + to, get(kCodesStartIndex + from));
    4852       13521 : }
    4853             : 
    4854             : 
    4855             : void Code::set_flags(Code::Flags flags) {
    4856             :   STATIC_ASSERT(Code::NUMBER_OF_KINDS <= KindField::kMax + 1);
    4857     2555744 :   WRITE_INT_FIELD(this, kFlagsOffset, flags);
    4858             : }
    4859             : 
    4860             : 
    4861      537880 : Code::Kind Code::kind() {
    4862      537880 :   return ExtractKindFromFlags(flags());
    4863             : }
    4864             : 
    4865             : bool Code::IsCodeStubOrIC() {
    4866             :   switch (kind()) {
    4867             :     case STUB:
    4868             :     case HANDLER:
    4869             : #define CASE_KIND(kind) case kind:
    4870             :       IC_KIND_LIST(CASE_KIND)
    4871             : #undef CASE_KIND
    4872             :       return true;
    4873             :     default:
    4874             :       return false;
    4875             :   }
    4876             : }
    4877             : 
    4878             : ExtraICState Code::extra_ic_state() {
    4879             :   DCHECK(is_binary_op_stub() || is_compare_ic_stub() ||
    4880             :          is_to_boolean_ic_stub() || is_debug_stub());
    4881             :   return ExtractExtraICStateFromFlags(flags());
    4882             : }
    4883             : 
    4884             : 
    4885             : // For initialization.
    4886             : void Code::set_raw_kind_specific_flags1(int value) {
    4887     2555744 :   WRITE_INT_FIELD(this, kKindSpecificFlags1Offset, value);
    4888             : }
    4889             : 
    4890             : 
    4891             : void Code::set_raw_kind_specific_flags2(int value) {
    4892     2555744 :   WRITE_INT_FIELD(this, kKindSpecificFlags2Offset, value);
    4893             : }
    4894             : 
    4895             : 
    4896             : inline bool Code::is_crankshafted() {
    4897             :   return IsCrankshaftedField::decode(
    4898       26647 :       READ_UINT32_FIELD(this, kKindSpecificFlags2Offset));
    4899             : }
    4900             : 
    4901             : 
    4902             : inline bool Code::is_hydrogen_stub() {
    4903       53294 :   return is_crankshafted() && kind() != OPTIMIZED_FUNCTION;
    4904             : }
    4905             : 
    4906    42986441 : inline bool Code::is_interpreter_trampoline_builtin() {
    4907    42986441 :   Builtins* builtins = GetIsolate()->builtins();
    4908    94114770 :   return this == *builtins->InterpreterEntryTrampoline() ||
    4909    93917989 :          this == *builtins->InterpreterEnterBytecodeAdvance() ||
    4910    93917989 :          this == *builtins->InterpreterEnterBytecodeDispatch();
    4911             : }
    4912             : 
    4913             : inline bool Code::has_unwinding_info() const {
    4914   365728465 :   return HasUnwindingInfoField::decode(READ_UINT32_FIELD(this, kFlagsOffset));
    4915             : }
    4916             : 
    4917             : inline void Code::set_has_unwinding_info(bool state) {
    4918             :   uint32_t previous = READ_UINT32_FIELD(this, kFlagsOffset);
    4919             :   uint32_t updated_value = HasUnwindingInfoField::update(previous, state);
    4920     2555744 :   WRITE_UINT32_FIELD(this, kFlagsOffset, updated_value);
    4921             : }
    4922             : 
    4923             : inline void Code::set_is_crankshafted(bool value) {
    4924      279048 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
    4925             :   int updated = IsCrankshaftedField::update(previous, value);
    4926     2834792 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
    4927             : }
    4928             : 
    4929             : inline bool Code::has_tagged_params() {
    4930     1840521 :   int flags = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
    4931             :   return HasTaggedStackField::decode(flags);
    4932             : }
    4933             : 
    4934             : inline void Code::set_has_tagged_params(bool value) {
    4935       99023 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
    4936             :   int updated = HasTaggedStackField::update(previous, value);
    4937     2654767 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
    4938             : }
    4939             : 
    4940      266483 : inline bool Code::is_turbofanned() {
    4941             :   return IsTurbofannedField::decode(
    4942    12546931 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    4943             : }
    4944             : 
    4945             : 
    4946             : inline void Code::set_is_turbofanned(bool value) {
    4947      912392 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    4948             :   int updated = IsTurbofannedField::update(previous, value);
    4949      912392 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    4950             : }
    4951             : 
    4952             : 
    4953             : inline bool Code::can_have_weak_objects() {
    4954             :   DCHECK(kind() == OPTIMIZED_FUNCTION);
    4955             :   return CanHaveWeakObjectsField::decode(
    4956     4073613 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    4957             : }
    4958             : 
    4959             : 
    4960             : inline void Code::set_can_have_weak_objects(bool value) {
    4961             :   DCHECK(kind() == OPTIMIZED_FUNCTION);
    4962      640383 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    4963             :   int updated = CanHaveWeakObjectsField::update(previous, value);
    4964      640383 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    4965             : }
    4966             : 
    4967             : inline bool Code::is_construct_stub() {
    4968             :   DCHECK(kind() == BUILTIN);
    4969             :   return IsConstructStubField::decode(
    4970        4099 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    4971             : }
    4972             : 
    4973             : inline void Code::set_is_construct_stub(bool value) {
    4974             :   DCHECK(kind() == BUILTIN);
    4975    14906341 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    4976             :   int updated = IsConstructStubField::update(previous, value);
    4977    14906341 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    4978             : }
    4979             : 
    4980             : inline bool Code::is_promise_rejection() {
    4981             :   DCHECK(kind() == BUILTIN);
    4982             :   return IsPromiseRejectionField::decode(
    4983        2288 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    4984             : }
    4985             : 
    4986             : inline void Code::set_is_promise_rejection(bool value) {
    4987             :   DCHECK(kind() == BUILTIN);
    4988         688 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    4989             :   int updated = IsPromiseRejectionField::update(previous, value);
    4990         688 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    4991             : }
    4992             : 
    4993             : inline bool Code::is_exception_caught() {
    4994             :   DCHECK(kind() == BUILTIN);
    4995             :   return IsExceptionCaughtField::decode(
    4996             :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    4997             : }
    4998             : 
    4999             : inline void Code::set_is_exception_caught(bool value) {
    5000             :   DCHECK(kind() == BUILTIN);
    5001          43 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    5002             :   int updated = IsExceptionCaughtField::update(previous, value);
    5003          43 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    5004             : }
    5005             : 
    5006             : bool Code::has_deoptimization_support() {
    5007             :   DCHECK_EQ(FUNCTION, kind());
    5008      588595 :   unsigned flags = READ_UINT32_FIELD(this, kFullCodeFlags);
    5009             :   return FullCodeFlagsHasDeoptimizationSupportField::decode(flags);
    5010             : }
    5011             : 
    5012             : 
    5013             : void Code::set_has_deoptimization_support(bool value) {
    5014             :   DCHECK_EQ(FUNCTION, kind());
    5015     1309315 :   unsigned flags = READ_UINT32_FIELD(this, kFullCodeFlags);
    5016             :   flags = FullCodeFlagsHasDeoptimizationSupportField::update(flags, value);
    5017     1309315 :   WRITE_UINT32_FIELD(this, kFullCodeFlags, flags);
    5018             : }
    5019             : 
    5020             : 
    5021             : bool Code::has_debug_break_slots() {
    5022             :   DCHECK_EQ(FUNCTION, kind());
    5023     4666214 :   unsigned flags = READ_UINT32_FIELD(this, kFullCodeFlags);
    5024             :   return FullCodeFlagsHasDebugBreakSlotsField::decode(flags);
    5025             : }
    5026             : 
    5027             : 
    5028             : void Code::set_has_debug_break_slots(bool value) {
    5029             :   DCHECK_EQ(FUNCTION, kind());
    5030        3435 :   unsigned flags = READ_UINT32_FIELD(this, kFullCodeFlags);
    5031             :   flags = FullCodeFlagsHasDebugBreakSlotsField::update(flags, value);
    5032        3435 :   WRITE_UINT32_FIELD(this, kFullCodeFlags, flags);
    5033             : }
    5034             : 
    5035             : 
    5036             : bool Code::has_reloc_info_for_serialization() {
    5037             :   DCHECK_EQ(FUNCTION, kind());
    5038      228705 :   unsigned flags = READ_UINT32_FIELD(this, kFullCodeFlags);
    5039             :   return FullCodeFlagsHasRelocInfoForSerialization::decode(flags);
    5040             : }
    5041             : 
    5042             : 
    5043             : void Code::set_has_reloc_info_for_serialization(bool value) {
    5044             :   DCHECK_EQ(FUNCTION, kind());
    5045             :   unsigned flags = READ_UINT32_FIELD(this, kFullCodeFlags);
    5046             :   flags = FullCodeFlagsHasRelocInfoForSerialization::update(flags, value);
    5047     1080610 :   WRITE_UINT32_FIELD(this, kFullCodeFlags, flags);
    5048             : }
    5049             : 
    5050             : 
    5051             : int Code::allow_osr_at_loop_nesting_level() {
    5052             :   DCHECK_EQ(FUNCTION, kind());
    5053       13279 :   int fields = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
    5054             :   return AllowOSRAtLoopNestingLevelField::decode(fields);
    5055             : }
    5056             : 
    5057             : 
    5058             : void Code::set_allow_osr_at_loop_nesting_level(int level) {
    5059             :   DCHECK_EQ(FUNCTION, kind());
    5060             :   DCHECK(level >= 0 && level <= AbstractCode::kMaxLoopNestingMarker);
    5061     1092694 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
    5062             :   int updated = AllowOSRAtLoopNestingLevelField::update(previous, level);
    5063     1092694 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
    5064             : }
    5065             : 
    5066             : 
    5067             : int Code::profiler_ticks() {
    5068             :   DCHECK_EQ(FUNCTION, kind());
    5069             :   return ProfilerTicksField::decode(
    5070      234864 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    5071             : }
    5072             : 
    5073             : 
    5074             : void Code::set_profiler_ticks(int ticks) {
    5075     5582618 :   if (kind() == FUNCTION) {
    5076     4433431 :     unsigned previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    5077             :     unsigned updated = ProfilerTicksField::update(previous, ticks);
    5078     5582619 :     WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    5079             :   }
    5080             : }
    5081             : 
    5082     1262264 : int Code::builtin_index() { return READ_INT_FIELD(this, kBuiltinIndexOffset); }
    5083             : 
    5084             : void Code::set_builtin_index(int index) {
    5085     2583265 :   WRITE_INT_FIELD(this, kBuiltinIndexOffset, index);
    5086             : }
    5087             : 
    5088             : 
    5089             : unsigned Code::stack_slots() {
    5090             :   DCHECK(is_crankshafted());
    5091             :   return StackSlotsField::decode(
    5092     5570241 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    5093             : }
    5094             : 
    5095             : 
    5096     1191440 : void Code::set_stack_slots(unsigned slots) {
    5097     1191440 :   CHECK(slots <= (1 << kStackSlotsBitCount));
    5098             :   DCHECK(is_crankshafted());
    5099     1191440 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    5100             :   int updated = StackSlotsField::update(previous, slots);
    5101     1191440 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    5102     1191440 : }
    5103             : 
    5104             : 
    5105             : unsigned Code::safepoint_table_offset() {
    5106             :   DCHECK(is_crankshafted());
    5107             :   return SafepointTableOffsetField::decode(
    5108     1732479 :       READ_UINT32_FIELD(this, kKindSpecificFlags2Offset));
    5109             : }
    5110             : 
    5111             : 
    5112     1191440 : void Code::set_safepoint_table_offset(unsigned offset) {
    5113     1191440 :   CHECK(offset <= (1 << kSafepointTableOffsetBitCount));
    5114             :   DCHECK(is_crankshafted());
    5115             :   DCHECK(IsAligned(offset, static_cast<unsigned>(kIntSize)));
    5116     1191440 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
    5117             :   int updated = SafepointTableOffsetField::update(previous, offset);
    5118     1191440 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
    5119     1191440 : }
    5120             : 
    5121             : 
    5122             : unsigned Code::back_edge_table_offset() {
    5123             :   DCHECK_EQ(FUNCTION, kind());
    5124             :   return BackEdgeTableOffsetField::decode(
    5125       17366 :       READ_UINT32_FIELD(this, kKindSpecificFlags2Offset)) << kPointerSizeLog2;
    5126             : }
    5127             : 
    5128             : 
    5129             : void Code::set_back_edge_table_offset(unsigned offset) {
    5130             :   DCHECK_EQ(FUNCTION, kind());
    5131             :   DCHECK(IsAligned(offset, static_cast<unsigned>(kPointerSize)));
    5132     1080610 :   offset = offset >> kPointerSizeLog2;
    5133     1080610 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
    5134             :   int updated = BackEdgeTableOffsetField::update(previous, offset);
    5135     1080610 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
    5136             : }
    5137             : 
    5138             : 
    5139             : bool Code::back_edges_patched_for_osr() {
    5140             :   DCHECK_EQ(FUNCTION, kind());
    5141             :   return allow_osr_at_loop_nesting_level() > 0;
    5142             : }
    5143             : 
    5144             : 
    5145      209596 : uint16_t Code::to_boolean_state() { return extra_ic_state(); }
    5146             : 
    5147             : 
    5148             : bool Code::marked_for_deoptimization() {
    5149             :   DCHECK(kind() == OPTIMIZED_FUNCTION);
    5150             :   return MarkedForDeoptimizationField::decode(
    5151     2076377 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    5152             : }
    5153             : 
    5154             : 
    5155             : void Code::set_marked_for_deoptimization(bool flag) {
    5156             :   DCHECK(kind() == OPTIMIZED_FUNCTION);
    5157             :   DCHECK_IMPLIES(flag, AllowDeoptimization::IsAllowed(GetIsolate()));
    5158     1071693 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    5159             :   int updated = MarkedForDeoptimizationField::update(previous, flag);
    5160     1071693 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    5161             : }
    5162             : 
    5163             : bool Code::deopt_already_counted() {
    5164             :   DCHECK(kind() == OPTIMIZED_FUNCTION);
    5165             :   return DeoptAlreadyCountedField::decode(
    5166       24374 :       READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
    5167             : }
    5168             : 
    5169             : void Code::set_deopt_already_counted(bool flag) {
    5170             :   DCHECK(kind() == OPTIMIZED_FUNCTION);
    5171             :   DCHECK_IMPLIES(flag, AllowDeoptimization::IsAllowed(GetIsolate()));
    5172      360495 :   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
    5173             :   int updated = DeoptAlreadyCountedField::update(previous, flag);
    5174      360495 :   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
    5175             : }
    5176             : 
    5177             : bool Code::is_inline_cache_stub() {
    5178             :   Kind kind = this->kind();
    5179    15206559 :   switch (kind) {
    5180             : #define CASE(name) case name: return true;
    5181             :     IC_KIND_LIST(CASE)
    5182             : #undef CASE
    5183             :     default: return false;
    5184             :   }
    5185             : }
    5186             : 
    5187             : bool Code::is_debug_stub() {
    5188      132634 :   if (kind() != BUILTIN) return false;
    5189           0 :   switch (builtin_index()) {
    5190             : #define CASE_DEBUG_BUILTIN(name) case Builtins::k##name:
    5191             :     BUILTIN_LIST_DBG(CASE_DEBUG_BUILTIN)
    5192             : #undef CASE_DEBUG_BUILTIN
    5193             :       return true;
    5194             :     default:
    5195             :       return false;
    5196             :   }
    5197             :   return false;
    5198             : }
    5199             : bool Code::is_handler() { return kind() == HANDLER; }
    5200             : bool Code::is_stub() { return kind() == STUB; }
    5201             : bool Code::is_binary_op_stub() { return kind() == BINARY_OP_IC; }
    5202             : bool Code::is_compare_ic_stub() { return kind() == COMPARE_IC; }
    5203             : bool Code::is_to_boolean_ic_stub() { return kind() == TO_BOOLEAN_IC; }
    5204             : bool Code::is_optimized_code() { return kind() == OPTIMIZED_FUNCTION; }
    5205             : bool Code::is_wasm_code() { return kind() == WASM_FUNCTION; }
    5206             : 
    5207             : Address Code::constant_pool() {
    5208             :   Address constant_pool = NULL;
    5209             :   if (FLAG_enable_embedded_constant_pool) {
    5210             :     int offset = constant_pool_offset();
    5211             :     if (offset < instruction_size()) {
    5212             :       constant_pool = FIELD_ADDR(this, kHeaderSize + offset);
    5213             :     }
    5214             :   }
    5215             :   return constant_pool;
    5216             : }
    5217             : 
    5218             : Code::Flags Code::ComputeFlags(Kind kind, ExtraICState extra_ic_state) {
    5219             :   // Compute the bit mask.
    5220             :   unsigned int bits =
    5221      320005 :       KindField::encode(kind) | ExtraICStateField::encode(extra_ic_state);
    5222             :   return static_cast<Flags>(bits);
    5223             : }
    5224             : 
    5225             : Code::Flags Code::ComputeHandlerFlags(Kind handler_kind) {
    5226             :   return ComputeFlags(Code::HANDLER, handler_kind);
    5227             : }
    5228             : 
    5229             : 
    5230             : Code::Kind Code::ExtractKindFromFlags(Flags flags) {
    5231             :   return KindField::decode(flags);
    5232             : }
    5233             : 
    5234             : 
    5235             : ExtraICState Code::ExtractExtraICStateFromFlags(Flags flags) {
    5236             :   return ExtraICStateField::decode(flags);
    5237             : }
    5238             : 
    5239             : 
    5240   314361537 : Code* Code::GetCodeFromTargetAddress(Address address) {
    5241             :   HeapObject* code = HeapObject::FromAddress(address - Code::kHeaderSize);
    5242             :   // GetCodeFromTargetAddress might be called when marking objects during mark
    5243             :   // sweep. reinterpret_cast is therefore used instead of the more appropriate
    5244             :   // Code::cast. Code::cast does not work when the object's map is
    5245             :   // marked.
    5246             :   Code* result = reinterpret_cast<Code*>(code);
    5247   314361537 :   return result;
    5248             : }
    5249             : 
    5250             : 
    5251    61686674 : Object* Code::GetObjectFromEntryAddress(Address location_of_address) {
    5252             :   return HeapObject::
    5253   265637709 :       FromAddress(Memory::Address_at(location_of_address) - Code::kHeaderSize);
    5254             : }
    5255             : 
    5256             : 
    5257             : bool Code::CanContainWeakObjects() {
    5258    34953019 :   return is_optimized_code() && can_have_weak_objects();
    5259             : }
    5260             : 
    5261             : 
    5262    30879406 : bool Code::IsWeakObject(Object* object) {
    5263    30879406 :   return (CanContainWeakObjects() && IsWeakObjectInOptimizedCode(object));
    5264             : }
    5265             : 
    5266             : 
    5267    10108942 : bool Code::IsWeakObjectInOptimizedCode(Object* object) {
    5268    10108941 :   if (object->IsMap()) {
    5269      338806 :     return Map::cast(object)->CanTransition();
    5270             :   }
    5271     9770135 :   if (object->IsCell()) {
    5272             :     object = Cell::cast(object)->value();
    5273     9770134 :   } else if (object->IsPropertyCell()) {
    5274             :     object = PropertyCell::cast(object)->value();
    5275             :   }
    5276    17898852 :   if (object->IsJSReceiver() || object->IsContext()) {
    5277             :     return true;
    5278             :   }
    5279     6762778 :   return false;
    5280             : }
    5281             : 
    5282             : 
    5283        9133 : int AbstractCode::instruction_size() {
    5284        9133 :   if (IsCode()) {
    5285        8685 :     return GetCode()->instruction_size();
    5286             :   } else {
    5287         448 :     return GetBytecodeArray()->length();
    5288             :   }
    5289             : }
    5290             : 
    5291     2268639 : ByteArray* AbstractCode::source_position_table() {
    5292     2268639 :   if (IsCode()) {
    5293      603756 :     return GetCode()->SourcePositionTable();
    5294             :   } else {
    5295     1664883 :     return GetBytecodeArray()->SourcePositionTable();
    5296             :   }
    5297             : }
    5298             : 
    5299        1300 : void AbstractCode::set_source_position_table(ByteArray* source_position_table) {
    5300        1300 :   if (IsCode()) {
    5301         184 :     GetCode()->set_source_position_table(source_position_table);
    5302             :   } else {
    5303        1116 :     GetBytecodeArray()->set_source_position_table(source_position_table);
    5304             :   }
    5305        1300 : }
    5306             : 
    5307       46982 : Object* AbstractCode::stack_frame_cache() {
    5308             :   Object* maybe_table;
    5309       46982 :   if (IsCode()) {
    5310             :     maybe_table = GetCode()->source_position_table();
    5311             :   } else {
    5312             :     maybe_table = GetBytecodeArray()->source_position_table();
    5313             :   }
    5314       46982 :   if (maybe_table->IsSourcePositionTableWithFrameCache()) {
    5315             :     return SourcePositionTableWithFrameCache::cast(maybe_table)
    5316       38041 :         ->stack_frame_cache();
    5317             :   }
    5318             :   return Smi::kZero;
    5319             : }
    5320             : 
    5321           0 : int AbstractCode::SizeIncludingMetadata() {
    5322           0 :   if (IsCode()) {
    5323           0 :     return GetCode()->SizeIncludingMetadata();
    5324             :   } else {
    5325           0 :     return GetBytecodeArray()->SizeIncludingMetadata();
    5326             :   }
    5327             : }
    5328      211546 : int AbstractCode::ExecutableSize() {
    5329      211546 :   if (IsCode()) {
    5330      209623 :     return GetCode()->ExecutableSize();
    5331             :   } else {
    5332        1923 :     return GetBytecodeArray()->BytecodeArraySize();
    5333             :   }
    5334             : }
    5335             : 
    5336      172489 : Address AbstractCode::instruction_start() {
    5337      172489 :   if (IsCode()) {
    5338      169877 :     return GetCode()->instruction_start();
    5339             :   } else {
    5340        2612 :     return GetBytecodeArray()->GetFirstBytecodeAddress();
    5341             :   }
    5342             : }
    5343             : 
    5344             : Address AbstractCode::instruction_end() {
    5345             :   if (IsCode()) {
    5346             :     return GetCode()->instruction_end();
    5347             :   } else {
    5348             :     return GetBytecodeArray()->GetFirstBytecodeAddress() +
    5349             :            GetBytecodeArray()->length();
    5350             :   }
    5351             : }
    5352             : 
    5353             : bool AbstractCode::contains(byte* inner_pointer) {
    5354             :   return (address() <= inner_pointer) && (inner_pointer <= address() + Size());
    5355             : }
    5356             : 
    5357      162407 : AbstractCode::Kind AbstractCode::kind() {
    5358      162407 :   if (IsCode()) {
    5359             :     STATIC_ASSERT(AbstractCode::FUNCTION ==
    5360             :                   static_cast<AbstractCode::Kind>(Code::FUNCTION));
    5361      157419 :     return static_cast<AbstractCode::Kind>(GetCode()->kind());
    5362             :   } else {
    5363             :     return INTERPRETED_FUNCTION;
    5364             :   }
    5365             : }
    5366             : 
    5367             : Code* AbstractCode::GetCode() { return Code::cast(this); }
    5368             : 
    5369             : BytecodeArray* AbstractCode::GetBytecodeArray() {
    5370             :   return BytecodeArray::cast(this);
    5371             : }
    5372             : 
    5373          48 : Object* Map::prototype() const {
    5374   661943310 :   return READ_FIELD(this, kPrototypeOffset);
    5375             : }
    5376             : 
    5377             : 
    5378    63522453 : void Map::set_prototype(Object* value, WriteBarrierMode mode) {
    5379             :   DCHECK(value->IsNull(GetIsolate()) || value->IsJSReceiver());
    5380    63522453 :   WRITE_FIELD(this, kPrototypeOffset, value);
    5381   116765140 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kPrototypeOffset, value, mode);
    5382    63522450 : }
    5383             : 
    5384             : 
    5385      239461 : LayoutDescriptor* Map::layout_descriptor_gc_safe() {
    5386      239461 :   Object* layout_desc = READ_FIELD(this, kLayoutDescriptorOffset);
    5387      239461 :   return LayoutDescriptor::cast_gc_safe(layout_desc);
    5388             : }
    5389             : 
    5390             : 
    5391             : bool Map::HasFastPointerLayout() const {
    5392   146532385 :   Object* layout_desc = READ_FIELD(this, kLayoutDescriptorOffset);
    5393             :   return LayoutDescriptor::IsFastPointerLayout(layout_desc);
    5394             : }
    5395             : 
    5396             : 
    5397    44229697 : void Map::UpdateDescriptors(DescriptorArray* descriptors,
    5398             :                             LayoutDescriptor* layout_desc) {
    5399    44229697 :   set_instance_descriptors(descriptors);
    5400             :   if (FLAG_unbox_double_fields) {
    5401    44229697 :     if (layout_descriptor()->IsSlowLayout()) {
    5402        3965 :       set_layout_descriptor(layout_desc);
    5403             :     }
    5404             : #ifdef VERIFY_HEAP
    5405             :     // TODO(ishell): remove these checks from VERIFY_HEAP mode.
    5406             :     if (FLAG_verify_heap) {
    5407             :       CHECK(layout_descriptor()->IsConsistentWithMap(this));
    5408             :       CHECK(visitor_id() == Heap::GetStaticVisitorIdForMap(this));
    5409             :     }
    5410             : #else
    5411             :     SLOW_DCHECK(layout_descriptor()->IsConsistentWithMap(this));
    5412             :     DCHECK(visitor_id() == Heap::GetStaticVisitorIdForMap(this));
    5413             : #endif
    5414             :   }
    5415    44229697 : }
    5416             : 
    5417             : 
    5418    28535470 : void Map::InitializeDescriptors(DescriptorArray* descriptors,
    5419             :                                 LayoutDescriptor* layout_desc) {
    5420    28535470 :   int len = descriptors->number_of_descriptors();
    5421    28535470 :   set_instance_descriptors(descriptors);
    5422             :   SetNumberOfOwnDescriptors(len);
    5423             : 
    5424             :   if (FLAG_unbox_double_fields) {
    5425    28535460 :     set_layout_descriptor(layout_desc);
    5426             : #ifdef VERIFY_HEAP
    5427             :     // TODO(ishell): remove these checks from VERIFY_HEAP mode.
    5428             :     if (FLAG_verify_heap) {
    5429             :       CHECK(layout_descriptor()->IsConsistentWithMap(this));
    5430             :     }
    5431             : #else
    5432             :     SLOW_DCHECK(layout_descriptor()->IsConsistentWithMap(this));
    5433             : #endif
    5434    28535459 :     set_visitor_id(Heap::GetStaticVisitorIdForMap(this));
    5435             :   }
    5436    28535463 : }
    5437             : 
    5438             : 
    5439  1494476724 : ACCESSORS(Map, instance_descriptors, DescriptorArray, kDescriptorsOffset)
    5440   365311010 : ACCESSORS(Map, layout_descriptor, LayoutDescriptor, kLayoutDescriptorOffset)
    5441             : 
    5442             : void Map::set_bit_field3(uint32_t bits) {
    5443             :   if (kInt32Size != kPointerSize) {
    5444   164791237 :     WRITE_UINT32_FIELD(this, kBitField3Offset + kInt32Size, 0);
    5445             :   }
    5446   197657460 :   WRITE_UINT32_FIELD(this, kBitField3Offset, bits);
    5447             : }
    5448             : 
    5449             : 
    5450             : uint32_t Map::bit_field3() const {
    5451  2231565387 :   return READ_UINT32_FIELD(this, kBitField3Offset);
    5452             : }
    5453             : 
    5454             : 
    5455             : LayoutDescriptor* Map::GetLayoutDescriptor() {
    5456             :   return FLAG_unbox_double_fields ? layout_descriptor()
    5457             :                                   : LayoutDescriptor::FastPointerLayout();
    5458             : }
    5459             : 
    5460             : 
    5461        6588 : void Map::AppendDescriptor(Descriptor* desc) {
    5462             :   DescriptorArray* descriptors = instance_descriptors();
    5463             :   int number_of_own_descriptors = NumberOfOwnDescriptors();
    5464             :   DCHECK(descriptors->number_of_descriptors() == number_of_own_descriptors);
    5465        6588 :   descriptors->Append(desc);
    5466        6588 :   SetNumberOfOwnDescriptors(number_of_own_descriptors + 1);
    5467             : 
    5468             : // This function does not support appending double field descriptors and
    5469             : // it should never try to (otherwise, layout descriptor must be updated too).
    5470             : #ifdef DEBUG
    5471             :   PropertyDetails details = desc->GetDetails();
    5472             :   CHECK(details.location() != kField || !details.representation().IsDouble());
    5473             : #endif
    5474        6588 : }
    5475             : 
    5476             : 
    5477   181111832 : Object* Map::GetBackPointer() {
    5478             :   Object* object = constructor_or_backpointer();
    5479   181111826 :   if (object->IsMap()) {
    5480             :     return object;
    5481             :   }
    5482    45723082 :   return GetIsolate()->heap()->undefined_value();
    5483             : }
    5484             : 
    5485             : 
    5486             : Map* Map::ElementsTransitionMap() {
    5487             :   return TransitionArray::SearchSpecial(
    5488     3091912 :       this, GetHeap()->elements_transition_symbol());
    5489             : }
    5490             : 
    5491             : 
    5492   297398552 : ACCESSORS(Map, raw_transitions, Object, kTransitionsOrPrototypeInfoOffset)
    5493             : 
    5494             : 
    5495             : Object* Map::prototype_info() const {
    5496             :   DCHECK(is_prototype_map());
    5497    88781822 :   return READ_FIELD(this, Map::kTransitionsOrPrototypeInfoOffset);
    5498             : }
    5499             : 
    5500             : 
    5501    11504364 : void Map::set_prototype_info(Object* value, WriteBarrierMode mode) {
    5502             :   DCHECK(is_prototype_map());
    5503    11504364 :   WRITE_FIELD(this, Map::kTransitionsOrPrototypeInfoOffset, value);
    5504    34513092 :   CONDITIONAL_WRITE_BARRIER(
    5505             :       GetHeap(), this, Map::kTransitionsOrPrototypeInfoOffset, value, mode);
    5506    11504363 : }
    5507             : 
    5508             : 
    5509             : void Map::SetBackPointer(Object* value, WriteBarrierMode mode) {
    5510             :   DCHECK(instance_type() >= FIRST_JS_RECEIVER_TYPE);
    5511             :   DCHECK(value->IsMap());
    5512             :   DCHECK(GetBackPointer()->IsUndefined(GetIsolate()));
    5513             :   DCHECK(!value->IsMap() ||
    5514             :          Map::cast(value)->GetConstructor() == constructor_or_backpointer());
    5515    11753523 :   set_constructor_or_backpointer(value, mode);
    5516             : }
    5517             : 
    5518             : ACCESSORS(JSArgumentsObject, length, Object, kLengthOffset);
    5519             : ACCESSORS(JSSloppyArgumentsObject, callee, Object, kCalleeOffset);
    5520             : 
    5521    32149486 : ACCESSORS(Map, code_cache, FixedArray, kCodeCacheOffset)
    5522    52726300 : ACCESSORS(Map, dependent_code, DependentCode, kDependentCodeOffset)
    5523   161338083 : ACCESSORS(Map, weak_cell_cache, Object, kWeakCellCacheOffset)
    5524   871821200 : ACCESSORS(Map, constructor_or_backpointer, Object,
    5525             :           kConstructorOrBackPointerOffset)
    5526             : 
    5527   109784087 : Object* Map::GetConstructor() const {
    5528             :   Object* maybe_constructor = constructor_or_backpointer();
    5529             :   // Follow any back pointers.
    5530   625864973 :   while (maybe_constructor->IsMap()) {
    5531             :     maybe_constructor =
    5532             :         Map::cast(maybe_constructor)->constructor_or_backpointer();
    5533             :   }
    5534   109784079 :   return maybe_constructor;
    5535             : }
    5536             : 
    5537     2519690 : FunctionTemplateInfo* Map::GetFunctionTemplateInfo() const {
    5538     2519690 :   Object* constructor = GetConstructor();
    5539     2519690 :   if (constructor->IsJSFunction()) {
    5540             :     DCHECK(JSFunction::cast(constructor)->shared()->IsApiFunction());
    5541     2519690 :     return JSFunction::cast(constructor)->shared()->get_api_func_data();
    5542             :   }
    5543             :   DCHECK(constructor->IsFunctionTemplateInfo());
    5544             :   return FunctionTemplateInfo::cast(constructor);
    5545             : }
    5546             : 
    5547             : void Map::SetConstructor(Object* constructor, WriteBarrierMode mode) {
    5548             :   // Never overwrite a back pointer with a constructor.
    5549             :   DCHECK(!constructor_or_backpointer()->IsMap());
    5550     9434094 :   set_constructor_or_backpointer(constructor, mode);
    5551             : }
    5552             : 
    5553             : 
    5554      190289 : Handle<Map> Map::CopyInitialMap(Handle<Map> map) {
    5555             :   return CopyInitialMap(map, map->instance_size(), map->GetInObjectProperties(),
    5556      190289 :                         map->unused_property_fields());
    5557             : }
    5558             : 
    5559             : 
    5560        5182 : ACCESSORS(JSBoundFunction, bound_target_function, JSReceiver,
    5561             :           kBoundTargetFunctionOffset)
    5562        3426 : ACCESSORS(JSBoundFunction, bound_this, Object, kBoundThisOffset)
    5563        3959 : ACCESSORS(JSBoundFunction, bound_arguments, FixedArray, kBoundArgumentsOffset)
    5564             : 
    5565   595454109 : ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)
    5566   202379971 : ACCESSORS(JSFunction, feedback_vector_cell, Cell, kFeedbackVectorOffset)
    5567    47589396 : ACCESSORS(JSFunction, next_function_link, Object, kNextFunctionLinkOffset)
    5568             : 
    5569    18519714 : ACCESSORS(JSGlobalObject, native_context, Context, kNativeContextOffset)
    5570      388996 : ACCESSORS(JSGlobalObject, global_proxy, JSObject, kGlobalProxyOffset)
    5571             : 
    5572     8995513 : ACCESSORS(JSGlobalProxy, native_context, Object, kNativeContextOffset)
    5573      427964 : ACCESSORS(JSGlobalProxy, hash, Object, kHashOffset)
    5574             : 
    5575      932260 : ACCESSORS(AccessorInfo, name, Object, kNameOffset)
    5576     5291212 : SMI_ACCESSORS(AccessorInfo, flag, kFlagOffset)
    5577     2731072 : ACCESSORS(AccessorInfo, expected_receiver_type, Object,
    5578             :           kExpectedReceiverTypeOffset)
    5579             : 
    5580     1441710 : ACCESSORS(AccessorInfo, getter, Object, kGetterOffset)
    5581    40768653 : ACCESSORS(AccessorInfo, setter, Object, kSetterOffset)
    5582      369018 : ACCESSORS(AccessorInfo, js_getter, Object, kJsGetterOffset)
    5583    41475242 : ACCESSORS(AccessorInfo, data, Object, kDataOffset)
    5584             : 
    5585       24522 : ACCESSORS(PromiseResolveThenableJobInfo, thenable, JSReceiver, kThenableOffset)
    5586       24522 : ACCESSORS(PromiseResolveThenableJobInfo, then, JSReceiver, kThenOffset)
    5587       24522 : ACCESSORS(PromiseResolveThenableJobInfo, resolve, JSFunction, kResolveOffset)
    5588       24522 : ACCESSORS(PromiseResolveThenableJobInfo, reject, JSFunction, kRejectOffset)
    5589       24522 : ACCESSORS(PromiseResolveThenableJobInfo, context, Context, kContextOffset);
    5590             : 
    5591      230276 : ACCESSORS(PromiseReactionJobInfo, value, Object, kValueOffset);
    5592      230276 : ACCESSORS(PromiseReactionJobInfo, tasks, Object, kTasksOffset);
    5593      230276 : ACCESSORS(PromiseReactionJobInfo, deferred_promise, Object,
    5594             :           kDeferredPromiseOffset);
    5595      230276 : ACCESSORS(PromiseReactionJobInfo, deferred_on_resolve, Object,
    5596             :           kDeferredOnResolveOffset);
    5597      230276 : ACCESSORS(PromiseReactionJobInfo, deferred_on_reject, Object,
    5598             :           kDeferredOnRejectOffset);
    5599      230276 : ACCESSORS(PromiseReactionJobInfo, context, Context, kContextOffset);
    5600             : 
    5601             : ACCESSORS(AsyncGeneratorRequest, next, Object, kNextOffset)
    5602             : SMI_ACCESSORS(AsyncGeneratorRequest, resume_mode, kResumeModeOffset)
    5603             : ACCESSORS(AsyncGeneratorRequest, value, Object, kValueOffset)
    5604             : ACCESSORS(AsyncGeneratorRequest, promise, Object, kPromiseOffset)
    5605             : 
    5606             : Map* PrototypeInfo::ObjectCreateMap() {
    5607             :   return Map::cast(WeakCell::cast(object_create_map())->value());
    5608             : }
    5609             : 
    5610             : // static
    5611      187555 : void PrototypeInfo::SetObjectCreateMap(Handle<PrototypeInfo> info,
    5612             :                                        Handle<Map> map) {
    5613      187555 :   Handle<WeakCell> cell = Map::WeakCellForMap(map);
    5614      187555 :   info->set_object_create_map(*cell);
    5615      187555 : }
    5616             : 
    5617      187616 : bool PrototypeInfo::HasObjectCreateMap() {
    5618             :   Object* cache = object_create_map();
    5619      187677 :   return cache->IsWeakCell() && !WeakCell::cast(cache)->cleared();
    5620             : }
    5621             : 
    5622     5486241 : bool FunctionTemplateInfo::instantiated() {
    5623     5486243 :   return shared_function_info()->IsSharedFunctionInfo();
    5624             : }
    5625             : 
    5626     3962823 : FunctionTemplateInfo* FunctionTemplateInfo::GetParent(Isolate* isolate) {
    5627             :   Object* parent = parent_template();
    5628             :   return parent->IsUndefined(isolate) ? nullptr
    5629     3962823 :                                       : FunctionTemplateInfo::cast(parent);
    5630             : }
    5631             : 
    5632      515464 : ObjectTemplateInfo* ObjectTemplateInfo::GetParent(Isolate* isolate) {
    5633             :   Object* maybe_ctor = constructor();
    5634      515464 :   if (maybe_ctor->IsUndefined(isolate)) return nullptr;
    5635             :   FunctionTemplateInfo* constructor = FunctionTemplateInfo::cast(maybe_ctor);
    5636             :   while (true) {
    5637      200208 :     constructor = constructor->GetParent(isolate);
    5638      200208 :     if (constructor == nullptr) return nullptr;
    5639             :     Object* maybe_obj = constructor->instance_template();
    5640         416 :     if (!maybe_obj->IsUndefined(isolate)) {
    5641             :       return ObjectTemplateInfo::cast(maybe_obj);
    5642             :     }
    5643             :   }
    5644             :   return nullptr;
    5645             : }
    5646             : 
    5647     1676075 : ACCESSORS(PrototypeInfo, weak_cell, Object, kWeakCellOffset)
    5648     3524350 : ACCESSORS(PrototypeInfo, prototype_users, Object, kPrototypeUsersOffset)
    5649      750342 : ACCESSORS(PrototypeInfo, object_create_map, Object, kObjectCreateMap)
    5650     4625922 : SMI_ACCESSORS(PrototypeInfo, registry_slot, kRegistrySlotOffset)
    5651     5993670 : ACCESSORS(PrototypeInfo, validity_cell, Object, kValidityCellOffset)
    5652    29723366 : SMI_ACCESSORS(PrototypeInfo, bit_field, kBitFieldOffset)
    5653             : BOOL_ACCESSORS(PrototypeInfo, bit_field, should_be_fast_map, kShouldBeFastBit)
    5654             : 
    5655     8494074 : ACCESSORS(Tuple2, value1, Object, kValue1Offset)
    5656     8539769 : ACCESSORS(Tuple2, value2, Object, kValue2Offset)
    5657     7744650 : ACCESSORS(Tuple3, value3, Object, kValue3Offset)
    5658             : 
    5659     3675986 : ACCESSORS(ContextExtension, scope_info, ScopeInfo, kScopeInfoOffset)
    5660    11389026 : ACCESSORS(ContextExtension, extension, Object, kExtensionOffset)
    5661             : 
    5662      687212 : SMI_ACCESSORS(ConstantElementsPair, elements_kind, kElementsKindOffset)
    5663     1299255 : ACCESSORS(ConstantElementsPair, constant_values, FixedArrayBase,
    5664             :           kConstantValuesOffset)
    5665             : 
    5666        1753 : ACCESSORS(JSModuleNamespace, module, Module, kModuleOffset)
    5667             : 
    5668       45224 : ACCESSORS(Module, code, Object, kCodeOffset)
    5669       19862 : ACCESSORS(Module, exports, ObjectHashTable, kExportsOffset)
    5670        8063 : ACCESSORS(Module, regular_exports, FixedArray, kRegularExportsOffset)
    5671        6994 : ACCESSORS(Module, regular_imports, FixedArray, kRegularImportsOffset)
    5672        7316 : ACCESSORS(Module, module_namespace, HeapObject, kModuleNamespaceOffset)
    5673       13189 : ACCESSORS(Module, requested_modules, FixedArray, kRequestedModulesOffset)
    5674        6266 : SMI_ACCESSORS(Module, status, kStatusOffset)
    5675        6104 : SMI_ACCESSORS(Module, hash, kHashOffset)
    5676             : 
    5677       14810 : bool Module::evaluated() const { return code()->IsModuleInfo(); }
    5678             : 
    5679        1875 : void Module::set_evaluated() {
    5680             :   DCHECK(instantiated());
    5681             :   DCHECK(!evaluated());
    5682             :   return set_code(
    5683        1875 :       JSFunction::cast(code())->shared()->scope_info()->ModuleDescriptorInfo());
    5684             : }
    5685             : 
    5686       16674 : bool Module::instantiated() const { return !code()->IsSharedFunctionInfo(); }
    5687             : 
    5688        5085 : ModuleInfo* Module::info() const {
    5689        5369 :   if (evaluated()) return ModuleInfo::cast(code());
    5690        4801 :   ScopeInfo* scope_info = instantiated()
    5691             :                               ? JSFunction::cast(code())->shared()->scope_info()
    5692        4801 :                               : SharedFunctionInfo::cast(code())->scope_info();
    5693        4801 :   return scope_info->ModuleDescriptorInfo();
    5694             : }
    5695             : 
    5696    20892510 : ACCESSORS(AccessorPair, getter, Object, kGetterOffset)
    5697     1142753 : ACCESSORS(AccessorPair, setter, Object, kSetterOffset)
    5698             : 
    5699        3672 : ACCESSORS(AccessCheckInfo, callback, Object, kCallbackOffset)
    5700        1232 : ACCESSORS(AccessCheckInfo, named_interceptor, Object, kNamedInterceptorOffset)
    5701        1563 : ACCESSORS(AccessCheckInfo, indexed_interceptor, Object,
    5702             :           kIndexedInterceptorOffset)
    5703        3860 : ACCESSORS(AccessCheckInfo, data, Object, kDataOffset)
    5704             : 
    5705      876009 : ACCESSORS(InterceptorInfo, getter, Object, kGetterOffset)
    5706     1082351 : ACCESSORS(InterceptorInfo, setter, Object, kSetterOffset)
    5707      282121 : ACCESSORS(InterceptorInfo, query, Object, kQueryOffset)
    5708         357 : ACCESSORS(InterceptorInfo, descriptor, Object, kDescriptorOffset)
    5709         452 : ACCESSORS(InterceptorInfo, deleter, Object, kDeleterOffset)
    5710        1152 : ACCESSORS(InterceptorInfo, enumerator, Object, kEnumeratorOffset)
    5711         613 : ACCESSORS(InterceptorInfo, definer, Object, kDefinerOffset)
    5712     1443583 : ACCESSORS(InterceptorInfo, data, Object, kDataOffset)
    5713     1079231 : SMI_ACCESSORS(InterceptorInfo, flags, kFlagsOffset)
    5714             : BOOL_ACCESSORS(InterceptorInfo, flags, can_intercept_symbols,
    5715             :                kCanInterceptSymbolsBit)
    5716             : BOOL_ACCESSORS(InterceptorInfo, flags, all_can_read, kAllCanReadBit)
    5717             : BOOL_ACCESSORS(InterceptorInfo, flags, non_masking, kNonMasking)
    5718             : 
    5719    62789992 : ACCESSORS(CallHandlerInfo, callback, Object, kCallbackOffset)
    5720    62782652 : ACCESSORS(CallHandlerInfo, data, Object, kDataOffset)
    5721             : 
    5722    12637912 : ACCESSORS(TemplateInfo, tag, Object, kTagOffset)
    5723    18353645 : ACCESSORS(TemplateInfo, serial_number, Object, kSerialNumberOffset)
    5724    11954212 : SMI_ACCESSORS(TemplateInfo, number_of_properties, kNumberOfProperties)
    5725    12857915 : ACCESSORS(TemplateInfo, property_list, Object, kPropertyListOffset)
    5726     4532004 : ACCESSORS(TemplateInfo, property_accessors, Object, kPropertyAccessorsOffset)
    5727             : 
    5728    62821178 : ACCESSORS(FunctionTemplateInfo, call_code, Object, kCallCodeOffset)
    5729     4486328 : ACCESSORS(FunctionTemplateInfo, prototype_template, Object,
    5730             :           kPrototypeTemplateOffset)
    5731     7314745 : ACCESSORS(FunctionTemplateInfo, prototype_provider_template, Object,
    5732             :           kPrototypeProviderTemplateOffset)
    5733             : 
    5734     7685293 : ACCESSORS(FunctionTemplateInfo, parent_template, Object, kParentTemplateOffset)
    5735     9630540 : ACCESSORS(FunctionTemplateInfo, named_property_handler, Object,
    5736             :           kNamedPropertyHandlerOffset)
    5737     8553562 : ACCESSORS(FunctionTemplateInfo, indexed_property_handler, Object,
    5738             :           kIndexedPropertyHandlerOffset)
    5739     5020838 : ACCESSORS(FunctionTemplateInfo, instance_template, Object,
    5740             :           kInstanceTemplateOffset)
    5741     3950128 : ACCESSORS(FunctionTemplateInfo, class_name, Object, kClassNameOffset)
    5742    52396807 : ACCESSORS(FunctionTemplateInfo, signature, Object, kSignatureOffset)
    5743     3851954 : ACCESSORS(FunctionTemplateInfo, instance_call_handler, Object,
    5744             :           kInstanceCallHandlerOffset)
    5745      331368 : ACCESSORS(FunctionTemplateInfo, access_check_info, Object,
    5746             :           kAccessCheckInfoOffset)
    5747    20663948 : ACCESSORS(FunctionTemplateInfo, shared_function_info, Object,
    5748             :           kSharedFunctionInfoOffset)
    5749    11289923 : ACCESSORS(FunctionTemplateInfo, cached_property_name, Object,
    5750             :           kCachedPropertyNameOffset)
    5751             : 
    5752   116908537 : SMI_ACCESSORS(FunctionTemplateInfo, flag, kFlagOffset)
    5753             : 
    5754     2064039 : ACCESSORS(ObjectTemplateInfo, constructor, Object, kConstructorOffset)
    5755     2820554 : ACCESSORS(ObjectTemplateInfo, data, Object, kDataOffset)
    5756             : 
    5757             : int ObjectTemplateInfo::embedder_field_count() const {
    5758             :   Object* value = data();
    5759             :   DCHECK(value->IsSmi());
    5760      453191 :   return EmbedderFieldCount::decode(Smi::cast(value)->value());
    5761             : }
    5762             : 
    5763      127497 : void ObjectTemplateInfo::set_embedder_field_count(int count) {
    5764             :   return set_data(Smi::FromInt(
    5765      382491 :       EmbedderFieldCount::update(Smi::cast(data())->value(), count)));
    5766             : }
    5767             : 
    5768             : bool ObjectTemplateInfo::immutable_proto() const {
    5769             :   Object* value = data();
    5770             :   DCHECK(value->IsSmi());
    5771      508629 :   return IsImmutablePrototype::decode(Smi::cast(value)->value());
    5772             : }
    5773             : 
    5774          21 : void ObjectTemplateInfo::set_immutable_proto(bool immutable) {
    5775             :   return set_data(Smi::FromInt(
    5776          63 :       IsImmutablePrototype::update(Smi::cast(data())->value(), immutable)));
    5777             : }
    5778             : 
    5779             : int TemplateList::length() const {
    5780             :   return Smi::cast(FixedArray::cast(this)->get(kLengthIndex))->value();
    5781             : }
    5782             : 
    5783             : Object* TemplateList::get(int index) const {
    5784      140145 :   return FixedArray::cast(this)->get(kFirstElementIndex + index);
    5785             : }
    5786             : 
    5787             : void TemplateList::set(int index, Object* value) {
    5788         185 :   FixedArray::cast(this)->set(kFirstElementIndex + index, value);
    5789             : }
    5790             : 
    5791    21505037 : ACCESSORS(AllocationSite, transition_info, Object, kTransitionInfoOffset)
    5792     7317223 : ACCESSORS(AllocationSite, nested_site, Object, kNestedSiteOffset)
    5793    13216419 : SMI_ACCESSORS(AllocationSite, pretenure_data, kPretenureDataOffset)
    5794    16580738 : SMI_ACCESSORS(AllocationSite, pretenure_create_count,
    5795             :               kPretenureCreateCountOffset)
    5796     1866023 : ACCESSORS(AllocationSite, dependent_code, DependentCode,
    5797             :           kDependentCodeOffset)
    5798    10530323 : ACCESSORS(AllocationSite, weak_next, Object, kWeakNextOffset)
    5799    19052019 : ACCESSORS(AllocationMemento, allocation_site, Object, kAllocationSiteOffset)
    5800             : 
    5801    43802081 : ACCESSORS(Script, source, Object, kSourceOffset)
    5802     8805434 : ACCESSORS(Script, name, Object, kNameOffset)
    5803     8534695 : SMI_ACCESSORS(Script, id, kIdOffset)
    5804     3821279 : SMI_ACCESSORS(Script, line_offset, kLineOffsetOffset)
    5805     2582428 : SMI_ACCESSORS(Script, column_offset, kColumnOffsetOffset)
    5806    25040173 : ACCESSORS(Script, context_data, Object, kContextOffset)
    5807    11549017 : ACCESSORS(Script, wrapper, HeapObject, kWrapperOffset)
    5808    39678060 : SMI_ACCESSORS(Script, type, kTypeOffset)
    5809    11340669 : ACCESSORS(Script, line_ends, Object, kLineEndsOffset)
    5810    10212806 : ACCESSORS_CHECKED(Script, eval_from_shared, Object, kEvalFromSharedOffset,
    5811             :                   this->type() != TYPE_WASM)
    5812     3402698 : SMI_ACCESSORS_CHECKED(Script, eval_from_position, kEvalFromPositionOffset,
    5813             :                       this->type() != TYPE_WASM)
    5814    20184651 : ACCESSORS(Script, shared_function_infos, FixedArray, kSharedFunctionInfosOffset)
    5815    15421653 : SMI_ACCESSORS(Script, flags, kFlagsOffset)
    5816      357378 : ACCESSORS(Script, source_url, Object, kSourceUrlOffset)
    5817       77185 : ACCESSORS(Script, source_mapping_url, Object, kSourceMappingUrlOffset)
    5818       37711 : ACCESSORS_CHECKED(Script, wasm_compiled_module, Object, kEvalFromSharedOffset,
    5819             :                   this->type() == TYPE_WASM)
    5820     6284379 : ACCESSORS(Script, preparsed_scope_data, PodArray<uint32_t>,
    5821             :           kPreParsedScopeDataOffset)
    5822             : 
    5823             : Script::CompilationType Script::compilation_type() {
    5824             :   return BooleanBit::get(flags(), kCompilationTypeBit) ?
    5825     4894607 :       COMPILATION_TYPE_EVAL : COMPILATION_TYPE_HOST;
    5826             : }
    5827             : void Script::set_compilation_type(CompilationType type) {
    5828             :   set_flags(BooleanBit::set(flags(), kCompilationTypeBit,
    5829             :       type == COMPILATION_TYPE_EVAL));
    5830             : }
    5831           0 : Script::CompilationState Script::compilation_state() {
    5832             :   return BooleanBit::get(flags(), kCompilationStateBit) ?
    5833       12100 :       COMPILATION_STATE_COMPILED : COMPILATION_STATE_INITIAL;
    5834             : }
    5835             : void Script::set_compilation_state(CompilationState state) {
    5836             :   set_flags(BooleanBit::set(flags(), kCompilationStateBit,
    5837             :       state == COMPILATION_STATE_COMPILED));
    5838             : }
    5839             : ScriptOriginOptions Script::origin_options() {
    5840      144835 :   return ScriptOriginOptions((flags() & kOriginOptionsMask) >>
    5841      144835 :                              kOriginOptionsShift);
    5842             : }
    5843             : void Script::set_origin_options(ScriptOriginOptions origin_options) {
    5844             :   DCHECK(!(origin_options.Flags() & ~((1 << kOriginOptionsSize) - 1)));
    5845     1501984 :   set_flags((flags() & ~kOriginOptionsMask) |
    5846     1501984 :             (origin_options.Flags() << kOriginOptionsShift));
    5847             : }
    5848             : 
    5849             : 
    5850   125113900 : ACCESSORS(DebugInfo, shared, SharedFunctionInfo, kSharedFunctionInfoIndex)
    5851      328538 : SMI_ACCESSORS(DebugInfo, debugger_hints, kDebuggerHintsIndex)
    5852    18713120 : ACCESSORS(DebugInfo, debug_bytecode_array, Object, kDebugBytecodeArrayIndex)
    5853     3637058 : ACCESSORS(DebugInfo, break_points, FixedArray, kBreakPointsStateIndex)
    5854             : 
    5855     1634039 : bool DebugInfo::HasDebugBytecodeArray() {
    5856     1634039 :   return debug_bytecode_array()->IsBytecodeArray();
    5857             : }
    5858             : 
    5859             : bool DebugInfo::HasDebugCode() {
    5860             :   Code* code = shared()->code();
    5861             :   bool has = code->kind() == Code::FUNCTION;
    5862             :   DCHECK(!has || code->has_debug_break_slots());
    5863             :   return has;
    5864             : }
    5865             : 
    5866             : BytecodeArray* DebugInfo::OriginalBytecodeArray() {
    5867             :   DCHECK(HasDebugBytecodeArray());
    5868             :   return shared()->bytecode_array();
    5869             : }
    5870             : 
    5871             : BytecodeArray* DebugInfo::DebugBytecodeArray() {
    5872             :   DCHECK(HasDebugBytecodeArray());
    5873             :   return BytecodeArray::cast(debug_bytecode_array());
    5874             : }
    5875             : 
    5876             : Code* DebugInfo::DebugCode() {
    5877             :   DCHECK(HasDebugCode());
    5878             :   return shared()->code();
    5879             : }
    5880             : 
    5881      144079 : SMI_ACCESSORS(BreakPointInfo, source_position, kSourcePositionIndex)
    5882      272006 : ACCESSORS(BreakPointInfo, break_point_objects, Object, kBreakPointObjectsIndex)
    5883             : 
    5884       71263 : SMI_ACCESSORS(StackFrameInfo, line_number, kLineNumberIndex)
    5885       71223 : SMI_ACCESSORS(StackFrameInfo, column_number, kColumnNumberIndex)
    5886       70953 : SMI_ACCESSORS(StackFrameInfo, script_id, kScriptIdIndex)
    5887       76847 : ACCESSORS(StackFrameInfo, script_name, Object, kScriptNameIndex)
    5888      121874 : ACCESSORS(StackFrameInfo, script_name_or_source_url, Object,
    5889             :           kScriptNameOrSourceUrlIndex)
    5890      157089 : ACCESSORS(StackFrameInfo, function_name, Object, kFunctionNameIndex)
    5891      134661 : SMI_ACCESSORS(StackFrameInfo, flag, kFlagIndex)
    5892             : BOOL_ACCESSORS(StackFrameInfo, flag, is_eval, kIsEvalBit)
    5893             : BOOL_ACCESSORS(StackFrameInfo, flag, is_constructor, kIsConstructorBit)
    5894             : BOOL_ACCESSORS(StackFrameInfo, flag, is_wasm, kIsWasmBit)
    5895       19268 : SMI_ACCESSORS(StackFrameInfo, id, kIdIndex)
    5896             : 
    5897      285227 : ACCESSORS(SourcePositionTableWithFrameCache, source_position_table, ByteArray,
    5898             :           kSourcePositionTableIndex)
    5899       66778 : ACCESSORS(SourcePositionTableWithFrameCache, stack_frame_cache,
    5900             :           UnseededNumberDictionary, kStackFrameCacheIndex)
    5901             : 
    5902    55606333 : ACCESSORS(SharedFunctionInfo, name, Object, kNameOffset)
    5903    79621494 : ACCESSORS(SharedFunctionInfo, optimized_code_map, FixedArray,
    5904             :           kOptimizedCodeMapOffset)
    5905    45437317 : ACCESSORS(SharedFunctionInfo, construct_stub, Code, kConstructStubOffset)
    5906   115001317 : ACCESSORS(SharedFunctionInfo, feedback_metadata, FeedbackMetadata,
    5907             :           kFeedbackMetadataOffset)
    5908    27190060 : SMI_ACCESSORS(SharedFunctionInfo, function_literal_id, kFunctionLiteralIdOffset)
    5909             : #if TRACE_MAPS
    5910             : SMI_ACCESSORS(SharedFunctionInfo, unique_id, kUniqueIdOffset)
    5911             : #endif
    5912    67683031 : ACCESSORS(SharedFunctionInfo, instance_class_name, Object,
    5913             :           kInstanceClassNameOffset)
    5914   296308121 : ACCESSORS(SharedFunctionInfo, function_data, Object, kFunctionDataOffset)
    5915   127589901 : ACCESSORS(SharedFunctionInfo, script, Object, kScriptOffset)
    5916    60941687 : ACCESSORS(SharedFunctionInfo, debug_info, Object, kDebugInfoOffset)
    5917    37309111 : ACCESSORS(SharedFunctionInfo, function_identifier, Object,
    5918             :           kFunctionIdentifierOffset)
    5919             : 
    5920     7525101 : SMI_ACCESSORS(FunctionTemplateInfo, length, kLengthOffset)
    5921             : BOOL_ACCESSORS(FunctionTemplateInfo, flag, hidden_prototype,
    5922             :                kHiddenPrototypeBit)
    5923             : BOOL_ACCESSORS(FunctionTemplateInfo, flag, undetectable, kUndetectableBit)
    5924             : BOOL_ACCESSORS(FunctionTemplateInfo, flag, needs_access_check,
    5925             :                kNeedsAccessCheckBit)
    5926             : BOOL_ACCESSORS(FunctionTemplateInfo, flag, read_only_prototype,
    5927             :                kReadOnlyPrototypeBit)
    5928             : BOOL_ACCESSORS(FunctionTemplateInfo, flag, remove_prototype,
    5929             :                kRemovePrototypeBit)
    5930             : BOOL_ACCESSORS(FunctionTemplateInfo, flag, do_not_cache,
    5931             :                kDoNotCacheBit)
    5932             : BOOL_ACCESSORS(FunctionTemplateInfo, flag, accept_any_receiver,
    5933             :                kAcceptAnyReceiver)
    5934             : BOOL_ACCESSORS(SharedFunctionInfo, start_position_and_type, is_named_expression,
    5935             :                kIsNamedExpressionBit)
    5936      867898 : BOOL_ACCESSORS(SharedFunctionInfo, start_position_and_type, is_toplevel,
    5937             :                kIsTopLevelBit)
    5938             : 
    5939             : #if V8_HOST_ARCH_32_BIT
    5940             : SMI_ACCESSORS(SharedFunctionInfo, length, kLengthOffset)
    5941             : SMI_ACCESSORS(SharedFunctionInfo, internal_formal_parameter_count,
    5942             :               kFormalParameterCountOffset)
    5943             : SMI_ACCESSORS(SharedFunctionInfo, expected_nof_properties,
    5944             :               kExpectedNofPropertiesOffset)
    5945             : SMI_ACCESSORS(SharedFunctionInfo, start_position_and_type,
    5946             :               kStartPositionAndTypeOffset)
    5947             : SMI_ACCESSORS(SharedFunctionInfo, end_position, kEndPositionOffset)
    5948             : SMI_ACCESSORS(SharedFunctionInfo, function_token_position,
    5949             :               kFunctionTokenPositionOffset)
    5950             : SMI_ACCESSORS(SharedFunctionInfo, compiler_hints,
    5951             :               kCompilerHintsOffset)
    5952             : SMI_ACCESSORS(SharedFunctionInfo, opt_count_and_bailout_reason,
    5953             :               kOptCountAndBailoutReasonOffset)
    5954             : SMI_ACCESSORS(SharedFunctionInfo, counters, kCountersOffset)
    5955             : SMI_ACCESSORS(SharedFunctionInfo, ast_node_count, kAstNodeCountOffset)
    5956             : SMI_ACCESSORS(SharedFunctionInfo, profiler_ticks, kProfilerTicksOffset)
    5957             : 
    5958             : #else
    5959             : 
    5960             : #if V8_TARGET_LITTLE_ENDIAN
    5961             : #define PSEUDO_SMI_LO_ALIGN 0
    5962             : #define PSEUDO_SMI_HI_ALIGN kIntSize
    5963             : #else
    5964             : #define PSEUDO_SMI_LO_ALIGN kIntSize
    5965             : #define PSEUDO_SMI_HI_ALIGN 0
    5966             : #endif
    5967             : 
    5968             : #define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset)                          \
    5969             :   STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_LO_ALIGN);         \
    5970             :   int holder::name() const {                                                   \
    5971             :     int value = READ_INT_FIELD(this, offset);                                  \
    5972             :     DCHECK(kHeapObjectTag == 1);                                               \
    5973             :     DCHECK((value & kHeapObjectTag) == 0);                                     \
    5974             :     return value >> 1;                                                         \
    5975             :   }                                                                            \
    5976             :   void holder::set_##name(int value) {                                         \
    5977             :     DCHECK(kHeapObjectTag == 1);                                               \
    5978             :     DCHECK((value & 0xC0000000) == 0xC0000000 || (value & 0xC0000000) == 0x0); \
    5979             :     WRITE_INT_FIELD(this, offset, (value << 1) & ~kHeapObjectTag);             \
    5980             :   }
    5981             : 
    5982             : #define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset)                  \
    5983             :   STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_HI_ALIGN); \
    5984             :   INT_ACCESSORS(holder, name, offset)
    5985             : 
    5986             : 
    5987    26130922 : PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo, length, kLengthOffset)
    5988    36092862 : PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo, internal_formal_parameter_count,
    5989             :                         kFormalParameterCountOffset)
    5990             : 
    5991    19997150 : PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo,
    5992             :                         expected_nof_properties,
    5993             :                         kExpectedNofPropertiesOffset)
    5994             : 
    5995    21464246 : PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo, end_position, kEndPositionOffset)
    5996    60801539 : PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo,
    5997             :                         start_position_and_type,
    5998             :                         kStartPositionAndTypeOffset)
    5999             : 
    6000    16940919 : PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo,
    6001             :                         function_token_position,
    6002             :                         kFunctionTokenPositionOffset)
    6003   181564658 : PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo,
    6004             :                         compiler_hints,
    6005             :                         kCompilerHintsOffset)
    6006             : 
    6007    12486588 : PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo,
    6008             :                         opt_count_and_bailout_reason,
    6009             :                         kOptCountAndBailoutReasonOffset)
    6010   103896717 : PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo, counters, kCountersOffset)
    6011             : 
    6012    14290196 : PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo,
    6013             :                         ast_node_count,
    6014             :                         kAstNodeCountOffset)
    6015    19405953 : PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo,
    6016             :                         profiler_ticks,
    6017             :                         kProfilerTicksOffset)
    6018             : 
    6019             : #endif
    6020             : 
    6021           0 : AbstractCode* SharedFunctionInfo::abstract_code() {
    6022     1399512 :   if (HasBytecodeArray()) {
    6023           0 :     return AbstractCode::cast(bytecode_array());
    6024             :   } else {
    6025           0 :     return AbstractCode::cast(code());
    6026             :   }
    6027             : }
    6028             : 
    6029     1404578 : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, allows_lazy_compilation,
    6030             :                kAllowLazyCompilation)
    6031             : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, uses_arguments,
    6032             :                kUsesArguments)
    6033             : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, has_duplicate_parameters,
    6034             :                kHasDuplicateParameters)
    6035        8178 : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, asm_function, kIsAsmFunction)
    6036             : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_declaration,
    6037             :                kIsDeclaration)
    6038             : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, marked_for_tier_up,
    6039             :                kMarkedForTierUp)
    6040             : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints,
    6041             :                has_concurrent_optimization_job, kHasConcurrentOptimizationJob)
    6042             : 
    6043             : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, needs_home_object,
    6044             :                kNeedsHomeObject)
    6045      105056 : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, native, kNative)
    6046        2868 : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, force_inline, kForceInline)
    6047             : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, must_use_ignition_turbo,
    6048             :                kMustUseIgnitionTurbo)
    6049      273634 : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, dont_flush, kDontFlush)
    6050        1028 : BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_asm_wasm_broken,
    6051             :                kIsAsmWasmBroken)
    6052             : 
    6053           0 : BOOL_GETTER(SharedFunctionInfo, compiler_hints, optimization_disabled,
    6054             :             kOptimizationDisabled)
    6055             : 
    6056        2168 : void SharedFunctionInfo::set_optimization_disabled(bool disable) {
    6057             :   set_compiler_hints(BooleanBit::set(compiler_hints(),
    6058             :                                      kOptimizationDisabled,
    6059             :                                      disable));
    6060        2168 : }
    6061             : 
    6062             : LanguageMode SharedFunctionInfo::language_mode() {
    6063             :   STATIC_ASSERT(LANGUAGE_END == 2);
    6064             :   return construct_language_mode(
    6065             :       BooleanBit::get(compiler_hints(), kStrictModeFunction));
    6066             : }
    6067             : 
    6068             : void SharedFunctionInfo::set_language_mode(LanguageMode language_mode) {
    6069             :   STATIC_ASSERT(LANGUAGE_END == 2);
    6070             :   // We only allow language mode transitions that set the same language mode
    6071             :   // again or go up in the chain:
    6072             :   DCHECK(is_sloppy(this->language_mode()) || is_strict(language_mode));
    6073             :   int hints = compiler_hints();
    6074             :   hints = BooleanBit::set(hints, kStrictModeFunction, is_strict(language_mode));
    6075             :   set_compiler_hints(hints);
    6076             : }
    6077             : 
    6078      471496 : FunctionKind SharedFunctionInfo::kind() const {
    6079    32961805 :   return FunctionKindBits::decode(compiler_hints());
    6080             : }
    6081             : 
    6082             : void SharedFunctionInfo::set_kind(FunctionKind kind) {
    6083             :   DCHECK(IsValidFunctionKind(kind));
    6084             :   int hints = compiler_hints();
    6085    24947548 :   hints = FunctionKindBits::update(hints, kind);
    6086             :   set_compiler_hints(hints);
    6087             : }
    6088             : 
    6089     3587062 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints,
    6090             :                name_should_print_as_anonymous, kNameShouldPrintAsAnonymous)
    6091    12470776 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints, is_anonymous_expression,
    6092             :                kIsAnonymousExpression)
    6093         546 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints, deserialized, kDeserialized)
    6094       22148 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints, has_no_side_effect,
    6095             :                kHasNoSideEffect)
    6096       22148 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints, computed_has_no_side_effect,
    6097             :                kComputedHasNoSideEffect)
    6098       43472 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints, debug_is_blackboxed,
    6099             :                kDebugIsBlackboxed)
    6100     2153338 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints, computed_debug_is_blackboxed,
    6101             :                kComputedDebugIsBlackboxed)
    6102      115502 : BOOL_ACCESSORS(SharedFunctionInfo, debugger_hints, has_reported_binary_coverage,
    6103             :                kHasReportedBinaryCoverage)
    6104             : 
    6105       92778 : bool Script::HasValidSource() {
    6106             :   Object* src = this->source();
    6107       92778 :   if (!src->IsString()) return true;
    6108             :   String* src_str = String::cast(src);
    6109       92778 :   if (!StringShape(src_str).IsExternal()) return true;
    6110       56022 :   if (src_str->IsOneByteRepresentation()) {
    6111       55994 :     return ExternalOneByteString::cast(src)->resource() != NULL;
    6112          28 :   } else if (src_str->IsTwoByteRepresentation()) {
    6113          28 :     return ExternalTwoByteString::cast(src)->resource() != NULL;
    6114             :   }
    6115             :   return true;
    6116             : }
    6117             : 
    6118             : 
    6119             : void SharedFunctionInfo::DontAdaptArguments() {
    6120             :   DCHECK(code()->kind() == Code::BUILTIN || code()->kind() == Code::STUB);
    6121             :   set_internal_formal_parameter_count(kDontAdaptArgumentsSentinel);
    6122             : }
    6123             : 
    6124             : 
    6125      196129 : int SharedFunctionInfo::start_position() const {
    6126     7938651 :   return start_position_and_type() >> kStartPositionShift;
    6127             : }
    6128             : 
    6129             : 
    6130             : void SharedFunctionInfo::set_start_position(int start_position) {
    6131     6237413 :   set_start_position_and_type((start_position << kStartPositionShift)
    6132     6237492 :     | (start_position_and_type() & ~kStartPositionMask));
    6133             : }
    6134             : 
    6135             : 
    6136   189282432 : Code* SharedFunctionInfo::code() const {
    6137   325033538 :   return Code::cast(READ_FIELD(this, kCodeOffset));
    6138             : }
    6139             : 
    6140             : 
    6141    13594484 : void SharedFunctionInfo::set_code(Code* value, WriteBarrierMode mode) {
    6142             :   DCHECK(value->kind() != Code::OPTIMIZED_FUNCTION);
    6143             :   // If the SharedFunctionInfo has bytecode we should never mark it for lazy
    6144             :   // compile, since the bytecode is never flushed.
    6145             :   DCHECK(value != GetIsolate()->builtins()->builtin(Builtins::kCompileLazy) ||
    6146             :          !HasBytecodeArray());
    6147    13594484 :   WRITE_FIELD(this, kCodeOffset, value);
    6148    40783473 :   CONDITIONAL_WRITE_BARRIER(value->GetHeap(), this, kCodeOffset, value, mode);
    6149    13594501 : }
    6150             : 
    6151             : 
    6152     2935139 : void SharedFunctionInfo::ReplaceCode(Code* value) {
    6153             :   // If the GC metadata field is already used then the function was
    6154             :   // enqueued as a code flushing candidate and we remove it now.
    6155     2935139 :   if (code()->gc_metadata() != NULL) {
    6156           0 :     CodeFlusher* flusher = GetHeap()->mark_compact_collector()->code_flusher();
    6157           0 :     flusher->EvictCandidate(this);
    6158             :   }
    6159             : 
    6160             :   DCHECK(code()->gc_metadata() == NULL && value->gc_metadata() == NULL);
    6161             : #ifdef DEBUG
    6162             :   Code::VerifyRecompiledCode(code(), value);
    6163             : #endif  // DEBUG
    6164             : 
    6165     2935139 :   set_code(value);
    6166     2935144 : }
    6167             : 
    6168             : bool SharedFunctionInfo::IsInterpreted() const {
    6169     6029814 :   return code()->is_interpreter_trampoline_builtin();
    6170             : }
    6171             : 
    6172             : bool SharedFunctionInfo::HasBaselineCode() const {
    6173       11715 :   return code()->kind() == Code::FUNCTION;
    6174             : }
    6175             : 
    6176      230847 : ScopeInfo* SharedFunctionInfo::scope_info() const {
    6177     7909969 :   return reinterpret_cast<ScopeInfo*>(READ_FIELD(this, kScopeInfoOffset));
    6178             : }
    6179             : 
    6180             : 
    6181    19827977 : void SharedFunctionInfo::set_scope_info(ScopeInfo* value,
    6182             :                                         WriteBarrierMode mode) {
    6183    19827977 :   WRITE_FIELD(this, kScopeInfoOffset, reinterpret_cast<Object*>(value));
    6184    59483915 :   CONDITIONAL_WRITE_BARRIER(GetHeap(),
    6185             :                             this,
    6186             :                             kScopeInfoOffset,
    6187             :                             reinterpret_cast<Object*>(value),
    6188             :                             mode);
    6189    19827981 : }
    6190             : 
    6191    73929605 : ACCESSORS(SharedFunctionInfo, outer_scope_info, HeapObject,
    6192             :           kOuterScopeInfoOffset)
    6193             : 
    6194     1027840 : bool SharedFunctionInfo::is_compiled() const {
    6195             :   Builtins* builtins = GetIsolate()->builtins();
    6196             :   DCHECK(code() != builtins->builtin(Builtins::kCompileOptimizedConcurrent));
    6197             :   DCHECK(code() != builtins->builtin(Builtins::kCompileOptimized));
    6198     1027840 :   return code() != builtins->builtin(Builtins::kCompileLazy);
    6199             : }
    6200             : 
    6201        1659 : int SharedFunctionInfo::GetLength() const {
    6202             :   DCHECK(is_compiled());
    6203             :   DCHECK(HasLength());
    6204        1659 :   return length();
    6205             : }
    6206             : 
    6207             : bool SharedFunctionInfo::HasLength() const {
    6208             :   DCHECK_IMPLIES(length() < 0, length() == kInvalidLength);
    6209             :   return length() != kInvalidLength;
    6210             : }
    6211             : 
    6212             : bool SharedFunctionInfo::has_simple_parameters() {
    6213             :   return scope_info()->HasSimpleParameters();
    6214             : }
    6215             : 
    6216             : bool SharedFunctionInfo::HasDebugInfo() const {
    6217             :   bool has_debug_info = !debug_info()->IsSmi();
    6218             :   DCHECK_EQ(debug_info()->IsStruct(), has_debug_info);
    6219             :   DCHECK(!has_debug_info || HasDebugCode());
    6220             :   return has_debug_info;
    6221             : }
    6222             : 
    6223             : DebugInfo* SharedFunctionInfo::GetDebugInfo() const {
    6224             :   DCHECK(HasDebugInfo());
    6225             :   return DebugInfo::cast(debug_info());
    6226             : }
    6227             : 
    6228      147937 : bool SharedFunctionInfo::HasDebugCode() const {
    6229      290239 :   if (HasBaselineCode()) return code()->has_debug_break_slots();
    6230        5635 :   return HasBytecodeArray();
    6231             : }
    6232             : 
    6233             : int SharedFunctionInfo::debugger_hints() const {
    6234    11895004 :   if (HasDebugInfo()) return GetDebugInfo()->debugger_hints();
    6235             :   return Smi::cast(debug_info())->value();
    6236             : }
    6237             : 
    6238     9207492 : void SharedFunctionInfo::set_debugger_hints(int value) {
    6239     9207492 :   if (HasDebugInfo()) {
    6240             :     GetDebugInfo()->set_debugger_hints(value);
    6241             :   } else {
    6242     9206091 :     set_debug_info(Smi::FromInt(value));
    6243             :   }
    6244     9207494 : }
    6245             : 
    6246    68713040 : bool SharedFunctionInfo::IsApiFunction() {
    6247    68713039 :   return function_data()->IsFunctionTemplateInfo();
    6248             : }
    6249             : 
    6250             : 
    6251             : FunctionTemplateInfo* SharedFunctionInfo::get_api_func_data() {
    6252             :   DCHECK(IsApiFunction());
    6253             :   return FunctionTemplateInfo::cast(function_data());
    6254             : }
    6255             : 
    6256             : void SharedFunctionInfo::set_api_func_data(FunctionTemplateInfo* data) {
    6257             :   DCHECK(function_data()->IsUndefined(GetIsolate()));
    6258     3761998 :   set_function_data(data);
    6259             : }
    6260             : 
    6261     3107982 : bool SharedFunctionInfo::HasBytecodeArray() const {
    6262     3107983 :   return function_data()->IsBytecodeArray();
    6263             : }
    6264             : 
    6265      104681 : BytecodeArray* SharedFunctionInfo::bytecode_array() const {
    6266             :   DCHECK(HasBytecodeArray());
    6267      104681 :   return BytecodeArray::cast(function_data());
    6268             : }
    6269             : 
    6270        1581 : void SharedFunctionInfo::set_bytecode_array(BytecodeArray* bytecode) {
    6271             :   DCHECK(function_data()->IsUndefined(GetIsolate()));
    6272     2079421 :   set_function_data(bytecode);
    6273        1581 : }
    6274             : 
    6275             : void SharedFunctionInfo::ClearBytecodeArray() {
    6276             :   DCHECK(function_data()->IsUndefined(GetIsolate()) || HasBytecodeArray());
    6277        7350 :   set_function_data(GetHeap()->undefined_value());
    6278             : }
    6279             : 
    6280    20595848 : bool SharedFunctionInfo::HasAsmWasmData() const {
    6281    20595848 :   return function_data()->IsFixedArray();
    6282             : }
    6283             : 
    6284       13483 : FixedArray* SharedFunctionInfo::asm_wasm_data() const {
    6285             :   DCHECK(HasAsmWasmData());
    6286       13483 :   return FixedArray::cast(function_data());
    6287             : }
    6288             : 
    6289             : void SharedFunctionInfo::set_asm_wasm_data(FixedArray* data) {
    6290             :   DCHECK(function_data()->IsUndefined(GetIsolate()) || HasAsmWasmData());
    6291        3616 :   set_function_data(data);
    6292             : }
    6293             : 
    6294         507 : void SharedFunctionInfo::ClearAsmWasmData() {
    6295             :   DCHECK(function_data()->IsUndefined(GetIsolate()) || HasAsmWasmData());
    6296         507 :   set_function_data(GetHeap()->undefined_value());
    6297         507 : }
    6298             : 
    6299             : bool SharedFunctionInfo::HasBuiltinFunctionId() {
    6300             :   return function_identifier()->IsSmi();
    6301             : }
    6302             : 
    6303             : BuiltinFunctionId SharedFunctionInfo::builtin_function_id() {
    6304             :   DCHECK(HasBuiltinFunctionId());
    6305             :   return static_cast<BuiltinFunctionId>(
    6306      275460 :       Smi::cast(function_identifier())->value());
    6307             : }
    6308             : 
    6309             : void SharedFunctionInfo::set_builtin_function_id(BuiltinFunctionId id) {
    6310       24539 :   set_function_identifier(Smi::FromInt(id));
    6311             : }
    6312             : 
    6313     3676372 : bool SharedFunctionInfo::HasInferredName() {
    6314     3676373 :   return function_identifier()->IsString();
    6315             : }
    6316             : 
    6317     3676373 : String* SharedFunctionInfo::inferred_name() {
    6318     3676373 :   if (HasInferredName()) {
    6319     2818871 :     return String::cast(function_identifier());
    6320             :   }
    6321             :   Isolate* isolate = GetIsolate();
    6322             :   DCHECK(function_identifier()->IsUndefined(isolate) || HasBuiltinFunctionId());
    6323      857502 :   return isolate->heap()->empty_string();
    6324             : }
    6325             : 
    6326             : void SharedFunctionInfo::set_inferred_name(String* inferred_name) {
    6327             :   DCHECK(function_identifier()->IsUndefined(GetIsolate()) || HasInferredName());
    6328     6235390 :   set_function_identifier(inferred_name);
    6329             : }
    6330             : 
    6331    56411325 : int SharedFunctionInfo::ic_age() {
    6332   138919872 :   return ICAgeBits::decode(counters());
    6333             : }
    6334             : 
    6335             : 
    6336             : void SharedFunctionInfo::set_ic_age(int ic_age) {
    6337     9009354 :   set_counters(ICAgeBits::update(counters(), ic_age));
    6338             : }
    6339             : 
    6340             : 
    6341          91 : int SharedFunctionInfo::deopt_count() {
    6342          91 :   return DeoptCountBits::decode(counters());
    6343             : }
    6344             : 
    6345             : 
    6346             : void SharedFunctionInfo::set_deopt_count(int deopt_count) {
    6347       74714 :   set_counters(DeoptCountBits::update(counters(), deopt_count));
    6348             : }
    6349             : 
    6350             : 
    6351             : void SharedFunctionInfo::increment_deopt_count() {
    6352             :   int value = counters();
    6353             :   int deopt_count = DeoptCountBits::decode(value);
    6354             :   // Saturate the deopt count when incrementing, rather than overflowing.
    6355      258660 :   if (deopt_count < DeoptCountBits::kMax) {
    6356      515102 :     set_counters(DeoptCountBits::update(value, deopt_count + 1));
    6357             :   }
    6358             : }
    6359             : 
    6360             : 
    6361             : int SharedFunctionInfo::opt_reenable_tries() {
    6362          44 :   return OptReenableTriesBits::decode(counters());
    6363             : }
    6364             : 
    6365             : 
    6366             : void SharedFunctionInfo::set_opt_reenable_tries(int tries) {
    6367          44 :   set_counters(OptReenableTriesBits::update(counters(), tries));
    6368             : }
    6369             : 
    6370             : 
    6371      167208 : int SharedFunctionInfo::opt_count() {
    6372      167208 :   return OptCountBits::decode(opt_count_and_bailout_reason());
    6373             : }
    6374             : 
    6375             : 
    6376             : void SharedFunctionInfo::set_opt_count(int opt_count) {
    6377             :   set_opt_count_and_bailout_reason(
    6378     1359224 :       OptCountBits::update(opt_count_and_bailout_reason(), opt_count));
    6379             : }
    6380             : 
    6381             : 
    6382             : BailoutReason SharedFunctionInfo::disable_optimization_reason() {
    6383             :   return static_cast<BailoutReason>(
    6384      183948 :       DisabledOptimizationReasonBits::decode(opt_count_and_bailout_reason()));
    6385             : }
    6386             : 
    6387             : 
    6388             : bool SharedFunctionInfo::has_deoptimization_support() {
    6389             :   Code* code = this->code();
    6390     1181085 :   return code->kind() == Code::FUNCTION && code->has_deoptimization_support();
    6391             : }
    6392             : 
    6393             : 
    6394          44 : void SharedFunctionInfo::TryReenableOptimization() {
    6395             :   int tries = opt_reenable_tries();
    6396          44 :   set_opt_reenable_tries((tries + 1) & OptReenableTriesBits::kMax);
    6397             :   // We reenable optimization whenever the number of tries is a large
    6398             :   // enough power of 2.
    6399          44 :   if (tries >= 16 && (((tries - 1) & tries) == 0)) {
    6400             :     set_optimization_disabled(false);
    6401             :     set_deopt_count(0);
    6402             :   }
    6403          44 : }
    6404             : 
    6405             : 
    6406        2168 : void SharedFunctionInfo::set_disable_optimization_reason(BailoutReason reason) {
    6407             :   set_opt_count_and_bailout_reason(DisabledOptimizationReasonBits::update(
    6408      118486 :       opt_count_and_bailout_reason(), reason));
    6409        2168 : }
    6410             : 
    6411    29774352 : bool SharedFunctionInfo::IsUserJavaScript() {
    6412             :   Object* script_obj = script();
    6413    29774352 :   if (script_obj->IsUndefined(GetIsolate())) return false;
    6414             :   Script* script = Script::cast(script_obj);
    6415    27904310 :   return script->IsUserJavaScript();
    6416             : }
    6417             : 
    6418    20872220 : bool SharedFunctionInfo::IsSubjectToDebugging() {
    6419    20872220 :   return IsUserJavaScript() && !HasAsmWasmData();
    6420             : }
    6421             : 
    6422             : bool SharedFunctionInfo::OptimizedCodeMapIsCleared() const {
    6423    45338421 :   return optimized_code_map() == GetHeap()->empty_fixed_array();
    6424             : }
    6425             : 
    6426     7710166 : FeedbackVector* JSFunction::feedback_vector() const {
    6427             :   DCHECK(feedback_vector_cell()->value()->IsFeedbackVector());
    6428     7710166 :   return FeedbackVector::cast(feedback_vector_cell()->value());
    6429             : }
    6430             : 
    6431     1922411 : bool JSFunction::IsOptimized() {
    6432     4640017 :   return code()->kind() == Code::OPTIMIZED_FUNCTION;
    6433             : }
    6434             : 
    6435        4578 : bool JSFunction::IsInterpreted() {
    6436     7182730 :   return code()->is_interpreter_trampoline_builtin();
    6437             : }
    6438             : 
    6439             : bool JSFunction::IsMarkedForOptimization() {
    6440      356137 :   return code() == GetIsolate()->builtins()->builtin(
    6441             :       Builtins::kCompileOptimized);
    6442             : }
    6443             : 
    6444             : 
    6445        5903 : bool JSFunction::IsMarkedForConcurrentOptimization() {
    6446        5903 :   return code() == GetIsolate()->builtins()->builtin(
    6447        5903 :       Builtins::kCompileOptimizedConcurrent);
    6448             : }
    6449             : 
    6450             : 
    6451        4270 : bool JSFunction::IsInOptimizationQueue() {
    6452      614149 :   return code() == GetIsolate()->builtins()->builtin(
    6453        4270 :       Builtins::kInOptimizationQueue);
    6454             : }
    6455             : 
    6456             : 
    6457      199284 : void JSFunction::CompleteInobjectSlackTrackingIfActive() {
    6458      256174 :   if (has_initial_map() && initial_map()->IsInobjectSlackTrackingInProgress()) {
    6459       40945 :     initial_map()->CompleteInobjectSlackTracking();
    6460             :   }
    6461      199284 : }
    6462             : 
    6463             : 
    6464             : bool Map::IsInobjectSlackTrackingInProgress() {
    6465    45730476 :   return construction_counter() != Map::kNoSlackTracking;
    6466             : }
    6467             : 
    6468             : 
    6469      408109 : void Map::InobjectSlackTrackingStep() {
    6470      816218 :   if (!IsInobjectSlackTrackingInProgress()) return;
    6471             :   int counter = construction_counter();
    6472      408109 :   set_construction_counter(counter - 1);
    6473      408109 :   if (counter == kSlackTrackingCounterEnd) {
    6474        2177 :     CompleteInobjectSlackTracking();
    6475             :   }
    6476             : }
    6477             : 
    6478             : AbstractCode* JSFunction::abstract_code() {
    6479         840 :   if (IsInterpreted()) {
    6480             :     return AbstractCode::cast(shared()->bytecode_array());
    6481             :   } else {
    6482         840 :     return AbstractCode::cast(code());
    6483             :   }
    6484             : }
    6485             : 
    6486   139146334 : Code* JSFunction::code() {
    6487             :   return Code::cast(
    6488   139146334 :       Code::GetObjectFromEntryAddress(FIELD_ADDR(this, kCodeEntryOffset)));
    6489             : }
    6490             : 
    6491             : 
    6492    29732407 : void JSFunction::set_code(Code* value) {
    6493             :   DCHECK(!GetHeap()->InNewSpace(value));
    6494    29732407 :   Address entry = value->entry();
    6495    29732407 :   WRITE_INTPTR_FIELD(this, kCodeEntryOffset, reinterpret_cast<intptr_t>(entry));
    6496             :   GetHeap()->incremental_marking()->RecordWriteOfCodeEntry(
    6497             :       this,
    6498             :       HeapObject::RawField(this, kCodeEntryOffset),
    6499    59464814 :       value);
    6500    29732408 : }
    6501             : 
    6502             : 
    6503             : void JSFunction::set_code_no_write_barrier(Code* value) {
    6504             :   DCHECK(!GetHeap()->InNewSpace(value));
    6505     1358068 :   Address entry = value->entry();
    6506     1358068 :   WRITE_INTPTR_FIELD(this, kCodeEntryOffset, reinterpret_cast<intptr_t>(entry));
    6507             : }
    6508             : 
    6509             : 
    6510     2717606 : void JSFunction::ReplaceCode(Code* code) {
    6511             :   bool was_optimized = IsOptimized();
    6512     2717606 :   bool is_optimized = code->kind() == Code::OPTIMIZED_FUNCTION;
    6513             : 
    6514     2717606 :   if (was_optimized && is_optimized) {
    6515             :     shared()->EvictFromOptimizedCodeMap(this->code(),
    6516          82 :         "Replacing with another optimized code");
    6517             :   }
    6518             : 
    6519     2717606 :   set_code(code);
    6520             : 
    6521             :   // Add/remove the function from the list of optimized functions for this
    6522             :   // context based on the state change.
    6523     2717607 :   if (!was_optimized && is_optimized) {
    6524     1474345 :     context()->native_context()->AddOptimizedFunction(this);
    6525             :   }
    6526     2717606 :   if (was_optimized && !is_optimized) {
    6527             :     // TODO(titzer): linear in the number of optimized functions; fix!
    6528           6 :     context()->native_context()->RemoveOptimizedFunction(this);
    6529             :   }
    6530     2717606 : }
    6531             : 
    6532    10237310 : bool JSFunction::has_feedback_vector() const {
    6533    10237309 :   return !feedback_vector_cell()->value()->IsUndefined(GetIsolate());
    6534             : }
    6535             : 
    6536    18762130 : JSFunction::FeedbackVectorState JSFunction::GetFeedbackVectorState(
    6537             :     Isolate* isolate) const {
    6538             :   Cell* cell = feedback_vector_cell();
    6539    18762130 :   if (cell == isolate->heap()->undefined_cell()) {
    6540             :     return TOP_LEVEL_SCRIPT_NEEDS_VECTOR;
    6541    22875396 :   } else if (cell->value() == isolate->heap()->undefined_value() ||
    6542    10237190 :              !has_feedback_vector()) {
    6543             :     return NEEDS_VECTOR;
    6544             :   }
    6545    10237189 :   return HAS_VECTOR;
    6546             : }
    6547             : 
    6548       38602 : Context* JSFunction::context() {
    6549    55475549 :   return Context::cast(READ_FIELD(this, kContextOffset));
    6550             : }
    6551             : 
    6552         489 : bool JSFunction::has_context() const {
    6553         978 :   return READ_FIELD(this, kContextOffset)->IsContext();
    6554             : }
    6555             : 
    6556          86 : JSObject* JSFunction::global_proxy() {
    6557     1809399 :   return context()->global_proxy();
    6558             : }
    6559             : 
    6560             : 
    6561      597788 : Context* JSFunction::native_context() { return context()->native_context(); }
    6562             : 
    6563             : 
    6564    26520730 : void JSFunction::set_context(Object* value) {
    6565             :   DCHECK(value->IsUndefined(GetIsolate()) || value->IsContext());
    6566    26520730 :   WRITE_FIELD(this, kContextOffset, value);
    6567    79562190 :   WRITE_BARRIER(GetHeap(), this, kContextOffset, value);
    6568    26520736 : }
    6569             : 
    6570   155103582 : ACCESSORS(JSFunction, prototype_or_initial_map, Object,
    6571             :           kPrototypeOrInitialMapOffset)
    6572             : 
    6573             : 
    6574        5997 : Map* JSFunction::initial_map() {
    6575        5997 :   return Map::cast(prototype_or_initial_map());
    6576             : }
    6577             : 
    6578             : 
    6579    27804507 : bool JSFunction::has_initial_map() {
    6580    27804507 :   return prototype_or_initial_map()->IsMap();
    6581             : }
    6582             : 
    6583             : 
    6584      682420 : bool JSFunction::has_instance_prototype() {
    6585     1335741 :   return has_initial_map() ||
    6586      682420 :          !prototype_or_initial_map()->IsTheHole(GetIsolate());
    6587             : }
    6588             : 
    6589             : 
    6590      210768 : bool JSFunction::has_prototype() {
    6591      210768 :   return map()->has_non_instance_prototype() || has_instance_prototype();
    6592             : }
    6593             : 
    6594             : 
    6595             : Object* JSFunction::instance_prototype() {
    6596             :   DCHECK(has_instance_prototype());
    6597     5251744 :   if (has_initial_map()) return initial_map()->prototype();
    6598             :   // When there is no initial map and the prototype is a JSObject, the
    6599             :   // initial map field is used for the prototype field.
    6600             :   return prototype_or_initial_map();
    6601             : }
    6602             : 
    6603             : 
    6604     4871787 : Object* JSFunction::prototype() {
    6605             :   DCHECK(has_prototype());
    6606             :   // If the function's prototype property has been set to a non-JSObject
    6607             :   // value, that value is stored in the constructor field of the map.
    6608     4871787 :   if (map()->has_non_instance_prototype()) {
    6609       21542 :     Object* prototype = map()->GetConstructor();
    6610             :     // The map must have a prototype in that field, not a back pointer.
    6611             :     DCHECK(!prototype->IsMap());
    6612             :     DCHECK(!prototype->IsFunctionTemplateInfo());
    6613       21542 :     return prototype;
    6614             :   }
    6615     4850245 :   return instance_prototype();
    6616             : }
    6617             : 
    6618             : 
    6619             : bool JSFunction::is_compiled() {
    6620             :   Builtins* builtins = GetIsolate()->builtins();
    6621     1954492 :   return code() != builtins->builtin(Builtins::kCompileLazy) &&
    6622     1900599 :          code() != builtins->builtin(Builtins::kCompileOptimized) &&
    6623             :          code() != builtins->builtin(Builtins::kCompileOptimizedConcurrent);
    6624             : }
    6625             : 
    6626     7632798 : ACCESSORS(JSProxy, target, JSReceiver, kTargetOffset)
    6627    15141702 : ACCESSORS(JSProxy, handler, Object, kHandlerOffset)
    6628       50674 : ACCESSORS(JSProxy, hash, Object, kHashOffset)
    6629             : 
    6630     7509846 : bool JSProxy::IsRevoked() const { return !handler()->IsJSReceiver(); }
    6631             : 
    6632     2519292 : ACCESSORS(JSCollection, table, Object, kTableOffset)
    6633             : 
    6634             : 
    6635             : #define ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(name, type, offset)    \
    6636             :   template<class Derived, class TableType>                           \
    6637             :   type* OrderedHashTableIterator<Derived, TableType>::name() const { \
    6638             :     return type::cast(READ_FIELD(this, offset));                     \
    6639             :   }                                                                  \
    6640             :   template<class Derived, class TableType>                           \
    6641             :   void OrderedHashTableIterator<Derived, TableType>::set_##name(     \
    6642             :       type* value, WriteBarrierMode mode) {                          \
    6643             :     WRITE_FIELD(this, offset, value);                                \
    6644             :     CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode); \
    6645             :   }
    6646             : 
    6647       95525 : ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(table, Object, kTableOffset)
    6648      143412 : ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(index, Object, kIndexOffset)
    6649       49493 : ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(kind, Object, kKindOffset)
    6650             : 
    6651             : #undef ORDERED_HASH_TABLE_ITERATOR_ACCESSORS
    6652             : 
    6653             : 
    6654      420534 : ACCESSORS(JSWeakCollection, table, Object, kTableOffset)
    6655       22247 : ACCESSORS(JSWeakCollection, next, Object, kNextOffset)
    6656             : 
    6657             : 
    6658      153295 : Address Foreign::foreign_address() {
    6659   112742127 :   return AddressFrom<Address>(READ_INTPTR_FIELD(this, kForeignAddressOffset));
    6660             : }
    6661             : 
    6662             : 
    6663             : void Foreign::set_foreign_address(Address value) {
    6664     4379807 :   WRITE_INTPTR_FIELD(this, kForeignAddressOffset, OffsetFrom(value));
    6665             : }
    6666             : 
    6667             : 
    6668      118205 : ACCESSORS(JSGeneratorObject, function, JSFunction, kFunctionOffset)
    6669      184080 : ACCESSORS(JSGeneratorObject, context, Context, kContextOffset)
    6670      112695 : ACCESSORS(JSGeneratorObject, receiver, Object, kReceiverOffset)
    6671       74073 : ACCESSORS(JSGeneratorObject, input_or_debug_pos, Object, kInputOrDebugPosOffset)
    6672      138334 : SMI_ACCESSORS(JSGeneratorObject, resume_mode, kResumeModeOffset)
    6673      107914 : SMI_ACCESSORS(JSGeneratorObject, continuation, kContinuationOffset)
    6674      112641 : ACCESSORS(JSGeneratorObject, register_file, FixedArray, kRegisterFileOffset)
    6675             : 
    6676           0 : bool JSGeneratorObject::is_suspended() const {
    6677             :   DCHECK_LT(kGeneratorExecuting, 0);
    6678             :   DCHECK_LT(kGeneratorClosed, 0);
    6679          54 :   return continuation() >= 0;
    6680             : }
    6681             : 
    6682             : bool JSGeneratorObject::is_closed() const {
    6683             :   return continuation() == kGeneratorClosed;
    6684             : }
    6685             : 
    6686             : bool JSGeneratorObject::is_executing() const {
    6687             :   return continuation() == kGeneratorExecuting;
    6688             : }
    6689             : 
    6690             : ACCESSORS(JSAsyncGeneratorObject, queue, HeapObject, kQueueOffset)
    6691           0 : ACCESSORS(JSAsyncGeneratorObject, await_input_or_debug_pos, Object,
    6692             :           kAwaitInputOrDebugPosOffset)
    6693           0 : ACCESSORS(JSAsyncGeneratorObject, awaited_promise, HeapObject,
    6694             :           kAwaitedPromiseOffset)
    6695             : 
    6696     5318963 : ACCESSORS(JSValue, value, Object, kValueOffset)
    6697             : 
    6698             : 
    6699             : HeapNumber* HeapNumber::cast(Object* object) {
    6700             :   SLOW_DCHECK(object->IsHeapNumber() || object->IsMutableHeapNumber());
    6701             :   return reinterpret_cast<HeapNumber*>(object);
    6702             : }
    6703             : 
    6704             : 
    6705             : const HeapNumber* HeapNumber::cast(const Object* object) {
    6706             :   SLOW_DCHECK(object->IsHeapNumber() || object->IsMutableHeapNumber());
    6707             :   return reinterpret_cast<const HeapNumber*>(object);
    6708             : }
    6709             : 
    6710             : 
    6711      856058 : ACCESSORS(JSDate, value, Object, kValueOffset)
    6712      256713 : ACCESSORS(JSDate, cache_stamp, Object, kCacheStampOffset)
    6713       19349 : ACCESSORS(JSDate, year, Object, kYearOffset)
    6714       18339 : ACCESSORS(JSDate, month, Object, kMonthOffset)
    6715       18072 : ACCESSORS(JSDate, day, Object, kDayOffset)
    6716       17959 : ACCESSORS(JSDate, weekday, Object, kWeekdayOffset)
    6717       22846 : ACCESSORS(JSDate, hour, Object, kHourOffset)
    6718       19281 : ACCESSORS(JSDate, min, Object, kMinOffset)
    6719       18310 : ACCESSORS(JSDate, sec, Object, kSecOffset)
    6720             : 
    6721             : 
    6722     1411156 : SMI_ACCESSORS(JSMessageObject, type, kTypeOffset)
    6723     4247805 : ACCESSORS(JSMessageObject, argument, Object, kArgumentsOffset)
    6724     4304459 : ACCESSORS(JSMessageObject, script, Object, kScriptOffset)
    6725     4216548 : ACCESSORS(JSMessageObject, stack_frames, Object, kStackFramesOffset)
    6726     1519521 : SMI_ACCESSORS(JSMessageObject, start_position, kStartPositionOffset)
    6727     1430242 : SMI_ACCESSORS(JSMessageObject, end_position, kEndPositionOffset)
    6728     1458110 : SMI_ACCESSORS(JSMessageObject, error_level, kErrorLevelOffset)
    6729             : 
    6730   375295465 : INT_ACCESSORS(Code, instruction_size, kInstructionSizeOffset)
    6731   180369035 : INT_ACCESSORS(Code, prologue_offset, kPrologueOffset)
    6732     2555745 : INT_ACCESSORS(Code, constant_pool_offset, kConstantPoolOffset)
    6733             : #define CODE_ACCESSORS(name, type, offset)           \
    6734             :   ACCESSORS_CHECKED2(Code, name, type, offset, true, \
    6735             :                      !GetHeap()->InNewSpace(value))
    6736    11269431 : CODE_ACCESSORS(relocation_info, ByteArray, kRelocationInfoOffset)
    6737     6259969 : CODE_ACCESSORS(handler_table, FixedArray, kHandlerTableOffset)
    6738    15181515 : CODE_ACCESSORS(deoptimization_data, FixedArray, kDeoptimizationDataOffset)
    6739    21282057 : CODE_ACCESSORS(source_position_table, Object, kSourcePositionTableOffset)
    6740     7685659 : CODE_ACCESSORS(trap_handler_index, Smi, kTrapHandlerIndex)
    6741    18659115 : CODE_ACCESSORS(raw_type_feedback_info, Object, kTypeFeedbackInfoOffset)
    6742     7987360 : CODE_ACCESSORS(next_code_link, Object, kNextCodeLinkOffset)
    6743             : #undef CODE_ACCESSORS
    6744             : 
    6745             : void Code::WipeOutHeader() {
    6746        1366 :   WRITE_FIELD(this, kRelocationInfoOffset, NULL);
    6747        1366 :   WRITE_FIELD(this, kHandlerTableOffset, NULL);
    6748        1366 :   WRITE_FIELD(this, kDeoptimizationDataOffset, NULL);
    6749        1366 :   WRITE_FIELD(this, kSourcePositionTableOffset, NULL);
    6750             :   // Do not wipe out major/minor keys on a code stub or IC
    6751        2732 :   if (!READ_FIELD(this, kTypeFeedbackInfoOffset)->IsSmi()) {
    6752           0 :     WRITE_FIELD(this, kTypeFeedbackInfoOffset, NULL);
    6753             :   }
    6754        1366 :   WRITE_FIELD(this, kNextCodeLinkOffset, NULL);
    6755        1366 :   WRITE_FIELD(this, kGCMetadataOffset, NULL);
    6756             : }
    6757             : 
    6758             : 
    6759             : Object* Code::type_feedback_info() {
    6760             :   DCHECK(kind() == FUNCTION);
    6761             :   return raw_type_feedback_info();
    6762             : }
    6763             : 
    6764             : 
    6765     1080611 : void Code::set_type_feedback_info(Object* value, WriteBarrierMode mode) {
    6766             :   DCHECK(kind() == FUNCTION);
    6767     1080611 :   set_raw_type_feedback_info(value, mode);
    6768     3241822 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kTypeFeedbackInfoOffset,
    6769             :                             value, mode);
    6770     1080609 : }
    6771             : 
    6772     1959488 : ByteArray* Code::SourcePositionTable() {
    6773             :   Object* maybe_table = source_position_table();
    6774     1959491 :   if (maybe_table->IsByteArray()) return ByteArray::cast(maybe_table);
    6775             :   DCHECK(maybe_table->IsSourcePositionTableWithFrameCache());
    6776             :   return SourcePositionTableWithFrameCache::cast(maybe_table)
    6777       39662 :       ->source_position_table();
    6778             : }
    6779             : 
    6780             : uint32_t Code::stub_key() {
    6781             :   DCHECK(IsCodeStubOrIC());
    6782             :   Smi* smi_key = Smi::cast(raw_type_feedback_info());
    6783      879221 :   return static_cast<uint32_t>(smi_key->value());
    6784             : }
    6785             : 
    6786             : 
    6787             : void Code::set_stub_key(uint32_t key) {
    6788             :   DCHECK(IsCodeStubOrIC());
    6789      518314 :   set_raw_type_feedback_info(Smi::FromInt(key));
    6790             : }
    6791             : 
    6792             : 
    6793    18820862 : ACCESSORS(Code, gc_metadata, Object, kGCMetadataOffset)
    6794     5111448 : INT_ACCESSORS(Code, ic_age, kICAgeOffset)
    6795             : 
    6796             : 
    6797          14 : byte* Code::instruction_start()  {
    6798          14 :   return FIELD_ADDR(this, kHeaderSize);
    6799             : }
    6800             : 
    6801             : 
    6802             : byte* Code::instruction_end()  {
    6803      894470 :   return instruction_start() + instruction_size();
    6804             : }
    6805             : 
    6806             : int Code::GetUnwindingInfoSizeOffset() const {
    6807             :   DCHECK(has_unwinding_info());
    6808          31 :   return RoundUp(kHeaderSize + instruction_size(), kInt64Size);
    6809             : }
    6810             : 
    6811             : int Code::unwinding_info_size() const {
    6812             :   DCHECK(has_unwinding_info());
    6813             :   return static_cast<int>(
    6814           6 :       READ_UINT64_FIELD(this, GetUnwindingInfoSizeOffset()));
    6815             : }
    6816             : 
    6817             : void Code::set_unwinding_info_size(int value) {
    6818             :   DCHECK(has_unwinding_info());
    6819          25 :   WRITE_UINT64_FIELD(this, GetUnwindingInfoSizeOffset(), value);
    6820             : }
    6821             : 
    6822             : byte* Code::unwinding_info_start() {
    6823             :   DCHECK(has_unwinding_info());
    6824          31 :   return FIELD_ADDR(this, GetUnwindingInfoSizeOffset()) + kInt64Size;
    6825             : }
    6826             : 
    6827             : byte* Code::unwinding_info_end() {
    6828             :   DCHECK(has_unwinding_info());
    6829           6 :   return unwinding_info_start() + unwinding_info_size();
    6830             : }
    6831             : 
    6832   365728465 : int Code::body_size() {
    6833             :   int unpadded_body_size =
    6834             :       has_unwinding_info()
    6835           6 :           ? static_cast<int>(unwinding_info_end() - instruction_start())
    6836   365728471 :           : instruction_size();
    6837   365728465 :   return RoundUp(unpadded_body_size, kObjectAlignment);
    6838             : }
    6839             : 
    6840      848834 : int Code::SizeIncludingMetadata() {
    6841             :   int size = CodeSize();
    6842      848836 :   size += relocation_info()->Size();
    6843      848836 :   size += deoptimization_data()->Size();
    6844      848836 :   size += handler_table()->Size();
    6845      848834 :   if (kind() == FUNCTION) {
    6846     1697673 :     size += SourcePositionTable()->Size();
    6847             :   }
    6848      848837 :   return size;
    6849             : }
    6850             : 
    6851             : ByteArray* Code::unchecked_relocation_info() {
    6852   180420327 :   return reinterpret_cast<ByteArray*>(READ_FIELD(this, kRelocationInfoOffset));
    6853             : }
    6854             : 
    6855             : 
    6856             : byte* Code::relocation_start() {
    6857             :   return unchecked_relocation_info()->GetDataStartAddress();
    6858             : }
    6859             : 
    6860             : 
    6861             : int Code::relocation_size() {
    6862             :   return unchecked_relocation_info()->length();
    6863             : }
    6864             : 
    6865             : 
    6866             : byte* Code::entry() {
    6867             :   return instruction_start();
    6868             : }
    6869             : 
    6870             : 
    6871             : bool Code::contains(byte* inner_pointer) {
    6872     1975316 :   return (address() <= inner_pointer) && (inner_pointer <= address() + Size());
    6873             : }
    6874             : 
    6875             : 
    6876             : int Code::ExecutableSize() {
    6877             :   // Check that the assumptions about the layout of the code object holds.
    6878             :   DCHECK_EQ(static_cast<int>(instruction_start() - address()),
    6879             :             Code::kHeaderSize);
    6880      209623 :   return instruction_size() + Code::kHeaderSize;
    6881             : }
    6882             : 
    6883             : 
    6884   365446999 : int Code::CodeSize() { return SizeFor(body_size()); }
    6885             : 
    6886             : 
    6887   259862490 : ACCESSORS(JSArray, length, Object, kLengthOffset)
    6888             : 
    6889             : 
    6890       16661 : void* JSArrayBuffer::backing_store() const {
    6891    56549154 :   intptr_t ptr = READ_INTPTR_FIELD(this, kBackingStoreOffset);
    6892    56549154 :   return reinterpret_cast<void*>(ptr);
    6893             : }
    6894             : 
    6895             : 
    6896             : void JSArrayBuffer::set_backing_store(void* value, WriteBarrierMode mode) {
    6897      149047 :   intptr_t ptr = reinterpret_cast<intptr_t>(value);
    6898      152315 :   WRITE_INTPTR_FIELD(this, kBackingStoreOffset, ptr);
    6899             : }
    6900             : 
    6901             : 
    6902      742003 : ACCESSORS(JSArrayBuffer, byte_length, Object, kByteLengthOffset)
    6903             : 
    6904             : 
    6905             : void JSArrayBuffer::set_bit_field(uint32_t bits) {
    6906             :   if (kInt32Size != kPointerSize) {
    6907             : #if V8_TARGET_LITTLE_ENDIAN
    6908      183528 :     WRITE_UINT32_FIELD(this, kBitFieldSlot + kInt32Size, 0);
    6909             : #else
    6910             :     WRITE_UINT32_FIELD(this, kBitFieldSlot, 0);
    6911             : #endif
    6912             :   }
    6913      595829 :   WRITE_UINT32_FIELD(this, kBitFieldOffset, bits);
    6914             : }
    6915             : 
    6916             : 
    6917             : uint32_t JSArrayBuffer::bit_field() const {
    6918    97092689 :   return READ_UINT32_FIELD(this, kBitFieldOffset);
    6919             : }
    6920             : 
    6921             : 
    6922         210 : bool JSArrayBuffer::is_external() { return IsExternal::decode(bit_field()); }
    6923             : 
    6924             : 
    6925        3020 : void JSArrayBuffer::set_is_external(bool value) {
    6926             :   DCHECK(!value || !has_guard_region());
    6927             :   set_bit_field(IsExternal::update(bit_field(), value));
    6928        3020 : }
    6929             : 
    6930             : 
    6931             : bool JSArrayBuffer::is_neuterable() {
    6932             :   return IsNeuterable::decode(bit_field());
    6933             : }
    6934             : 
    6935             : 
    6936             : void JSArrayBuffer::set_is_neuterable(bool value) {
    6937             :   set_bit_field(IsNeuterable::update(bit_field(), value));
    6938             : }
    6939             : 
    6940             : 
    6941             : bool JSArrayBuffer::was_neutered() { return WasNeutered::decode(bit_field()); }
    6942             : 
    6943             : 
    6944             : void JSArrayBuffer::set_was_neutered(bool value) {
    6945             :   set_bit_field(WasNeutered::update(bit_field(), value));
    6946             : }
    6947             : 
    6948             : 
    6949    37389600 : bool JSArrayBuffer::is_shared() { return IsShared::decode(bit_field()); }
    6950             : 
    6951             : 
    6952             : void JSArrayBuffer::set_is_shared(bool value) {
    6953             :   set_bit_field(IsShared::update(bit_field(), value));
    6954             : }
    6955             : 
    6956             : bool JSArrayBuffer::has_guard_region() {
    6957             :   return HasGuardRegion::decode(bit_field());
    6958             : }
    6959             : 
    6960             : void JSArrayBuffer::set_has_guard_region(bool value) {
    6961             :   set_bit_field(HasGuardRegion::update(bit_field(), value));
    6962             : }
    6963             : 
    6964    18720017 : Object* JSArrayBufferView::byte_offset() const {
    6965    18735121 :   if (WasNeutered()) return Smi::kZero;
    6966    18734944 :   return Object::cast(READ_FIELD(this, kByteOffsetOffset));
    6967             : }
    6968             : 
    6969             : 
    6970        5943 : void JSArrayBufferView::set_byte_offset(Object* value, WriteBarrierMode mode) {
    6971        5943 :   WRITE_FIELD(this, kByteOffsetOffset, value);
    6972       17829 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kByteOffsetOffset, value, mode);
    6973        5943 : }
    6974             : 
    6975             : 
    6976       16292 : Object* JSArrayBufferView::byte_length() const {
    6977       50021 :   if (WasNeutered()) return Smi::kZero;
    6978       49844 :   return Object::cast(READ_FIELD(this, kByteLengthOffset));
    6979             : }
    6980             : 
    6981             : 
    6982        5943 : void JSArrayBufferView::set_byte_length(Object* value, WriteBarrierMode mode) {
    6983        5943 :   WRITE_FIELD(this, kByteLengthOffset, value);
    6984       17829 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kByteLengthOffset, value, mode);
    6985        5943 : }
    6986             : 
    6987             : 
    6988    78243441 : ACCESSORS(JSArrayBufferView, buffer, Object, kBufferOffset)
    6989             : #ifdef VERIFY_HEAP
    6990             : ACCESSORS(JSArrayBufferView, raw_byte_offset, Object, kByteOffsetOffset)
    6991             : ACCESSORS(JSArrayBufferView, raw_byte_length, Object, kByteLengthOffset)
    6992             : #endif
    6993             : 
    6994             : 
    6995       41689 : bool JSArrayBufferView::WasNeutered() const {
    6996       41689 :   return JSArrayBuffer::cast(buffer())->was_neutered();
    6997             : }
    6998             : 
    6999             : 
    7000    18743642 : Object* JSTypedArray::length() const {
    7001    18743875 :   if (WasNeutered()) return Smi::kZero;
    7002    18743830 :   return Object::cast(READ_FIELD(this, kLengthOffset));
    7003             : }
    7004             : 
    7005             : 
    7006       59720 : uint32_t JSTypedArray::length_value() const {
    7007       59720 :   if (WasNeutered()) return 0;
    7008       59594 :   uint32_t index = 0;
    7009      119188 :   CHECK(Object::cast(READ_FIELD(this, kLengthOffset))->ToArrayLength(&index));
    7010       59594 :   return index;
    7011             : }
    7012             : 
    7013             : 
    7014         372 : void JSTypedArray::set_length(Object* value, WriteBarrierMode mode) {
    7015         372 :   WRITE_FIELD(this, kLengthOffset, value);
    7016        1116 :   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kLengthOffset, value, mode);
    7017         372 : }
    7018             : 
    7019             : // static
    7020       43779 : MaybeHandle<JSTypedArray> JSTypedArray::Validate(Isolate* isolate,
    7021             :                                                  Handle<Object> receiver,
    7022             :                                                  const char* method_name) {
    7023       43779 :   if (V8_UNLIKELY(!receiver->IsJSTypedArray())) {
    7024             :     const MessageTemplate::Template message = MessageTemplate::kNotTypedArray;
    7025        3388 :     THROW_NEW_ERROR(isolate, NewTypeError(message), JSTypedArray);
    7026             :   }
    7027             : 
    7028             :   Handle<JSTypedArray> array = Handle<JSTypedArray>::cast(receiver);
    7029       42085 :   if (V8_UNLIKELY(array->WasNeutered())) {
    7030             :     const MessageTemplate::Template message =
    7031             :         MessageTemplate::kDetachedOperation;
    7032             :     Handle<String> operation =
    7033         756 :         isolate->factory()->NewStringFromAsciiChecked(method_name);
    7034        1512 :     THROW_NEW_ERROR(isolate, NewTypeError(message, operation), JSTypedArray);
    7035             :   }
    7036             : 
    7037             :   // spec describes to return `buffer`, but it may disrupt current
    7038             :   // implementations, and it's much useful to return array for now.
    7039             :   return array;
    7040             : }
    7041             : 
    7042             : #ifdef VERIFY_HEAP
    7043             : ACCESSORS(JSTypedArray, raw_length, Object, kLengthOffset)
    7044             : #endif
    7045             : 
    7046             : ACCESSORS(JSPromiseCapability, promise, Object, kPromiseOffset)
    7047             : ACCESSORS(JSPromiseCapability, resolve, Object, kResolveOffset)
    7048             : ACCESSORS(JSPromiseCapability, reject, Object, kRejectOffset)
    7049             : 
    7050         508 : SMI_ACCESSORS(JSPromise, status, kStatusOffset)
    7051          42 : ACCESSORS(JSPromise, result, Object, kResultOffset)
    7052        5642 : ACCESSORS(JSPromise, deferred_promise, Object, kDeferredPromiseOffset)
    7053             : ACCESSORS(JSPromise, deferred_on_resolve, Object, kDeferredOnResolveOffset)
    7054             : ACCESSORS(JSPromise, deferred_on_reject, Object, kDeferredOnRejectOffset)
    7055             : ACCESSORS(JSPromise, fulfill_reactions, Object, kFulfillReactionsOffset)
    7056        5642 : ACCESSORS(JSPromise, reject_reactions, Object, kRejectReactionsOffset)
    7057       18672 : SMI_ACCESSORS(JSPromise, flags, kFlagsOffset)
    7058       15424 : BOOL_ACCESSORS(JSPromise, flags, has_handler, kHasHandlerBit)
    7059             : BOOL_ACCESSORS(JSPromise, flags, handled_hint, kHandledHintBit)
    7060             : 
    7061    13818381 : ACCESSORS(JSRegExp, data, Object, kDataOffset)
    7062     2149278 : ACCESSORS(JSRegExp, flags, Object, kFlagsOffset)
    7063     2149338 : ACCESSORS(JSRegExp, source, Object, kSourceOffset)
    7064             : 
    7065             : 
    7066     3959556 : JSRegExp::Type JSRegExp::TypeTag() {
    7067             :   Object* data = this->data();
    7068     3959556 :   if (data->IsUndefined(GetIsolate())) return JSRegExp::NOT_COMPILED;
    7069             :   Smi* smi = Smi::cast(FixedArray::cast(data)->get(kTagIndex));
    7070     3959556 :   return static_cast<JSRegExp::Type>(smi->value());
    7071             : }
    7072             : 
    7073             : 
    7074      368276 : int JSRegExp::CaptureCount() {
    7075      368276 :   switch (TypeTag()) {
    7076             :     case ATOM:
    7077             :       return 0;
    7078             :     case IRREGEXP:
    7079       15492 :       return Smi::cast(DataAt(kIrregexpCaptureCountIndex))->value();
    7080             :     default:
    7081           0 :       UNREACHABLE();
    7082             :       return -1;
    7083             :   }
    7084             : }
    7085             : 
    7086             : 
    7087      156112 : JSRegExp::Flags JSRegExp::GetFlags() {
    7088             :   DCHECK(this->data()->IsFixedArray());
    7089             :   Object* data = this->data();
    7090             :   Smi* smi = Smi::cast(FixedArray::cast(data)->get(kFlagsIndex));
    7091      156112 :   return Flags(smi->value());
    7092             : }
    7093             : 
    7094             : 
    7095             : String* JSRegExp::Pattern() {
    7096             :   DCHECK(this->data()->IsFixedArray());
    7097             :   Object* data = this->data();
    7098             :   String* pattern = String::cast(FixedArray::cast(data)->get(kSourceIndex));
    7099             :   return pattern;
    7100             : }
    7101             : 
    7102         173 : Object* JSRegExp::CaptureNameMap() {
    7103             :   DCHECK(this->data()->IsFixedArray());
    7104             :   DCHECK_EQ(TypeTag(), IRREGEXP);
    7105             :   Object* value = DataAt(kIrregexpCaptureNameMapIndex);
    7106             :   DCHECK_NE(value, Smi::FromInt(JSRegExp::kUninitializedValue));
    7107         173 :   return value;
    7108             : }
    7109             : 
    7110             : Object* JSRegExp::DataAt(int index) {
    7111             :   DCHECK(TypeTag() != NOT_COMPILED);
    7112             :   return FixedArray::cast(data())->get(index);
    7113             : }
    7114             : 
    7115             : 
    7116             : void JSRegExp::SetDataAt(int index, Object* value) {
    7117             :   DCHECK(TypeTag() != NOT_COMPILED);
    7118             :   DCHECK(index >= kDataIndex);  // Only implementation data can be set this way.
    7119        3557 :   FixedArray::cast(data())->set(index, value);
    7120             : }
    7121             : 
    7122           0 : void JSRegExp::SetLastIndex(int index) {
    7123             :   static const int offset =
    7124             :       kSize + JSRegExp::kLastIndexFieldIndex * kPointerSize;
    7125             :   Smi* value = Smi::FromInt(index);
    7126        4048 :   WRITE_FIELD(this, offset, value);
    7127           0 : }
    7128             : 
    7129           0 : Object* JSRegExp::LastIndex() {
    7130             :   static const int offset =
    7131             :       kSize + JSRegExp::kLastIndexFieldIndex * kPointerSize;
    7132        8997 :   return READ_FIELD(this, offset);
    7133             : }
    7134             : 
    7135      679480 : ElementsKind JSObject::GetElementsKind() {
    7136             :   ElementsKind kind = map()->elements_kind();
    7137             : #if VERIFY_HEAP && DEBUG
    7138             :   FixedArrayBase* fixed_array =
    7139             :       reinterpret_cast<FixedArrayBase*>(READ_FIELD(this, kElementsOffset));
    7140             : 
    7141             :   // If a GC was caused while constructing this object, the elements
    7142             :   // pointer may point to a one pointer filler map.
    7143             :   if (ElementsAreSafeToExamine()) {
    7144             :     Map* map = fixed_array->map();
    7145             :     if (IsFastSmiOrObjectElementsKind(kind)) {
    7146             :       DCHECK(map == GetHeap()->fixed_array_map() ||
    7147             :              map == GetHeap()->fixed_cow_array_map());
    7148             :     } else if (IsFastDoubleElementsKind(kind)) {
    7149             :       DCHECK(fixed_array->IsFixedDoubleArray() ||
    7150             :              fixed_array == GetHeap()->empty_fixed_array());
    7151             :     } else if (kind == DICTIONARY_ELEMENTS) {
    7152             :       DCHECK(fixed_array->IsFixedArray());
    7153             :       DCHECK(fixed_array->IsDictionary());
    7154             :     } else {
    7155             :       DCHECK(kind > DICTIONARY_ELEMENTS);
    7156             :     }
    7157             :     DCHECK(!IsSloppyArgumentsElementsKind(kind) ||
    7158             :            (elements()->IsFixedArray() && elements()->length() >= 2));
    7159             :   }
    7160             : #endif
    7161      679480 :   return kind;
    7162             : }
    7163             : 
    7164             : 
    7165     3186002 : bool JSObject::HasFastObjectElements() {
    7166     3186002 :   return IsFastObjectElementsKind(GetElementsKind());
    7167             : }
    7168             : 
    7169             : 
    7170     1913597 : bool JSObject::HasFastSmiElements() {
    7171     1913597 :   return IsFastSmiElementsKind(GetElementsKind());
    7172             : }
    7173             : 
    7174             : 
    7175     2254997 : bool JSObject::HasFastSmiOrObjectElements() {
    7176     2254997 :   return IsFastSmiOrObjectElementsKind(GetElementsKind());
    7177             : }
    7178             : 
    7179             : 
    7180     3910721 : bool JSObject::HasFastDoubleElements() {
    7181     3910721 :   return IsFastDoubleElementsKind(GetElementsKind());
    7182             : }
    7183             : 
    7184             : 
    7185     8250813 : bool JSObject::HasFastHoleyElements() {
    7186     8250813 :   return IsFastHoleyElementsKind(GetElementsKind());
    7187             : }
    7188             : 
    7189             : 
    7190     5330974 : bool JSObject::HasFastElements() {
    7191     5330974 :   return IsFastElementsKind(GetElementsKind());
    7192             : }
    7193             : 
    7194             : 
    7195      960100 : bool JSObject::HasDictionaryElements() {
    7196      960100 :   return GetElementsKind() == DICTIONARY_ELEMENTS;
    7197             : }
    7198             : 
    7199             : 
    7200             : bool JSObject::HasFastArgumentsElements() {
    7201             :   return GetElementsKind() == FAST_SLOPPY_ARGUMENTS_ELEMENTS;
    7202             : }
    7203             : 
    7204             : 
    7205      631210 : bool JSObject::HasSlowArgumentsElements() {
    7206      631210 :   return GetElementsKind() == SLOW_SLOPPY_ARGUMENTS_ELEMENTS;
    7207             : }
    7208             : 
    7209             : 
    7210     1228826 : bool JSObject::HasSloppyArgumentsElements() {
    7211     1228826 :   return IsSloppyArgumentsElementsKind(GetElementsKind());
    7212             : }
    7213             : 
    7214      129458 : bool JSObject::HasStringWrapperElements() {
    7215      129458 :   return IsStringWrapperElementsKind(GetElementsKind());
    7216             : }
    7217             : 
    7218     2200931 : bool JSObject::HasFastStringWrapperElements() {
    7219     2200931 :   return GetElementsKind() == FAST_STRING_WRAPPER_ELEMENTS;
    7220             : }
    7221             : 
    7222      211591 : bool JSObject::HasSlowStringWrapperElements() {
    7223      211591 :   return GetElementsKind() == SLOW_STRING_WRAPPER_ELEMENTS;
    7224             : }
    7225             : 
    7226     1970254 : bool JSObject::HasFixedTypedArrayElements() {
    7227             :   DCHECK_NOT_NULL(elements());
    7228     1970254 :   return map()->has_fixed_typed_array_elements();
    7229             : }
    7230             : 
    7231             : #define FIXED_TYPED_ELEMENTS_CHECK(Type, type, TYPE, ctype, size)      \
    7232             :   bool JSObject::HasFixed##Type##Elements() {                          \
    7233             :     HeapObject* array = elements();                                    \
    7234             :     DCHECK(array != NULL);                                             \
    7235             :     if (!array->IsHeapObject()) return false;                          \
    7236             :     return array->map()->instance_type() == FIXED_##TYPE##_ARRAY_TYPE; \
    7237             :   }
    7238             : 
    7239        1890 : TYPED_ARRAYS(FIXED_TYPED_ELEMENTS_CHECK)
    7240             : 
    7241             : #undef FIXED_TYPED_ELEMENTS_CHECK
    7242             : 
    7243             : 
    7244           0 : bool JSObject::HasNamedInterceptor() {
    7245           0 :   return map()->has_named_interceptor();
    7246             : }
    7247             : 
    7248             : 
    7249       24606 : bool JSObject::HasIndexedInterceptor() {
    7250       24606 :   return map()->has_indexed_interceptor();
    7251             : }
    7252             : 
    7253             : 
    7254             : GlobalDictionary* JSObject::global_dictionary() {
    7255             :   DCHECK(!HasFastProperties());
    7256             :   DCHECK(IsJSGlobalObject());
    7257             :   return GlobalDictionary::cast(properties());
    7258             : }
    7259             : 
    7260             : 
    7261        4562 : SeededNumberDictionary* JSObject::element_dictionary() {
    7262             :   DCHECK(HasDictionaryElements() || HasSlowStringWrapperElements());
    7263        4562 :   return SeededNumberDictionary::cast(elements());
    7264             : }
    7265             : 
    7266             : 
    7267             : bool Name::IsHashFieldComputed(uint32_t field) {
    7268   838348481 :   return (field & kHashNotComputedMask) == 0;
    7269             : }
    7270             : 
    7271             : 
    7272             : bool Name::HasHashCode() {
    7273             :   return IsHashFieldComputed(hash_field());
    7274             : }
    7275             : 
    7276             : 
    7277    19589942 : uint32_t Name::Hash() {
    7278             :   // Fast case: has hash code already been computed?
    7279             :   uint32_t field = hash_field();
    7280   620958112 :   if (IsHashFieldComputed(field)) return field >> kHashShift;
    7281             :   // Slow case: compute hash code and set it. Has to be a string.
    7282    29114635 :   return String::cast(this)->ComputeAndSetHash();
    7283             : }
    7284             : 
    7285             : 
    7286   357132199 : bool Name::IsPrivate() {
    7287   398664763 :   return this->IsSymbol() && Symbol::cast(this)->is_private();
    7288             : }
    7289             : 
    7290             : 
    7291             : StringHasher::StringHasher(int length, uint32_t seed)
    7292             :   : length_(length),
    7293             :     raw_running_hash_(seed),
    7294             :     array_index_(0),
    7295   188524907 :     is_array_index_(0 < length_ && length_ <= String::kMaxArrayIndexSize),
    7296   401530187 :     is_first_char_(true) {
    7297             :   DCHECK(FLAG_randomize_hashes || raw_running_hash_ == 0);
    7298             : }
    7299             : 
    7300             : 
    7301             : bool StringHasher::has_trivial_hash() {
    7302             :   return length_ > String::kMaxHashCalcLength;
    7303             : }
    7304             : 
    7305             : 
    7306             : uint32_t StringHasher::AddCharacterCore(uint32_t running_hash, uint16_t c) {
    7307  2646596745 :   running_hash += c;
    7308  2646596745 :   running_hash += (running_hash << 10);
    7309  2646596745 :   running_hash ^= (running_hash >> 6);
    7310             :   return running_hash;
    7311             : }
    7312             : 
    7313             : 
    7314             : uint32_t StringHasher::GetHashCore(uint32_t running_hash) {
    7315   217421890 :   running_hash += (running_hash << 3);
    7316   217421890 :   running_hash ^= (running_hash >> 11);
    7317   217421890 :   running_hash += (running_hash << 15);
    7318   217421890 :   if ((running_hash & String::kHashBitMask) == 0) {
    7319             :     return kZeroHash;
    7320             :   }
    7321             :   return running_hash;
    7322             : }
    7323             : 
    7324             : 
    7325             : uint32_t StringHasher::ComputeRunningHash(uint32_t running_hash,
    7326             :                                           const uc16* chars, int length) {
    7327             :   DCHECK_NOT_NULL(chars);
    7328             :   DCHECK(length >= 0);
    7329         175 :   for (int i = 0; i < length; ++i) {
    7330         175 :     running_hash = AddCharacterCore(running_hash, *chars++);
    7331             :   }
    7332             :   return running_hash;
    7333             : }
    7334             : 
    7335             : 
    7336             : uint32_t StringHasher::ComputeRunningHashOneByte(uint32_t running_hash,
    7337             :                                                  const char* chars,
    7338             :                                                  int length) {
    7339             :   DCHECK_NOT_NULL(chars);
    7340             :   DCHECK(length >= 0);
    7341       85696 :   for (int i = 0; i < length; ++i) {
    7342       85696 :     uint16_t c = static_cast<uint16_t>(*chars++);
    7343             :     running_hash = AddCharacterCore(running_hash, c);
    7344             :   }
    7345             :   return running_hash;
    7346             : }
    7347             : 
    7348             : 
    7349             : void StringHasher::AddCharacter(uint16_t c) {
    7350             :   // Use the Jenkins one-at-a-time hash function to update the hash
    7351             :   // for the given character.
    7352  5113013644 :   raw_running_hash_ = AddCharacterCore(raw_running_hash_, c);
    7353             : }
    7354             : 
    7355             : 
    7356   182392333 : bool StringHasher::UpdateIndex(uint16_t c) {
    7357             :   DCHECK(is_array_index_);
    7358   182392333 :   if (c < '0' || c > '9') {
    7359   145564525 :     is_array_index_ = false;
    7360   145564525 :     return false;
    7361             :   }
    7362    36827808 :   int d = c - '0';
    7363    36827808 :   if (is_first_char_) {
    7364    10680698 :     is_first_char_ = false;
    7365    10680698 :     if (c == '0' && length_ > 1) {
    7366       18092 :       is_array_index_ = false;
    7367       18092 :       return false;
    7368             :     }
    7369             :   }
    7370    36809716 :   if (array_index_ > 429496729U - ((d + 3) >> 3)) {
    7371        4579 :     is_array_index_ = false;
    7372        4579 :     return false;
    7373             :   }
    7374    36805137 :   array_index_ = array_index_ * 10 + d;
    7375    36805137 :   return true;
    7376             : }
    7377             : 
    7378             : 
    7379             : template<typename Char>
    7380   199102097 : inline void StringHasher::AddCharacters(const Char* chars, int length) {
    7381             :   DCHECK(sizeof(Char) == 1 || sizeof(Char) == 2);
    7382             :   int i = 0;
    7383   199102097 :   if (is_array_index_) {
    7384    36798899 :     for (; i < length; i++) {
    7385   157908044 :       AddCharacter(chars[i]);
    7386   157908044 :       if (!UpdateIndex(chars[i])) {
    7387   121109137 :         i++;
    7388   121109137 :         break;
    7389             :       }
    7390             :     }
    7391             :   }
    7392  1871002795 :   for (; i < length; i++) {
    7393             :     DCHECK(!is_array_index_);
    7394  1871002795 :     AddCharacter(chars[i]);
    7395             :   }
    7396   199102089 : }
    7397             : 
    7398             : 
    7399             : template <typename schar>
    7400   159409091 : uint32_t StringHasher::HashSequentialString(const schar* chars,
    7401             :                                             int length,
    7402             :                                             uint32_t seed) {
    7403             :   StringHasher hasher(length, seed);
    7404   159409091 :   if (!hasher.has_trivial_hash()) hasher.AddCharacters(chars, length);
    7405   159409203 :   return hasher.GetHashField();
    7406             : }
    7407             : 
    7408             : 
    7409             : IteratingStringHasher::IteratingStringHasher(int len, uint32_t seed)
    7410             :     : StringHasher(len, seed) {}
    7411             : 
    7412             : 
    7413    29115816 : uint32_t IteratingStringHasher::Hash(String* string, uint32_t seed) {
    7414             :   IteratingStringHasher hasher(string->length(), seed);
    7415             :   // Nothing to do.
    7416    29115816 :   if (hasher.has_trivial_hash()) return hasher.GetHashField();
    7417    29054970 :   ConsString* cons_string = String::VisitFlat(&hasher, string);
    7418    29054975 :   if (cons_string == nullptr) return hasher.GetHashField();
    7419     2502618 :   hasher.VisitConsString(cons_string);
    7420     2502618 :   return hasher.GetHashField();
    7421             : }
    7422             : 
    7423             : 
    7424             : void IteratingStringHasher::VisitOneByteString(const uint8_t* chars,
    7425             :                                                int length) {
    7426    35073669 :   AddCharacters(chars, length);
    7427             : }
    7428             : 
    7429             : 
    7430             : void IteratingStringHasher::VisitTwoByteString(const uint16_t* chars,
    7431             :                                                int length) {
    7432     4304452 :   AddCharacters(chars, length);
    7433             : }
    7434             : 
    7435             : 
    7436   175732130 : bool Name::AsArrayIndex(uint32_t* index) {
    7437   175732131 :   return IsString() && String::cast(this)->AsArrayIndex(index);
    7438             : }
    7439             : 
    7440             : 
    7441   184860899 : bool String::AsArrayIndex(uint32_t* index) {
    7442             :   uint32_t field = hash_field();
    7443   184860899 :   if (IsHashFieldComputed(field) && (field & kIsNotArrayIndexMask)) {
    7444             :     return false;
    7445             :   }
    7446    23899336 :   return SlowAsArrayIndex(index);
    7447             : }
    7448             : 
    7449             : 
    7450             : void String::SetForwardedInternalizedString(String* canonical) {
    7451             :   DCHECK(IsInternalizedString());
    7452             :   DCHECK(HasHashCode());
    7453        2756 :   if (canonical == this) return;  // No need to forward.
    7454             :   DCHECK(SlowEquals(canonical));
    7455             :   DCHECK(canonical->IsInternalizedString());
    7456             :   DCHECK(canonical->HasHashCode());
    7457        2756 :   WRITE_FIELD(this, kHashFieldSlot, canonical);
    7458             :   // Setting the hash field to a tagged value sets the LSB, causing the hash
    7459             :   // code to be interpreted as uninitialized.  We use this fact to recognize
    7460             :   // that we have a forwarded string.
    7461             :   DCHECK(!HasHashCode());
    7462             : }
    7463             : 
    7464             : 
    7465             : String* String::GetForwardedInternalizedString() {
    7466             :   DCHECK(IsInternalizedString());
    7467        8177 :   if (HasHashCode()) return this;
    7468        2426 :   String* canonical = String::cast(READ_FIELD(this, kHashFieldSlot));
    7469             :   DCHECK(canonical->IsInternalizedString());
    7470             :   DCHECK(SlowEquals(canonical));
    7471             :   DCHECK(canonical->HasHashCode());
    7472             :   return canonical;
    7473             : }
    7474             : 
    7475             : 
    7476             : // static
    7477           0 : Maybe<bool> Object::GreaterThan(Handle<Object> x, Handle<Object> y) {
    7478           0 :   Maybe<ComparisonResult> result = Compare(x, y);
    7479           0 :   if (result.IsJust()) {
    7480           0 :     switch (result.FromJust()) {
    7481             :       case ComparisonResult::kGreaterThan:
    7482             :         return Just(true);
    7483             :       case ComparisonResult::kLessThan:
    7484             :       case ComparisonResult::kEqual:
    7485             :       case ComparisonResult::kUndefined:
    7486             :         return Just(false);
    7487             :     }
    7488             :   }
    7489             :   return Nothing<bool>();
    7490             : }
    7491             : 
    7492             : 
    7493             : // static
    7494           0 : Maybe<bool> Object::GreaterThanOrEqual(Handle<Object> x, Handle<Object> y) {
    7495           0 :   Maybe<ComparisonResult> result = Compare(x, y);
    7496           0 :   if (result.IsJust()) {
    7497           0 :     switch (result.FromJust()) {
    7498             :       case ComparisonResult::kEqual:
    7499             :       case ComparisonResult::kGreaterThan:
    7500             :         return Just(true);
    7501             :       case ComparisonResult::kLessThan:
    7502             :       case ComparisonResult::kUndefined:
    7503             :         return Just(false);
    7504             :     }
    7505             :   }
    7506             :   return Nothing<bool>();
    7507             : }
    7508             : 
    7509             : 
    7510             : // static
    7511           0 : Maybe<bool> Object::LessThan(Handle<Object> x, Handle<Object> y) {
    7512           0 :   Maybe<ComparisonResult> result = Compare(x, y);
    7513           0 :   if (result.IsJust()) {
    7514           0 :     switch (result.FromJust()) {
    7515             :       case ComparisonResult::kLessThan:
    7516             :         return Just(true);
    7517             :       case ComparisonResult::kEqual:
    7518             :       case ComparisonResult::kGreaterThan:
    7519             :       case ComparisonResult::kUndefined:
    7520             :         return Just(false);
    7521             :     }
    7522             :   }
    7523             :   return Nothing<bool>();
    7524             : }
    7525             : 
    7526             : 
    7527             : // static
    7528           0 : Maybe<bool> Object::LessThanOrEqual(Handle<Object> x, Handle<Object> y) {
    7529           0 :   Maybe<ComparisonResult> result = Compare(x, y);
    7530           0 :   if (result.IsJust()) {
    7531           0 :     switch (result.FromJust()) {
    7532             :       case ComparisonResult::kEqual:
    7533             :       case ComparisonResult::kLessThan:
    7534             :         return Just(true);
    7535             :       case ComparisonResult::kGreaterThan:
    7536             :       case ComparisonResult::kUndefined:
    7537             :         return Just(false);
    7538             :     }
    7539             :   }
    7540             :   return Nothing<bool>();
    7541             : }
    7542             : 
    7543      206902 : MaybeHandle<Object> Object::GetPropertyOrElement(Handle<Object> object,
    7544             :                                                  Handle<Name> name) {
    7545             :   LookupIterator it =
    7546      206902 :       LookupIterator::PropertyOrElement(name->GetIsolate(), object, name);
    7547      206902 :   return GetProperty(&it);
    7548             : }
    7549             : 
    7550             : MaybeHandle<Object> Object::SetPropertyOrElement(Handle<Object> object,
    7551             :                                                  Handle<Name> name,
    7552             :                                                  Handle<Object> value,
    7553             :                                                  LanguageMode language_mode,
    7554             :                                                  StoreFromKeyed store_mode) {
    7555             :   LookupIterator it =
    7556             :       LookupIterator::PropertyOrElement(name->GetIsolate(), object, name);
    7557             :   MAYBE_RETURN_NULL(SetProperty(&it, value, language_mode, store_mode));
    7558             :   return value;
    7559             : }
    7560             : 
    7561       15375 : MaybeHandle<Object> Object::GetPropertyOrElement(Handle<Object> receiver,
    7562             :                                                  Handle<Name> name,
    7563             :                                                  Handle<JSReceiver> holder) {
    7564             :   LookupIterator it = LookupIterator::PropertyOrElement(
    7565       15375 :       name->GetIsolate(), receiver, name, holder);
    7566       15375 :   return GetProperty(&it);
    7567             : }
    7568             : 
    7569             : 
    7570    26564419 : void JSReceiver::initialize_properties() {
    7571             :   DCHECK(!GetHeap()->InNewSpace(GetHeap()->empty_fixed_array()));
    7572             :   DCHECK(!GetHeap()->InNewSpace(GetHeap()->empty_properties_dictionary()));
    7573    26564419 :   if (map()->is_dictionary_map()) {
    7574       45340 :     WRITE_FIELD(this, kPropertiesOffset,
    7575       45340 :                 GetHeap()->empty_properties_dictionary());
    7576             :   } else {
    7577    26519079 :     WRITE_FIELD(this, kPropertiesOffset, GetHeap()->empty_fixed_array());
    7578             :   }
    7579    26564419 : }
    7580             : 
    7581             : 
    7582   296297702 : bool JSReceiver::HasFastProperties() {
    7583             :   DCHECK_EQ(properties()->IsDictionary(), map()->is_dictionary_map());
    7584   296297702 :   return !properties()->IsDictionary();
    7585             : }
    7586             : 
    7587             : 
    7588     2880880 : NameDictionary* JSReceiver::property_dictionary() {
    7589             :   DCHECK(!HasFastProperties());
    7590             :   DCHECK(!IsJSGlobalObject());
    7591     2880880 :   return NameDictionary::cast(properties());
    7592             : }
    7593             : 
    7594      452408 : Maybe<bool> JSReceiver::HasProperty(Handle<JSReceiver> object,
    7595             :                                     Handle<Name> name) {
    7596             :   LookupIterator it = LookupIterator::PropertyOrElement(object->GetIsolate(),
    7597      452408 :                                                         object, name, object);
    7598      452408 :   return HasProperty(&it);
    7599             : }
    7600             : 
    7601             : 
    7602    10390548 : Maybe<bool> JSReceiver::HasOwnProperty(Handle<JSReceiver> object,
    7603             :                                        Handle<Name> name) {
    7604    10390548 :   if (object->IsJSObject()) {  // Shortcut
    7605             :     LookupIterator it = LookupIterator::PropertyOrElement(
    7606    10388657 :         object->GetIsolate(), object, name, object, LookupIterator::OWN);
    7607    10388657 :     return HasProperty(&it);
    7608             :   }
    7609             : 
    7610             :   Maybe<PropertyAttributes> attributes =
    7611        1891 :       JSReceiver::GetOwnPropertyAttributes(object, name);
    7612        1891 :   MAYBE_RETURN(attributes, Nothing<bool>());
    7613        1751 :   return Just(attributes.FromJust() != ABSENT);
    7614             : }
    7615             : 
    7616          30 : Maybe<bool> JSReceiver::HasOwnProperty(Handle<JSReceiver> object,
    7617             :                                        uint32_t index) {
    7618          30 :   if (object->IsJSObject()) {  // Shortcut
    7619             :     LookupIterator it(object->GetIsolate(), object, index, object,
    7620             :                       LookupIterator::OWN);
    7621          30 :     return HasProperty(&it);
    7622             :   }
    7623             : 
    7624             :   Maybe<PropertyAttributes> attributes =
    7625           0 :       JSReceiver::GetOwnPropertyAttributes(object, index);
    7626           0 :   MAYBE_RETURN(attributes, Nothing<bool>());
    7627           0 :   return Just(attributes.FromJust() != ABSENT);
    7628             : }
    7629             : 
    7630     1839368 : Maybe<PropertyAttributes> JSReceiver::GetPropertyAttributes(
    7631             :     Handle<JSReceiver> object, Handle<Name> name) {
    7632             :   LookupIterator it = LookupIterator::PropertyOrElement(name->GetIsolate(),
    7633     1839368 :                                                         object, name, object);
    7634     1839368 :   return GetPropertyAttributes(&it);
    7635             : }
    7636             : 
    7637             : 
    7638     1228577 : Maybe<PropertyAttributes> JSReceiver::GetOwnPropertyAttributes(
    7639             :     Handle<JSReceiver> object, Handle<Name> name) {
    7640             :   LookupIterator it = LookupIterator::PropertyOrElement(
    7641     1228577 :       name->GetIsolate(), object, name, object, LookupIterator::OWN);
    7642     1228577 :   return GetPropertyAttributes(&it);
    7643             : }
    7644             : 
    7645           0 : Maybe<PropertyAttributes> JSReceiver::GetOwnPropertyAttributes(
    7646             :     Handle<JSReceiver> object, uint32_t index) {
    7647             :   LookupIterator it(object->GetIsolate(), object, index, object,
    7648             :                     LookupIterator::OWN);
    7649           0 :   return GetPropertyAttributes(&it);
    7650             : }
    7651             : 
    7652     1812033 : Maybe<bool> JSReceiver::HasElement(Handle<JSReceiver> object, uint32_t index) {
    7653             :   LookupIterator it(object->GetIsolate(), object, index, object);
    7654     1812033 :   return HasProperty(&it);
    7655             : }
    7656             : 
    7657             : 
    7658             : Maybe<PropertyAttributes> JSReceiver::GetElementAttributes(
    7659             :     Handle<JSReceiver> object, uint32_t index) {
    7660             :   Isolate* isolate = object->GetIsolate();
    7661             :   LookupIterator it(isolate, object, index, object);
    7662             :   return GetPropertyAttributes(&it);
    7663             : }
    7664             : 
    7665             : 
    7666             : Maybe<PropertyAttributes> JSReceiver::GetOwnElementAttributes(
    7667             :     Handle<JSReceiver> object, uint32_t index) {
    7668             :   Isolate* isolate = object->GetIsolate();
    7669             :   LookupIterator it(isolate, object, index, object, LookupIterator::OWN);
    7670             :   return GetPropertyAttributes(&it);
    7671             : }
    7672             : 
    7673             : 
    7674             : bool JSGlobalObject::IsDetached() {
    7675             :   return JSGlobalProxy::cast(global_proxy())->IsDetachedFrom(this);
    7676             : }
    7677             : 
    7678             : 
    7679      980097 : bool JSGlobalProxy::IsDetachedFrom(JSGlobalObject* global) const {
    7680             :   const PrototypeIterator iter(this->GetIsolate(),
    7681             :                                const_cast<JSGlobalProxy*>(this));
    7682      980097 :   return iter.GetCurrent() != global;
    7683             : }
    7684             : 
    7685             : inline int JSGlobalProxy::SizeWithEmbedderFields(int embedder_field_count) {
    7686             :   DCHECK_GE(embedder_field_count, 0);
    7687      106839 :   return kSize + embedder_field_count * kPointerSize;
    7688             : }
    7689             : 
    7690        5646 : Smi* JSReceiver::GetOrCreateIdentityHash(Isolate* isolate,
    7691             :                                          Handle<JSReceiver> object) {
    7692             :   return object->IsJSProxy() ? JSProxy::GetOrCreateIdentityHash(
    7693             :                                    isolate, Handle<JSProxy>::cast(object))
    7694             :                              : JSObject::GetOrCreateIdentityHash(
    7695        8074 :                                    isolate, Handle<JSObject>::cast(object));
    7696             : }
    7697             : 
    7698       16991 : Object* JSReceiver::GetIdentityHash(Isolate* isolate,
    7699             :                                     Handle<JSReceiver> receiver) {
    7700             :   return receiver->IsJSProxy()
    7701             :              ? JSProxy::GetIdentityHash(Handle<JSProxy>::cast(receiver))
    7702             :              : JSObject::GetIdentityHash(isolate,
    7703       33716 :                                          Handle<JSObject>::cast(receiver));
    7704             : }
    7705             : 
    7706             : 
    7707             : bool AccessorInfo::all_can_read() {
    7708             :   return BooleanBit::get(flag(), kAllCanReadBit);
    7709             : }
    7710             : 
    7711             : 
    7712             : void AccessorInfo::set_all_can_read(bool value) {
    7713             :   set_flag(BooleanBit::set(flag(), kAllCanReadBit, value));
    7714             : }
    7715             : 
    7716             : 
    7717             : bool AccessorInfo::all_can_write() {
    7718             :   return BooleanBit::get(flag(), kAllCanWriteBit);
    7719             : }
    7720             : 
    7721             : 
    7722             : void AccessorInfo::set_all_can_write(bool value) {
    7723             :   set_flag(BooleanBit::set(flag(), kAllCanWriteBit, value));
    7724             : }
    7725             : 
    7726             : 
    7727             : bool AccessorInfo::is_special_data_property() {
    7728             :   return BooleanBit::get(flag(), kSpecialDataProperty);
    7729             : }
    7730             : 
    7731             : 
    7732             : void AccessorInfo::set_is_special_data_property(bool value) {
    7733             :   set_flag(BooleanBit::set(flag(), kSpecialDataProperty, value));
    7734             : }
    7735             : 
    7736             : bool AccessorInfo::replace_on_access() {
    7737             :   return BooleanBit::get(flag(), kReplaceOnAccess);
    7738             : }
    7739             : 
    7740             : void AccessorInfo::set_replace_on_access(bool value) {
    7741             :   set_flag(BooleanBit::set(flag(), kReplaceOnAccess, value));
    7742             : }
    7743             : 
    7744             : bool AccessorInfo::is_sloppy() { return BooleanBit::get(flag(), kIsSloppy); }
    7745             : 
    7746             : void AccessorInfo::set_is_sloppy(bool value) {
    7747             :   set_flag(BooleanBit::set(flag(), kIsSloppy, value));
    7748             : }
    7749             : 
    7750             : PropertyAttributes AccessorInfo::property_attributes() {
    7751      118411 :   return AttributesField::decode(static_cast<uint32_t>(flag()));
    7752             : }
    7753             : 
    7754             : 
    7755             : void AccessorInfo::set_property_attributes(PropertyAttributes attributes) {
    7756      248810 :   set_flag(AttributesField::update(flag(), attributes));
    7757             : }
    7758             : 
    7759       17500 : bool FunctionTemplateInfo::IsTemplateFor(JSObject* object) {
    7760       17500 :   return IsTemplateFor(object->map());
    7761             : }
    7762             : 
    7763     2670258 : bool AccessorInfo::IsCompatibleReceiver(Object* receiver) {
    7764     2670258 :   if (!HasExpectedReceiverType()) return true;
    7765         406 :   if (!receiver->IsJSObject()) return false;
    7766             :   return FunctionTemplateInfo::cast(expected_receiver_type())
    7767         406 :       ->IsTemplateFor(JSObject::cast(receiver)->map());
    7768             : }
    7769             : 
    7770             : 
    7771     2710068 : bool AccessorInfo::HasExpectedReceiverType() {
    7772     2710067 :   return expected_receiver_type()->IsFunctionTemplateInfo();
    7773             : }
    7774             : 
    7775             : 
    7776             : Object* AccessorPair::get(AccessorComponent component) {
    7777       71561 :   return component == ACCESSOR_GETTER ? getter() : setter();
    7778             : }
    7779             : 
    7780             : 
    7781             : void AccessorPair::set(AccessorComponent component, Object* value) {
    7782             :   if (component == ACCESSOR_GETTER) {
    7783             :     set_getter(value);
    7784             :   } else {
    7785             :     set_setter(value);
    7786             :   }
    7787             : }
    7788             : 
    7789             : 
    7790      507260 : void AccessorPair::SetComponents(Object* getter, Object* setter) {
    7791             :   Isolate* isolate = GetIsolate();
    7792      507261 :   if (!getter->IsNull(isolate)) set_getter(getter);
    7793      507260 :   if (!setter->IsNull(isolate)) set_setter(setter);
    7794      507260 : }
    7795             : 
    7796             : 
    7797             : bool AccessorPair::Equals(AccessorPair* pair) {
    7798             :   return (this == pair) || pair->Equals(getter(), setter());
    7799             : }
    7800             : 
    7801             : 
    7802             : bool AccessorPair::Equals(Object* getter_value, Object* setter_value) {
    7803       51468 :   return (getter() == getter_value) && (setter() == setter_value);
    7804             : }
    7805             : 
    7806             : 
    7807             : bool AccessorPair::ContainsAccessor() {
    7808             :   return IsJSAccessor(getter()) || IsJSAccessor(setter());
    7809             : }
    7810             : 
    7811             : 
    7812             : bool AccessorPair::IsJSAccessor(Object* obj) {
    7813             :   return obj->IsCallable() || obj->IsUndefined(GetIsolate());
    7814             : }
    7815             : 
    7816             : 
    7817             : template<typename Derived, typename Shape, typename Key>
    7818     6169770 : void Dictionary<Derived, Shape, Key>::SetEntry(int entry,
    7819             :                                                Handle<Object> key,
    7820             :                                                Handle<Object> value) {
    7821             :   this->SetEntry(entry, key, value, PropertyDetails(Smi::kZero));
    7822     6169770 : }
    7823             : 
    7824             : 
    7825             : template<typename Derived, typename Shape, typename Key>
    7826           0 : void Dictionary<Derived, Shape, Key>::SetEntry(int entry,
    7827             :                                                Handle<Object> key,
    7828             :                                                Handle<Object> value,
    7829             :                                                PropertyDetails details) {
    7830    45016951 :   Shape::SetEntry(static_cast<Derived*>(this), entry, key, value, details);
    7831           0 : }
    7832             : 
    7833             : 
    7834             : template <typename Key>
    7835             : template <typename Dictionary>
    7836    36185291 : void BaseDictionaryShape<Key>::SetEntry(Dictionary* dict, int entry,
    7837             :                                         Handle<Object> key,
    7838             :                                         Handle<Object> value,
    7839             :                                         PropertyDetails details) {
    7840             :   STATIC_ASSERT(Dictionary::kEntrySize == 2 || Dictionary::kEntrySize == 3);
    7841             :   DCHECK(!key->IsName() || details.dictionary_index() > 0);
    7842             :   int index = dict->EntryToIndex(entry);
    7843             :   DisallowHeapAllocation no_gc;
    7844    36185291 :   WriteBarrierMode mode = dict->GetWriteBarrierMode(no_gc);
    7845    36185291 :   dict->set(index + Dictionary::kEntryKeyIndex, *key, mode);
    7846    36185291 :   dict->set(index + Dictionary::kEntryValueIndex, *value, mode);
    7847             :   if (Dictionary::kEntrySize == 3) {
    7848             :     dict->set(index + Dictionary::kEntryDetailsIndex, details.AsSmi());
    7849             :   }
    7850    36185291 : }
    7851             : 
    7852             : 
    7853             : template <typename Dictionary>
    7854     8831660 : void GlobalDictionaryShape::SetEntry(Dictionary* dict, int entry,
    7855             :                                      Handle<Object> key, Handle<Object> value,
    7856             :                                      PropertyDetails details) {
    7857             :   STATIC_ASSERT(Dictionary::kEntrySize == 2);
    7858             :   DCHECK(!key->IsName() || details.dictionary_index() > 0);
    7859             :   DCHECK(value->IsPropertyCell());
    7860             :   int index = dict->EntryToIndex(entry);
    7861             :   DisallowHeapAllocation no_gc;
    7862     8831660 :   WriteBarrierMode mode = dict->GetWriteBarrierMode(no_gc);
    7863     8831661 :   dict->set(index + Dictionary::kEntryKeyIndex, *key, mode);
    7864     8831661 :   dict->set(index + Dictionary::kEntryValueIndex, *value, mode);
    7865             :   PropertyCell::cast(*value)->set_property_details(details);
    7866     8831663 : }
    7867             : 
    7868             : 
    7869             : bool NumberDictionaryShape::IsMatch(uint32_t key, Object* other) {
    7870             :   DCHECK(other->IsNumber());
    7871   107706833 :   return key == static_cast<uint32_t>(other->Number());
    7872             : }
    7873             : 
    7874             : 
    7875             : uint32_t UnseededNumberDictionaryShape::Hash(uint32_t key) {
    7876             :   return ComputeIntegerHash(key, 0);
    7877             : }
    7878             : 
    7879             : 
    7880      181703 : uint32_t UnseededNumberDictionaryShape::HashForObject(uint32_t key,
    7881             :                                                       Object* other) {
    7882             :   DCHECK(other->IsNumber());
    7883      363406 :   return ComputeIntegerHash(static_cast<uint32_t>(other->Number()), 0);
    7884             : }
    7885             : 
    7886             : Map* UnseededNumberDictionaryShape::GetMap(Isolate* isolate) {
    7887      381990 :   return isolate->heap()->unseeded_number_dictionary_map();
    7888             : }
    7889             : 
    7890             : uint32_t SeededNumberDictionaryShape::SeededHash(uint32_t key, uint32_t seed) {
    7891             :   return ComputeIntegerHash(key, seed);
    7892             : }
    7893             : 
    7894             : 
    7895     3607223 : uint32_t SeededNumberDictionaryShape::SeededHashForObject(uint32_t key,
    7896             :                                                           uint32_t seed,
    7897             :                                                           Object* other) {
    7898             :   DCHECK(other->IsNumber());
    7899     7214446 :   return ComputeIntegerHash(static_cast<uint32_t>(other->Number()), seed);
    7900             : }
    7901             : 
    7902             : 
    7903             : Handle<Object> NumberDictionaryShape::AsHandle(Isolate* isolate, uint32_t key) {
    7904     7691383 :   return isolate->factory()->NewNumberFromUint(key);
    7905             : }
    7906             : 
    7907             : 
    7908             : bool NameDictionaryShape::IsMatch(Handle<Name> key, Object* other) {
    7909             :   DCHECK(Name::cast(other)->IsUniqueName());
    7910             :   DCHECK(key->IsUniqueName());
    7911             :   return *key == other;
    7912             : }
    7913             : 
    7914             : 
    7915    30903220 : uint32_t NameDictionaryShape::Hash(Handle<Name> key) {
    7916    30903220 :   return key->Hash();
    7917             : }
    7918             : 
    7919             : 
    7920             : uint32_t NameDictionaryShape::HashForObject(Handle<Name> key, Object* other) {
    7921             :   return Name::cast(other)->Hash();
    7922             : }
    7923             : 
    7924             : 
    7925             : Handle<Object> NameDictionaryShape::AsHandle(Isolate* isolate,
    7926             :                                              Handle<Name> key) {
    7927             :   DCHECK(key->IsUniqueName());
    7928             :   return key;
    7929             : }
    7930             : 
    7931             : 
    7932             : template <typename Dictionary>
    7933             : PropertyDetails GlobalDictionaryShape::DetailsAt(Dictionary* dict, int entry) {
    7934             :   DCHECK(entry >= 0);  // Not found is -1, which is not caught by get().
    7935   167670363 :   Object* raw_value = dict->ValueAt(entry);
    7936             :   DCHECK(raw_value->IsPropertyCell());
    7937             :   PropertyCell* cell = PropertyCell::cast(raw_value);
    7938             :   return cell->property_details();
    7939             : }
    7940             : 
    7941             : 
    7942             : template <typename Dictionary>
    7943           0 : void GlobalDictionaryShape::DetailsAtPut(Dictionary* dict, int entry,
    7944             :                                          PropertyDetails value) {
    7945             :   DCHECK(entry >= 0);  // Not found is -1, which is not caught by get().
    7946           0 :   Object* raw_value = dict->ValueAt(entry);
    7947             :   DCHECK(raw_value->IsPropertyCell());
    7948             :   PropertyCell* cell = PropertyCell::cast(raw_value);
    7949             :   cell->set_property_details(value);
    7950           0 : }
    7951             : 
    7952             : 
    7953             : template <typename Dictionary>
    7954    13622742 : bool GlobalDictionaryShape::IsDeleted(Dictionary* dict, int entry) {
    7955             :   DCHECK(dict->ValueAt(entry)->IsPropertyCell());
    7956             :   Isolate* isolate = dict->GetIsolate();
    7957    27245484 :   return PropertyCell::cast(dict->ValueAt(entry))->value()->IsTheHole(isolate);
    7958             : }
    7959             : 
    7960             : 
    7961             : bool ObjectHashTableShape::IsMatch(Handle<Object> key, Object* other) {
    7962     1455324 :   return key->SameValue(other);
    7963             : }
    7964             : 
    7965             : 
    7966             : uint32_t ObjectHashTableShape::Hash(Handle<Object> key) {
    7967           0 :   return Smi::cast(key->GetHash())->value();
    7968             : }
    7969             : 
    7970             : 
    7971             : uint32_t ObjectHashTableShape::HashForObject(Handle<Object> key,
    7972             :                                              Object* other) {
    7973      629056 :   return Smi::cast(other->GetHash())->value();
    7974             : }
    7975             : 
    7976             : 
    7977             : Handle<Object> ObjectHashTableShape::AsHandle(Isolate* isolate,
    7978             :                                               Handle<Object> key) {
    7979             :   return key;
    7980             : }
    7981             : 
    7982             : 
    7983             : Handle<ObjectHashTable> ObjectHashTable::Shrink(
    7984             :     Handle<ObjectHashTable> table, Handle<Object> key) {
    7985         125 :   return DerivedHashTable::Shrink(table, key);
    7986             : }
    7987             : 
    7988             : 
    7989        9807 : Object* OrderedHashMap::ValueAt(int entry) {
    7990       19614 :   return get(EntryToIndex(entry) + kValueOffset);
    7991             : }
    7992             : 
    7993             : 
    7994             : template <int entrysize>
    7995     5515638 : bool WeakHashTableShape<entrysize>::IsMatch(Handle<Object> key, Object* other) {
    7996     5515638 :   if (other->IsWeakCell()) other = WeakCell::cast(other)->value();
    7997             :   return key->IsWeakCell() ? WeakCell::cast(*key)->value() == other
    7998    11031276 :                            : *key == other;
    7999             : }
    8000             : 
    8001             : 
    8002             : template <int entrysize>
    8003     2247910 : uint32_t WeakHashTableShape<entrysize>::Hash(Handle<Object> key) {
    8004             :   intptr_t hash =
    8005             :       key->IsWeakCell()
    8006             :           ? reinterpret_cast<intptr_t>(WeakCell::cast(*key)->value())
    8007     4495826 :           : reinterpret_cast<intptr_t>(*key);
    8008     2247913 :   return (uint32_t)(hash & 0xFFFFFFFF);
    8009             : }
    8010             : 
    8011             : 
    8012             : template <int entrysize>
    8013     1275479 : uint32_t WeakHashTableShape<entrysize>::HashForObject(Handle<Object> key,
    8014             :                                                       Object* other) {
    8015     1275479 :   if (other->IsWeakCell()) other = WeakCell::cast(other)->value();
    8016     1275479 :   intptr_t hash = reinterpret_cast<intptr_t>(other);
    8017     1275479 :   return (uint32_t)(hash & 0xFFFFFFFF);
    8018             : }
    8019             : 
    8020             : 
    8021             : template <int entrysize>
    8022             : Handle<Object> WeakHashTableShape<entrysize>::AsHandle(Isolate* isolate,
    8023             :                                                        Handle<Object> key) {
    8024             :   return key;
    8025             : }
    8026             : 
    8027             : 
    8028        6746 : ACCESSORS(ModuleInfoEntry, export_name, Object, kExportNameOffset)
    8029        5584 : ACCESSORS(ModuleInfoEntry, local_name, Object, kLocalNameOffset)
    8030        6661 : ACCESSORS(ModuleInfoEntry, import_name, Object, kImportNameOffset)
    8031        5102 : SMI_ACCESSORS(ModuleInfoEntry, module_request, kModuleRequestOffset)
    8032        4655 : SMI_ACCESSORS(ModuleInfoEntry, cell_index, kCellIndexOffset)
    8033        2313 : SMI_ACCESSORS(ModuleInfoEntry, beg_pos, kBegPosOffset)
    8034        2313 : SMI_ACCESSORS(ModuleInfoEntry, end_pos, kEndPosOffset)
    8035             : 
    8036    69539039 : void Map::ClearCodeCache(Heap* heap) {
    8037             :   // No write barrier is needed since empty_fixed_array is not in new space.
    8038             :   // Please note this function is used during marking:
    8039             :   //  - MarkCompactCollector::MarkUnmarkedObject
    8040             :   //  - IncrementalMarking::Step
    8041    69539039 :   WRITE_FIELD(this, kCodeCacheOffset, heap->empty_fixed_array());
    8042    44592621 : }
    8043             : 
    8044             : 
    8045     6130353 : int Map::SlackForArraySize(int old_size, int size_limit) {
    8046     6130353 :   const int max_slack = size_limit - old_size;
    8047     6130353 :   CHECK_LE(0, max_slack);
    8048     6130353 :   if (old_size < 4) {
    8049             :     DCHECK_LE(1, max_slack);
    8050             :     return 1;
    8051             :   }
    8052     6411900 :   return Min(max_slack, old_size / 4);
    8053             : }
    8054             : 
    8055             : 
    8056        2438 : void JSArray::set_length(Smi* length) {
    8057             :   // Don't need a write barrier for a Smi.
    8058    28365536 :   set_length(static_cast<Object*>(length), SKIP_WRITE_BARRIER);
    8059        2438 : }
    8060             : 
    8061             : 
    8062     1719033 : bool JSArray::SetLengthWouldNormalize(Heap* heap, uint32_t new_length) {
    8063             :   // This constant is somewhat arbitrary. Any large enough value would work.
    8064             :   const uint32_t kMaxFastArrayLength = 32 * 1024 * 1024;
    8065             :   // If the new array won't fit in a some non-trivial fraction of the max old
    8066             :   // space size, then force it to go dictionary mode.
    8067             :   uint32_t heap_based_upper_bound =
    8068     1719033 :       static_cast<uint32_t>((heap->MaxOldGenerationSize() / kDoubleSize) / 4);
    8069             :   return new_length >= Min(kMaxFastArrayLength, heap_based_upper_bound);
    8070             : }
    8071             : 
    8072             : 
    8073             : bool JSArray::AllowsSetLength() {
    8074             :   bool result = elements()->IsFixedArray() || elements()->IsFixedDoubleArray();
    8075             :   DCHECK(result == !HasFixedTypedArrayElements());
    8076             :   return result;
    8077             : }
    8078             : 
    8079             : 
    8080      141370 : void JSArray::SetContent(Handle<JSArray> array,
    8081             :                          Handle<FixedArrayBase> storage) {
    8082             :   EnsureCanContainElements(array, storage, storage->length(),
    8083      282740 :                            ALLOW_COPIED_DOUBLE_ELEMENTS);
    8084             : 
    8085             :   DCHECK((storage->map() == array->GetHeap()->fixed_double_array_map() &&
    8086             :           IsFastDoubleElementsKind(array->GetElementsKind())) ||
    8087             :          ((storage->map() != array->GetHeap()->fixed_double_array_map()) &&
    8088             :           (IsFastObjectElementsKind(array->GetElementsKind()) ||
    8089             :            (IsFastSmiElementsKind(array->GetElementsKind()) &&
    8090             :             Handle<FixedArray>::cast(storage)->ContainsOnlySmisOrHoles()))));
    8091      141370 :   array->set_elements(*storage);
    8092             :   array->set_length(Smi::FromInt(storage->length()));
    8093      141370 : }
    8094             : 
    8095             : 
    8096      876449 : bool JSArray::HasArrayPrototype(Isolate* isolate) {
    8097     1752898 :   return map()->prototype() == *isolate->initial_array_prototype();
    8098             : }
    8099             : 
    8100             : 
    8101             : int TypeFeedbackInfo::ic_total_count() {
    8102      161719 :   int current = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
    8103             :   return ICTotalCountField::decode(current);
    8104             : }
    8105             : 
    8106             : 
    8107             : void TypeFeedbackInfo::set_ic_total_count(int count) {
    8108     1080614 :   int value = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
    8109             :   value = ICTotalCountField::update(value,
    8110     2161228 :                                     ICTotalCountField::decode(count));
    8111     1080614 :   WRITE_FIELD(this, kStorage1Offset, Smi::FromInt(value));
    8112             : }
    8113             : 
    8114             : 
    8115             : int TypeFeedbackInfo::ic_with_type_info_count() {
    8116      161719 :   int current = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
    8117             :   return ICsWithTypeInfoCountField::decode(current);
    8118             : }
    8119             : 
    8120             : 
    8121             : void TypeFeedbackInfo::change_ic_with_type_info_count(int delta) {
    8122      764022 :   if (delta == 0) return;
    8123      725739 :   int value = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
    8124      725739 :   int new_count = ICsWithTypeInfoCountField::decode(value) + delta;
    8125             :   // We can get negative count here when the type-feedback info is
    8126             :   // shared between two code objects. The can only happen when
    8127             :   // the debugger made a shallow copy of code object (see Heap::CopyCode).
    8128             :   // Since we do not optimize when the debugger is active, we can skip
    8129             :   // this counter update.
    8130      725739 :   if (new_count >= 0) {
    8131      725739 :     new_count &= ICsWithTypeInfoCountField::kMask;
    8132     1451478 :     value = ICsWithTypeInfoCountField::update(value, new_count);
    8133      725739 :     WRITE_FIELD(this, kStorage2Offset, Smi::FromInt(value));
    8134             :   }
    8135             : }
    8136             : 
    8137             : 
    8138             : int TypeFeedbackInfo::ic_generic_count() {
    8139      186279 :   return Smi::cast(READ_FIELD(this, kStorage3Offset))->value();
    8140             : }
    8141             : 
    8142             : 
    8143             : void TypeFeedbackInfo::change_ic_generic_count(int delta) {
    8144      764022 :   if (delta == 0) return;
    8145       24560 :   int new_count = ic_generic_count() + delta;
    8146       24560 :   if (new_count >= 0) {
    8147       24560 :     new_count &= ~Smi::kMinValue;
    8148       24560 :     WRITE_FIELD(this, kStorage3Offset, Smi::FromInt(new_count));
    8149             :   }
    8150             : }
    8151             : 
    8152             : 
    8153             : void TypeFeedbackInfo::initialize_storage() {
    8154     1080614 :   WRITE_FIELD(this, kStorage1Offset, Smi::kZero);
    8155     1080614 :   WRITE_FIELD(this, kStorage2Offset, Smi::kZero);
    8156     1080614 :   WRITE_FIELD(this, kStorage3Offset, Smi::kZero);
    8157             : }
    8158             : 
    8159             : 
    8160             : void TypeFeedbackInfo::change_own_type_change_checksum() {
    8161     3977353 :   int value = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
    8162     3977353 :   int checksum = OwnTypeChangeChecksum::decode(value);
    8163     3977353 :   checksum = (checksum + 1) % (1 << kTypeChangeChecksumBits);
    8164     3977353 :   value = OwnTypeChangeChecksum::update(value, checksum);
    8165             :   // Ensure packed bit field is in Smi range.
    8166             :   if (value > Smi::kMaxValue) value |= Smi::kMinValue;
    8167             :   if (value < Smi::kMinValue) value &= ~Smi::kMinValue;
    8168     3977353 :   WRITE_FIELD(this, kStorage1Offset, Smi::FromInt(value));
    8169             : }
    8170             : 
    8171             : 
    8172             : void TypeFeedbackInfo::set_inlined_type_change_checksum(int checksum) {
    8173             :   int value = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
    8174             :   int mask = (1 << kTypeChangeChecksumBits) - 1;
    8175      260261 :   value = InlinedTypeChangeChecksum::update(value, checksum & mask);
    8176             :   // Ensure packed bit field is in Smi range.
    8177             :   if (value > Smi::kMaxValue) value |= Smi::kMinValue;
    8178             :   if (value < Smi::kMinValue) value &= ~Smi::kMinValue;
    8179      260261 :   WRITE_FIELD(this, kStorage2Offset, Smi::FromInt(value));
    8180             : }
    8181             : 
    8182             : 
    8183             : int TypeFeedbackInfo::own_type_change_checksum() {
    8184      367622 :   int value = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
    8185      367622 :   return OwnTypeChangeChecksum::decode(value);
    8186             : }
    8187             : 
    8188             : 
    8189             : bool TypeFeedbackInfo::matches_inlined_type_change_checksum(int checksum) {
    8190      260261 :   int value = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
    8191             :   int mask = (1 << kTypeChangeChecksumBits) - 1;
    8192      520522 :   return InlinedTypeChangeChecksum::decode(value) == (checksum & mask);
    8193             : }
    8194             : 
    8195             : 
    8196         235 : SMI_ACCESSORS(AliasedArgumentsEntry, aliased_context_slot, kAliasedContextSlot)
    8197             : 
    8198             : 
    8199   192057104 : Relocatable::Relocatable(Isolate* isolate) {
    8200    96028552 :   isolate_ = isolate;
    8201    96028552 :   prev_ = isolate->relocatable_top();
    8202             :   isolate->set_relocatable_top(this);
    8203             : }
    8204             : 
    8205             : 
    8206    96024968 : Relocatable::~Relocatable() {
    8207             :   DCHECK_EQ(isolate_->relocatable_top(), this);
    8208    96024968 :   isolate_->set_relocatable_top(prev_);
    8209           0 : }
    8210             : 
    8211             : 
    8212             : template<class Derived, class TableType>
    8213           0 : Object* OrderedHashTableIterator<Derived, TableType>::CurrentKey() {
    8214             :   TableType* table(TableType::cast(this->table()));
    8215             :   int index = Smi::cast(this->index())->value();
    8216       10193 :   Object* key = table->KeyAt(index);
    8217             :   DCHECK(!key->IsTheHole(table->GetIsolate()));
    8218           0 :   return key;
    8219             : }
    8220             : 
    8221             : 
    8222        6608 : void JSSetIterator::PopulateValueArray(FixedArray* array) {
    8223        6608 :   array->set(0, CurrentKey());
    8224        6608 : }
    8225             : 
    8226             : 
    8227        3585 : void JSMapIterator::PopulateValueArray(FixedArray* array) {
    8228        3585 :   array->set(0, CurrentKey());
    8229        3585 :   array->set(1, CurrentValue());
    8230        3585 : }
    8231             : 
    8232             : 
    8233             : Object* JSMapIterator::CurrentValue() {
    8234             :   OrderedHashMap* table(OrderedHashMap::cast(this->table()));
    8235             :   int index = Smi::cast(this->index())->value();
    8236        3585 :   Object* value = table->ValueAt(index);
    8237             :   DCHECK(!value->IsTheHole(table->GetIsolate()));
    8238             :   return value;
    8239             : }
    8240             : 
    8241             : 
    8242             : String::SubStringRange::SubStringRange(String* string, int first, int length)
    8243             :     : string_(string),
    8244             :       first_(first),
    8245           0 :       length_(length == -1 ? string->length() : length) {}
    8246             : 
    8247             : 
    8248             : class String::SubStringRange::iterator final {
    8249             :  public:
    8250             :   typedef std::forward_iterator_tag iterator_category;
    8251             :   typedef int difference_type;
    8252             :   typedef uc16 value_type;
    8253             :   typedef uc16* pointer;
    8254             :   typedef uc16& reference;
    8255             : 
    8256             :   iterator(const iterator& other)
    8257             :       : content_(other.content_), offset_(other.offset_) {}
    8258             : 
    8259           0 :   uc16 operator*() { return content_.Get(offset_); }
    8260             :   bool operator==(const iterator& other) const {
    8261             :     return content_.UsesSameString(other.content_) && offset_ == other.offset_;
    8262             :   }
    8263             :   bool operator!=(const iterator& other) const {
    8264           0 :     return !content_.UsesSameString(other.content_) || offset_ != other.offset_;
    8265             :   }
    8266             :   iterator& operator++() {
    8267           0 :     ++offset_;
    8268             :     return *this;
    8269             :   }
    8270             :   iterator operator++(int);
    8271             : 
    8272             :  private:
    8273             :   friend class String;
    8274             :   iterator(String* from, int offset)
    8275           0 :       : content_(from->GetFlatContent()), offset_(offset) {}
    8276             :   String::FlatContent content_;
    8277             :   int offset_;
    8278             : };
    8279             : 
    8280             : 
    8281             : String::SubStringRange::iterator String::SubStringRange::begin() {
    8282             :   return String::SubStringRange::iterator(string_, first_);
    8283             : }
    8284             : 
    8285             : 
    8286             : String::SubStringRange::iterator String::SubStringRange::end() {
    8287           0 :   return String::SubStringRange::iterator(string_, first_ + length_);
    8288             : }
    8289             : 
    8290             : 
    8291             : // Predictably converts HeapObject* or Address to uint32 by calculating
    8292             : // offset of the address in respective MemoryChunk.
    8293             : static inline uint32_t ObjectAddressForHashing(void* object) {
    8294   120793121 :   uint32_t value = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(object));
    8295   120793121 :   return value & MemoryChunk::kAlignmentMask;
    8296             : }
    8297             : 
    8298         392 : static inline Handle<Object> MakeEntryPair(Isolate* isolate, uint32_t index,
    8299             :                                            Handle<Object> value) {
    8300         392 :   Handle<Object> key = isolate->factory()->Uint32ToString(index);
    8301             :   Handle<FixedArray> entry_storage =
    8302         392 :       isolate->factory()->NewUninitializedFixedArray(2);
    8303             :   {
    8304         392 :     entry_storage->set(0, *key, SKIP_WRITE_BARRIER);
    8305         392 :     entry_storage->set(1, *value, SKIP_WRITE_BARRIER);
    8306             :   }
    8307             :   return isolate->factory()->NewJSArrayWithElements(entry_storage,
    8308         392 :                                                     FAST_ELEMENTS, 2);
    8309             : }
    8310             : 
    8311         560 : static inline Handle<Object> MakeEntryPair(Isolate* isolate, Handle<Name> key,
    8312             :                                            Handle<Object> value) {
    8313             :   Handle<FixedArray> entry_storage =
    8314         560 :       isolate->factory()->NewUninitializedFixedArray(2);
    8315             :   {
    8316         560 :     entry_storage->set(0, *key, SKIP_WRITE_BARRIER);
    8317         560 :     entry_storage->set(1, *value, SKIP_WRITE_BARRIER);
    8318             :   }
    8319             :   return isolate->factory()->NewJSArrayWithElements(entry_storage,
    8320         560 :                                                     FAST_ELEMENTS, 2);
    8321             : }
    8322             : 
    8323        1847 : ACCESSORS(JSIteratorResult, value, Object, kValueOffset)
    8324           0 : ACCESSORS(JSIteratorResult, done, Object, kDoneOffset)
    8325             : 
    8326          45 : ACCESSORS(JSArrayIterator, object, Object, kIteratedObjectOffset)
    8327          90 : ACCESSORS(JSArrayIterator, index, Object, kNextIndexOffset)
    8328          45 : ACCESSORS(JSArrayIterator, object_map, Object, kIteratedObjectMapOffset)
    8329             : 
    8330         996 : ACCESSORS(JSAsyncFromSyncIterator, sync_iterator, JSReceiver,
    8331             :           kSyncIteratorOffset)
    8332             : 
    8333          24 : ACCESSORS(JSStringIterator, string, String, kStringOffset)
    8334          16 : SMI_ACCESSORS(JSStringIterator, index, kNextIndexOffset)
    8335             : 
    8336             : #undef INT_ACCESSORS
    8337             : #undef ACCESSORS
    8338             : #undef ACCESSORS_CHECKED
    8339             : #undef ACCESSORS_CHECKED2
    8340             : #undef SMI_ACCESSORS
    8341             : #undef SYNCHRONIZED_SMI_ACCESSORS
    8342             : #undef NOBARRIER_SMI_ACCESSORS
    8343             : #undef BOOL_GETTER
    8344             : #undef BOOL_ACCESSORS
    8345             : #undef NOBARRIER_READ_FIELD
    8346             : #undef NOBARRIER_WRITE_FIELD
    8347             : #undef WRITE_BARRIER
    8348             : #undef CONDITIONAL_WRITE_BARRIER
    8349             : #undef READ_DOUBLE_FIELD
    8350             : #undef WRITE_DOUBLE_FIELD
    8351             : #undef READ_INT_FIELD
    8352             : #undef WRITE_INT_FIELD
    8353             : #undef READ_INTPTR_FIELD
    8354             : #undef WRITE_INTPTR_FIELD
    8355             : #undef READ_UINT8_FIELD
    8356             : #undef WRITE_UINT8_FIELD
    8357             : #undef READ_INT8_FIELD
    8358             : #undef WRITE_INT8_FIELD
    8359             : #undef READ_UINT16_FIELD
    8360             : #undef WRITE_UINT16_FIELD
    8361             : #undef READ_INT16_FIELD
    8362             : #undef WRITE_INT16_FIELD
    8363             : #undef READ_UINT32_FIELD
    8364             : #undef WRITE_UINT32_FIELD
    8365             : #undef READ_INT32_FIELD
    8366             : #undef WRITE_INT32_FIELD
    8367             : #undef READ_FLOAT_FIELD
    8368             : #undef WRITE_FLOAT_FIELD
    8369             : #undef READ_UINT64_FIELD
    8370             : #undef WRITE_UINT64_FIELD
    8371             : #undef READ_INT64_FIELD
    8372             : #undef WRITE_INT64_FIELD
    8373             : #undef READ_BYTE_FIELD
    8374             : #undef WRITE_BYTE_FIELD
    8375             : #undef NOBARRIER_READ_BYTE_FIELD
    8376             : #undef NOBARRIER_WRITE_BYTE_FIELD
    8377             : 
    8378             : }  // namespace internal
    8379             : }  // namespace v8
    8380             : 
    8381             : #include "src/objects/object-macros-undef.h"
    8382             : 
    8383             : #endif  // V8_OBJECTS_INL_H_

Generated by: LCOV version 1.10