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