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/execution/frames.h"
9#include "src/handles/handles-inl.h"
10#include "src/heap/heap.h"
11#include "src/objects/arguments.h"
12#include "src/objects/cell.h"
13#include "src/objects/contexts.h"
14#include "src/objects/heap-number.h"
15#include "src/objects/js-collection.h"
16#include "src/objects/js-generator.h"
17#include "src/objects/objects-inl.h"
18#include "src/objects/ordered-hash-table.h"
19#include "src/objects/source-text-module.h"
20
21namespace v8 {
22namespace internal {
23namespace compiler {
24
25// static
26FieldAccess AccessBuilder::ForExternalIntPtr() {
27  FieldAccess access = {kUntaggedBase,      0,           MaybeHandle<Name>(),
28                        MaybeHandle<Map>(), Type::Any(), MachineType::IntPtr(),
29                        kNoWriteBarrier};
30  return access;
31}
32
33// static
34FieldAccess AccessBuilder::ForMap(WriteBarrierKind write_barrier) {
35  FieldAccess access = {kTaggedBase,           HeapObject::kMapOffset,
36                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
37                        Type::OtherInternal(), MachineType::MapInHeader(),
38                        write_barrier};
39  return access;
40}
41
42// static
43FieldAccess AccessBuilder::ForHeapNumberValue() {
44  FieldAccess access = {
45      kTaggedBase,        HeapNumber::kValueOffset,   MaybeHandle<Name>(),
46      MaybeHandle<Map>(), TypeCache::Get()->kFloat64, MachineType::Float64(),
47      kNoWriteBarrier};
48  return access;
49}
50
51// static
52FieldAccess AccessBuilder::ForBigIntBitfield() {
53  FieldAccess access = {
54      kTaggedBase,        BigInt::kBitfieldOffset,  MaybeHandle<Name>(),
55      MaybeHandle<Map>(), TypeCache::Get()->kInt32, MachineType::Uint32(),
56      kNoWriteBarrier};
57  return access;
58}
59
60// static
61FieldAccess AccessBuilder::ForBigIntOptionalPadding() {
62  DCHECK_EQ(FIELD_SIZE(BigInt::kOptionalPaddingOffset), 4);
63  FieldAccess access = {
64      kTaggedBase,        BigInt::kOptionalPaddingOffset, MaybeHandle<Name>(),
65      MaybeHandle<Map>(), TypeCache::Get()->kInt32,       MachineType::Uint32(),
66      kNoWriteBarrier};
67  return access;
68}
69
70// static
71FieldAccess AccessBuilder::ForBigIntLeastSignificantDigit64() {
72  DCHECK_EQ(BigInt::SizeFor(1) - BigInt::SizeFor(0), 8);
73  FieldAccess access = {
74      kTaggedBase,        BigInt::kDigitsOffset,        MaybeHandle<Name>(),
75      MaybeHandle<Map>(), TypeCache::Get()->kBigUint64, MachineType::Uint64(),
76      kNoWriteBarrier};
77  return access;
78}
79
80// static
81FieldAccess AccessBuilder::ForJSObjectPropertiesOrHash() {
82  FieldAccess access = {kTaggedBase,         JSObject::kPropertiesOrHashOffset,
83                        MaybeHandle<Name>(), MaybeHandle<Map>(),
84                        Type::Any(),         MachineType::AnyTagged(),
85                        kFullWriteBarrier};
86  return access;
87}
88
89// static
90FieldAccess AccessBuilder::ForJSObjectPropertiesOrHashKnownPointer() {
91  FieldAccess access = {kTaggedBase,         JSObject::kPropertiesOrHashOffset,
92                        MaybeHandle<Name>(), MaybeHandle<Map>(),
93                        Type::Any(),         MachineType::TaggedPointer(),
94                        kPointerWriteBarrier};
95  return access;
96}
97
98// static
99FieldAccess AccessBuilder::ForJSObjectElements() {
100  FieldAccess access = {kTaggedBase,         JSObject::kElementsOffset,
101                        MaybeHandle<Name>(), MaybeHandle<Map>(),
102                        Type::Internal(),    MachineType::TaggedPointer(),
103                        kPointerWriteBarrier};
104  return access;
105}
106
107// static
108FieldAccess AccessBuilder::ForJSObjectInObjectProperty(
109    const MapRef& map, int index, MachineType machine_type) {
110  int const offset = map.GetInObjectPropertyOffset(index);
111  FieldAccess access = {kTaggedBase,         offset,
112                        MaybeHandle<Name>(), MaybeHandle<Map>(),
113                        Type::NonInternal(), machine_type,
114                        kFullWriteBarrier};
115  return access;
116}
117
118// static
119FieldAccess AccessBuilder::ForJSObjectOffset(
120    int offset, WriteBarrierKind write_barrier_kind) {
121  FieldAccess access = {kTaggedBase,         offset,
122                        MaybeHandle<Name>(), MaybeHandle<Map>(),
123                        Type::NonInternal(), MachineType::AnyTagged(),
124                        write_barrier_kind};
125  return access;
126}
127
128// static
129FieldAccess AccessBuilder::ForJSCollectionTable() {
130  FieldAccess access = {kTaggedBase,           JSCollection::kTableOffset,
131                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
132                        Type::OtherInternal(), MachineType::TaggedPointer(),
133                        kPointerWriteBarrier};
134  return access;
135}
136
137// static
138FieldAccess AccessBuilder::ForJSCollectionIteratorTable() {
139  FieldAccess access = {
140      kTaggedBase,           JSCollectionIterator::kTableOffset,
141      MaybeHandle<Name>(),   MaybeHandle<Map>(),
142      Type::OtherInternal(), MachineType::TaggedPointer(),
143      kPointerWriteBarrier};
144  return access;
145}
146
147// static
148FieldAccess AccessBuilder::ForJSCollectionIteratorIndex() {
149  FieldAccess access = {kTaggedBase,
150                        JSCollectionIterator::kIndexOffset,
151                        MaybeHandle<Name>(),
152                        MaybeHandle<Map>(),
153                        TypeCache::Get()->kFixedArrayLengthType,
154                        MachineType::TaggedSigned(),
155                        kNoWriteBarrier};
156  return access;
157}
158
159// static
160FieldAccess AccessBuilder::ForJSFunctionPrototypeOrInitialMap() {
161  FieldAccess access = {
162      kTaggedBase,         JSFunction::kPrototypeOrInitialMapOffset,
163      MaybeHandle<Name>(), MaybeHandle<Map>(),
164      Type::Any(),         MachineType::TaggedPointer(),
165      kPointerWriteBarrier};
166  return access;
167}
168
169// static
170FieldAccess AccessBuilder::ForJSFunctionContext() {
171  FieldAccess access = {kTaggedBase,         JSFunction::kContextOffset,
172                        MaybeHandle<Name>(), MaybeHandle<Map>(),
173                        Type::Internal(),    MachineType::TaggedPointer(),
174                        kPointerWriteBarrier};
175  return access;
176}
177
178// static
179FieldAccess AccessBuilder::ForJSFunctionSharedFunctionInfo() {
180  FieldAccess access = {
181      kTaggedBase,           JSFunction::kSharedFunctionInfoOffset,
182      Handle<Name>(),        MaybeHandle<Map>(),
183      Type::OtherInternal(), MachineType::TaggedPointer(),
184      kPointerWriteBarrier};
185  return access;
186}
187
188// static
189FieldAccess AccessBuilder::ForJSFunctionFeedbackCell() {
190  FieldAccess access = {kTaggedBase,         JSFunction::kFeedbackCellOffset,
191                        Handle<Name>(),      MaybeHandle<Map>(),
192                        Type::Internal(),    MachineType::TaggedPointer(),
193                        kPointerWriteBarrier};
194  return access;
195}
196
197// static
198FieldAccess AccessBuilder::ForJSFunctionCode() {
199  FieldAccess access = {kTaggedBase,           JSFunction::kCodeOffset,
200                        Handle<Name>(),        MaybeHandle<Map>(),
201                        Type::OtherInternal(), MachineType::TaggedPointer(),
202                        kPointerWriteBarrier};
203  return access;
204}
205
206// static
207FieldAccess AccessBuilder::ForJSBoundFunctionBoundTargetFunction() {
208  FieldAccess access = {
209      kTaggedBase,         JSBoundFunction::kBoundTargetFunctionOffset,
210      Handle<Name>(),      MaybeHandle<Map>(),
211      Type::Callable(),    MachineType::TaggedPointer(),
212      kPointerWriteBarrier};
213  return access;
214}
215
216// static
217FieldAccess AccessBuilder::ForJSBoundFunctionBoundThis() {
218  FieldAccess access = {kTaggedBase,         JSBoundFunction::kBoundThisOffset,
219                        Handle<Name>(),      MaybeHandle<Map>(),
220                        Type::NonInternal(), MachineType::AnyTagged(),
221                        kFullWriteBarrier};
222  return access;
223}
224
225// static
226FieldAccess AccessBuilder::ForJSBoundFunctionBoundArguments() {
227  FieldAccess access = {
228      kTaggedBase,         JSBoundFunction::kBoundArgumentsOffset,
229      Handle<Name>(),      MaybeHandle<Map>(),
230      Type::Internal(),    MachineType::TaggedPointer(),
231      kPointerWriteBarrier};
232  return access;
233}
234
235// static
236FieldAccess AccessBuilder::ForJSGeneratorObjectContext() {
237  FieldAccess access = {kTaggedBase,         JSGeneratorObject::kContextOffset,
238                        Handle<Name>(),      MaybeHandle<Map>(),
239                        Type::Internal(),    MachineType::TaggedPointer(),
240                        kPointerWriteBarrier};
241  return access;
242}
243
244// static
245FieldAccess AccessBuilder::ForJSGeneratorObjectFunction() {
246  FieldAccess access = {kTaggedBase,
247                        JSGeneratorObject::kFunctionOffset,
248                        Handle<Name>(),
249                        MaybeHandle<Map>(),
250                        Type::CallableFunction(),
251                        MachineType::TaggedPointer(),
252                        kPointerWriteBarrier};
253  return access;
254}
255
256// static
257FieldAccess AccessBuilder::ForJSGeneratorObjectReceiver() {
258  FieldAccess access = {kTaggedBase,         JSGeneratorObject::kReceiverOffset,
259                        Handle<Name>(),      MaybeHandle<Map>(),
260                        Type::Internal(),    MachineType::TaggedPointer(),
261                        kPointerWriteBarrier};
262  return access;
263}
264
265// static
266FieldAccess AccessBuilder::ForJSGeneratorObjectContinuation() {
267  FieldAccess access = {
268      kTaggedBase,         JSGeneratorObject::kContinuationOffset,
269      Handle<Name>(),      MaybeHandle<Map>(),
270      Type::SignedSmall(), MachineType::TaggedSigned(),
271      kNoWriteBarrier};
272  return access;
273}
274
275// static
276FieldAccess AccessBuilder::ForJSGeneratorObjectInputOrDebugPos() {
277  FieldAccess access = {
278      kTaggedBase,         JSGeneratorObject::kInputOrDebugPosOffset,
279      Handle<Name>(),      MaybeHandle<Map>(),
280      Type::NonInternal(), MachineType::AnyTagged(),
281      kFullWriteBarrier};
282  return access;
283}
284
285// static
286FieldAccess AccessBuilder::ForJSGeneratorObjectParametersAndRegisters() {
287  FieldAccess access = {
288      kTaggedBase,         JSGeneratorObject::kParametersAndRegistersOffset,
289      Handle<Name>(),      MaybeHandle<Map>(),
290      Type::Internal(),    MachineType::TaggedPointer(),
291      kPointerWriteBarrier};
292  return access;
293}
294
295// static
296FieldAccess AccessBuilder::ForJSGeneratorObjectResumeMode() {
297  FieldAccess access = {
298      kTaggedBase,         JSGeneratorObject::kResumeModeOffset,
299      Handle<Name>(),      MaybeHandle<Map>(),
300      Type::SignedSmall(), MachineType::TaggedSigned(),
301      kNoWriteBarrier};
302  return access;
303}
304
305// static
306FieldAccess AccessBuilder::ForJSAsyncFunctionObjectPromise() {
307  FieldAccess access = {
308      kTaggedBase,         JSAsyncFunctionObject::kPromiseOffset,
309      Handle<Name>(),      MaybeHandle<Map>(),
310      Type::OtherObject(), MachineType::TaggedPointer(),
311      kPointerWriteBarrier};
312  return access;
313}
314
315// static
316FieldAccess AccessBuilder::ForJSAsyncGeneratorObjectQueue() {
317  FieldAccess access = {
318      kTaggedBase,         JSAsyncGeneratorObject::kQueueOffset,
319      Handle<Name>(),      MaybeHandle<Map>(),
320      Type::NonInternal(), MachineType::AnyTagged(),
321      kFullWriteBarrier};
322  return access;
323}
324
325// static
326FieldAccess AccessBuilder::ForJSAsyncGeneratorObjectIsAwaiting() {
327  FieldAccess access = {
328      kTaggedBase,         JSAsyncGeneratorObject::kIsAwaitingOffset,
329      Handle<Name>(),      MaybeHandle<Map>(),
330      Type::SignedSmall(), MachineType::TaggedSigned(),
331      kNoWriteBarrier};
332  return access;
333}
334
335// static
336FieldAccess AccessBuilder::ForJSArrayLength(ElementsKind elements_kind) {
337  TypeCache const* type_cache = TypeCache::Get();
338  FieldAccess access = {kTaggedBase,
339                        JSArray::kLengthOffset,
340                        Handle<Name>(),
341                        MaybeHandle<Map>(),
342                        type_cache->kJSArrayLengthType,
343                        MachineType::AnyTagged(),
344                        kFullWriteBarrier};
345  if (IsDoubleElementsKind(elements_kind)) {
346    access.type = type_cache->kFixedDoubleArrayLengthType;
347    access.machine_type = MachineType::TaggedSigned();
348    access.write_barrier_kind = kNoWriteBarrier;
349  } else if (IsFastElementsKind(elements_kind)) {
350    access.type = type_cache->kFixedArrayLengthType;
351    access.machine_type = MachineType::TaggedSigned();
352    access.write_barrier_kind = kNoWriteBarrier;
353  }
354  return access;
355}
356
357// static
358FieldAccess AccessBuilder::ForJSArrayBufferBitField() {
359  FieldAccess access = {
360      kTaggedBase,        JSArrayBuffer::kBitFieldOffset, MaybeHandle<Name>(),
361      MaybeHandle<Map>(), TypeCache::Get()->kUint8,       MachineType::Uint32(),
362      kNoWriteBarrier};
363  return access;
364}
365
366// static
367FieldAccess AccessBuilder::ForJSArrayBufferViewBuffer() {
368  FieldAccess access = {kTaggedBase,           JSArrayBufferView::kBufferOffset,
369                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
370                        Type::OtherInternal(), MachineType::TaggedPointer(),
371                        kPointerWriteBarrier};
372  return access;
373}
374
375// static
376FieldAccess AccessBuilder::ForJSArrayBufferViewByteLength() {
377  FieldAccess access = {kTaggedBase,
378                        JSArrayBufferView::kByteLengthOffset,
379                        MaybeHandle<Name>(),
380                        MaybeHandle<Map>(),
381                        TypeCache::Get()->kJSArrayBufferViewByteLengthType,
382                        MachineType::UintPtr(),
383                        kNoWriteBarrier};
384  return access;
385}
386
387// static
388FieldAccess AccessBuilder::ForJSArrayBufferViewByteOffset() {
389  FieldAccess access = {kTaggedBase,
390                        JSArrayBufferView::kByteOffsetOffset,
391                        MaybeHandle<Name>(),
392                        MaybeHandle<Map>(),
393                        TypeCache::Get()->kJSArrayBufferViewByteOffsetType,
394                        MachineType::UintPtr(),
395                        kNoWriteBarrier};
396  return access;
397}
398
399// static
400FieldAccess AccessBuilder::ForJSTypedArrayLength() {
401  FieldAccess access = {kTaggedBase,
402                        JSTypedArray::kLengthOffset,
403                        MaybeHandle<Name>(),
404                        MaybeHandle<Map>(),
405                        TypeCache::Get()->kJSTypedArrayLengthType,
406                        MachineType::UintPtr(),
407                        kNoWriteBarrier};
408  return access;
409}
410
411// static
412FieldAccess AccessBuilder::ForJSTypedArrayBasePointer() {
413  FieldAccess access = {kTaggedBase,           JSTypedArray::kBasePointerOffset,
414                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
415                        Type::OtherInternal(), MachineType::AnyTagged(),
416                        kFullWriteBarrier};
417  return access;
418}
419
420// static
421FieldAccess AccessBuilder::ForJSTypedArrayExternalPointer() {
422  FieldAccess access = {
423      kTaggedBase,
424      JSTypedArray::kExternalPointerOffset,
425      MaybeHandle<Name>(),
426      MaybeHandle<Map>(),
427#ifdef V8_SANDBOXED_POINTERS
428      Type::SandboxedPointer(),
429      MachineType::SandboxedPointer(),
430#else
431      Type::ExternalPointer(),
432      MachineType::Pointer(),
433#endif
434      kNoWriteBarrier,
435      ConstFieldInfo::None(),
436      false,
437  };
438  return access;
439}
440
441// static
442FieldAccess AccessBuilder::ForJSDataViewDataPointer() {
443  FieldAccess access = {
444      kTaggedBase,
445      JSDataView::kDataPointerOffset,
446      MaybeHandle<Name>(),
447      MaybeHandle<Map>(),
448#ifdef V8_SANDBOXED_POINTERS
449      Type::SandboxedPointer(),
450      MachineType::SandboxedPointer(),
451#else
452      Type::ExternalPointer(),
453      MachineType::Pointer(),
454#endif
455      kNoWriteBarrier,
456      ConstFieldInfo::None(),
457      false,
458  };
459  return access;
460}
461
462// static
463FieldAccess AccessBuilder::ForJSDateValue() {
464  FieldAccess access = {kTaggedBase,
465                        JSDate::kValueOffset,
466                        MaybeHandle<Name>(),
467                        MaybeHandle<Map>(),
468                        TypeCache::Get()->kJSDateValueType,
469                        MachineType::AnyTagged(),
470                        kFullWriteBarrier};
471  return access;
472}
473
474// static
475FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) {
476  FieldAccess access = {
477      kTaggedBase,         JSDate::kValueOffset + index * kTaggedSize,
478      MaybeHandle<Name>(), MaybeHandle<Map>(),
479      Type::Number(),      MachineType::AnyTagged(),
480      kFullWriteBarrier};
481  return access;
482}
483
484// static
485FieldAccess AccessBuilder::ForJSIteratorResultDone() {
486  FieldAccess access = {kTaggedBase,         JSIteratorResult::kDoneOffset,
487                        MaybeHandle<Name>(), MaybeHandle<Map>(),
488                        Type::NonInternal(), MachineType::AnyTagged(),
489                        kFullWriteBarrier};
490  return access;
491}
492
493// static
494FieldAccess AccessBuilder::ForJSIteratorResultValue() {
495  FieldAccess access = {kTaggedBase,         JSIteratorResult::kValueOffset,
496                        MaybeHandle<Name>(), MaybeHandle<Map>(),
497                        Type::NonInternal(), MachineType::AnyTagged(),
498                        kFullWriteBarrier};
499  return access;
500}
501
502// static
503FieldAccess AccessBuilder::ForJSRegExpData() {
504  FieldAccess access = {kTaggedBase,         JSRegExp::kDataOffset,
505                        MaybeHandle<Name>(), MaybeHandle<Map>(),
506                        Type::NonInternal(), MachineType::AnyTagged(),
507                        kFullWriteBarrier};
508  return access;
509}
510
511// static
512FieldAccess AccessBuilder::ForJSRegExpFlags() {
513  FieldAccess access = {kTaggedBase,         JSRegExp::kFlagsOffset,
514                        MaybeHandle<Name>(), MaybeHandle<Map>(),
515                        Type::NonInternal(), MachineType::AnyTagged(),
516                        kFullWriteBarrier};
517  return access;
518}
519
520// static
521FieldAccess AccessBuilder::ForJSRegExpLastIndex() {
522  FieldAccess access = {kTaggedBase,         JSRegExp::kLastIndexOffset,
523                        MaybeHandle<Name>(), MaybeHandle<Map>(),
524                        Type::NonInternal(), MachineType::AnyTagged(),
525                        kFullWriteBarrier};
526  return access;
527}
528
529// static
530FieldAccess AccessBuilder::ForJSRegExpSource() {
531  FieldAccess access = {kTaggedBase,         JSRegExp::kSourceOffset,
532                        MaybeHandle<Name>(), MaybeHandle<Map>(),
533                        Type::NonInternal(), MachineType::AnyTagged(),
534                        kFullWriteBarrier};
535  return access;
536}
537
538// static
539FieldAccess AccessBuilder::ForFixedArrayLength() {
540  FieldAccess access = {kTaggedBase,
541                        FixedArray::kLengthOffset,
542                        MaybeHandle<Name>(),
543                        MaybeHandle<Map>(),
544                        TypeCache::Get()->kFixedArrayLengthType,
545                        MachineType::TaggedSigned(),
546                        kNoWriteBarrier};
547  return access;
548}
549
550// static
551FieldAccess AccessBuilder::ForWeakFixedArrayLength() {
552  FieldAccess access = {kTaggedBase,
553                        WeakFixedArray::kLengthOffset,
554                        MaybeHandle<Name>(),
555                        MaybeHandle<Map>(),
556                        TypeCache::Get()->kWeakFixedArrayLengthType,
557                        MachineType::TaggedSigned(),
558                        kNoWriteBarrier};
559  return access;
560}
561
562// static
563FieldAccess AccessBuilder::ForSloppyArgumentsElementsContext() {
564  FieldAccess access = {
565      kTaggedBase,         SloppyArgumentsElements::kContextOffset,
566      MaybeHandle<Name>(), MaybeHandle<Map>(),
567      Type::Any(),         MachineType::TaggedPointer(),
568      kPointerWriteBarrier};
569  return access;
570}
571
572// static
573FieldAccess AccessBuilder::ForSloppyArgumentsElementsArguments() {
574  FieldAccess access = {
575      kTaggedBase,         SloppyArgumentsElements::kArgumentsOffset,
576      MaybeHandle<Name>(), MaybeHandle<Map>(),
577      Type::Any(),         MachineType::TaggedPointer(),
578      kPointerWriteBarrier};
579  return access;
580}
581
582// static
583FieldAccess AccessBuilder::ForPropertyArrayLengthAndHash() {
584  FieldAccess access = {
585      kTaggedBase,         PropertyArray::kLengthAndHashOffset,
586      MaybeHandle<Name>(), MaybeHandle<Map>(),
587      Type::SignedSmall(), MachineType::TaggedSigned(),
588      kNoWriteBarrier};
589  return access;
590}
591
592// static
593FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
594  FieldAccess access = {
595      kTaggedBase,           DescriptorArray::kEnumCacheOffset,
596      Handle<Name>(),        MaybeHandle<Map>(),
597      Type::OtherInternal(), MachineType::TaggedPointer(),
598      kPointerWriteBarrier};
599  return access;
600}
601
602// static
603FieldAccess AccessBuilder::ForMapBitField() {
604  FieldAccess access = {
605      kTaggedBase,        Map::kBitFieldOffset,     Handle<Name>(),
606      MaybeHandle<Map>(), TypeCache::Get()->kUint8, MachineType::Uint8(),
607      kNoWriteBarrier};
608  return access;
609}
610
611// static
612FieldAccess AccessBuilder::ForMapBitField2() {
613  FieldAccess access = {
614      kTaggedBase,        Map::kBitField2Offset,    Handle<Name>(),
615      MaybeHandle<Map>(), TypeCache::Get()->kUint8, MachineType::Uint8(),
616      kNoWriteBarrier};
617  return access;
618}
619
620// static
621FieldAccess AccessBuilder::ForMapBitField3() {
622  FieldAccess access = {
623      kTaggedBase,        Map::kBitField3Offset,    Handle<Name>(),
624      MaybeHandle<Map>(), TypeCache::Get()->kInt32, MachineType::Int32(),
625      kNoWriteBarrier};
626  return access;
627}
628
629// static
630FieldAccess AccessBuilder::ForMapDescriptors() {
631  FieldAccess access = {kTaggedBase,           Map::kInstanceDescriptorsOffset,
632                        Handle<Name>(),        MaybeHandle<Map>(),
633                        Type::OtherInternal(), MachineType::TaggedPointer(),
634                        kPointerWriteBarrier};
635  return access;
636}
637
638// static
639FieldAccess AccessBuilder::ForMapInstanceType() {
640  FieldAccess access = {
641      kTaggedBase,        Map::kInstanceTypeOffset,  Handle<Name>(),
642      MaybeHandle<Map>(), TypeCache::Get()->kUint16, MachineType::Uint16(),
643      kNoWriteBarrier};
644  return access;
645}
646
647// static
648FieldAccess AccessBuilder::ForMapPrototype() {
649  FieldAccess access = {kTaggedBase,         Map::kPrototypeOffset,
650                        Handle<Name>(),      MaybeHandle<Map>(),
651                        Type::Any(),         MachineType::TaggedPointer(),
652                        kPointerWriteBarrier};
653  return access;
654}
655
656// static
657FieldAccess AccessBuilder::ForMapNativeContext() {
658  FieldAccess access = {
659      kTaggedBase,         Map::kConstructorOrBackPointerOrNativeContextOffset,
660      Handle<Name>(),      MaybeHandle<Map>(),
661      Type::Any(),         MachineType::TaggedPointer(),
662      kPointerWriteBarrier};
663  return access;
664}
665
666// static
667FieldAccess AccessBuilder::ForModuleRegularExports() {
668  FieldAccess access = {
669      kTaggedBase,           SourceTextModule::kRegularExportsOffset,
670      Handle<Name>(),        MaybeHandle<Map>(),
671      Type::OtherInternal(), MachineType::TaggedPointer(),
672      kPointerWriteBarrier};
673  return access;
674}
675
676// static
677FieldAccess AccessBuilder::ForModuleRegularImports() {
678  FieldAccess access = {
679      kTaggedBase,           SourceTextModule::kRegularImportsOffset,
680      Handle<Name>(),        MaybeHandle<Map>(),
681      Type::OtherInternal(), MachineType::TaggedPointer(),
682      kPointerWriteBarrier};
683  return access;
684}
685
686// static
687FieldAccess AccessBuilder::ForNameRawHashField() {
688  FieldAccess access = {kTaggedBase,        Name::kRawHashFieldOffset,
689                        Handle<Name>(),     MaybeHandle<Map>(),
690                        Type::Unsigned32(), MachineType::Uint32(),
691                        kNoWriteBarrier};
692  return access;
693}
694
695// static
696FieldAccess AccessBuilder::ForStringLength() {
697  FieldAccess access = {kTaggedBase,
698                        String::kLengthOffset,
699                        Handle<Name>(),
700                        MaybeHandle<Map>(),
701                        TypeCache::Get()->kStringLengthType,
702                        MachineType::Uint32(),
703                        kNoWriteBarrier};
704  return access;
705}
706
707// static
708FieldAccess AccessBuilder::ForConsStringFirst() {
709  FieldAccess access = {kTaggedBase,         ConsString::kFirstOffset,
710                        Handle<Name>(),      MaybeHandle<Map>(),
711                        Type::String(),      MachineType::TaggedPointer(),
712                        kPointerWriteBarrier};
713  return access;
714}
715
716// static
717FieldAccess AccessBuilder::ForConsStringSecond() {
718  FieldAccess access = {kTaggedBase,         ConsString::kSecondOffset,
719                        Handle<Name>(),      MaybeHandle<Map>(),
720                        Type::String(),      MachineType::TaggedPointer(),
721                        kPointerWriteBarrier};
722  return access;
723}
724
725// static
726FieldAccess AccessBuilder::ForThinStringActual() {
727  FieldAccess access = {kTaggedBase,         ThinString::kActualOffset,
728                        Handle<Name>(),      MaybeHandle<Map>(),
729                        Type::String(),      MachineType::TaggedPointer(),
730                        kPointerWriteBarrier};
731  return access;
732}
733
734// static
735FieldAccess AccessBuilder::ForSlicedStringOffset() {
736  FieldAccess access = {kTaggedBase,         SlicedString::kOffsetOffset,
737                        Handle<Name>(),      MaybeHandle<Map>(),
738                        Type::SignedSmall(), MachineType::TaggedSigned(),
739                        kNoWriteBarrier};
740  return access;
741}
742
743// static
744FieldAccess AccessBuilder::ForSlicedStringParent() {
745  FieldAccess access = {kTaggedBase,         SlicedString::kParentOffset,
746                        Handle<Name>(),      MaybeHandle<Map>(),
747                        Type::String(),      MachineType::TaggedPointer(),
748                        kPointerWriteBarrier};
749  return access;
750}
751
752// static
753FieldAccess AccessBuilder::ForExternalStringResourceData() {
754  FieldAccess access = {
755      kTaggedBase,
756      ExternalString::kResourceDataOffset,
757      Handle<Name>(),
758      MaybeHandle<Map>(),
759      Type::ExternalPointer(),
760      MachineType::Pointer(),
761      kNoWriteBarrier,
762      ConstFieldInfo::None(),
763      false,
764#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
765      kExternalStringResourceDataTag,
766#endif
767  };
768  return access;
769}
770
771// static
772ElementAccess AccessBuilder::ForSeqOneByteStringCharacter() {
773  ElementAccess access = {kTaggedBase, SeqOneByteString::kHeaderSize,
774                          TypeCache::Get()->kUint8, MachineType::Uint8(),
775                          kNoWriteBarrier};
776  return access;
777}
778
779// static
780ElementAccess AccessBuilder::ForSeqTwoByteStringCharacter() {
781  ElementAccess access = {kTaggedBase, SeqTwoByteString::kHeaderSize,
782                          TypeCache::Get()->kUint16, MachineType::Uint16(),
783                          kNoWriteBarrier};
784  return access;
785}
786
787// static
788FieldAccess AccessBuilder::ForJSGlobalProxyNativeContext() {
789  FieldAccess access = {
790      kTaggedBase,         JSGlobalProxy::kNativeContextOffset,
791      Handle<Name>(),      MaybeHandle<Map>(),
792      Type::Internal(),    MachineType::TaggedPointer(),
793      kPointerWriteBarrier};
794  return access;
795}
796
797// static
798FieldAccess AccessBuilder::ForJSArrayIteratorIteratedObject() {
799  FieldAccess access = {
800      kTaggedBase,         JSArrayIterator::kIteratedObjectOffset,
801      Handle<Name>(),      MaybeHandle<Map>(),
802      Type::Receiver(),    MachineType::TaggedPointer(),
803      kPointerWriteBarrier};
804  return access;
805}
806
807// static
808FieldAccess AccessBuilder::ForJSArrayIteratorNextIndex() {
809  // In generic case, cap to 2^53-1 (per ToLength() in spec) via
810  // kPositiveSafeInteger
811  FieldAccess access = {kTaggedBase,
812                        JSArrayIterator::kNextIndexOffset,
813                        Handle<Name>(),
814                        MaybeHandle<Map>(),
815                        TypeCache::Get()->kPositiveSafeInteger,
816                        MachineType::AnyTagged(),
817                        kFullWriteBarrier};
818  return access;
819}
820
821// static
822FieldAccess AccessBuilder::ForJSArrayIteratorKind() {
823  FieldAccess access = {kTaggedBase,
824                        JSArrayIterator::kKindOffset,
825                        Handle<Name>(),
826                        MaybeHandle<Map>(),
827                        TypeCache::Get()->kJSArrayIteratorKindType,
828                        MachineType::TaggedSigned(),
829                        kNoWriteBarrier};
830  return access;
831}
832
833// static
834FieldAccess AccessBuilder::ForJSStringIteratorString() {
835  FieldAccess access = {kTaggedBase,         JSStringIterator::kStringOffset,
836                        Handle<Name>(),      MaybeHandle<Map>(),
837                        Type::String(),      MachineType::TaggedPointer(),
838                        kPointerWriteBarrier};
839  return access;
840}
841
842// static
843FieldAccess AccessBuilder::ForJSStringIteratorIndex() {
844  FieldAccess access = {kTaggedBase,
845                        JSStringIterator::kIndexOffset,
846                        Handle<Name>(),
847                        MaybeHandle<Map>(),
848                        TypeCache::Get()->kStringLengthType,
849                        MachineType::TaggedSigned(),
850                        kNoWriteBarrier};
851  return access;
852}
853
854// static
855FieldAccess AccessBuilder::ForArgumentsLength() {
856  constexpr int offset = JSStrictArgumentsObject::kLengthOffset;
857  STATIC_ASSERT(offset == JSSloppyArgumentsObject::kLengthOffset);
858  FieldAccess access = {kTaggedBase,         offset,
859                        Handle<Name>(),      MaybeHandle<Map>(),
860                        Type::NonInternal(), MachineType::AnyTagged(),
861                        kFullWriteBarrier};
862  return access;
863}
864
865// static
866FieldAccess AccessBuilder::ForArgumentsCallee() {
867  FieldAccess access = {
868      kTaggedBase,         JSSloppyArgumentsObject::kCalleeOffset,
869      Handle<Name>(),      MaybeHandle<Map>(),
870      Type::NonInternal(), MachineType::AnyTagged(),
871      kFullWriteBarrier};
872  return access;
873}
874
875// static
876FieldAccess AccessBuilder::ForFixedArraySlot(
877    size_t index, WriteBarrierKind write_barrier_kind) {
878  int offset = FixedArray::OffsetOfElementAt(static_cast<int>(index));
879  FieldAccess access = {kTaggedBase,       offset,
880                        Handle<Name>(),    MaybeHandle<Map>(),
881                        Type::Any(),       MachineType::AnyTagged(),
882                        write_barrier_kind};
883  return access;
884}
885
886// static
887FieldAccess AccessBuilder::ForFeedbackVectorSlot(int index) {
888  int offset = FeedbackVector::OffsetOfElementAt(index);
889  FieldAccess access = {kTaggedBase,      offset,
890                        Handle<Name>(),   MaybeHandle<Map>(),
891                        Type::Any(),      MachineType::AnyTagged(),
892                        kFullWriteBarrier};
893  return access;
894}
895
896// static
897FieldAccess AccessBuilder::ForWeakFixedArraySlot(int index) {
898  int offset = WeakFixedArray::OffsetOfElementAt(index);
899  FieldAccess access = {kTaggedBase,      offset,
900                        Handle<Name>(),   MaybeHandle<Map>(),
901                        Type::Any(),      MachineType::AnyTagged(),
902                        kFullWriteBarrier};
903  return access;
904}
905// static
906FieldAccess AccessBuilder::ForCellValue() {
907  FieldAccess access = {kTaggedBase,      Cell::kValueOffset,
908                        Handle<Name>(),   MaybeHandle<Map>(),
909                        Type::Any(),      MachineType::AnyTagged(),
910                        kFullWriteBarrier};
911  return access;
912}
913
914// static
915FieldAccess AccessBuilder::ForScopeInfoFlags() {
916  FieldAccess access = {kTaggedBase,         ScopeInfo::kFlagsOffset,
917                        MaybeHandle<Name>(), MaybeHandle<Map>(),
918                        Type::SignedSmall(), MachineType::TaggedSigned(),
919                        kNoWriteBarrier};
920  return access;
921}
922
923// static
924FieldAccess AccessBuilder::ForContextSlot(size_t index) {
925  int offset = Context::OffsetOfElementAt(static_cast<int>(index));
926  DCHECK_EQ(offset,
927            Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag);
928  FieldAccess access = {kTaggedBase,      offset,
929                        Handle<Name>(),   MaybeHandle<Map>(),
930                        Type::Any(),      MachineType::AnyTagged(),
931                        kFullWriteBarrier};
932  return access;
933}
934
935// static
936FieldAccess AccessBuilder::ForContextSlotKnownPointer(size_t index) {
937  int offset = Context::OffsetOfElementAt(static_cast<int>(index));
938  DCHECK_EQ(offset,
939            Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag);
940  FieldAccess access = {kTaggedBase,         offset,
941                        Handle<Name>(),      MaybeHandle<Map>(),
942                        Type::Any(),         MachineType::TaggedPointer(),
943                        kPointerWriteBarrier};
944  return access;
945}
946
947// static
948ElementAccess AccessBuilder::ForFixedArrayElement() {
949  ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
950                          MachineType::AnyTagged(), kFullWriteBarrier};
951  return access;
952}
953
954// static
955ElementAccess AccessBuilder::ForWeakFixedArrayElement() {
956  ElementAccess const access = {kTaggedBase, WeakFixedArray::kHeaderSize,
957                                Type::Any(), MachineType::AnyTagged(),
958                                kFullWriteBarrier};
959  return access;
960}
961
962// static
963ElementAccess AccessBuilder::ForSloppyArgumentsElementsMappedEntry() {
964  ElementAccess access = {
965      kTaggedBase, SloppyArgumentsElements::kMappedEntriesOffset, Type::Any(),
966      MachineType::AnyTagged(), kFullWriteBarrier};
967  return access;
968}
969
970// statics
971ElementAccess AccessBuilder::ForFixedArrayElement(ElementsKind kind) {
972  ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
973                          MachineType::AnyTagged(), kFullWriteBarrier};
974  switch (kind) {
975    case PACKED_SMI_ELEMENTS:
976      access.type = Type::SignedSmall();
977      access.machine_type = MachineType::TaggedSigned();
978      access.write_barrier_kind = kNoWriteBarrier;
979      break;
980    case HOLEY_SMI_ELEMENTS:
981      access.type = TypeCache::Get()->kHoleySmi;
982      break;
983    case PACKED_ELEMENTS:
984      access.type = Type::NonInternal();
985      break;
986    case HOLEY_ELEMENTS:
987      break;
988    case PACKED_DOUBLE_ELEMENTS:
989      access.type = Type::Number();
990      access.write_barrier_kind = kNoWriteBarrier;
991      access.machine_type = MachineType::Float64();
992      break;
993    case HOLEY_DOUBLE_ELEMENTS:
994      access.type = Type::NumberOrHole();
995      access.write_barrier_kind = kNoWriteBarrier;
996      access.machine_type = MachineType::Float64();
997      break;
998    default:
999      UNREACHABLE();
1000  }
1001  return access;
1002}
1003
1004// static
1005ElementAccess AccessBuilder::ForStackArgument() {
1006  ElementAccess access = {
1007      kUntaggedBase,
1008      CommonFrameConstants::kFixedFrameSizeAboveFp - kSystemPointerSize,
1009      Type::NonInternal(), MachineType::Pointer(),
1010      WriteBarrierKind::kNoWriteBarrier};
1011  return access;
1012}
1013
1014// static
1015ElementAccess AccessBuilder::ForFixedDoubleArrayElement() {
1016  ElementAccess access = {kTaggedBase, FixedDoubleArray::kHeaderSize,
1017                          TypeCache::Get()->kFloat64, MachineType::Float64(),
1018                          kNoWriteBarrier};
1019  return access;
1020}
1021
1022// static
1023FieldAccess AccessBuilder::ForEnumCacheKeys() {
1024  FieldAccess access = {kTaggedBase,           EnumCache::kKeysOffset,
1025                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
1026                        Type::OtherInternal(), MachineType::TaggedPointer(),
1027                        kPointerWriteBarrier};
1028  return access;
1029}
1030
1031// static
1032FieldAccess AccessBuilder::ForEnumCacheIndices() {
1033  FieldAccess access = {kTaggedBase,           EnumCache::kIndicesOffset,
1034                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
1035                        Type::OtherInternal(), MachineType::TaggedPointer(),
1036                        kPointerWriteBarrier};
1037  return access;
1038}
1039
1040// static
1041ElementAccess AccessBuilder::ForTypedArrayElement(ExternalArrayType type,
1042                                                  bool is_external) {
1043  BaseTaggedness taggedness = is_external ? kUntaggedBase : kTaggedBase;
1044  int header_size = is_external ? 0 : ByteArray::kHeaderSize;
1045  switch (type) {
1046    case kExternalInt8Array: {
1047      ElementAccess access = {taggedness, header_size, Type::Signed32(),
1048                              MachineType::Int8(), kNoWriteBarrier};
1049      return access;
1050    }
1051    case kExternalUint8Array:
1052    case kExternalUint8ClampedArray: {
1053      ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
1054                              MachineType::Uint8(), kNoWriteBarrier};
1055      return access;
1056    }
1057    case kExternalInt16Array: {
1058      ElementAccess access = {taggedness, header_size, Type::Signed32(),
1059                              MachineType::Int16(), kNoWriteBarrier};
1060      return access;
1061    }
1062    case kExternalUint16Array: {
1063      ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
1064                              MachineType::Uint16(), kNoWriteBarrier};
1065      return access;
1066    }
1067    case kExternalInt32Array: {
1068      ElementAccess access = {taggedness, header_size, Type::Signed32(),
1069                              MachineType::Int32(), kNoWriteBarrier};
1070      return access;
1071    }
1072    case kExternalUint32Array: {
1073      ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
1074                              MachineType::Uint32(), kNoWriteBarrier};
1075      return access;
1076    }
1077    case kExternalFloat32Array: {
1078      ElementAccess access = {taggedness, header_size, Type::Number(),
1079                              MachineType::Float32(), kNoWriteBarrier};
1080      return access;
1081    }
1082    case kExternalFloat64Array: {
1083      ElementAccess access = {taggedness, header_size, Type::Number(),
1084                              MachineType::Float64(), kNoWriteBarrier};
1085      return access;
1086    }
1087    case kExternalBigInt64Array:
1088    case kExternalBigUint64Array:
1089      // TODO(neis/jkummerow): Define appropriate types.
1090      UNIMPLEMENTED();
1091  }
1092  UNREACHABLE();
1093}
1094
1095// static
1096FieldAccess AccessBuilder::ForHashTableBaseNumberOfElements() {
1097  FieldAccess access = {
1098      kTaggedBase,
1099      FixedArray::OffsetOfElementAt(HashTableBase::kNumberOfElementsIndex),
1100      MaybeHandle<Name>(),
1101      MaybeHandle<Map>(),
1102      Type::SignedSmall(),
1103      MachineType::TaggedSigned(),
1104      kNoWriteBarrier};
1105  return access;
1106}
1107
1108// static
1109FieldAccess AccessBuilder::ForHashTableBaseNumberOfDeletedElement() {
1110  FieldAccess access = {kTaggedBase,
1111                        FixedArray::OffsetOfElementAt(
1112                            HashTableBase::kNumberOfDeletedElementsIndex),
1113                        MaybeHandle<Name>(),
1114                        MaybeHandle<Map>(),
1115                        Type::SignedSmall(),
1116                        MachineType::TaggedSigned(),
1117                        kNoWriteBarrier};
1118  return access;
1119}
1120
1121// static
1122FieldAccess AccessBuilder::ForHashTableBaseCapacity() {
1123  FieldAccess access = {
1124      kTaggedBase,
1125      FixedArray::OffsetOfElementAt(HashTableBase::kCapacityIndex),
1126      MaybeHandle<Name>(),
1127      MaybeHandle<Map>(),
1128      Type::SignedSmall(),
1129      MachineType::TaggedSigned(),
1130      kNoWriteBarrier};
1131  return access;
1132}
1133
1134// static
1135FieldAccess AccessBuilder::ForOrderedHashMapOrSetNextTable() {
1136  // TODO(turbofan): This will be redundant with the HashTableBase
1137  // methods above once the hash table unification is done.
1138  STATIC_ASSERT(OrderedHashMap::NextTableOffset() ==
1139                OrderedHashSet::NextTableOffset());
1140  FieldAccess const access = {
1141      kTaggedBase,         OrderedHashMap::NextTableOffset(),
1142      MaybeHandle<Name>(), MaybeHandle<Map>(),
1143      Type::Any(),         MachineType::AnyTagged(),
1144      kFullWriteBarrier};
1145  return access;
1146}
1147
1148// static
1149FieldAccess AccessBuilder::ForOrderedHashMapOrSetNumberOfBuckets() {
1150  // TODO(turbofan): This will be redundant with the HashTableBase
1151  // methods above once the hash table unification is done.
1152  STATIC_ASSERT(OrderedHashMap::NumberOfBucketsOffset() ==
1153                OrderedHashSet::NumberOfBucketsOffset());
1154  FieldAccess const access = {kTaggedBase,
1155                              OrderedHashMap::NumberOfBucketsOffset(),
1156                              MaybeHandle<Name>(),
1157                              MaybeHandle<Map>(),
1158                              TypeCache::Get()->kFixedArrayLengthType,
1159                              MachineType::TaggedSigned(),
1160                              kNoWriteBarrier};
1161  return access;
1162}
1163
1164// static
1165FieldAccess AccessBuilder::ForOrderedHashMapOrSetNumberOfDeletedElements() {
1166  // TODO(turbofan): This will be redundant with the HashTableBase
1167  // methods above once the hash table unification is done.
1168  STATIC_ASSERT(OrderedHashMap::NumberOfDeletedElementsOffset() ==
1169                OrderedHashSet::NumberOfDeletedElementsOffset());
1170  FieldAccess const access = {kTaggedBase,
1171                              OrderedHashMap::NumberOfDeletedElementsOffset(),
1172                              MaybeHandle<Name>(),
1173                              MaybeHandle<Map>(),
1174                              TypeCache::Get()->kFixedArrayLengthType,
1175                              MachineType::TaggedSigned(),
1176                              kNoWriteBarrier};
1177  return access;
1178}
1179
1180// static
1181FieldAccess AccessBuilder::ForOrderedHashMapOrSetNumberOfElements() {
1182  // TODO(turbofan): This will be redundant with the HashTableBase
1183  // methods above once the hash table unification is done.
1184  STATIC_ASSERT(OrderedHashMap::NumberOfElementsOffset() ==
1185                OrderedHashSet::NumberOfElementsOffset());
1186  FieldAccess const access = {kTaggedBase,
1187                              OrderedHashMap::NumberOfElementsOffset(),
1188                              MaybeHandle<Name>(),
1189                              MaybeHandle<Map>(),
1190                              TypeCache::Get()->kFixedArrayLengthType,
1191                              MachineType::TaggedSigned(),
1192                              kNoWriteBarrier};
1193  return access;
1194}
1195
1196// static
1197ElementAccess AccessBuilder::ForOrderedHashMapEntryValue() {
1198  ElementAccess const access = {kTaggedBase,
1199                                OrderedHashMap::HashTableStartOffset() +
1200                                    OrderedHashMap::kValueOffset * kTaggedSize,
1201                                Type::Any(), MachineType::AnyTagged(),
1202                                kFullWriteBarrier};
1203  return access;
1204}
1205
1206// static
1207FieldAccess AccessBuilder::ForDictionaryNextEnumerationIndex() {
1208  FieldAccess access = {
1209      kTaggedBase,
1210      FixedArray::OffsetOfElementAt(NameDictionary::kNextEnumerationIndexIndex),
1211      MaybeHandle<Name>(),
1212      MaybeHandle<Map>(),
1213      Type::SignedSmall(),
1214      MachineType::TaggedSigned(),
1215      kNoWriteBarrier};
1216  return access;
1217}
1218
1219// static
1220FieldAccess AccessBuilder::ForDictionaryObjectHashIndex() {
1221  FieldAccess access = {
1222      kTaggedBase,
1223      FixedArray::OffsetOfElementAt(NameDictionary::kObjectHashIndex),
1224      MaybeHandle<Name>(),
1225      MaybeHandle<Map>(),
1226      Type::SignedSmall(),
1227      MachineType::TaggedSigned(),
1228      kNoWriteBarrier};
1229  return access;
1230}
1231
1232// static
1233FieldAccess AccessBuilder::ForFeedbackCellInterruptBudget() {
1234  FieldAccess access = {kTaggedBase,
1235                        FeedbackCell::kInterruptBudgetOffset,
1236                        Handle<Name>(),
1237                        MaybeHandle<Map>(),
1238                        TypeCache::Get()->kInt32,
1239                        MachineType::Int32(),
1240                        kNoWriteBarrier};
1241  return access;
1242}
1243
1244// static
1245FieldAccess AccessBuilder::ForFeedbackVectorInvocationCount() {
1246  FieldAccess access = {kTaggedBase,
1247                        FeedbackVector::kInvocationCountOffset,
1248                        Handle<Name>(),
1249                        MaybeHandle<Map>(),
1250                        TypeCache::Get()->kInt32,
1251                        MachineType::Int32(),
1252                        kNoWriteBarrier};
1253  return access;
1254}
1255
1256// static
1257FieldAccess AccessBuilder::ForFeedbackVectorFlags() {
1258  FieldAccess access = {
1259      kTaggedBase,        FeedbackVector::kFlagsOffset, Handle<Name>(),
1260      MaybeHandle<Map>(), TypeCache::Get()->kUint32,    MachineType::Uint32(),
1261      kNoWriteBarrier};
1262  return access;
1263}
1264
1265// static
1266FieldAccess AccessBuilder::ForFeedbackVectorClosureFeedbackCellArray() {
1267  FieldAccess access = {
1268      kTaggedBase,      FeedbackVector::kClosureFeedbackCellArrayOffset,
1269      Handle<Name>(),   MaybeHandle<Map>(),
1270      Type::Any(),      MachineType::TaggedPointer(),
1271      kFullWriteBarrier};
1272  return access;
1273}
1274
1275}  // namespace compiler
1276}  // namespace internal
1277}  // namespace v8
1278