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