access-builder.cc 39.9 KB
Newer Older
1 2 3 4 5
// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/compiler/access-builder.h"
6

7
#include "src/compiler/type-cache.h"
8
#include "src/execution/frames.h"
9
#include "src/handles/handles-inl.h"
10
#include "src/heap/heap.h"
11
#include "src/objects/arguments.h"
12
#include "src/objects/cell.h"
13
#include "src/objects/contexts.h"
14
#include "src/objects/heap-number.h"
15
#include "src/objects/js-collection.h"
16
#include "src/objects/js-generator.h"
17
#include "src/objects/objects-inl.h"
18
#include "src/objects/ordered-hash-table.h"
19
#include "src/objects/source-text-module.h"
20 21 22 23 24

namespace v8 {
namespace internal {
namespace compiler {

25
// static
26 27 28
FieldAccess AccessBuilder::ForExternalIntPtr() {
  FieldAccess access = {kUntaggedBase,      0,           MaybeHandle<Name>(),
                        MaybeHandle<Map>(), Type::Any(), MachineType::IntPtr(),
29
                        kNoWriteBarrier};
30 31 32
  return access;
}

33 34
// static
FieldAccess AccessBuilder::ForMap() {
35 36 37 38
  FieldAccess access = {kTaggedBase,           HeapObject::kMapOffset,
                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::TaggedPointer(),
                        kMapWriteBarrier};
39
  return access;
40 41
}

42 43
// static
FieldAccess AccessBuilder::ForHeapNumberValue() {
44
  FieldAccess access = {
45 46
      kTaggedBase,        HeapNumber::kValueOffset,   MaybeHandle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kFloat64, MachineType::Float64(),
47
      kNoWriteBarrier};
48 49 50
  return access;
}

51 52 53
// static
FieldAccess AccessBuilder::ForBigIntBitfield() {
  FieldAccess access = {
54 55
      kTaggedBase,        BigInt::kBitfieldOffset,  MaybeHandle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kInt32, MachineType::Uint32(),
56 57 58
      kNoWriteBarrier};
  return access;
}
59

60 61 62 63 64 65 66 67 68 69
// static
FieldAccess AccessBuilder::ForBigIntOptionalPadding() {
  DCHECK_EQ(FIELD_SIZE(BigInt::kOptionalPaddingOffset), 4);
  FieldAccess access = {
      kTaggedBase,        BigInt::kOptionalPaddingOffset, MaybeHandle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kInt32,       MachineType::Uint32(),
      kNoWriteBarrier};
  return access;
}

70 71
// static
FieldAccess AccessBuilder::ForBigIntLeastSignificantDigit64() {
72
  DCHECK_EQ(BigInt::SizeFor(1) - BigInt::SizeFor(0), 8);
73 74 75 76 77 78 79
  FieldAccess access = {
      kTaggedBase,        BigInt::kDigitsOffset,        MaybeHandle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kBigUint64, MachineType::Uint64(),
      kNoWriteBarrier};
  return access;
}

80
// static
81
FieldAccess AccessBuilder::ForJSObjectPropertiesOrHash() {
82 83 84 85
  FieldAccess access = {kTaggedBase,         JSObject::kPropertiesOrHashOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::Any(),         MachineType::AnyTagged(),
                        kFullWriteBarrier,   LoadSensitivity::kCritical};
86
  return access;
87 88
}

89 90
// static
FieldAccess AccessBuilder::ForJSObjectPropertiesOrHashKnownPointer() {
91 92 93 94
  FieldAccess access = {kTaggedBase,          JSObject::kPropertiesOrHashOffset,
                        MaybeHandle<Name>(),  MaybeHandle<Map>(),
                        Type::Any(),          MachineType::TaggedPointer(),
                        kPointerWriteBarrier, LoadSensitivity::kCritical};
95 96 97
  return access;
}

98 99
// static
FieldAccess AccessBuilder::ForJSObjectElements() {
100 101 102 103
  FieldAccess access = {kTaggedBase,          JSObject::kElementsOffset,
                        MaybeHandle<Name>(),  MaybeHandle<Map>(),
                        Type::Internal(),     MachineType::TaggedPointer(),
                        kPointerWriteBarrier, LoadSensitivity::kCritical};
104
  return access;
105 106
}

107
// static
108
FieldAccess AccessBuilder::ForJSObjectInObjectProperty(const MapRef& map,
109
                                                       int index) {
110
  int const offset = map.GetInObjectPropertyOffset(index);
111 112 113 114
  FieldAccess access = {kTaggedBase,         offset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
115 116 117
  return access;
}

118 119 120
// static
FieldAccess AccessBuilder::ForJSObjectOffset(
    int offset, WriteBarrierKind write_barrier_kind) {
121 122 123 124
  FieldAccess access = {kTaggedBase,         offset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        write_barrier_kind};
125 126
  return access;
}
127

128 129
// static
FieldAccess AccessBuilder::ForJSCollectionTable() {
130 131 132 133
  FieldAccess access = {kTaggedBase,           JSCollection::kTableOffset,
                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
134 135 136
  return access;
}

137 138 139 140 141
// static
FieldAccess AccessBuilder::ForJSCollectionIteratorTable() {
  FieldAccess access = {
      kTaggedBase,           JSCollectionIterator::kTableOffset,
      MaybeHandle<Name>(),   MaybeHandle<Map>(),
142
      Type::OtherInternal(), MachineType::TaggedPointer(),
143 144 145 146 147 148 149 150 151 152
      kPointerWriteBarrier};
  return access;
}

// static
FieldAccess AccessBuilder::ForJSCollectionIteratorIndex() {
  FieldAccess access = {kTaggedBase,
                        JSCollectionIterator::kIndexOffset,
                        MaybeHandle<Name>(),
                        MaybeHandle<Map>(),
153
                        TypeCache::Get()->kFixedArrayLengthType,
154
                        MachineType::TaggedSigned(),
155 156 157 158
                        kNoWriteBarrier};
  return access;
}

159 160
// static
FieldAccess AccessBuilder::ForJSFunctionPrototypeOrInitialMap() {
161 162 163
  FieldAccess access = {
      kTaggedBase,         JSFunction::kPrototypeOrInitialMapOffset,
      MaybeHandle<Name>(), MaybeHandle<Map>(),
164
      Type::Any(),         MachineType::TaggedPointer(),
165
      kPointerWriteBarrier};
166 167 168
  return access;
}

169 170
// static
FieldAccess AccessBuilder::ForJSFunctionContext() {
171 172 173 174
  FieldAccess access = {kTaggedBase,         JSFunction::kContextOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::Internal(),    MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
175
  return access;
176 177
}

178 179
// static
FieldAccess AccessBuilder::ForJSFunctionSharedFunctionInfo() {
180 181 182
  FieldAccess access = {
      kTaggedBase,           JSFunction::kSharedFunctionInfoOffset,
      Handle<Name>(),        MaybeHandle<Map>(),
183
      Type::OtherInternal(), MachineType::TaggedPointer(),
184
      kPointerWriteBarrier};
185
  return access;
186 187
}

188
// static
189
FieldAccess AccessBuilder::ForJSFunctionFeedbackCell() {
190 191 192 193
  FieldAccess access = {kTaggedBase,         JSFunction::kFeedbackCellOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::Internal(),    MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
194 195 196 197
  return access;
}

// static
198
FieldAccess AccessBuilder::ForJSFunctionCode() {
199 200 201 202
  FieldAccess access = {kTaggedBase,           JSFunction::kCodeOffset,
                        Handle<Name>(),        MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
203 204 205
  return access;
}

206 207 208 209 210
// static
FieldAccess AccessBuilder::ForJSBoundFunctionBoundTargetFunction() {
  FieldAccess access = {
      kTaggedBase,         JSBoundFunction::kBoundTargetFunctionOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
211
      Type::Callable(),    MachineType::TaggedPointer(),
212 213 214 215 216 217
      kPointerWriteBarrier};
  return access;
}

// static
FieldAccess AccessBuilder::ForJSBoundFunctionBoundThis() {
218 219 220 221
  FieldAccess access = {kTaggedBase,         JSBoundFunction::kBoundThisOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
222 223 224 225 226 227 228 229
  return access;
}

// static
FieldAccess AccessBuilder::ForJSBoundFunctionBoundArguments() {
  FieldAccess access = {
      kTaggedBase,         JSBoundFunction::kBoundArgumentsOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
230
      Type::Internal(),    MachineType::TaggedPointer(),
231 232 233 234
      kPointerWriteBarrier};
  return access;
}

235 236
// static
FieldAccess AccessBuilder::ForJSGeneratorObjectContext() {
237 238 239 240
  FieldAccess access = {kTaggedBase,         JSGeneratorObject::kContextOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::Internal(),    MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
241 242 243
  return access;
}

244 245
// static
FieldAccess AccessBuilder::ForJSGeneratorObjectFunction() {
246 247 248 249
  FieldAccess access = {kTaggedBase,         JSGeneratorObject::kFunctionOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::Function(),    MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
250 251 252 253 254
  return access;
}

// static
FieldAccess AccessBuilder::ForJSGeneratorObjectReceiver() {
255 256 257 258
  FieldAccess access = {kTaggedBase,         JSGeneratorObject::kReceiverOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::Internal(),    MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
259 260 261
  return access;
}

262 263
// static
FieldAccess AccessBuilder::ForJSGeneratorObjectContinuation() {
264 265 266
  FieldAccess access = {
      kTaggedBase,         JSGeneratorObject::kContinuationOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
267
      Type::SignedSmall(), MachineType::TaggedSigned(),
268
      kNoWriteBarrier};
269 270 271
  return access;
}

272
// static
273
FieldAccess AccessBuilder::ForJSGeneratorObjectInputOrDebugPos() {
274 275 276
  FieldAccess access = {
      kTaggedBase,         JSGeneratorObject::kInputOrDebugPosOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
277
      Type::NonInternal(), MachineType::AnyTagged(),
278
      kFullWriteBarrier};
279 280 281
  return access;
}

282
// static
283
FieldAccess AccessBuilder::ForJSGeneratorObjectParametersAndRegisters() {
284
  FieldAccess access = {
285
      kTaggedBase,         JSGeneratorObject::kParametersAndRegistersOffset,
286
      Handle<Name>(),      MaybeHandle<Map>(),
287
      Type::Internal(),    MachineType::TaggedPointer(),
288
      kPointerWriteBarrier};
289 290 291
  return access;
}

292 293
// static
FieldAccess AccessBuilder::ForJSGeneratorObjectResumeMode() {
294 295 296
  FieldAccess access = {
      kTaggedBase,         JSGeneratorObject::kResumeModeOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
297
      Type::SignedSmall(), MachineType::TaggedSigned(),
298
      kNoWriteBarrier};
299 300 301
  return access;
}

302 303 304 305 306
// static
FieldAccess AccessBuilder::ForJSAsyncFunctionObjectPromise() {
  FieldAccess access = {
      kTaggedBase,         JSAsyncFunctionObject::kPromiseOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
307
      Type::OtherObject(), MachineType::TaggedPointer(),
308
      kPointerWriteBarrier};
309 310 311
  return access;
}

312 313 314 315 316
// static
FieldAccess AccessBuilder::ForJSAsyncGeneratorObjectQueue() {
  FieldAccess access = {
      kTaggedBase,         JSAsyncGeneratorObject::kQueueOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
317
      Type::NonInternal(), MachineType::AnyTagged(),
318 319 320 321 322
      kFullWriteBarrier};
  return access;
}

// static
323
FieldAccess AccessBuilder::ForJSAsyncGeneratorObjectIsAwaiting() {
324
  FieldAccess access = {
325
      kTaggedBase,         JSAsyncGeneratorObject::kIsAwaitingOffset,
326
      Handle<Name>(),      MaybeHandle<Map>(),
327
      Type::SignedSmall(), MachineType::TaggedSigned(),
328
      kNoWriteBarrier};
329 330 331
  return access;
}

332 333
// static
FieldAccess AccessBuilder::ForJSArrayLength(ElementsKind elements_kind) {
334
  TypeCache const* type_cache = TypeCache::Get();
335 336 337
  FieldAccess access = {kTaggedBase,
                        JSArray::kLengthOffset,
                        Handle<Name>(),
338
                        MaybeHandle<Map>(),
339
                        type_cache->kJSArrayLengthType,
340
                        MachineType::AnyTagged(),
341
                        kFullWriteBarrier};
342
  if (IsDoubleElementsKind(elements_kind)) {
343
    access.type = type_cache->kFixedDoubleArrayLengthType;
344
    access.machine_type = MachineType::TaggedSigned();
345
    access.write_barrier_kind = kNoWriteBarrier;
346
  } else if (IsFastElementsKind(elements_kind)) {
347
    access.type = type_cache->kFixedArrayLengthType;
348
    access.machine_type = MachineType::TaggedSigned();
349
    access.write_barrier_kind = kNoWriteBarrier;
350 351 352 353
  }
  return access;
}

354 355
// static
FieldAccess AccessBuilder::ForJSArrayBufferBitField() {
356 357
  FieldAccess access = {
      kTaggedBase,        JSArrayBuffer::kBitFieldOffset, MaybeHandle<Name>(),
358
      MaybeHandle<Map>(), TypeCache::Get()->kUint8,       MachineType::Uint32(),
359
      kNoWriteBarrier};
360 361 362 363 364
  return access;
}

// static
FieldAccess AccessBuilder::ForJSArrayBufferViewBuffer() {
365 366 367 368
  FieldAccess access = {kTaggedBase,           JSArrayBufferView::kBufferOffset,
                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
369 370 371
  return access;
}

372 373 374 375 376
// static
FieldAccess AccessBuilder::ForJSArrayBufferViewByteLength() {
  FieldAccess access = {kTaggedBase,
                        JSArrayBufferView::kByteLengthOffset,
                        MaybeHandle<Name>(),
377
                        MaybeHandle<Map>(),
378
                        TypeCache::Get()->kJSArrayBufferViewByteLengthType,
379 380
                        MachineType::UintPtr(),
                        kNoWriteBarrier};
381 382 383 384 385 386 387 388
  return access;
}

// static
FieldAccess AccessBuilder::ForJSArrayBufferViewByteOffset() {
  FieldAccess access = {kTaggedBase,
                        JSArrayBufferView::kByteOffsetOffset,
                        MaybeHandle<Name>(),
389
                        MaybeHandle<Map>(),
390
                        TypeCache::Get()->kJSArrayBufferViewByteOffsetType,
391 392
                        MachineType::UintPtr(),
                        kNoWriteBarrier};
393 394 395 396 397 398 399 400
  return access;
}

// static
FieldAccess AccessBuilder::ForJSTypedArrayLength() {
  FieldAccess access = {kTaggedBase,
                        JSTypedArray::kLengthOffset,
                        MaybeHandle<Name>(),
401
                        MaybeHandle<Map>(),
402
                        TypeCache::Get()->kJSTypedArrayLengthType,
403
                        MachineType::UintPtr(),
404 405
                        kNoWriteBarrier};
  return access;
406 407
}

408 409
// static
FieldAccess AccessBuilder::ForJSTypedArrayBasePointer() {
410 411 412 413
  FieldAccess access = {kTaggedBase,           JSTypedArray::kBasePointerOffset,
                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier,     LoadSensitivity::kCritical};
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
  return access;
}

// static
FieldAccess AccessBuilder::ForJSTypedArrayExternalPointer() {
  FieldAccess access = {kTaggedBase,
                        JSTypedArray::kExternalPointerOffset,
                        MaybeHandle<Name>(),
                        MaybeHandle<Map>(),
                        Type::ExternalPointer(),
                        MachineType::Pointer(),
                        kNoWriteBarrier,
                        LoadSensitivity::kCritical};
  return access;
}

430 431 432 433 434 435 436 437 438
// static
FieldAccess AccessBuilder::ForJSDataViewDataPointer() {
  FieldAccess access = {kTaggedBase,           JSDataView::kDataPointerOffset,
                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::Pointer(),
                        kNoWriteBarrier};
  return access;
}

439 440 441 442 443
// static
FieldAccess AccessBuilder::ForJSDateValue() {
  FieldAccess access = {kTaggedBase,
                        JSDate::kValueOffset,
                        MaybeHandle<Name>(),
444
                        MaybeHandle<Map>(),
445
                        TypeCache::Get()->kJSDateValueType,
446
                        MachineType::AnyTagged(),
447 448
                        kFullWriteBarrier};
  return access;
449
}
450

451 452
// static
FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) {
453
  FieldAccess access = {
454
      kTaggedBase,         JSDate::kValueOffset + index * kTaggedSize,
455
      MaybeHandle<Name>(), MaybeHandle<Map>(),
456
      Type::Number(),      MachineType::AnyTagged(),
457
      kFullWriteBarrier};
458
  return access;
459 460
}

461 462
// static
FieldAccess AccessBuilder::ForJSIteratorResultDone() {
463 464 465 466
  FieldAccess access = {kTaggedBase,         JSIteratorResult::kDoneOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
467 468 469 470 471
  return access;
}

// static
FieldAccess AccessBuilder::ForJSIteratorResultValue() {
472 473 474 475
  FieldAccess access = {kTaggedBase,         JSIteratorResult::kValueOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
476 477 478
  return access;
}

479 480
// static
FieldAccess AccessBuilder::ForJSRegExpData() {
481 482 483 484
  FieldAccess access = {kTaggedBase,         JSRegExp::kDataOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
485 486
  return access;
}
487

488 489
// static
FieldAccess AccessBuilder::ForJSRegExpFlags() {
490 491 492 493
  FieldAccess access = {kTaggedBase,         JSRegExp::kFlagsOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
494 495 496
  return access;
}

497 498
// static
FieldAccess AccessBuilder::ForJSRegExpLastIndex() {
499 500 501 502
  FieldAccess access = {kTaggedBase,         JSRegExp::kLastIndexOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
503 504
  return access;
}
505 506 507

// static
FieldAccess AccessBuilder::ForJSRegExpSource() {
508 509 510 511
  FieldAccess access = {kTaggedBase,         JSRegExp::kSourceOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
512 513 514
  return access;
}

515
// static
516
FieldAccess AccessBuilder::ForFixedArrayLength() {
517 518 519
  FieldAccess access = {kTaggedBase,
                        FixedArray::kLengthOffset,
                        MaybeHandle<Name>(),
520
                        MaybeHandle<Map>(),
521
                        TypeCache::Get()->kFixedArrayLengthType,
522
                        MachineType::TaggedSigned(),
523
                        kNoWriteBarrier};
524
  return access;
525 526
}

527
// static
528 529 530 531
FieldAccess AccessBuilder::ForPropertyArrayLengthAndHash() {
  FieldAccess access = {
      kTaggedBase,         PropertyArray::kLengthAndHashOffset,
      MaybeHandle<Name>(), MaybeHandle<Map>(),
532
      Type::SignedSmall(), MachineType::TaggedSigned(),
533
      kNoWriteBarrier};
534 535 536
  return access;
}

537
// static
538
FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
539
  FieldAccess access = {
540
      kTaggedBase,           DescriptorArray::kEnumCacheOffset,
541
      Handle<Name>(),        MaybeHandle<Map>(),
542
      Type::OtherInternal(), MachineType::TaggedPointer(),
543
      kPointerWriteBarrier};
544
  return access;
545 546
}

547 548
// static
FieldAccess AccessBuilder::ForMapBitField() {
549
  FieldAccess access = {
550 551
      kTaggedBase,        Map::kBitFieldOffset,     Handle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kUint8, MachineType::Uint8(),
552
      kNoWriteBarrier};
553 554 555
  return access;
}

556 557 558
// static
FieldAccess AccessBuilder::ForMapBitField2() {
  FieldAccess access = {
559 560
      kTaggedBase,        Map::kBitField2Offset,    Handle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kUint8, MachineType::Uint8(),
561 562 563
      kNoWriteBarrier};
  return access;
}
564

565
// static
566
FieldAccess AccessBuilder::ForMapBitField3() {
567
  FieldAccess access = {
568 569
      kTaggedBase,        Map::kBitField3Offset,    Handle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kInt32, MachineType::Int32(),
570
      kNoWriteBarrier};
571
  return access;
572 573 574 575
}

// static
FieldAccess AccessBuilder::ForMapDescriptors() {
576 577 578 579
  FieldAccess access = {kTaggedBase,           Map::kInstanceDescriptorsOffset,
                        Handle<Name>(),        MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
580
  return access;
581 582
}

583 584
// static
FieldAccess AccessBuilder::ForMapInstanceType() {
585
  FieldAccess access = {
586 587
      kTaggedBase,        Map::kInstanceTypeOffset,  Handle<Name>(),
      MaybeHandle<Map>(), TypeCache::Get()->kUint16, MachineType::Uint16(),
588
      kNoWriteBarrier};
589
  return access;
590 591
}

592 593
// static
FieldAccess AccessBuilder::ForMapPrototype() {
594 595 596 597
  FieldAccess access = {kTaggedBase,         Map::kPrototypeOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::Any(),         MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
598 599 600
  return access;
}

601 602
// static
FieldAccess AccessBuilder::ForModuleRegularExports() {
603
  FieldAccess access = {
604
      kTaggedBase,           SourceTextModule::kRegularExportsOffset,
605
      Handle<Name>(),        MaybeHandle<Map>(),
606
      Type::OtherInternal(), MachineType::TaggedPointer(),
607
      kPointerWriteBarrier};
608 609 610 611 612
  return access;
}

// static
FieldAccess AccessBuilder::ForModuleRegularImports() {
613
  FieldAccess access = {
614
      kTaggedBase,           SourceTextModule::kRegularImportsOffset,
615
      Handle<Name>(),        MaybeHandle<Map>(),
616
      Type::OtherInternal(), MachineType::TaggedPointer(),
617
      kPointerWriteBarrier};
618 619
  return access;
}
620

621 622
// static
FieldAccess AccessBuilder::ForNameHashField() {
623 624 625
  FieldAccess access = {kTaggedBase,        Name::kHashFieldOffset,
                        Handle<Name>(),     MaybeHandle<Map>(),
                        Type::Unsigned32(), MachineType::Uint32(),
626
                        kNoWriteBarrier};
627 628 629
  return access;
}

630
// static
631
FieldAccess AccessBuilder::ForStringLength() {
632 633 634
  FieldAccess access = {kTaggedBase,
                        String::kLengthOffset,
                        Handle<Name>(),
635
                        MaybeHandle<Map>(),
636
                        TypeCache::Get()->kStringLengthType,
637
                        MachineType::Uint32(),
638
                        kNoWriteBarrier};
639
  return access;
640 641
}

642 643
// static
FieldAccess AccessBuilder::ForConsStringFirst() {
644 645 646 647
  FieldAccess access = {kTaggedBase,         ConsString::kFirstOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::String(),      MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
648 649 650 651 652
  return access;
}

// static
FieldAccess AccessBuilder::ForConsStringSecond() {
653 654 655 656
  FieldAccess access = {kTaggedBase,         ConsString::kSecondOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::String(),      MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
657 658 659 660 661
  return access;
}

// static
FieldAccess AccessBuilder::ForThinStringActual() {
662 663 664 665
  FieldAccess access = {kTaggedBase,         ThinString::kActualOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::String(),      MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
666 667 668 669 670
  return access;
}

// static
FieldAccess AccessBuilder::ForSlicedStringOffset() {
671 672 673 674
  FieldAccess access = {kTaggedBase,         SlicedString::kOffsetOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::SignedSmall(), MachineType::TaggedSigned(),
                        kNoWriteBarrier};
675 676 677 678 679
  return access;
}

// static
FieldAccess AccessBuilder::ForSlicedStringParent() {
680 681 682 683
  FieldAccess access = {kTaggedBase,         SlicedString::kParentOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::String(),      MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
684 685 686 687 688 689 690 691
  return access;
}

// static
FieldAccess AccessBuilder::ForExternalStringResourceData() {
  FieldAccess access = {kTaggedBase,
                        ExternalString::kResourceDataOffset,
                        Handle<Name>(),
692
                        MaybeHandle<Map>(),
693
                        Type::ExternalPointer(),
694 695 696 697 698 699 700 701
                        MachineType::Pointer(),
                        kNoWriteBarrier};
  return access;
}

// static
ElementAccess AccessBuilder::ForSeqOneByteStringCharacter() {
  ElementAccess access = {kTaggedBase, SeqOneByteString::kHeaderSize,
702
                          TypeCache::Get()->kUint8, MachineType::Uint8(),
703 704 705 706 707 708 709
                          kNoWriteBarrier};
  return access;
}

// static
ElementAccess AccessBuilder::ForSeqTwoByteStringCharacter() {
  ElementAccess access = {kTaggedBase, SeqTwoByteString::kHeaderSize,
710
                          TypeCache::Get()->kUint16, MachineType::Uint16(),
711 712 713
                          kNoWriteBarrier};
  return access;
}
714

715 716 717 718 719
// static
FieldAccess AccessBuilder::ForJSGlobalProxyNativeContext() {
  FieldAccess access = {
      kTaggedBase,         JSGlobalProxy::kNativeContextOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
720
      Type::Internal(),    MachineType::TaggedPointer(),
721 722 723 724
      kPointerWriteBarrier};
  return access;
}

725
// static
726
FieldAccess AccessBuilder::ForJSArrayIteratorIteratedObject() {
727 728 729
  FieldAccess access = {
      kTaggedBase,         JSArrayIterator::kIteratedObjectOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
730
      Type::Receiver(),    MachineType::TaggedPointer(),
731
      kPointerWriteBarrier};
732 733 734 735
  return access;
}

// static
736
FieldAccess AccessBuilder::ForJSArrayIteratorNextIndex() {
737 738 739 740 741
  // In generic case, cap to 2^53-1 (per ToLength() in spec) via
  // kPositiveSafeInteger
  FieldAccess access = {kTaggedBase,
                        JSArrayIterator::kNextIndexOffset,
                        Handle<Name>(),
742
                        MaybeHandle<Map>(),
743
                        TypeCache::Get()->kPositiveSafeInteger,
744
                        MachineType::AnyTagged(),
745 746 747 748 749
                        kFullWriteBarrier};
  return access;
}

// static
750 751 752 753 754
FieldAccess AccessBuilder::ForJSArrayIteratorKind() {
  FieldAccess access = {kTaggedBase,
                        JSArrayIterator::kKindOffset,
                        Handle<Name>(),
                        MaybeHandle<Map>(),
755
                        TypeCache::Get()->kJSArrayIteratorKindType,
756
                        MachineType::TaggedSigned(),
757
                        kNoWriteBarrier};
758 759 760
  return access;
}

761 762
// static
FieldAccess AccessBuilder::ForJSStringIteratorString() {
763 764 765 766
  FieldAccess access = {kTaggedBase,         JSStringIterator::kStringOffset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::String(),      MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
767 768 769 770 771 772
  return access;
}

// static
FieldAccess AccessBuilder::ForJSStringIteratorIndex() {
  FieldAccess access = {kTaggedBase,
773
                        JSStringIterator::kIndexOffset,
774
                        Handle<Name>(),
775
                        MaybeHandle<Map>(),
776
                        TypeCache::Get()->kStringLengthType,
777
                        MachineType::TaggedSigned(),
778 779 780
                        kNoWriteBarrier};
  return access;
}
781 782 783

// static
FieldAccess AccessBuilder::ForArgumentsLength() {
784 785 786 787 788 789
  constexpr int offset = JSStrictArgumentsObject::kLengthOffset;
  STATIC_ASSERT(offset == JSSloppyArgumentsObject::kLengthOffset);
  FieldAccess access = {kTaggedBase,         offset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::NonInternal(), MachineType::AnyTagged(),
                        kFullWriteBarrier};
790 791 792
  return access;
}

793 794
// static
FieldAccess AccessBuilder::ForArgumentsCallee() {
795 796 797
  FieldAccess access = {
      kTaggedBase,         JSSloppyArgumentsObject::kCalleeOffset,
      Handle<Name>(),      MaybeHandle<Map>(),
798
      Type::NonInternal(), MachineType::AnyTagged(),
799
      kFullWriteBarrier};
800 801 802
  return access;
}

803
// static
804 805
FieldAccess AccessBuilder::ForFixedArraySlot(
    size_t index, WriteBarrierKind write_barrier_kind) {
806
  int offset = FixedArray::OffsetOfElementAt(static_cast<int>(index));
807 808
  FieldAccess access = {kTaggedBase,       offset,
                        Handle<Name>(),    MaybeHandle<Map>(),
809
                        Type::Any(),       MachineType::AnyTagged(),
810
                        write_barrier_kind};
811 812 813
  return access;
}

814 815
// static
FieldAccess AccessBuilder::ForCellValue() {
816 817
  FieldAccess access = {kTaggedBase,       Cell::kValueOffset,
                        Handle<Name>(),    MaybeHandle<Map>(),
818
                        Type::Any(),       MachineType::AnyTagged(),
819
                        kFullWriteBarrier, LoadSensitivity::kCritical};
820 821 822
  return access;
}

823 824
// static
FieldAccess AccessBuilder::ForScopeInfoFlags() {
825 826 827 828
  FieldAccess access = {kTaggedBase,         ScopeInfo::kFlagsOffset,
                        MaybeHandle<Name>(), MaybeHandle<Map>(),
                        Type::SignedSmall(), MachineType::TaggedSigned(),
                        kNoWriteBarrier};
829 830 831
  return access;
}

832 833
// static
FieldAccess AccessBuilder::ForContextSlot(size_t index) {
834
  int offset = Context::OffsetOfElementAt(static_cast<int>(index));
835 836
  DCHECK_EQ(offset,
            Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag);
837 838
  FieldAccess access = {kTaggedBase,      offset,
                        Handle<Name>(),   MaybeHandle<Map>(),
839
                        Type::Any(),      MachineType::AnyTagged(),
840
                        kFullWriteBarrier};
841
  return access;
842 843
}

844 845 846 847 848
// static
FieldAccess AccessBuilder::ForContextSlotKnownPointer(size_t index) {
  int offset = Context::OffsetOfElementAt(static_cast<int>(index));
  DCHECK_EQ(offset,
            Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag);
849 850 851 852
  FieldAccess access = {kTaggedBase,         offset,
                        Handle<Name>(),      MaybeHandle<Map>(),
                        Type::Any(),         MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
853 854 855
  return access;
}

856 857
// static
ElementAccess AccessBuilder::ForFixedArrayElement() {
858
  ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
859
                          MachineType::AnyTagged(), kFullWriteBarrier};
860
  return access;
861 862
}

863
// static
864 865
ElementAccess AccessBuilder::ForFixedArrayElement(
    ElementsKind kind, LoadSensitivity load_sensitivity) {
866 867 868
  ElementAccess access = {kTaggedBase,       FixedArray::kHeaderSize,
                          Type::Any(),       MachineType::AnyTagged(),
                          kFullWriteBarrier, load_sensitivity};
869
  switch (kind) {
870
    case PACKED_SMI_ELEMENTS:
871
      access.type = Type::SignedSmall();
872
      access.machine_type = MachineType::TaggedSigned();
873 874
      access.write_barrier_kind = kNoWriteBarrier;
      break;
875
    case HOLEY_SMI_ELEMENTS:
876
      access.type = TypeCache::Get()->kHoleySmi;
877
      break;
878
    case PACKED_ELEMENTS:
879 880
      access.type = Type::NonInternal();
      break;
881
    case HOLEY_ELEMENTS:
882
      break;
883
    case PACKED_DOUBLE_ELEMENTS:
884 885 886 887
      access.type = Type::Number();
      access.write_barrier_kind = kNoWriteBarrier;
      access.machine_type = MachineType::Float64();
      break;
888
    case HOLEY_DOUBLE_ELEMENTS:
889
      access.type = Type::NumberOrHole();
890 891 892
      access.write_barrier_kind = kNoWriteBarrier;
      access.machine_type = MachineType::Float64();
      break;
893 894 895 896 897
    default:
      UNREACHABLE();
  }
  return access;
}
898

899 900 901 902 903
// static
ElementAccess AccessBuilder::ForStackArgument() {
  ElementAccess access = {
      kUntaggedBase,
      CommonFrameConstants::kFixedFrameSizeAboveFp - kSystemPointerSize,
904
      Type::NonInternal(), MachineType::Pointer(),
905 906 907 908
      WriteBarrierKind::kNoWriteBarrier};
  return access;
}

909 910 911
// static
ElementAccess AccessBuilder::ForFixedDoubleArrayElement() {
  ElementAccess access = {kTaggedBase, FixedDoubleArray::kHeaderSize,
912
                          TypeCache::Get()->kFloat64, MachineType::Float64(),
913
                          kNoWriteBarrier};
914 915 916
  return access;
}

917
// static
918
FieldAccess AccessBuilder::ForEnumCacheKeys() {
919 920 921 922
  FieldAccess access = {kTaggedBase,           EnumCache::kKeysOffset,
                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
923 924 925 926 927
  return access;
}

// static
FieldAccess AccessBuilder::ForEnumCacheIndices() {
928 929 930 931
  FieldAccess access = {kTaggedBase,           EnumCache::kIndicesOffset,
                        MaybeHandle<Name>(),   MaybeHandle<Map>(),
                        Type::OtherInternal(), MachineType::TaggedPointer(),
                        kPointerWriteBarrier};
932 933
  return access;
}
934

935
// static
936 937 938
ElementAccess AccessBuilder::ForTypedArrayElement(
    ExternalArrayType type, bool is_external,
    LoadSensitivity load_sensitivity) {
939
  BaseTaggedness taggedness = is_external ? kUntaggedBase : kTaggedBase;
940
  int header_size = is_external ? 0 : ByteArray::kHeaderSize;
941
  switch (type) {
942
    case kExternalInt8Array: {
943 944 945
      ElementAccess access = {taggedness,       header_size,
                              Type::Signed32(), MachineType::Int8(),
                              kNoWriteBarrier,  load_sensitivity};
946 947
      return access;
    }
948
    case kExternalUint8Array:
949
    case kExternalUint8ClampedArray: {
950 951 952
      ElementAccess access = {taggedness,         header_size,
                              Type::Unsigned32(), MachineType::Uint8(),
                              kNoWriteBarrier,    load_sensitivity};
953 954 955
      return access;
    }
    case kExternalInt16Array: {
956 957 958
      ElementAccess access = {taggedness,       header_size,
                              Type::Signed32(), MachineType::Int16(),
                              kNoWriteBarrier,  load_sensitivity};
959 960 961
      return access;
    }
    case kExternalUint16Array: {
962 963 964
      ElementAccess access = {taggedness,         header_size,
                              Type::Unsigned32(), MachineType::Uint16(),
                              kNoWriteBarrier,    load_sensitivity};
965 966 967
      return access;
    }
    case kExternalInt32Array: {
968 969 970
      ElementAccess access = {taggedness,       header_size,
                              Type::Signed32(), MachineType::Int32(),
                              kNoWriteBarrier,  load_sensitivity};
971 972 973
      return access;
    }
    case kExternalUint32Array: {
974 975 976
      ElementAccess access = {taggedness,         header_size,
                              Type::Unsigned32(), MachineType::Uint32(),
                              kNoWriteBarrier,    load_sensitivity};
977 978 979
      return access;
    }
    case kExternalFloat32Array: {
980 981 982
      ElementAccess access = {taggedness,      header_size,
                              Type::Number(),  MachineType::Float32(),
                              kNoWriteBarrier, load_sensitivity};
983 984 985
      return access;
    }
    case kExternalFloat64Array: {
986 987 988
      ElementAccess access = {taggedness,      header_size,
                              Type::Number(),  MachineType::Float64(),
                              kNoWriteBarrier, load_sensitivity};
989 990
      return access;
    }
991 992 993 994
    case kExternalBigInt64Array:
    case kExternalBigUint64Array:
      // TODO(neis/jkummerow): Define appropriate types.
      UNIMPLEMENTED();
995 996
  }
  UNREACHABLE();
997 998
}

999 1000 1001 1002 1003 1004 1005 1006
// static
FieldAccess AccessBuilder::ForHashTableBaseNumberOfElements() {
  FieldAccess access = {
      kTaggedBase,
      FixedArray::OffsetOfElementAt(HashTableBase::kNumberOfElementsIndex),
      MaybeHandle<Name>(),
      MaybeHandle<Map>(),
      Type::SignedSmall(),
1007
      MachineType::TaggedSigned(),
1008 1009 1010 1011 1012 1013
      kNoWriteBarrier};
  return access;
}

// static
FieldAccess AccessBuilder::ForHashTableBaseNumberOfDeletedElement() {
1014 1015 1016 1017 1018 1019
  FieldAccess access = {kTaggedBase,
                        FixedArray::OffsetOfElementAt(
                            HashTableBase::kNumberOfDeletedElementsIndex),
                        MaybeHandle<Name>(),
                        MaybeHandle<Map>(),
                        Type::SignedSmall(),
1020
                        MachineType::TaggedSigned(),
1021
                        kNoWriteBarrier};
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
  return access;
}

// static
FieldAccess AccessBuilder::ForHashTableBaseCapacity() {
  FieldAccess access = {
      kTaggedBase,
      FixedArray::OffsetOfElementAt(HashTableBase::kCapacityIndex),
      MaybeHandle<Name>(),
      MaybeHandle<Map>(),
      Type::SignedSmall(),
1033
      MachineType::TaggedSigned(),
1034 1035 1036 1037
      kNoWriteBarrier};
  return access;
}

1038
// static
1039
FieldAccess AccessBuilder::ForOrderedHashMapOrSetNextTable() {
1040 1041
  // TODO(turbofan): This will be redundant with the HashTableBase
  // methods above once the hash table unification is done.
1042 1043
  STATIC_ASSERT(OrderedHashMap::NextTableOffset() ==
                OrderedHashSet::NextTableOffset());
1044
  FieldAccess const access = {
1045
      kTaggedBase,         OrderedHashMap::NextTableOffset(),
1046
      MaybeHandle<Name>(), MaybeHandle<Map>(),
1047
      Type::Any(),         MachineType::AnyTagged(),
1048 1049 1050 1051 1052
      kFullWriteBarrier};
  return access;
}

// static
1053
FieldAccess AccessBuilder::ForOrderedHashMapOrSetNumberOfBuckets() {
1054 1055
  // TODO(turbofan): This will be redundant with the HashTableBase
  // methods above once the hash table unification is done.
1056 1057
  STATIC_ASSERT(OrderedHashMap::NumberOfBucketsOffset() ==
                OrderedHashSet::NumberOfBucketsOffset());
1058
  FieldAccess const access = {kTaggedBase,
1059
                              OrderedHashMap::NumberOfBucketsOffset(),
1060 1061
                              MaybeHandle<Name>(),
                              MaybeHandle<Map>(),
1062
                              TypeCache::Get()->kFixedArrayLengthType,
1063
                              MachineType::TaggedSigned(),
1064
                              kNoWriteBarrier};
1065 1066 1067 1068
  return access;
}

// static
1069
FieldAccess AccessBuilder::ForOrderedHashMapOrSetNumberOfDeletedElements() {
1070 1071
  // TODO(turbofan): This will be redundant with the HashTableBase
  // methods above once the hash table unification is done.
1072 1073
  STATIC_ASSERT(OrderedHashMap::NumberOfDeletedElementsOffset() ==
                OrderedHashSet::NumberOfDeletedElementsOffset());
1074
  FieldAccess const access = {kTaggedBase,
1075
                              OrderedHashMap::NumberOfDeletedElementsOffset(),
1076 1077
                              MaybeHandle<Name>(),
                              MaybeHandle<Map>(),
1078
                              TypeCache::Get()->kFixedArrayLengthType,
1079
                              MachineType::TaggedSigned(),
1080
                              kNoWriteBarrier};
1081 1082 1083
  return access;
}

1084
// static
1085
FieldAccess AccessBuilder::ForOrderedHashMapOrSetNumberOfElements() {
1086 1087
  // TODO(turbofan): This will be redundant with the HashTableBase
  // methods above once the hash table unification is done.
1088 1089
  STATIC_ASSERT(OrderedHashMap::NumberOfElementsOffset() ==
                OrderedHashSet::NumberOfElementsOffset());
1090
  FieldAccess const access = {kTaggedBase,
1091
                              OrderedHashMap::NumberOfElementsOffset(),
1092 1093
                              MaybeHandle<Name>(),
                              MaybeHandle<Map>(),
1094
                              TypeCache::Get()->kFixedArrayLengthType,
1095
                              MachineType::TaggedSigned(),
1096 1097 1098 1099
                              kNoWriteBarrier};
  return access;
}

1100 1101
// static
ElementAccess AccessBuilder::ForOrderedHashMapEntryValue() {
1102 1103 1104 1105 1106
  ElementAccess const access = {kTaggedBase,
                                OrderedHashMap::HashTableStartOffset() +
                                    OrderedHashMap::kValueOffset * kTaggedSize,
                                Type::Any(), MachineType::AnyTagged(),
                                kFullWriteBarrier};
1107 1108 1109
  return access;
}

1110 1111 1112 1113 1114 1115 1116 1117
// static
FieldAccess AccessBuilder::ForDictionaryNextEnumerationIndex() {
  FieldAccess access = {
      kTaggedBase,
      FixedArray::OffsetOfElementAt(NameDictionary::kNextEnumerationIndexIndex),
      MaybeHandle<Name>(),
      MaybeHandle<Map>(),
      Type::SignedSmall(),
1118
      MachineType::TaggedSigned(),
1119 1120 1121 1122
      kNoWriteBarrier};
  return access;
}

1123 1124 1125 1126 1127 1128 1129 1130
// static
FieldAccess AccessBuilder::ForDictionaryObjectHashIndex() {
  FieldAccess access = {
      kTaggedBase,
      FixedArray::OffsetOfElementAt(NameDictionary::kObjectHashIndex),
      MaybeHandle<Name>(),
      MaybeHandle<Map>(),
      Type::SignedSmall(),
1131
      MachineType::TaggedSigned(),
1132 1133 1134 1135
      kNoWriteBarrier};
  return access;
}

1136 1137 1138
}  // namespace compiler
}  // namespace internal
}  // namespace v8