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