[Turbofan]: Use new MachineTypes in access-builder.

src/compiler/access-builder.cc

 // 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"
 
 #include "src/compiler/type-cache.h"
 #include "src/contexts.h"
 #include "src/frames.h"
 #include "src/handles-inl.h"
@@ skipping 212 matching lines @@
                         MachineType::Uint32(), kNoWriteBarrier};
   return access;
 }
 
 // static
 FieldAccess AccessBuilder::ForJSArrayBufferViewBuffer() {
   FieldAccess access = {kTaggedBase,
                         JSArrayBufferView::kBufferOffset,
                         MaybeHandle<Name>(),
                         Type::TaggedPointer(),
-                        MachineType::AnyTagged(),
+                        MachineType::TaggedPointer(),
                         kPointerWriteBarrier};
   return access;
 }
 
 // static
 FieldAccess AccessBuilder::ForJSArrayBufferViewByteLength() {
   FieldAccess access = {kTaggedBase,
                         JSArrayBufferView::kByteLengthOffset,
                         MaybeHandle<Name>(),
                         TypeCache::Get().kPositiveInteger,
@@ skipping 115 matching lines @@
                         kNoWriteBarrier};
   return access;
 }
 
 // static
 FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
   FieldAccess access = {kTaggedBase,
                         DescriptorArray::kEnumCacheOffset,
                         Handle<Name>(),
                         Type::TaggedPointer(),
-                        MachineType::AnyTagged(),
+                        MachineType::TaggedPointer(),
                         kPointerWriteBarrier};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache() {
   FieldAccess access = {kTaggedBase,
                         DescriptorArray::kEnumCacheBridgeCacheOffset,
                         Handle<Name>(),
                         Type::TaggedPointer(),
-                        MachineType::AnyTagged(),
+                        MachineType::TaggedPointer(),
                         kPointerWriteBarrier};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapBitField() {
   FieldAccess access = {kTaggedBase,          Map::kBitFieldOffset,
                         Handle<Name>(),       TypeCache::Get().kUint8,
                         MachineType::Uint8(), kNoWriteBarrier};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapBitField3() {
   FieldAccess access = {kTaggedBase,          Map::kBitField3Offset,
                         Handle<Name>(),       TypeCache::Get().kInt32,
                         MachineType::Int32(), kNoWriteBarrier};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapDescriptors() {
-  FieldAccess access = {
-      kTaggedBase,           Map::kDescriptorsOffset,  Handle<Name>(),
-      Type::TaggedPointer(), MachineType::AnyTagged(), kPointerWriteBarrier};
+  FieldAccess access = {kTaggedBase,
+                        Map::kDescriptorsOffset,
+                        Handle<Name>(),
+                        Type::TaggedPointer(),
+                        MachineType::TaggedPointer(),
+                        kPointerWriteBarrier};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapInstanceType() {
   FieldAccess access = {kTaggedBase,          Map::kInstanceTypeOffset,
                         Handle<Name>(),       TypeCache::Get().kUint8,
                         MachineType::Uint8(), kNoWriteBarrier};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapPrototype() {
-  FieldAccess access = {
-      kTaggedBase,           Map::kPrototypeOffset,    Handle<Name>(),
-      Type::TaggedPointer(), MachineType::AnyTagged(), kPointerWriteBarrier};
+  FieldAccess access = {kTaggedBase,
+                        Map::kPrototypeOffset,
+                        Handle<Name>(),
+                        Type::TaggedPointer(),
+                        MachineType::TaggedPointer(),
+                        kPointerWriteBarrier};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForNameHashField() {
   FieldAccess access = {kTaggedBase,           Name::kHashFieldOffset,
                         Handle<Name>(),        Type::Internal(),
                         MachineType::Uint32(), kNoWriteBarrier};
   return access;
@@ skipping 165 matching lines @@
 
 
 // static
 FieldAccess AccessBuilder::ForPropertyCellValue() {
   return ForPropertyCellValue(Type::Tagged());
 }
 
 
 // static
 FieldAccess AccessBuilder::ForPropertyCellValue(Type* type) {
+  // Extract representation dimension of {type} into MachineType {r}.
+  MachineType r = MachineType::AnyTagged();
+  WriteBarrierKind w = kFullWriteBarrier;
+  if (type->Is(Type::TaggedSigned())) {
+    r = MachineType::TaggedSigned();
+    w = kNoWriteBarrier;
+  } else if (type->Is(Type::TaggedPointer())) {
+    r = MachineType::TaggedPointer();
+  }
   FieldAccess access = {
-      kTaggedBase, PropertyCell::kValueOffset, Handle<Name>(),
-      type,        MachineType::AnyTagged(),   kFullWriteBarrier};
+      kTaggedBase, PropertyCell::kValueOffset, Handle<Name>(), type, r, w};
   return access;
 }
 
 // static
 ElementAccess AccessBuilder::ForFixedArrayElement() {
   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Tagged(),
                           MachineType::AnyTagged(), kFullWriteBarrier};
   return access;
 }
 
 // static
 ElementAccess AccessBuilder::ForFixedArrayElement(ElementsKind kind) {
   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
                           MachineType::AnyTagged(), kFullWriteBarrier};
   switch (kind) {
     case FAST_SMI_ELEMENTS:
       access.type = TypeCache::Get().kSmi;
+      access.machine_type = MachineType::TaggedSigned();
       access.write_barrier_kind = kNoWriteBarrier;
       break;
     case FAST_HOLEY_SMI_ELEMENTS:
       access.type = TypeCache::Get().kHoleySmi;
       break;
     case FAST_ELEMENTS:
       access.type = Type::NonInternal();
       break;
     case FAST_HOLEY_ELEMENTS:
       break;
@@ skipping 73 matching lines @@
   }
   UNREACHABLE();
   ElementAccess access = {kUntaggedBase, 0, Type::None(), MachineType::None(),
                           kNoWriteBarrier};
   return access;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8