LCOV - code coverage report
Current view: top level - src/compiler - access-builder.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 215 321 67.0 %
Date: 2017-04-26 Functions: 52 83 62.7 %

          Line data    Source code
       1             : // Copyright 2014 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             : #include "src/compiler/access-builder.h"
       6             : 
       7             : #include "src/compiler/type-cache.h"
       8             : #include "src/contexts.h"
       9             : #include "src/frames.h"
      10             : #include "src/handles-inl.h"
      11             : #include "src/heap/heap.h"
      12             : #include "src/objects-inl.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : namespace compiler {
      17             : 
      18             : // static
      19           0 : FieldAccess AccessBuilder::ForExternalDoubleValue() {
      20             :   FieldAccess access = {kUntaggedBase,       0,
      21             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
      22             :                         Type::Number(),      MachineType::Float64(),
      23           0 :                         kNoWriteBarrier};
      24           0 :   return access;
      25             : }
      26             : 
      27             : // static
      28       78952 : FieldAccess AccessBuilder::ForExternalTaggedValue() {
      29             :   FieldAccess access = {kUntaggedBase,       0,
      30             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
      31             :                         Type::Any(),         MachineType::AnyTagged(),
      32      157904 :                         kNoWriteBarrier};
      33       78952 :   return access;
      34             : }
      35             : 
      36             : // static
      37          30 : FieldAccess AccessBuilder::ForExternalUint8Value() {
      38             :   FieldAccess access = {kUntaggedBase,           0,
      39             :                         MaybeHandle<Name>(),     MaybeHandle<Map>(),
      40          30 :                         TypeCache::Get().kUint8, MachineType::Uint8(),
      41          60 :                         kNoWriteBarrier};
      42          30 :   return access;
      43             : }
      44             : 
      45             : // static
      46      407595 : FieldAccess AccessBuilder::ForMap() {
      47             :   FieldAccess access = {kTaggedBase,           HeapObject::kMapOffset,
      48             :                         MaybeHandle<Name>(),   MaybeHandle<Map>(),
      49             :                         Type::OtherInternal(), MachineType::TaggedPointer(),
      50      815190 :                         kMapWriteBarrier};
      51      407595 :   return access;
      52             : }
      53             : 
      54             : 
      55             : // static
      56      204789 : FieldAccess AccessBuilder::ForHeapNumberValue() {
      57             :   FieldAccess access = {
      58             :       kTaggedBase,        HeapNumber::kValueOffset,  MaybeHandle<Name>(),
      59      204789 :       MaybeHandle<Map>(), TypeCache::Get().kFloat64, MachineType::Float64(),
      60      409577 :       kNoWriteBarrier};
      61      204788 :   return access;
      62             : }
      63             : 
      64             : 
      65             : // static
      66       29964 : FieldAccess AccessBuilder::ForJSObjectProperties() {
      67             :   FieldAccess access = {kTaggedBase,         JSObject::kPropertiesOffset,
      68             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
      69             :                         Type::Internal(),    MachineType::TaggedPointer(),
      70       59928 :                         kPointerWriteBarrier};
      71       29964 :   return access;
      72             : }
      73             : 
      74             : 
      75             : // static
      76       55511 : FieldAccess AccessBuilder::ForJSObjectElements() {
      77             :   FieldAccess access = {kTaggedBase,         JSObject::kElementsOffset,
      78             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
      79             :                         Type::Internal(),    MachineType::TaggedPointer(),
      80      111022 :                         kPointerWriteBarrier};
      81       55511 :   return access;
      82             : }
      83             : 
      84             : 
      85             : // static
      86        7530 : FieldAccess AccessBuilder::ForJSObjectInObjectProperty(Handle<Map> map,
      87             :                                                        int index) {
      88        7530 :   int const offset = map->GetInObjectPropertyOffset(index);
      89             :   FieldAccess access = {kTaggedBase,         offset,
      90             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
      91             :                         Type::NonInternal(), MachineType::AnyTagged(),
      92       15060 :                         kFullWriteBarrier};
      93        7530 :   return access;
      94             : }
      95             : 
      96             : // static
      97           0 : FieldAccess AccessBuilder::ForJSObjectOffset(
      98             :     int offset, WriteBarrierKind write_barrier_kind) {
      99             :   FieldAccess access = {kTaggedBase,         offset,
     100             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
     101             :                         Type::NonInternal(), MachineType::AnyTagged(),
     102           0 :                         write_barrier_kind};
     103           0 :   return access;
     104             : }
     105             : 
     106             : // static
     107        1125 : FieldAccess AccessBuilder::ForJSCollectionTable() {
     108             :   FieldAccess access = {kTaggedBase,           JSCollection::kTableOffset,
     109             :                         MaybeHandle<Name>(),   MaybeHandle<Map>(),
     110             :                         Type::OtherInternal(), MachineType::TaggedPointer(),
     111        2250 :                         kPointerWriteBarrier};
     112        1125 :   return access;
     113             : }
     114             : 
     115             : // static
     116           0 : FieldAccess AccessBuilder::ForJSFunctionPrototypeOrInitialMap() {
     117             :   FieldAccess access = {
     118             :       kTaggedBase,         JSFunction::kPrototypeOrInitialMapOffset,
     119             :       MaybeHandle<Name>(), MaybeHandle<Map>(),
     120             :       Type::Any(),         MachineType::AnyTagged(),
     121           0 :       kFullWriteBarrier};
     122           0 :   return access;
     123             : }
     124             : 
     125             : // static
     126      173520 : FieldAccess AccessBuilder::ForJSFunctionContext() {
     127             :   FieldAccess access = {kTaggedBase,         JSFunction::kContextOffset,
     128             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
     129             :                         Type::Internal(),    MachineType::AnyTagged(),
     130      347040 :                         kPointerWriteBarrier};
     131      173520 :   return access;
     132             : }
     133             : 
     134             : 
     135             : // static
     136           0 : FieldAccess AccessBuilder::ForJSFunctionSharedFunctionInfo() {
     137             :   FieldAccess access = {
     138             :       kTaggedBase,           JSFunction::kSharedFunctionInfoOffset,
     139             :       Handle<Name>(),        MaybeHandle<Map>(),
     140             :       Type::OtherInternal(), MachineType::TaggedPointer(),
     141           0 :       kPointerWriteBarrier};
     142           0 :   return access;
     143             : }
     144             : 
     145             : // static
     146           0 : FieldAccess AccessBuilder::ForJSFunctionFeedbackVector() {
     147             :   FieldAccess access = {kTaggedBase,         JSFunction::kFeedbackVectorOffset,
     148             :                         Handle<Name>(),      MaybeHandle<Map>(),
     149             :                         Type::Internal(),    MachineType::TaggedPointer(),
     150           0 :                         kPointerWriteBarrier};
     151           0 :   return access;
     152             : }
     153             : 
     154             : // static
     155           0 : FieldAccess AccessBuilder::ForJSFunctionCodeEntry() {
     156             :   FieldAccess access = {kTaggedBase,           JSFunction::kCodeEntryOffset,
     157             :                         Handle<Name>(),        MaybeHandle<Map>(),
     158             :                         Type::OtherInternal(), MachineType::Pointer(),
     159           0 :                         kNoWriteBarrier};
     160           0 :   return access;
     161             : }
     162             : 
     163             : // static
     164           0 : FieldAccess AccessBuilder::ForJSFunctionNextFunctionLink() {
     165             :   FieldAccess access = {
     166             :       kTaggedBase,         JSFunction::kNextFunctionLinkOffset,
     167             :       Handle<Name>(),      MaybeHandle<Map>(),
     168             :       Type::Any(),         MachineType::AnyTagged(),
     169           0 :       kPointerWriteBarrier};
     170           0 :   return access;
     171             : }
     172             : 
     173             : // static
     174        8754 : FieldAccess AccessBuilder::ForJSGeneratorObjectContext() {
     175             :   FieldAccess access = {kTaggedBase,         JSGeneratorObject::kContextOffset,
     176             :                         Handle<Name>(),      MaybeHandle<Map>(),
     177             :                         Type::Internal(),    MachineType::TaggedPointer(),
     178       17508 :                         kPointerWriteBarrier};
     179        8754 :   return access;
     180             : }
     181             : 
     182             : // static
     183        9893 : FieldAccess AccessBuilder::ForJSGeneratorObjectContinuation() {
     184             :   FieldAccess access = {
     185             :       kTaggedBase,         JSGeneratorObject::kContinuationOffset,
     186             :       Handle<Name>(),      MaybeHandle<Map>(),
     187             :       Type::SignedSmall(), MachineType::TaggedSigned(),
     188       19786 :       kNoWriteBarrier};
     189        9893 :   return access;
     190             : }
     191             : 
     192             : // static
     193       13233 : FieldAccess AccessBuilder::ForJSGeneratorObjectInputOrDebugPos() {
     194             :   FieldAccess access = {
     195             :       kTaggedBase,         JSGeneratorObject::kInputOrDebugPosOffset,
     196             :       Handle<Name>(),      MaybeHandle<Map>(),
     197             :       Type::NonInternal(), MachineType::AnyTagged(),
     198       26466 :       kFullWriteBarrier};
     199       13233 :   return access;
     200             : }
     201             : 
     202             : // static
     203          70 : FieldAccess AccessBuilder::ForJSAsyncGeneratorObjectAwaitInputOrDebugPos() {
     204             :   FieldAccess access = {
     205             :       kTaggedBase,         JSAsyncGeneratorObject::kAwaitInputOrDebugPosOffset,
     206             :       Handle<Name>(),      MaybeHandle<Map>(),
     207             :       Type::NonInternal(), MachineType::AnyTagged(),
     208         140 :       kFullWriteBarrier};
     209          70 :   return access;
     210             : }
     211             : 
     212             : // static
     213       36498 : FieldAccess AccessBuilder::ForJSGeneratorObjectRegisterFile() {
     214             :   FieldAccess access = {
     215             :       kTaggedBase,         JSGeneratorObject::kRegisterFileOffset,
     216             :       Handle<Name>(),      MaybeHandle<Map>(),
     217             :       Type::Internal(),    MachineType::AnyTagged(),
     218       72996 :       kPointerWriteBarrier};
     219       36498 :   return access;
     220             : }
     221             : 
     222             : // static
     223        6683 : FieldAccess AccessBuilder::ForJSGeneratorObjectResumeMode() {
     224             :   FieldAccess access = {
     225             :       kTaggedBase,         JSGeneratorObject::kResumeModeOffset,
     226             :       Handle<Name>(),      MaybeHandle<Map>(),
     227             :       Type::SignedSmall(), MachineType::TaggedSigned(),
     228       13366 :       kNoWriteBarrier};
     229        6683 :   return access;
     230             : }
     231             : 
     232             : // static
     233       30089 : FieldAccess AccessBuilder::ForJSArrayLength(ElementsKind elements_kind) {
     234       30089 :   TypeCache const& type_cache = TypeCache::Get();
     235             :   FieldAccess access = {kTaggedBase,
     236             :                         JSArray::kLengthOffset,
     237             :                         Handle<Name>(),
     238             :                         MaybeHandle<Map>(),
     239             :                         type_cache.kJSArrayLengthType,
     240             :                         MachineType::TaggedSigned(),
     241       60178 :                         kFullWriteBarrier};
     242       30089 :   if (IsFastDoubleElementsKind(elements_kind)) {
     243        2686 :     access.type = type_cache.kFixedDoubleArrayLengthType;
     244        2686 :     access.write_barrier_kind = kNoWriteBarrier;
     245       27403 :   } else if (IsFastElementsKind(elements_kind)) {
     246       27403 :     access.type = type_cache.kFixedArrayLengthType;
     247       27403 :     access.write_barrier_kind = kNoWriteBarrier;
     248             :   }
     249       30089 :   return access;
     250             : }
     251             : 
     252             : 
     253             : // static
     254           0 : FieldAccess AccessBuilder::ForJSArrayBufferBackingStore() {
     255             :   FieldAccess access = {
     256             :       kTaggedBase,           JSArrayBuffer::kBackingStoreOffset,
     257             :       MaybeHandle<Name>(),   MaybeHandle<Map>(),
     258             :       Type::OtherInternal(), MachineType::Pointer(),
     259           0 :       kNoWriteBarrier};
     260           0 :   return access;
     261             : }
     262             : 
     263             : // static
     264         325 : FieldAccess AccessBuilder::ForJSArrayBufferBitField() {
     265             :   FieldAccess access = {
     266             :       kTaggedBase,        JSArrayBuffer::kBitFieldOffset, MaybeHandle<Name>(),
     267         325 :       MaybeHandle<Map>(), TypeCache::Get().kUint8,        MachineType::Uint32(),
     268         650 :       kNoWriteBarrier};
     269         325 :   return access;
     270             : }
     271             : 
     272             : // static
     273        3177 : FieldAccess AccessBuilder::ForJSArrayBufferViewBuffer() {
     274             :   FieldAccess access = {kTaggedBase,           JSArrayBufferView::kBufferOffset,
     275             :                         MaybeHandle<Name>(),   MaybeHandle<Map>(),
     276             :                         Type::OtherInternal(), MachineType::TaggedPointer(),
     277        6354 :                         kPointerWriteBarrier};
     278        3177 :   return access;
     279             : }
     280             : 
     281             : // static
     282           9 : FieldAccess AccessBuilder::ForJSArrayBufferViewByteLength() {
     283             :   FieldAccess access = {kTaggedBase,
     284             :                         JSArrayBufferView::kByteLengthOffset,
     285             :                         MaybeHandle<Name>(),
     286             :                         MaybeHandle<Map>(),
     287           9 :                         TypeCache::Get().kPositiveInteger,
     288             :                         MachineType::AnyTagged(),
     289          18 :                         kFullWriteBarrier};
     290           9 :   return access;
     291             : }
     292             : 
     293             : // static
     294          49 : FieldAccess AccessBuilder::ForJSArrayBufferViewByteOffset() {
     295             :   FieldAccess access = {kTaggedBase,
     296             :                         JSArrayBufferView::kByteOffsetOffset,
     297             :                         MaybeHandle<Name>(),
     298             :                         MaybeHandle<Map>(),
     299          49 :                         TypeCache::Get().kPositiveInteger,
     300             :                         MachineType::AnyTagged(),
     301          98 :                         kFullWriteBarrier};
     302          49 :   return access;
     303             : }
     304             : 
     305             : // static
     306        3192 : FieldAccess AccessBuilder::ForJSTypedArrayLength() {
     307             :   FieldAccess access = {kTaggedBase,
     308             :                         JSTypedArray::kLengthOffset,
     309             :                         MaybeHandle<Name>(),
     310             :                         MaybeHandle<Map>(),
     311        3192 :                         TypeCache::Get().kJSTypedArrayLengthType,
     312             :                         MachineType::TaggedSigned(),
     313        6384 :                         kNoWriteBarrier};
     314        3192 :   return access;
     315             : }
     316             : 
     317             : // static
     318           0 : FieldAccess AccessBuilder::ForJSDateValue() {
     319             :   FieldAccess access = {kTaggedBase,
     320             :                         JSDate::kValueOffset,
     321             :                         MaybeHandle<Name>(),
     322             :                         MaybeHandle<Map>(),
     323           0 :                         TypeCache::Get().kJSDateValueType,
     324             :                         MachineType::AnyTagged(),
     325           0 :                         kFullWriteBarrier};
     326           0 :   return access;
     327             : }
     328             : 
     329             : // static
     330           0 : FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) {
     331             :   FieldAccess access = {
     332           0 :       kTaggedBase,         JSDate::kValueOffset + index * kPointerSize,
     333             :       MaybeHandle<Name>(), MaybeHandle<Map>(),
     334             :       Type::Number(),      MachineType::AnyTagged(),
     335           0 :       kFullWriteBarrier};
     336           0 :   return access;
     337             : }
     338             : 
     339             : 
     340             : // static
     341       12701 : FieldAccess AccessBuilder::ForJSIteratorResultDone() {
     342             :   FieldAccess access = {kTaggedBase,         JSIteratorResult::kDoneOffset,
     343             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
     344             :                         Type::NonInternal(), MachineType::AnyTagged(),
     345       25402 :                         kFullWriteBarrier};
     346       12701 :   return access;
     347             : }
     348             : 
     349             : 
     350             : // static
     351       12701 : FieldAccess AccessBuilder::ForJSIteratorResultValue() {
     352             :   FieldAccess access = {kTaggedBase,         JSIteratorResult::kValueOffset,
     353             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
     354             :                         Type::NonInternal(), MachineType::AnyTagged(),
     355       25402 :                         kFullWriteBarrier};
     356       12701 :   return access;
     357             : }
     358             : 
     359             : 
     360             : // static
     361           0 : FieldAccess AccessBuilder::ForJSRegExpFlags() {
     362             :   FieldAccess access = {kTaggedBase,         JSRegExp::kFlagsOffset,
     363             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
     364             :                         Type::NonInternal(), MachineType::AnyTagged(),
     365           0 :                         kFullWriteBarrier};
     366           0 :   return access;
     367             : }
     368             : 
     369             : 
     370             : // static
     371           0 : FieldAccess AccessBuilder::ForJSRegExpSource() {
     372             :   FieldAccess access = {kTaggedBase,         JSRegExp::kSourceOffset,
     373             :                         MaybeHandle<Name>(), MaybeHandle<Map>(),
     374             :                         Type::NonInternal(), MachineType::AnyTagged(),
     375           0 :                         kFullWriteBarrier};
     376           0 :   return access;
     377             : }
     378             : 
     379             : 
     380             : // static
     381       58861 : FieldAccess AccessBuilder::ForFixedArrayLength() {
     382             :   FieldAccess access = {kTaggedBase,
     383             :                         FixedArray::kLengthOffset,
     384             :                         MaybeHandle<Name>(),
     385             :                         MaybeHandle<Map>(),
     386       58861 :                         TypeCache::Get().kFixedArrayLengthType,
     387             :                         MachineType::TaggedSigned(),
     388      117722 :                         kNoWriteBarrier};
     389       58861 :   return access;
     390             : }
     391             : 
     392             : // static
     393        3063 : FieldAccess AccessBuilder::ForFixedTypedArrayBaseBasePointer() {
     394             :   FieldAccess access = {
     395             :       kTaggedBase,           FixedTypedArrayBase::kBasePointerOffset,
     396             :       MaybeHandle<Name>(),   MaybeHandle<Map>(),
     397             :       Type::OtherInternal(), MachineType::AnyTagged(),
     398        6126 :       kPointerWriteBarrier};
     399        3063 :   return access;
     400             : }
     401             : 
     402             : // static
     403        3063 : FieldAccess AccessBuilder::ForFixedTypedArrayBaseExternalPointer() {
     404             :   FieldAccess access = {kTaggedBase,
     405             :                         FixedTypedArrayBase::kExternalPointerOffset,
     406             :                         MaybeHandle<Name>(),
     407             :                         MaybeHandle<Map>(),
     408             :                         Type::ExternalPointer(),
     409             :                         MachineType::Pointer(),
     410        6126 :                         kNoWriteBarrier};
     411        3063 :   return access;
     412             : }
     413             : 
     414             : // static
     415           0 : FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
     416             :   FieldAccess access = {
     417             :       kTaggedBase,           DescriptorArray::kEnumCacheOffset,
     418             :       Handle<Name>(),        MaybeHandle<Map>(),
     419             :       Type::OtherInternal(), MachineType::TaggedPointer(),
     420           0 :       kPointerWriteBarrier};
     421           0 :   return access;
     422             : }
     423             : 
     424             : 
     425             : // static
     426           0 : FieldAccess AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache() {
     427             :   FieldAccess access = {
     428             :       kTaggedBase,           DescriptorArray::kEnumCacheBridgeCacheOffset,
     429             :       Handle<Name>(),        MaybeHandle<Map>(),
     430             :       Type::OtherInternal(), MachineType::TaggedPointer(),
     431           0 :       kPointerWriteBarrier};
     432           0 :   return access;
     433             : }
     434             : 
     435             : 
     436             : // static
     437      113396 : FieldAccess AccessBuilder::ForMapBitField() {
     438             :   FieldAccess access = {
     439             :       kTaggedBase,        Map::kBitFieldOffset,    Handle<Name>(),
     440      113396 :       MaybeHandle<Map>(), TypeCache::Get().kUint8, MachineType::Uint8(),
     441      226792 :       kNoWriteBarrier};
     442      113396 :   return access;
     443             : }
     444             : 
     445             : 
     446             : // static
     447         697 : FieldAccess AccessBuilder::ForMapBitField3() {
     448             :   FieldAccess access = {
     449             :       kTaggedBase,        Map::kBitField3Offset,   Handle<Name>(),
     450         697 :       MaybeHandle<Map>(), TypeCache::Get().kInt32, MachineType::Int32(),
     451        1394 :       kNoWriteBarrier};
     452         697 :   return access;
     453             : }
     454             : 
     455             : 
     456             : // static
     457           0 : FieldAccess AccessBuilder::ForMapDescriptors() {
     458             :   FieldAccess access = {kTaggedBase,           Map::kDescriptorsOffset,
     459             :                         Handle<Name>(),        MaybeHandle<Map>(),
     460             :                         Type::OtherInternal(), MachineType::TaggedPointer(),
     461           0 :                         kPointerWriteBarrier};
     462           0 :   return access;
     463             : }
     464             : 
     465             : 
     466             : // static
     467       63237 : FieldAccess AccessBuilder::ForMapInstanceType() {
     468             :   FieldAccess access = {
     469             :       kTaggedBase,        Map::kInstanceTypeOffset, Handle<Name>(),
     470       63237 :       MaybeHandle<Map>(), TypeCache::Get().kUint8,  MachineType::Uint8(),
     471      126475 :       kNoWriteBarrier};
     472       63238 :   return access;
     473             : }
     474             : 
     475             : 
     476             : // static
     477         988 : FieldAccess AccessBuilder::ForMapPrototype() {
     478             :   FieldAccess access = {kTaggedBase,         Map::kPrototypeOffset,
     479             :                         Handle<Name>(),      MaybeHandle<Map>(),
     480             :                         Type::Any(),         MachineType::TaggedPointer(),
     481        1976 :                         kPointerWriteBarrier};
     482         988 :   return access;
     483             : }
     484             : 
     485             : // static
     486         720 : FieldAccess AccessBuilder::ForModuleRegularExports() {
     487             :   FieldAccess access = {kTaggedBase,           Module::kRegularExportsOffset,
     488             :                         Handle<Name>(),        MaybeHandle<Map>(),
     489             :                         Type::OtherInternal(), MachineType::TaggedPointer(),
     490        1440 :                         kPointerWriteBarrier};
     491         720 :   return access;
     492             : }
     493             : 
     494             : // static
     495         172 : FieldAccess AccessBuilder::ForModuleRegularImports() {
     496             :   FieldAccess access = {kTaggedBase,           Module::kRegularImportsOffset,
     497             :                         Handle<Name>(),        MaybeHandle<Map>(),
     498             :                         Type::OtherInternal(), MachineType::TaggedPointer(),
     499         344 :                         kPointerWriteBarrier};
     500         172 :   return access;
     501             : }
     502             : 
     503             : // static
     504        4325 : FieldAccess AccessBuilder::ForNameHashField() {
     505             :   FieldAccess access = {kTaggedBase,        Name::kHashFieldOffset,
     506             :                         Handle<Name>(),     MaybeHandle<Map>(),
     507             :                         Type::Unsigned32(), MachineType::Uint32(),
     508        8650 :                         kNoWriteBarrier};
     509        4325 :   return access;
     510             : }
     511             : 
     512             : // static
     513        7428 : FieldAccess AccessBuilder::ForStringLength() {
     514             :   FieldAccess access = {kTaggedBase,
     515             :                         String::kLengthOffset,
     516             :                         Handle<Name>(),
     517             :                         MaybeHandle<Map>(),
     518        7428 :                         TypeCache::Get().kStringLengthType,
     519             :                         MachineType::TaggedSigned(),
     520       14856 :                         kNoWriteBarrier};
     521        7428 :   return access;
     522             : }
     523             : 
     524             : // static
     525        3341 : FieldAccess AccessBuilder::ForConsStringFirst() {
     526             :   FieldAccess access = {kTaggedBase,         ConsString::kFirstOffset,
     527             :                         Handle<Name>(),      MaybeHandle<Map>(),
     528             :                         Type::String(),      MachineType::TaggedPointer(),
     529        6682 :                         kPointerWriteBarrier};
     530        3341 :   return access;
     531             : }
     532             : 
     533             : // static
     534        3341 : FieldAccess AccessBuilder::ForConsStringSecond() {
     535             :   FieldAccess access = {kTaggedBase,         ConsString::kSecondOffset,
     536             :                         Handle<Name>(),      MaybeHandle<Map>(),
     537             :                         Type::String(),      MachineType::TaggedPointer(),
     538        6682 :                         kPointerWriteBarrier};
     539        3341 :   return access;
     540             : }
     541             : 
     542             : // static
     543           0 : FieldAccess AccessBuilder::ForThinStringActual() {
     544             :   FieldAccess access = {kTaggedBase,         ThinString::kActualOffset,
     545             :                         Handle<Name>(),      MaybeHandle<Map>(),
     546             :                         Type::String(),      MachineType::TaggedPointer(),
     547           0 :                         kPointerWriteBarrier};
     548           0 :   return access;
     549             : }
     550             : 
     551             : // static
     552           0 : FieldAccess AccessBuilder::ForSlicedStringOffset() {
     553             :   FieldAccess access = {kTaggedBase,         SlicedString::kOffsetOffset,
     554             :                         Handle<Name>(),      MaybeHandle<Map>(),
     555             :                         Type::SignedSmall(), MachineType::TaggedSigned(),
     556           0 :                         kNoWriteBarrier};
     557           0 :   return access;
     558             : }
     559             : 
     560             : // static
     561           0 : FieldAccess AccessBuilder::ForSlicedStringParent() {
     562             :   FieldAccess access = {kTaggedBase,         SlicedString::kParentOffset,
     563             :                         Handle<Name>(),      MaybeHandle<Map>(),
     564             :                         Type::String(),      MachineType::TaggedPointer(),
     565           0 :                         kPointerWriteBarrier};
     566           0 :   return access;
     567             : }
     568             : 
     569             : // static
     570           0 : FieldAccess AccessBuilder::ForExternalStringResourceData() {
     571             :   FieldAccess access = {kTaggedBase,
     572             :                         ExternalString::kResourceDataOffset,
     573             :                         Handle<Name>(),
     574             :                         MaybeHandle<Map>(),
     575             :                         Type::ExternalPointer(),
     576             :                         MachineType::Pointer(),
     577           0 :                         kNoWriteBarrier};
     578           0 :   return access;
     579             : }
     580             : 
     581             : // static
     582           0 : ElementAccess AccessBuilder::ForExternalOneByteStringCharacter() {
     583           0 :   ElementAccess access = {kUntaggedBase, 0, TypeCache::Get().kUint8,
     584           0 :                           MachineType::Uint8(), kNoWriteBarrier};
     585           0 :   return access;
     586             : }
     587             : 
     588             : // static
     589           0 : ElementAccess AccessBuilder::ForExternalTwoByteStringCharacter() {
     590           0 :   ElementAccess access = {kUntaggedBase, 0, TypeCache::Get().kUint16,
     591           0 :                           MachineType::Uint16(), kNoWriteBarrier};
     592           0 :   return access;
     593             : }
     594             : 
     595             : // static
     596           0 : ElementAccess AccessBuilder::ForSeqOneByteStringCharacter() {
     597             :   ElementAccess access = {kTaggedBase, SeqOneByteString::kHeaderSize,
     598           0 :                           TypeCache::Get().kUint8, MachineType::Uint8(),
     599           0 :                           kNoWriteBarrier};
     600           0 :   return access;
     601             : }
     602             : 
     603             : // static
     604           0 : ElementAccess AccessBuilder::ForSeqTwoByteStringCharacter() {
     605             :   ElementAccess access = {kTaggedBase, SeqTwoByteString::kHeaderSize,
     606           0 :                           TypeCache::Get().kUint16, MachineType::Uint16(),
     607           0 :                           kNoWriteBarrier};
     608           0 :   return access;
     609             : }
     610             : 
     611             : // static
     612           0 : FieldAccess AccessBuilder::ForJSGlobalObjectGlobalProxy() {
     613             :   FieldAccess access = {kTaggedBase,         JSGlobalObject::kGlobalProxyOffset,
     614             :                         Handle<Name>(),      MaybeHandle<Map>(),
     615             :                         Type::Receiver(),    MachineType::TaggedPointer(),
     616           0 :                         kPointerWriteBarrier};
     617           0 :   return access;
     618             : }
     619             : 
     620             : // static
     621           0 : FieldAccess AccessBuilder::ForJSGlobalObjectNativeContext() {
     622             :   FieldAccess access = {
     623             :       kTaggedBase,         JSGlobalObject::kNativeContextOffset,
     624             :       Handle<Name>(),      MaybeHandle<Map>(),
     625             :       Type::Internal(),    MachineType::TaggedPointer(),
     626           0 :       kPointerWriteBarrier};
     627           0 :   return access;
     628             : }
     629             : 
     630             : // static
     631        3648 : FieldAccess AccessBuilder::ForJSArrayIteratorObject() {
     632             :   FieldAccess access = {kTaggedBase,
     633             :                         JSArrayIterator::kIteratedObjectOffset,
     634             :                         Handle<Name>(),
     635             :                         MaybeHandle<Map>(),
     636             :                         Type::ReceiverOrUndefined(),
     637             :                         MachineType::TaggedPointer(),
     638        7296 :                         kPointerWriteBarrier};
     639        3648 :   return access;
     640             : }
     641             : 
     642             : // static
     643        3648 : FieldAccess AccessBuilder::ForJSArrayIteratorIndex(InstanceType instance_type,
     644             :                                                    ElementsKind elements_kind) {
     645             :   // In generic case, cap to 2^53-1 (per ToLength() in spec) via
     646             :   // kPositiveSafeInteger
     647             :   FieldAccess access = {kTaggedBase,
     648             :                         JSArrayIterator::kNextIndexOffset,
     649             :                         Handle<Name>(),
     650             :                         MaybeHandle<Map>(),
     651        3648 :                         TypeCache::Get().kPositiveSafeInteger,
     652             :                         MachineType::AnyTagged(),
     653        7296 :                         kFullWriteBarrier};
     654        3648 :   if (instance_type == JS_ARRAY_TYPE) {
     655        2766 :     if (IsFastDoubleElementsKind(elements_kind)) {
     656        1136 :       access.type = TypeCache::Get().kFixedDoubleArrayLengthType;
     657        1136 :       access.machine_type = MachineType::TaggedSigned();
     658        1136 :       access.write_barrier_kind = kNoWriteBarrier;
     659        1630 :     } else if (IsFastElementsKind(elements_kind)) {
     660        1630 :       access.type = TypeCache::Get().kFixedArrayLengthType;
     661        1630 :       access.machine_type = MachineType::TaggedSigned();
     662        1630 :       access.write_barrier_kind = kNoWriteBarrier;
     663             :     } else {
     664           0 :       access.type = TypeCache::Get().kJSArrayLengthType;
     665             :     }
     666         882 :   } else if (instance_type == JS_TYPED_ARRAY_TYPE) {
     667          28 :     access.type = TypeCache::Get().kJSTypedArrayLengthType;
     668          28 :     access.machine_type = MachineType::TaggedSigned();
     669          28 :     access.write_barrier_kind = kNoWriteBarrier;
     670             :   }
     671        3648 :   return access;
     672             : }
     673             : 
     674             : // static
     675        2224 : FieldAccess AccessBuilder::ForJSArrayIteratorObjectMap() {
     676             :   FieldAccess access = {
     677             :       kTaggedBase,           JSArrayIterator::kIteratedObjectMapOffset,
     678             :       Handle<Name>(),        MaybeHandle<Map>(),
     679             :       Type::OtherInternal(), MachineType::TaggedPointer(),
     680        4448 :       kPointerWriteBarrier};
     681        2224 :   return access;
     682             : }
     683             : 
     684             : // static
     685          99 : FieldAccess AccessBuilder::ForJSStringIteratorString() {
     686             :   FieldAccess access = {kTaggedBase,         JSStringIterator::kStringOffset,
     687             :                         Handle<Name>(),      MaybeHandle<Map>(),
     688             :                         Type::String(),      MachineType::TaggedPointer(),
     689         198 :                         kPointerWriteBarrier};
     690          99 :   return access;
     691             : }
     692             : 
     693             : // static
     694         144 : FieldAccess AccessBuilder::ForJSStringIteratorIndex() {
     695             :   FieldAccess access = {kTaggedBase,
     696             :                         JSStringIterator::kNextIndexOffset,
     697             :                         Handle<Name>(),
     698             :                         MaybeHandle<Map>(),
     699         144 :                         TypeCache::Get().kStringLengthType,
     700             :                         MachineType::TaggedSigned(),
     701         288 :                         kNoWriteBarrier};
     702         144 :   return access;
     703             : }
     704             : 
     705             : // static
     706           0 : FieldAccess AccessBuilder::ForValue() {
     707             :   FieldAccess access = {kTaggedBase,         JSValue::kValueOffset,
     708             :                         Handle<Name>(),      MaybeHandle<Map>(),
     709             :                         Type::NonInternal(), MachineType::AnyTagged(),
     710           0 :                         kFullWriteBarrier};
     711           0 :   return access;
     712             : }
     713             : 
     714             : 
     715             : // static
     716        4861 : FieldAccess AccessBuilder::ForArgumentsLength() {
     717             :   FieldAccess access = {kTaggedBase,         JSArgumentsObject::kLengthOffset,
     718             :                         Handle<Name>(),      MaybeHandle<Map>(),
     719             :                         Type::NonInternal(), MachineType::AnyTagged(),
     720        9722 :                         kFullWriteBarrier};
     721        4861 :   return access;
     722             : }
     723             : 
     724             : 
     725             : // static
     726        1429 : FieldAccess AccessBuilder::ForArgumentsCallee() {
     727             :   FieldAccess access = {
     728             :       kTaggedBase,         JSSloppyArgumentsObject::kCalleeOffset,
     729             :       Handle<Name>(),      MaybeHandle<Map>(),
     730             :       Type::NonInternal(), MachineType::AnyTagged(),
     731        2858 :       kPointerWriteBarrier};
     732        1429 :   return access;
     733             : }
     734             : 
     735             : 
     736             : // static
     737      123578 : FieldAccess AccessBuilder::ForFixedArraySlot(
     738             :     size_t index, WriteBarrierKind write_barrier_kind) {
     739      123578 :   int offset = FixedArray::OffsetOfElementAt(static_cast<int>(index));
     740             :   FieldAccess access = {kTaggedBase,         offset,
     741             :                         Handle<Name>(),      MaybeHandle<Map>(),
     742             :                         Type::NonInternal(), MachineType::AnyTagged(),
     743      247156 :                         write_barrier_kind};
     744      123578 :   return access;
     745             : }
     746             : 
     747             : 
     748             : // static
     749         892 : FieldAccess AccessBuilder::ForCellValue() {
     750             :   FieldAccess access = {kTaggedBase,      Cell::kValueOffset,
     751             :                         Handle<Name>(),   MaybeHandle<Map>(),
     752             :                         Type::Any(),      MachineType::AnyTagged(),
     753        1784 :                         kFullWriteBarrier};
     754         892 :   return access;
     755             : }
     756             : 
     757             : // static
     758     1044701 : FieldAccess AccessBuilder::ForContextSlot(size_t index) {
     759     1044701 :   int offset = Context::kHeaderSize + static_cast<int>(index) * kPointerSize;
     760             :   DCHECK_EQ(offset,
     761             :             Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag);
     762             :   FieldAccess access = {kTaggedBase,      offset,
     763             :                         Handle<Name>(),   MaybeHandle<Map>(),
     764             :                         Type::Any(),      MachineType::AnyTagged(),
     765     2089402 :                         kFullWriteBarrier};
     766     1044701 :   return access;
     767             : }
     768             : 
     769             : // static
     770       26782 : FieldAccess AccessBuilder::ForContextExtensionScopeInfo() {
     771             :   FieldAccess access = {
     772             :       kTaggedBase,           ContextExtension::kScopeInfoOffset,
     773             :       Handle<Name>(),        MaybeHandle<Map>(),
     774             :       Type::OtherInternal(), MachineType::AnyTagged(),
     775       53564 :       kFullWriteBarrier};
     776       26782 :   return access;
     777             : }
     778             : 
     779             : // static
     780       26782 : FieldAccess AccessBuilder::ForContextExtensionExtension() {
     781             :   FieldAccess access = {kTaggedBase,      ContextExtension::kExtensionOffset,
     782             :                         Handle<Name>(),   MaybeHandle<Map>(),
     783             :                         Type::Any(),      MachineType::AnyTagged(),
     784       53564 :                         kFullWriteBarrier};
     785       26782 :   return access;
     786             : }
     787             : 
     788             : // static
     789       15861 : ElementAccess AccessBuilder::ForFixedArrayElement() {
     790             :   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
     791       15861 :                           MachineType::AnyTagged(), kFullWriteBarrier};
     792       15861 :   return access;
     793             : }
     794             : 
     795             : // static
     796        2465 : ElementAccess AccessBuilder::ForFixedArrayElement(ElementsKind kind) {
     797             :   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
     798        2465 :                           MachineType::AnyTagged(), kFullWriteBarrier};
     799        2465 :   switch (kind) {
     800             :     case FAST_SMI_ELEMENTS:
     801         831 :       access.type = Type::SignedSmall();
     802         831 :       access.machine_type = MachineType::TaggedSigned();
     803         831 :       access.write_barrier_kind = kNoWriteBarrier;
     804         831 :       break;
     805             :     case FAST_HOLEY_SMI_ELEMENTS:
     806          65 :       access.type = TypeCache::Get().kHoleySmi;
     807          65 :       break;
     808             :     case FAST_ELEMENTS:
     809         942 :       access.type = Type::NonInternal();
     810         942 :       break;
     811             :     case FAST_HOLEY_ELEMENTS:
     812             :       break;
     813             :     case FAST_DOUBLE_ELEMENTS:
     814         609 :       access.type = Type::Number();
     815         609 :       access.write_barrier_kind = kNoWriteBarrier;
     816         609 :       access.machine_type = MachineType::Float64();
     817         609 :       break;
     818             :     case FAST_HOLEY_DOUBLE_ELEMENTS:
     819           0 :       access.type = Type::Number();
     820           0 :       access.write_barrier_kind = kNoWriteBarrier;
     821           0 :       access.machine_type = MachineType::Float64();
     822           0 :       break;
     823             :     default:
     824           0 :       UNREACHABLE();
     825             :       break;
     826             :   }
     827        2465 :   return access;
     828             : }
     829             : 
     830             : // static
     831         562 : ElementAccess AccessBuilder::ForFixedDoubleArrayElement() {
     832             :   ElementAccess access = {kTaggedBase, FixedDoubleArray::kHeaderSize,
     833         562 :                           TypeCache::Get().kFloat64, MachineType::Float64(),
     834        1124 :                           kNoWriteBarrier};
     835         562 :   return access;
     836             : }
     837             : 
     838             : 
     839             : // static
     840        8611 : ElementAccess AccessBuilder::ForTypedArrayElement(ExternalArrayType type,
     841             :                                                   bool is_external) {
     842        8611 :   BaseTaggedness taggedness = is_external ? kUntaggedBase : kTaggedBase;
     843        8611 :   int header_size = is_external ? 0 : FixedTypedArrayBase::kDataOffset;
     844        8611 :   switch (type) {
     845             :     case kExternalInt8Array: {
     846             :       ElementAccess access = {taggedness, header_size, Type::Signed32(),
     847             :                               MachineType::Int8(), kNoWriteBarrier};
     848         693 :       return access;
     849             :     }
     850             :     case kExternalUint8Array:
     851             :     case kExternalUint8ClampedArray: {
     852             :       ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
     853             :                               MachineType::Uint8(), kNoWriteBarrier};
     854        1711 :       return access;
     855             :     }
     856             :     case kExternalInt16Array: {
     857             :       ElementAccess access = {taggedness, header_size, Type::Signed32(),
     858             :                               MachineType::Int16(), kNoWriteBarrier};
     859         524 :       return access;
     860             :     }
     861             :     case kExternalUint16Array: {
     862             :       ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
     863             :                               MachineType::Uint16(), kNoWriteBarrier};
     864         613 :       return access;
     865             :     }
     866             :     case kExternalInt32Array: {
     867             :       ElementAccess access = {taggedness, header_size, Type::Signed32(),
     868             :                               MachineType::Int32(), kNoWriteBarrier};
     869        1842 :       return access;
     870             :     }
     871             :     case kExternalUint32Array: {
     872             :       ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
     873             :                               MachineType::Uint32(), kNoWriteBarrier};
     874         602 :       return access;
     875             :     }
     876             :     case kExternalFloat32Array: {
     877             :       ElementAccess access = {taggedness, header_size, Type::Number(),
     878             :                               MachineType::Float32(), kNoWriteBarrier};
     879        1875 :       return access;
     880             :     }
     881             :     case kExternalFloat64Array: {
     882             :       ElementAccess access = {taggedness, header_size, Type::Number(),
     883             :                               MachineType::Float64(), kNoWriteBarrier};
     884         751 :       return access;
     885             :     }
     886             :   }
     887           0 :   UNREACHABLE();
     888             :   ElementAccess access = {kUntaggedBase, 0, Type::None(), MachineType::None(),
     889             :                           kNoWriteBarrier};
     890             :   return access;
     891             : }
     892             : 
     893             : // static
     894           0 : FieldAccess AccessBuilder::ForHashTableBaseNumberOfElements() {
     895             :   FieldAccess access = {
     896             :       kTaggedBase,
     897             :       FixedArray::OffsetOfElementAt(HashTableBase::kNumberOfElementsIndex),
     898             :       MaybeHandle<Name>(),
     899             :       MaybeHandle<Map>(),
     900             :       Type::SignedSmall(),
     901             :       MachineType::TaggedSigned(),
     902           0 :       kNoWriteBarrier};
     903           0 :   return access;
     904             : }
     905             : 
     906             : // static
     907           0 : FieldAccess AccessBuilder::ForHashTableBaseNumberOfDeletedElement() {
     908             :   FieldAccess access = {
     909             :       kTaggedBase, FixedArray::OffsetOfElementAt(
     910             :                        HashTableBase::kNumberOfDeletedElementsIndex),
     911             :       MaybeHandle<Name>(), MaybeHandle<Map>(), Type::SignedSmall(),
     912           0 :       MachineType::TaggedSigned(), kNoWriteBarrier};
     913           0 :   return access;
     914             : }
     915             : 
     916             : // static
     917           0 : FieldAccess AccessBuilder::ForHashTableBaseCapacity() {
     918             :   FieldAccess access = {
     919             :       kTaggedBase,
     920             :       FixedArray::OffsetOfElementAt(HashTableBase::kCapacityIndex),
     921             :       MaybeHandle<Name>(),
     922             :       MaybeHandle<Map>(),
     923             :       Type::SignedSmall(),
     924             :       MachineType::TaggedSigned(),
     925           0 :       kNoWriteBarrier};
     926           0 :   return access;
     927             : }
     928             : 
     929             : // static
     930           0 : FieldAccess AccessBuilder::ForDictionaryMaxNumberKey() {
     931             :   FieldAccess access = {
     932             :       kTaggedBase,
     933             :       FixedArray::OffsetOfElementAt(NameDictionary::kMaxNumberKeyIndex),
     934             :       MaybeHandle<Name>(),
     935             :       MaybeHandle<Map>(),
     936             :       Type::Any(),
     937             :       MachineType::AnyTagged(),
     938           0 :       kNoWriteBarrier};
     939           0 :   return access;
     940             : }
     941             : 
     942             : // static
     943           0 : FieldAccess AccessBuilder::ForDictionaryNextEnumerationIndex() {
     944             :   FieldAccess access = {
     945             :       kTaggedBase,
     946             :       FixedArray::OffsetOfElementAt(NameDictionary::kNextEnumerationIndexIndex),
     947             :       MaybeHandle<Name>(),
     948             :       MaybeHandle<Map>(),
     949             :       Type::SignedSmall(),
     950             :       MachineType::TaggedSigned(),
     951           0 :       kNoWriteBarrier};
     952           0 :   return access;
     953             : }
     954             : 
     955             : }  // namespace compiler
     956             : }  // namespace internal
     957             : }  // namespace v8

Generated by: LCOV version 1.10