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