[turbofan] Introduce MachineRepresentation to PropertyAccessInfo.

src/compiler/js-native-context-specialization.cc

 // Copyright 2015 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/js-native-context-specialization.h"
 
 #include "src/accessors.h"
 #include "src/code-factory.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
@@ skipping 863 matching lines @@
                 3, VectorSlotPair(), ConvertReceiverMode::kNotNullOrUndefined),
             target, receiver, value, context, frame_state0, effect, control);
         control = graph()->NewNode(common()->IfSuccess(), effect);
         break;
       }
     }
   } else {
     DCHECK(access_info.IsDataField());
     FieldIndex const field_index = access_info.field_index();
     Type* const field_type = access_info.field_type();
+    MachineRepresentation const rep = access_info.representation();
     if (access_mode == AccessMode::kLoad &&
         access_info.holder().ToHandle(&holder)) {
       receiver = jsgraph()->Constant(holder);
     }
     Node* storage = receiver;
     if (!field_index.is_inobject()) {
       storage = effect = graph()->NewNode(
           simplified()->LoadField(AccessBuilder::ForJSObjectProperties()),
           storage, effect, control);
     }
+    // TODO(mvstanton): note that for the field_access.machine_type we don't
+    // incorporate the MachineRepresentation information that we have. This is
+    // done below, only if numerous conditions are met on a case by case basis.
+    // Is this the correct albeit conservative choice?
     FieldAccess field_access = {
         kTaggedBase, field_index.offset(),     name,
         field_type,  MachineType::AnyTagged(), kFullWriteBarrier};
     if (access_mode == AccessMode::kLoad) {
-      if (field_type->Is(Type::UntaggedFloat64())) {
-        // TODO(turbofan): We remove the representation axis from the type to
-        // avoid uninhabited representation types. This is a workaround until
-        // the {PropertyAccessInfo} is using {MachineRepresentation} instead.
-        field_access.type = Type::Union(
-            field_type, Type::Representation(Type::Number(), zone()), zone());
+      if (rep == MachineRepresentation::kFloat64) {
         if (!field_index.is_inobject() || field_index.is_hidden_field() ||
             !FLAG_unbox_double_fields) {
           storage = effect = graph()->NewNode(
               simplified()->LoadField(field_access), storage, effect, control);
           field_access.offset = HeapNumber::kValueOffset;
           field_access.name = MaybeHandle<Name>();
         }
         field_access.machine_type = MachineType::Float64();
       }
       value = effect = graph()->NewNode(simplified()->LoadField(field_access),
                                         storage, effect, control);
     } else {
       DCHECK_EQ(AccessMode::kStore, access_mode);
-      if (field_type->Is(Type::UntaggedFloat64())) {
-        // TODO(turbofan): We remove the representation axis from the type to
-        // avoid uninhabited representation types. This is a workaround until
-        // the {PropertyAccessInfo} is using {MachineRepresentation} instead.
-        field_access.type = Type::Union(
-            field_type, Type::Representation(Type::Number(), zone()), zone());
+      if (rep == MachineRepresentation::kFloat64) {
         value = effect = graph()->NewNode(simplified()->CheckNumber(), value,
                                           effect, control);
 
         if (!field_index.is_inobject() || field_index.is_hidden_field() ||
             !FLAG_unbox_double_fields) {
           if (access_info.HasTransitionMap()) {
             // Allocate a MutableHeapNumber for the new property.
             effect = graph()->NewNode(
                 common()->BeginRegion(RegionObservability::kNotObservable),
                 effect);
             Node* box = effect = graph()->NewNode(
                 simplified()->Allocate(NOT_TENURED),
                 jsgraph()->Constant(HeapNumber::kSize), effect, control);
             effect = graph()->NewNode(
                 simplified()->StoreField(AccessBuilder::ForMap()), box,
                 jsgraph()->HeapConstant(factory()->mutable_heap_number_map()),
                 effect, control);
             effect = graph()->NewNode(
                 simplified()->StoreField(AccessBuilder::ForHeapNumberValue()),
                 box, value, effect, control);
             value = effect =
                 graph()->NewNode(common()->FinishRegion(), box, effect);
 
+            // TODO(mvstanton): this looks like representation. Should we set
+            // {type}?
             field_access.type = Type::TaggedPointer();
+            field_access.machine_type = MachineType::TaggedPointer();
           } else {
             // We just store directly to the MutableHeapNumber.
             storage = effect =
                 graph()->NewNode(simplified()->LoadField(field_access), storage,
                                  effect, control);
             field_access.offset = HeapNumber::kValueOffset;
             field_access.name = MaybeHandle<Name>();
             field_access.machine_type = MachineType::Float64();
           }
         } else {
           // Unboxed double field, we store directly to the field.
           field_access.machine_type = MachineType::Float64();
         }
-      } else if (field_type->Is(Type::TaggedSigned())) {
+      } else if (rep == MachineRepresentation::kTaggedSigned) {
         value = effect = graph()->NewNode(simplified()->CheckTaggedSigned(),
                                           value, effect, control);
-      } else if (field_type->Is(Type::TaggedPointer())) {
+      } else if (rep == MachineRepresentation::kTaggedPointer) {
         // Ensure that {value} is a HeapObject.
         value = effect = graph()->NewNode(simplified()->CheckTaggedPointer(),
                                           value, effect, control);
         if (field_type->NumClasses() == 1) {
           // Emit a map check for the value.
           Node* field_map =
               jsgraph()->Constant(field_type->Classes().Current());
           effect = graph()->NewNode(simplified()->CheckMaps(1), value,
                                     field_map, effect, control);
         } else {
           DCHECK_EQ(0, field_type->NumClasses());
         }
       } else {
-        DCHECK(field_type->Is(Type::Tagged()));
+        // DCHECK(field_type->Is(Type::Tagged()));
+        DCHECK(rep == MachineRepresentation::kTagged);
       }
       Handle<Map> transition_map;
       if (access_info.transition_map().ToHandle(&transition_map)) {
         effect = graph()->NewNode(
             common()->BeginRegion(RegionObservability::kObservable), effect);
         effect = graph()->NewNode(
             simplified()->StoreField(AccessBuilder::ForMap()), receiver,
             jsgraph()->Constant(transition_map), effect, control);
       }
       effect = graph()->NewNode(simplified()->StoreField(field_access), storage,
@@ skipping 173 matching lines @@
     }
 
     // Compute the element access.
     Type* element_type = Type::NonInternal();
     MachineType element_machine_type = MachineType::AnyTagged();
     if (IsFastDoubleElementsKind(elements_kind)) {
       element_type = Type::Number();
       element_machine_type = MachineType::Float64();
     } else if (IsFastSmiElementsKind(elements_kind)) {
       element_type = type_cache_.kSmi;
+      element_machine_type = MachineType::TaggedSigned();
     }
     ElementAccess element_access = {kTaggedBase, FixedArray::kHeaderSize,
                                     element_type, element_machine_type,
                                     kFullWriteBarrier};
 
     // Access the actual element.
     if (access_mode == AccessMode::kLoad) {
       // Compute the real element access type, which includes the hole in case
       // of holey backing stores.
       if (elements_kind == FAST_HOLEY_ELEMENTS ||
           elements_kind == FAST_HOLEY_SMI_ELEMENTS) {
         element_access.type =
             Type::Union(element_type, Type::Hole(), graph()->zone());
+        element_access.machine_type = MachineType::AnyTagged();
       }
       // Perform the actual backing store access.
       value = effect =
           graph()->NewNode(simplified()->LoadElement(element_access), elements,
                            index, effect, control);
       // Handle loading from holey backing stores correctly, by either mapping
       // the hole to undefined if possible, or deoptimizing otherwise.
       if (elements_kind == FAST_HOLEY_ELEMENTS ||
           elements_kind == FAST_HOLEY_SMI_ELEMENTS) {
         // Check if we are allowed to turn the hole into undefined.
@@ skipping 292 matching lines @@
 }
 
 
 SimplifiedOperatorBuilder* JSNativeContextSpecialization::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8