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