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