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 14 namespace v8 { 15 namespace internal { 16 namespace compiler { 17 18 // static 19 FieldAccess AccessBuilder::ForExternalDoubleValue() { 20 FieldAccess access = {kUntaggedBase, 0, 21 MaybeHandle<Name>(), MaybeHandle<Map>(), 22 Type::Number(), MachineType::Float64(), 23 kNoWriteBarrier}; 24 return access; 25 } 26 27 // static 28 FieldAccess AccessBuilder::ForExternalTaggedValue() { 29 FieldAccess access = {kUntaggedBase, 0, 30 MaybeHandle<Name>(), MaybeHandle<Map>(), 31 Type::Any(), MachineType::AnyTagged(), 32 kNoWriteBarrier}; 33 return access; 34 } 35 36 // static 37 FieldAccess AccessBuilder::ForExternalUint8Value() { 38 FieldAccess access = {kUntaggedBase, 0, 39 MaybeHandle<Name>(), MaybeHandle<Map>(), 40 TypeCache::Get().kUint8, MachineType::Uint8(), 41 kNoWriteBarrier}; 42 return access; 43 } 44 45 // static 46 FieldAccess AccessBuilder::ForMap() { 47 FieldAccess access = {kTaggedBase, HeapObject::kMapOffset, 48 MaybeHandle<Name>(), MaybeHandle<Map>(), 49 Type::OtherInternal(), MachineType::TaggedPointer(), 50 kMapWriteBarrier}; 51 return access; 52 } 53 54 55 // static 56 FieldAccess AccessBuilder::ForHeapNumberValue() { 57 FieldAccess access = { 58 kTaggedBase, HeapNumber::kValueOffset, MaybeHandle<Name>(), 59 MaybeHandle<Map>(), TypeCache::Get().kFloat64, MachineType::Float64(), 60 kNoWriteBarrier}; 61 return access; 62 } 63 64 65 // static 66 FieldAccess AccessBuilder::ForJSObjectProperties() { 67 FieldAccess access = {kTaggedBase, JSObject::kPropertiesOffset, 68 MaybeHandle<Name>(), MaybeHandle<Map>(), 69 Type::Internal(), MachineType::TaggedPointer(), 70 kPointerWriteBarrier}; 71 return access; 72 } 73 74 75 // static 76 FieldAccess AccessBuilder::ForJSObjectElements() { 77 FieldAccess access = {kTaggedBase, JSObject::kElementsOffset, 78 MaybeHandle<Name>(), MaybeHandle<Map>(), 79 Type::Internal(), MachineType::TaggedPointer(), 80 kPointerWriteBarrier}; 81 return access; 82 } 83 84 85 // static 86 FieldAccess AccessBuilder::ForJSObjectInObjectProperty(Handle<Map> map, 87 int index) { 88 int const offset = map->GetInObjectPropertyOffset(index); 89 FieldAccess access = {kTaggedBase, offset, 90 MaybeHandle<Name>(), MaybeHandle<Map>(), 91 Type::NonInternal(), MachineType::AnyTagged(), 92 kFullWriteBarrier}; 93 return access; 94 } 95 96 // static 97 FieldAccess AccessBuilder::ForJSObjectOffset( 98 int offset, WriteBarrierKind write_barrier_kind) { 99 FieldAccess access = {kTaggedBase, offset, 100 MaybeHandle<Name>(), MaybeHandle<Map>(), 101 Type::NonInternal(), MachineType::AnyTagged(), 102 write_barrier_kind}; 103 return access; 104 } 105 106 // static 107 FieldAccess AccessBuilder::ForJSCollectionTable() { 108 FieldAccess access = {kTaggedBase, JSCollection::kTableOffset, 109 MaybeHandle<Name>(), MaybeHandle<Map>(), 110 Type::OtherInternal(), MachineType::TaggedPointer(), 111 kPointerWriteBarrier}; 112 return access; 113 } 114 115 // static 116 FieldAccess AccessBuilder::ForJSFunctionPrototypeOrInitialMap() { 117 FieldAccess access = { 118 kTaggedBase, JSFunction::kPrototypeOrInitialMapOffset, 119 MaybeHandle<Name>(), MaybeHandle<Map>(), 120 Type::Any(), MachineType::AnyTagged(), 121 kFullWriteBarrier}; 122 return access; 123 } 124 125 // static 126 FieldAccess AccessBuilder::ForJSFunctionContext() { 127 FieldAccess access = {kTaggedBase, JSFunction::kContextOffset, 128 MaybeHandle<Name>(), MaybeHandle<Map>(), 129 Type::Internal(), MachineType::AnyTagged(), 130 kPointerWriteBarrier}; 131 return access; 132 } 133 134 135 // static 136 FieldAccess AccessBuilder::ForJSFunctionSharedFunctionInfo() { 137 FieldAccess access = { 138 kTaggedBase, JSFunction::kSharedFunctionInfoOffset, 139 Handle<Name>(), MaybeHandle<Map>(), 140 Type::OtherInternal(), MachineType::TaggedPointer(), 141 kPointerWriteBarrier}; 142 return access; 143 } 144 145 // static 146 FieldAccess AccessBuilder::ForJSFunctionFeedbackVector() { 147 FieldAccess access = {kTaggedBase, JSFunction::kFeedbackVectorOffset, 148 Handle<Name>(), MaybeHandle<Map>(), 149 Type::Internal(), MachineType::TaggedPointer(), 150 kPointerWriteBarrier}; 151 return access; 152 } 153 154 // static 155 FieldAccess AccessBuilder::ForJSFunctionCodeEntry() { 156 FieldAccess access = {kTaggedBase, JSFunction::kCodeEntryOffset, 157 Handle<Name>(), MaybeHandle<Map>(), 158 Type::OtherInternal(), MachineType::Pointer(), 159 kNoWriteBarrier}; 160 return access; 161 } 162 163 // static 164 FieldAccess AccessBuilder::ForJSFunctionNextFunctionLink() { 165 FieldAccess access = { 166 kTaggedBase, JSFunction::kNextFunctionLinkOffset, 167 Handle<Name>(), MaybeHandle<Map>(), 168 Type::Any(), MachineType::AnyTagged(), 169 kPointerWriteBarrier}; 170 return access; 171 } 172 173 // static 174 FieldAccess AccessBuilder::ForJSGeneratorObjectContext() { 175 FieldAccess access = {kTaggedBase, JSGeneratorObject::kContextOffset, 176 Handle<Name>(), MaybeHandle<Map>(), 177 Type::Internal(), MachineType::TaggedPointer(), 178 kPointerWriteBarrier}; 179 return access; 180 } 181 182 // static 183 FieldAccess AccessBuilder::ForJSGeneratorObjectContinuation() { 184 FieldAccess access = { 185 kTaggedBase, JSGeneratorObject::kContinuationOffset, 186 Handle<Name>(), MaybeHandle<Map>(), 187 Type::SignedSmall(), MachineType::TaggedSigned(), 188 kNoWriteBarrier}; 189 return access; 190 } 191 192 // static 193 FieldAccess AccessBuilder::ForJSGeneratorObjectInputOrDebugPos() { 194 FieldAccess access = { 195 kTaggedBase, JSGeneratorObject::kInputOrDebugPosOffset, 196 Handle<Name>(), MaybeHandle<Map>(), 197 Type::NonInternal(), MachineType::AnyTagged(), 198 kFullWriteBarrier}; 199 return access; 200 } 201 202 // static 203 FieldAccess AccessBuilder::ForJSGeneratorObjectRegisterFile() { 204 FieldAccess access = { 205 kTaggedBase, JSGeneratorObject::kRegisterFileOffset, 206 Handle<Name>(), MaybeHandle<Map>(), 207 Type::Internal(), MachineType::AnyTagged(), 208 kPointerWriteBarrier}; 209 return access; 210 } 211 212 // static 213 FieldAccess AccessBuilder::ForJSGeneratorObjectResumeMode() { 214 FieldAccess access = { 215 kTaggedBase, JSGeneratorObject::kResumeModeOffset, 216 Handle<Name>(), MaybeHandle<Map>(), 217 Type::SignedSmall(), MachineType::TaggedSigned(), 218 kNoWriteBarrier}; 219 return access; 220 } 221 222 // static 223 FieldAccess AccessBuilder::ForJSArrayLength(ElementsKind elements_kind) { 224 TypeCache const& type_cache = TypeCache::Get(); 225 FieldAccess access = {kTaggedBase, 226 JSArray::kLengthOffset, 227 Handle<Name>(), 228 MaybeHandle<Map>(), 229 type_cache.kJSArrayLengthType, 230 MachineType::TaggedSigned(), 231 kFullWriteBarrier}; 232 if (IsFastDoubleElementsKind(elements_kind)) { 233 access.type = type_cache.kFixedDoubleArrayLengthType; 234 access.write_barrier_kind = kNoWriteBarrier; 235 } else if (IsFastElementsKind(elements_kind)) { 236 access.type = type_cache.kFixedArrayLengthType; 237 access.write_barrier_kind = kNoWriteBarrier; 238 } 239 return access; 240 } 241 242 243 // static 244 FieldAccess AccessBuilder::ForJSArrayBufferBackingStore() { 245 FieldAccess access = { 246 kTaggedBase, JSArrayBuffer::kBackingStoreOffset, 247 MaybeHandle<Name>(), MaybeHandle<Map>(), 248 Type::OtherInternal(), MachineType::Pointer(), 249 kNoWriteBarrier}; 250 return access; 251 } 252 253 // static 254 FieldAccess AccessBuilder::ForJSArrayBufferBitField() { 255 FieldAccess access = { 256 kTaggedBase, JSArrayBuffer::kBitFieldOffset, MaybeHandle<Name>(), 257 MaybeHandle<Map>(), TypeCache::Get().kUint8, MachineType::Uint32(), 258 kNoWriteBarrier}; 259 return access; 260 } 261 262 // static 263 FieldAccess AccessBuilder::ForJSArrayBufferViewBuffer() { 264 FieldAccess access = {kTaggedBase, JSArrayBufferView::kBufferOffset, 265 MaybeHandle<Name>(), MaybeHandle<Map>(), 266 Type::OtherInternal(), MachineType::TaggedPointer(), 267 kPointerWriteBarrier}; 268 return access; 269 } 270 271 // static 272 FieldAccess AccessBuilder::ForJSArrayBufferViewByteLength() { 273 FieldAccess access = {kTaggedBase, 274 JSArrayBufferView::kByteLengthOffset, 275 MaybeHandle<Name>(), 276 MaybeHandle<Map>(), 277 TypeCache::Get().kPositiveInteger, 278 MachineType::AnyTagged(), 279 kFullWriteBarrier}; 280 return access; 281 } 282 283 // static 284 FieldAccess AccessBuilder::ForJSArrayBufferViewByteOffset() { 285 FieldAccess access = {kTaggedBase, 286 JSArrayBufferView::kByteOffsetOffset, 287 MaybeHandle<Name>(), 288 MaybeHandle<Map>(), 289 TypeCache::Get().kPositiveInteger, 290 MachineType::AnyTagged(), 291 kFullWriteBarrier}; 292 return access; 293 } 294 295 // static 296 FieldAccess AccessBuilder::ForJSTypedArrayLength() { 297 FieldAccess access = {kTaggedBase, 298 JSTypedArray::kLengthOffset, 299 MaybeHandle<Name>(), 300 MaybeHandle<Map>(), 301 TypeCache::Get().kJSTypedArrayLengthType, 302 MachineType::TaggedSigned(), 303 kNoWriteBarrier}; 304 return access; 305 } 306 307 // static 308 FieldAccess AccessBuilder::ForJSDateValue() { 309 FieldAccess access = {kTaggedBase, 310 JSDate::kValueOffset, 311 MaybeHandle<Name>(), 312 MaybeHandle<Map>(), 313 TypeCache::Get().kJSDateValueType, 314 MachineType::AnyTagged(), 315 kFullWriteBarrier}; 316 return access; 317 } 318 319 // static 320 FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) { 321 FieldAccess access = { 322 kTaggedBase, JSDate::kValueOffset + index * kPointerSize, 323 MaybeHandle<Name>(), MaybeHandle<Map>(), 324 Type::Number(), MachineType::AnyTagged(), 325 kFullWriteBarrier}; 326 return access; 327 } 328 329 330 // static 331 FieldAccess AccessBuilder::ForJSIteratorResultDone() { 332 FieldAccess access = {kTaggedBase, JSIteratorResult::kDoneOffset, 333 MaybeHandle<Name>(), MaybeHandle<Map>(), 334 Type::NonInternal(), MachineType::AnyTagged(), 335 kFullWriteBarrier}; 336 return access; 337 } 338 339 340 // static 341 FieldAccess AccessBuilder::ForJSIteratorResultValue() { 342 FieldAccess access = {kTaggedBase, JSIteratorResult::kValueOffset, 343 MaybeHandle<Name>(), MaybeHandle<Map>(), 344 Type::NonInternal(), MachineType::AnyTagged(), 345 kFullWriteBarrier}; 346 return access; 347 } 348 349 350 // static 351 FieldAccess AccessBuilder::ForJSRegExpFlags() { 352 FieldAccess access = {kTaggedBase, JSRegExp::kFlagsOffset, 353 MaybeHandle<Name>(), MaybeHandle<Map>(), 354 Type::NonInternal(), MachineType::AnyTagged(), 355 kFullWriteBarrier}; 356 return access; 357 } 358 359 360 // static 361 FieldAccess AccessBuilder::ForJSRegExpSource() { 362 FieldAccess access = {kTaggedBase, JSRegExp::kSourceOffset, 363 MaybeHandle<Name>(), MaybeHandle<Map>(), 364 Type::NonInternal(), MachineType::AnyTagged(), 365 kFullWriteBarrier}; 366 return access; 367 } 368 369 370 // static 371 FieldAccess AccessBuilder::ForFixedArrayLength() { 372 FieldAccess access = {kTaggedBase, 373 FixedArray::kLengthOffset, 374 MaybeHandle<Name>(), 375 MaybeHandle<Map>(), 376 TypeCache::Get().kFixedArrayLengthType, 377 MachineType::TaggedSigned(), 378 kNoWriteBarrier}; 379 return access; 380 } 381 382 // static 383 FieldAccess AccessBuilder::ForFixedTypedArrayBaseBasePointer() { 384 FieldAccess access = { 385 kTaggedBase, FixedTypedArrayBase::kBasePointerOffset, 386 MaybeHandle<Name>(), MaybeHandle<Map>(), 387 Type::OtherInternal(), MachineType::AnyTagged(), 388 kPointerWriteBarrier}; 389 return access; 390 } 391 392 // static 393 FieldAccess AccessBuilder::ForFixedTypedArrayBaseExternalPointer() { 394 FieldAccess access = {kTaggedBase, 395 FixedTypedArrayBase::kExternalPointerOffset, 396 MaybeHandle<Name>(), 397 MaybeHandle<Map>(), 398 Type::ExternalPointer(), 399 MachineType::Pointer(), 400 kNoWriteBarrier}; 401 return access; 402 } 403 404 // static 405 FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() { 406 FieldAccess access = { 407 kTaggedBase, DescriptorArray::kEnumCacheOffset, 408 Handle<Name>(), MaybeHandle<Map>(), 409 Type::OtherInternal(), MachineType::TaggedPointer(), 410 kPointerWriteBarrier}; 411 return access; 412 } 413 414 415 // static 416 FieldAccess AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache() { 417 FieldAccess access = { 418 kTaggedBase, DescriptorArray::kEnumCacheBridgeCacheOffset, 419 Handle<Name>(), MaybeHandle<Map>(), 420 Type::OtherInternal(), MachineType::TaggedPointer(), 421 kPointerWriteBarrier}; 422 return access; 423 } 424 425 426 // static 427 FieldAccess AccessBuilder::ForMapBitField() { 428 FieldAccess access = { 429 kTaggedBase, Map::kBitFieldOffset, Handle<Name>(), 430 MaybeHandle<Map>(), TypeCache::Get().kUint8, MachineType::Uint8(), 431 kNoWriteBarrier}; 432 return access; 433 } 434 435 436 // static 437 FieldAccess AccessBuilder::ForMapBitField3() { 438 FieldAccess access = { 439 kTaggedBase, Map::kBitField3Offset, Handle<Name>(), 440 MaybeHandle<Map>(), TypeCache::Get().kInt32, MachineType::Int32(), 441 kNoWriteBarrier}; 442 return access; 443 } 444 445 446 // static 447 FieldAccess AccessBuilder::ForMapDescriptors() { 448 FieldAccess access = {kTaggedBase, Map::kDescriptorsOffset, 449 Handle<Name>(), MaybeHandle<Map>(), 450 Type::OtherInternal(), MachineType::TaggedPointer(), 451 kPointerWriteBarrier}; 452 return access; 453 } 454 455 456 // static 457 FieldAccess AccessBuilder::ForMapInstanceType() { 458 FieldAccess access = { 459 kTaggedBase, Map::kInstanceTypeOffset, Handle<Name>(), 460 MaybeHandle<Map>(), TypeCache::Get().kUint8, MachineType::Uint8(), 461 kNoWriteBarrier}; 462 return access; 463 } 464 465 466 // static 467 FieldAccess AccessBuilder::ForMapPrototype() { 468 FieldAccess access = {kTaggedBase, Map::kPrototypeOffset, 469 Handle<Name>(), MaybeHandle<Map>(), 470 Type::Any(), MachineType::TaggedPointer(), 471 kPointerWriteBarrier}; 472 return access; 473 } 474 475 // static 476 FieldAccess AccessBuilder::ForModuleRegularExports() { 477 FieldAccess access = {kTaggedBase, Module::kRegularExportsOffset, 478 Handle<Name>(), MaybeHandle<Map>(), 479 Type::OtherInternal(), MachineType::TaggedPointer(), 480 kPointerWriteBarrier}; 481 return access; 482 } 483 484 // static 485 FieldAccess AccessBuilder::ForModuleRegularImports() { 486 FieldAccess access = {kTaggedBase, Module::kRegularImportsOffset, 487 Handle<Name>(), MaybeHandle<Map>(), 488 Type::OtherInternal(), MachineType::TaggedPointer(), 489 kPointerWriteBarrier}; 490 return access; 491 } 492 493 // static 494 FieldAccess AccessBuilder::ForNameHashField() { 495 FieldAccess access = {kTaggedBase, Name::kHashFieldOffset, 496 Handle<Name>(), MaybeHandle<Map>(), 497 Type::Unsigned32(), MachineType::Uint32(), 498 kNoWriteBarrier}; 499 return access; 500 } 501 502 // static 503 FieldAccess AccessBuilder::ForStringLength() { 504 FieldAccess access = {kTaggedBase, 505 String::kLengthOffset, 506 Handle<Name>(), 507 MaybeHandle<Map>(), 508 TypeCache::Get().kStringLengthType, 509 MachineType::TaggedSigned(), 510 kNoWriteBarrier}; 511 return access; 512 } 513 514 // static 515 FieldAccess AccessBuilder::ForConsStringFirst() { 516 FieldAccess access = {kTaggedBase, ConsString::kFirstOffset, 517 Handle<Name>(), MaybeHandle<Map>(), 518 Type::String(), MachineType::TaggedPointer(), 519 kPointerWriteBarrier}; 520 return access; 521 } 522 523 // static 524 FieldAccess AccessBuilder::ForConsStringSecond() { 525 FieldAccess access = {kTaggedBase, ConsString::kSecondOffset, 526 Handle<Name>(), MaybeHandle<Map>(), 527 Type::String(), MachineType::TaggedPointer(), 528 kPointerWriteBarrier}; 529 return access; 530 } 531 532 // static 533 FieldAccess AccessBuilder::ForThinStringActual() { 534 FieldAccess access = {kTaggedBase, ThinString::kActualOffset, 535 Handle<Name>(), MaybeHandle<Map>(), 536 Type::String(), MachineType::TaggedPointer(), 537 kPointerWriteBarrier}; 538 return access; 539 } 540 541 // static 542 FieldAccess AccessBuilder::ForSlicedStringOffset() { 543 FieldAccess access = {kTaggedBase, SlicedString::kOffsetOffset, 544 Handle<Name>(), MaybeHandle<Map>(), 545 Type::SignedSmall(), MachineType::TaggedSigned(), 546 kNoWriteBarrier}; 547 return access; 548 } 549 550 // static 551 FieldAccess AccessBuilder::ForSlicedStringParent() { 552 FieldAccess access = {kTaggedBase, SlicedString::kParentOffset, 553 Handle<Name>(), MaybeHandle<Map>(), 554 Type::String(), MachineType::TaggedPointer(), 555 kPointerWriteBarrier}; 556 return access; 557 } 558 559 // static 560 FieldAccess AccessBuilder::ForExternalStringResourceData() { 561 FieldAccess access = {kTaggedBase, 562 ExternalString::kResourceDataOffset, 563 Handle<Name>(), 564 MaybeHandle<Map>(), 565 Type::ExternalPointer(), 566 MachineType::Pointer(), 567 kNoWriteBarrier}; 568 return access; 569 } 570 571 // static 572 ElementAccess AccessBuilder::ForExternalOneByteStringCharacter() { 573 ElementAccess access = {kUntaggedBase, 0, TypeCache::Get().kUint8, 574 MachineType::Uint8(), kNoWriteBarrier}; 575 return access; 576 } 577 578 // static 579 ElementAccess AccessBuilder::ForExternalTwoByteStringCharacter() { 580 ElementAccess access = {kUntaggedBase, 0, TypeCache::Get().kUint16, 581 MachineType::Uint16(), kNoWriteBarrier}; 582 return access; 583 } 584 585 // static 586 ElementAccess AccessBuilder::ForSeqOneByteStringCharacter() { 587 ElementAccess access = {kTaggedBase, SeqOneByteString::kHeaderSize, 588 TypeCache::Get().kUint8, MachineType::Uint8(), 589 kNoWriteBarrier}; 590 return access; 591 } 592 593 // static 594 ElementAccess AccessBuilder::ForSeqTwoByteStringCharacter() { 595 ElementAccess access = {kTaggedBase, SeqTwoByteString::kHeaderSize, 596 TypeCache::Get().kUint16, MachineType::Uint16(), 597 kNoWriteBarrier}; 598 return access; 599 } 600 601 // static 602 FieldAccess AccessBuilder::ForJSGlobalObjectGlobalProxy() { 603 FieldAccess access = {kTaggedBase, JSGlobalObject::kGlobalProxyOffset, 604 Handle<Name>(), MaybeHandle<Map>(), 605 Type::Receiver(), MachineType::TaggedPointer(), 606 kPointerWriteBarrier}; 607 return access; 608 } 609 610 // static 611 FieldAccess AccessBuilder::ForJSGlobalObjectNativeContext() { 612 FieldAccess access = { 613 kTaggedBase, JSGlobalObject::kNativeContextOffset, 614 Handle<Name>(), MaybeHandle<Map>(), 615 Type::Internal(), MachineType::TaggedPointer(), 616 kPointerWriteBarrier}; 617 return access; 618 } 619 620 // static 621 FieldAccess AccessBuilder::ForJSArrayIteratorObject() { 622 FieldAccess access = {kTaggedBase, 623 JSArrayIterator::kIteratedObjectOffset, 624 Handle<Name>(), 625 MaybeHandle<Map>(), 626 Type::ReceiverOrUndefined(), 627 MachineType::TaggedPointer(), 628 kPointerWriteBarrier}; 629 return access; 630 } 631 632 // static 633 FieldAccess AccessBuilder::ForJSArrayIteratorIndex(InstanceType instance_type, 634 ElementsKind elements_kind) { 635 // In generic case, cap to 2^53-1 (per ToLength() in spec) via 636 // kPositiveSafeInteger 637 FieldAccess access = {kTaggedBase, 638 JSArrayIterator::kNextIndexOffset, 639 Handle<Name>(), 640 MaybeHandle<Map>(), 641 TypeCache::Get().kPositiveSafeInteger, 642 MachineType::AnyTagged(), 643 kFullWriteBarrier}; 644 if (instance_type == JS_ARRAY_TYPE) { 645 if (IsFastDoubleElementsKind(elements_kind)) { 646 access.type = TypeCache::Get().kFixedDoubleArrayLengthType; 647 access.machine_type = MachineType::TaggedSigned(); 648 access.write_barrier_kind = kNoWriteBarrier; 649 } else if (IsFastElementsKind(elements_kind)) { 650 access.type = TypeCache::Get().kFixedArrayLengthType; 651 access.machine_type = MachineType::TaggedSigned(); 652 access.write_barrier_kind = kNoWriteBarrier; 653 } else { 654 access.type = TypeCache::Get().kJSArrayLengthType; 655 } 656 } else if (instance_type == JS_TYPED_ARRAY_TYPE) { 657 access.type = TypeCache::Get().kJSTypedArrayLengthType; 658 access.machine_type = MachineType::TaggedSigned(); 659 access.write_barrier_kind = kNoWriteBarrier; 660 } 661 return access; 662 } 663 664 // static 665 FieldAccess AccessBuilder::ForJSArrayIteratorObjectMap() { 666 FieldAccess access = { 667 kTaggedBase, JSArrayIterator::kIteratedObjectMapOffset, 668 Handle<Name>(), MaybeHandle<Map>(), 669 Type::OtherInternal(), MachineType::TaggedPointer(), 670 kPointerWriteBarrier}; 671 return access; 672 } 673 674 // static 675 FieldAccess AccessBuilder::ForJSStringIteratorString() { 676 FieldAccess access = {kTaggedBase, JSStringIterator::kStringOffset, 677 Handle<Name>(), MaybeHandle<Map>(), 678 Type::String(), MachineType::TaggedPointer(), 679 kPointerWriteBarrier}; 680 return access; 681 } 682 683 // static 684 FieldAccess AccessBuilder::ForJSStringIteratorIndex() { 685 FieldAccess access = {kTaggedBase, 686 JSStringIterator::kNextIndexOffset, 687 Handle<Name>(), 688 MaybeHandle<Map>(), 689 TypeCache::Get().kStringLengthType, 690 MachineType::TaggedSigned(), 691 kNoWriteBarrier}; 692 return access; 693 } 694 695 // static 696 FieldAccess AccessBuilder::ForValue() { 697 FieldAccess access = {kTaggedBase, JSValue::kValueOffset, 698 Handle<Name>(), MaybeHandle<Map>(), 699 Type::NonInternal(), MachineType::AnyTagged(), 700 kFullWriteBarrier}; 701 return access; 702 } 703 704 705 // static 706 FieldAccess AccessBuilder::ForArgumentsLength() { 707 FieldAccess access = {kTaggedBase, JSArgumentsObject::kLengthOffset, 708 Handle<Name>(), MaybeHandle<Map>(), 709 Type::NonInternal(), MachineType::AnyTagged(), 710 kFullWriteBarrier}; 711 return access; 712 } 713 714 715 // static 716 FieldAccess AccessBuilder::ForArgumentsCallee() { 717 FieldAccess access = { 718 kTaggedBase, JSSloppyArgumentsObject::kCalleeOffset, 719 Handle<Name>(), MaybeHandle<Map>(), 720 Type::NonInternal(), MachineType::AnyTagged(), 721 kPointerWriteBarrier}; 722 return access; 723 } 724 725 726 // static 727 FieldAccess AccessBuilder::ForFixedArraySlot( 728 size_t index, WriteBarrierKind write_barrier_kind) { 729 int offset = FixedArray::OffsetOfElementAt(static_cast<int>(index)); 730 FieldAccess access = {kTaggedBase, offset, 731 Handle<Name>(), MaybeHandle<Map>(), 732 Type::NonInternal(), MachineType::AnyTagged(), 733 write_barrier_kind}; 734 return access; 735 } 736 737 738 // static 739 FieldAccess AccessBuilder::ForCellValue() { 740 FieldAccess access = {kTaggedBase, Cell::kValueOffset, 741 Handle<Name>(), MaybeHandle<Map>(), 742 Type::Any(), MachineType::AnyTagged(), 743 kFullWriteBarrier}; 744 return access; 745 } 746 747 // static 748 FieldAccess AccessBuilder::ForContextSlot(size_t index) { 749 int offset = Context::kHeaderSize + static_cast<int>(index) * kPointerSize; 750 DCHECK_EQ(offset, 751 Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag); 752 FieldAccess access = {kTaggedBase, offset, 753 Handle<Name>(), MaybeHandle<Map>(), 754 Type::Any(), MachineType::AnyTagged(), 755 kFullWriteBarrier}; 756 return access; 757 } 758 759 // static 760 FieldAccess AccessBuilder::ForContextExtensionScopeInfo() { 761 FieldAccess access = { 762 kTaggedBase, ContextExtension::kScopeInfoOffset, 763 Handle<Name>(), MaybeHandle<Map>(), 764 Type::OtherInternal(), MachineType::AnyTagged(), 765 kFullWriteBarrier}; 766 return access; 767 } 768 769 // static 770 FieldAccess AccessBuilder::ForContextExtensionExtension() { 771 FieldAccess access = {kTaggedBase, ContextExtension::kExtensionOffset, 772 Handle<Name>(), MaybeHandle<Map>(), 773 Type::Any(), MachineType::AnyTagged(), 774 kFullWriteBarrier}; 775 return access; 776 } 777 778 // static 779 ElementAccess AccessBuilder::ForFixedArrayElement() { 780 ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(), 781 MachineType::AnyTagged(), kFullWriteBarrier}; 782 return access; 783 } 784 785 // static 786 ElementAccess AccessBuilder::ForFixedArrayElement(ElementsKind kind) { 787 ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(), 788 MachineType::AnyTagged(), kFullWriteBarrier}; 789 switch (kind) { 790 case FAST_SMI_ELEMENTS: 791 access.type = Type::SignedSmall(); 792 access.machine_type = MachineType::TaggedSigned(); 793 access.write_barrier_kind = kNoWriteBarrier; 794 break; 795 case FAST_HOLEY_SMI_ELEMENTS: 796 access.type = TypeCache::Get().kHoleySmi; 797 break; 798 case FAST_ELEMENTS: 799 access.type = Type::NonInternal(); 800 break; 801 case FAST_HOLEY_ELEMENTS: 802 break; 803 case FAST_DOUBLE_ELEMENTS: 804 access.type = Type::Number(); 805 access.write_barrier_kind = kNoWriteBarrier; 806 access.machine_type = MachineType::Float64(); 807 break; 808 case FAST_HOLEY_DOUBLE_ELEMENTS: 809 access.type = Type::Number(); 810 access.write_barrier_kind = kNoWriteBarrier; 811 access.machine_type = MachineType::Float64(); 812 break; 813 default: 814 UNREACHABLE(); 815 break; 816 } 817 return access; 818 } 819 820 // static 821 ElementAccess AccessBuilder::ForFixedDoubleArrayElement() { 822 ElementAccess access = {kTaggedBase, FixedDoubleArray::kHeaderSize, 823 TypeCache::Get().kFloat64, MachineType::Float64(), 824 kNoWriteBarrier}; 825 return access; 826 } 827 828 829 // static 830 ElementAccess AccessBuilder::ForTypedArrayElement(ExternalArrayType type, 831 bool is_external) { 832 BaseTaggedness taggedness = is_external ? kUntaggedBase : kTaggedBase; 833 int header_size = is_external ? 0 : FixedTypedArrayBase::kDataOffset; 834 switch (type) { 835 case kExternalInt8Array: { 836 ElementAccess access = {taggedness, header_size, Type::Signed32(), 837 MachineType::Int8(), kNoWriteBarrier}; 838 return access; 839 } 840 case kExternalUint8Array: 841 case kExternalUint8ClampedArray: { 842 ElementAccess access = {taggedness, header_size, Type::Unsigned32(), 843 MachineType::Uint8(), kNoWriteBarrier}; 844 return access; 845 } 846 case kExternalInt16Array: { 847 ElementAccess access = {taggedness, header_size, Type::Signed32(), 848 MachineType::Int16(), kNoWriteBarrier}; 849 return access; 850 } 851 case kExternalUint16Array: { 852 ElementAccess access = {taggedness, header_size, Type::Unsigned32(), 853 MachineType::Uint16(), kNoWriteBarrier}; 854 return access; 855 } 856 case kExternalInt32Array: { 857 ElementAccess access = {taggedness, header_size, Type::Signed32(), 858 MachineType::Int32(), kNoWriteBarrier}; 859 return access; 860 } 861 case kExternalUint32Array: { 862 ElementAccess access = {taggedness, header_size, Type::Unsigned32(), 863 MachineType::Uint32(), kNoWriteBarrier}; 864 return access; 865 } 866 case kExternalFloat32Array: { 867 ElementAccess access = {taggedness, header_size, Type::Number(), 868 MachineType::Float32(), kNoWriteBarrier}; 869 return access; 870 } 871 case kExternalFloat64Array: { 872 ElementAccess access = {taggedness, header_size, Type::Number(), 873 MachineType::Float64(), kNoWriteBarrier}; 874 return access; 875 } 876 } 877 UNREACHABLE(); 878 ElementAccess access = {kUntaggedBase, 0, Type::None(), MachineType::None(), 879 kNoWriteBarrier}; 880 return access; 881 } 882 883 // static 884 FieldAccess AccessBuilder::ForHashTableBaseNumberOfElements() { 885 FieldAccess access = { 886 kTaggedBase, 887 FixedArray::OffsetOfElementAt(HashTableBase::kNumberOfElementsIndex), 888 MaybeHandle<Name>(), 889 MaybeHandle<Map>(), 890 Type::SignedSmall(), 891 MachineType::TaggedSigned(), 892 kNoWriteBarrier}; 893 return access; 894 } 895 896 // static 897 FieldAccess AccessBuilder::ForHashTableBaseNumberOfDeletedElement() { 898 FieldAccess access = { 899 kTaggedBase, FixedArray::OffsetOfElementAt( 900 HashTableBase::kNumberOfDeletedElementsIndex), 901 MaybeHandle<Name>(), MaybeHandle<Map>(), Type::SignedSmall(), 902 MachineType::TaggedSigned(), kNoWriteBarrier}; 903 return access; 904 } 905 906 // static 907 FieldAccess AccessBuilder::ForHashTableBaseCapacity() { 908 FieldAccess access = { 909 kTaggedBase, 910 FixedArray::OffsetOfElementAt(HashTableBase::kCapacityIndex), 911 MaybeHandle<Name>(), 912 MaybeHandle<Map>(), 913 Type::SignedSmall(), 914 MachineType::TaggedSigned(), 915 kNoWriteBarrier}; 916 return access; 917 } 918 919 // static 920 FieldAccess AccessBuilder::ForDictionaryMaxNumberKey() { 921 FieldAccess access = { 922 kTaggedBase, 923 FixedArray::OffsetOfElementAt(NameDictionary::kMaxNumberKeyIndex), 924 MaybeHandle<Name>(), 925 MaybeHandle<Map>(), 926 Type::Any(), 927 MachineType::AnyTagged(), 928 kNoWriteBarrier}; 929 return access; 930 } 931 932 // static 933 FieldAccess AccessBuilder::ForDictionaryNextEnumerationIndex() { 934 FieldAccess access = { 935 kTaggedBase, 936 FixedArray::OffsetOfElementAt(NameDictionary::kNextEnumerationIndexIndex), 937 MaybeHandle<Name>(), 938 MaybeHandle<Map>(), 939 Type::SignedSmall(), 940 MachineType::TaggedSigned(), 941 kNoWriteBarrier}; 942 return access; 943 } 944 945 } // namespace compiler 946 } // namespace internal 947 } // namespace v8 948
