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