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