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