[turbofan] Make MachineType a pair of enums.

src/compiler/js-typed-lowering.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/code-factory.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/linkage.h"
@@ skipping 366 matching lines @@
     Node* left_exception =
         graph()->NewNode(common()->IfException(hint), left_conv, left_conv);
     Node* right_exception =
         graph()->NewNode(common()->IfException(hint), right_conv, right_conv);
     NodeProperties::ReplaceControlInput(if_success, right_conv);
     update_effect(right_conv);
 
     // Wire conversions to existing {IfException} continuation.
     Node* exception_merge = if_exception;
     Node* exception_value =
-        graph()->NewNode(common()->Phi(kMachAnyTagged, 2), left_exception,
-                         right_exception, exception_merge);
+        graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                         left_exception, right_exception, exception_merge);
     Node* exception_effect =
         graph()->NewNode(common()->EffectPhi(2), left_exception,
                          right_exception, exception_merge);
     for (Edge edge : exception_merge->use_edges()) {
       if (NodeProperties::IsEffectEdge(edge)) edge.UpdateTo(exception_effect);
       if (NodeProperties::IsValueEdge(edge)) edge.UpdateTo(exception_value);
     }
     NodeProperties::RemoveType(exception_merge);
     exception_merge->ReplaceInput(0, left_exception);
     exception_merge->ReplaceInput(1, right_exception);
@@ skipping 423 matching lines @@
     // Recursively try to reduce the input first.
     Reduction result = ReduceJSToString(input);
     if (result.Changed()) return result;
     return Changed(input);  // JSToString(JSToString(x)) => JSToString(x)
   }
   Type* input_type = NodeProperties::GetType(input);
   if (input_type->Is(Type::String())) {
     return Changed(input);  // JSToString(x:string) => x
   }
   if (input_type->Is(Type::Boolean())) {
-    return Replace(
-        graph()->NewNode(common()->Select(kMachAnyTagged), input,
-                         jsgraph()->HeapConstant(factory()->true_string()),
-                         jsgraph()->HeapConstant(factory()->false_string())));
+    return Replace(graph()->NewNode(
+        common()->Select(MachineRepresentation::kTagged), input,
+        jsgraph()->HeapConstant(factory()->true_string()),
+        jsgraph()->HeapConstant(factory()->false_string())));
   }
   if (input_type->Is(Type::Undefined())) {
     return Replace(jsgraph()->HeapConstant(factory()->undefined_string()));
   }
   if (input_type->Is(Type::Null())) {
     return Replace(jsgraph()->HeapConstant(factory()->null_string()));
   }
   // TODO(turbofan): js-typed-lowering of ToString(x:number)
   return NoChange();
 }
@@ skipping 75 matching lines @@
           receiver, context, frame_state, econvert, if_convert);
     }
 
     // The {receiver} is already a spec object.
     Node* if_done = if_true1;
     Node* edone = etrue1;
     Node* rdone = receiver;
 
     control = graph()->NewNode(common()->Merge(2), if_convert, if_done);
     effect = graph()->NewNode(common()->EffectPhi(2), econvert, edone, control);
-    receiver = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), rconvert,
-                                rdone, control);
+    receiver =
+        graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                         rconvert, rdone, control);
   }
   ReplaceWithValue(node, receiver, effect, control);
   return Changed(receiver);
 }
 
 
 Reduction JSTypedLowering::ReduceJSLoadNamed(Node* node) {
   DCHECK_EQ(IrOpcode::kJSLoadNamed, node->opcode());
   Node* receiver = NodeProperties::GetValueInput(node, 0);
   Type* receiver_type = NodeProperties::GetType(receiver);
@@ skipping 38 matching lines @@
   Node* key = NodeProperties::GetValueInput(node, 1);
   Node* base = NodeProperties::GetValueInput(node, 0);
   Type* key_type = NodeProperties::GetType(key);
   HeapObjectMatcher mbase(base);
   if (mbase.HasValue() && mbase.Value()->IsJSTypedArray()) {
     Handle<JSTypedArray> const array =
         Handle<JSTypedArray>::cast(mbase.Value());
     if (!array->GetBuffer()->was_neutered()) {
       array->GetBuffer()->set_is_neuterable(false);
       BufferAccess const access(array->type());
-      size_t const k = ElementSizeLog2Of(access.machine_type());
+      size_t const k =
+          ElementSizeLog2Of(access.machine_type().representation());
       double const byte_length = array->byte_length()->Number();
       CHECK_LT(k, arraysize(shifted_int32_ranges_));
       if (key_type->Is(shifted_int32_ranges_[k]) && byte_length <= kMaxInt) {
         // JSLoadProperty(typed-array, int32)
         Handle<FixedTypedArrayBase> elements =
             Handle<FixedTypedArrayBase>::cast(handle(array->elements()));
         Node* buffer = jsgraph()->PointerConstant(elements->external_pointer());
         Node* length = jsgraph()->Constant(byte_length);
         Node* effect = NodeProperties::GetEffectInput(node);
         Node* control = NodeProperties::GetControlInput(node);
@@ skipping 25 matching lines @@
   Node* value = NodeProperties::GetValueInput(node, 2);
   Type* key_type = NodeProperties::GetType(key);
   Type* value_type = NodeProperties::GetType(value);
   HeapObjectMatcher mbase(base);
   if (mbase.HasValue() && mbase.Value()->IsJSTypedArray()) {
     Handle<JSTypedArray> const array =
         Handle<JSTypedArray>::cast(mbase.Value());
     if (!array->GetBuffer()->was_neutered()) {
       array->GetBuffer()->set_is_neuterable(false);
       BufferAccess const access(array->type());
-      size_t const k = ElementSizeLog2Of(access.machine_type());
+      size_t const k =
+          ElementSizeLog2Of(access.machine_type().representation());
       double const byte_length = array->byte_length()->Number();
       CHECK_LT(k, arraysize(shifted_int32_ranges_));
       if (access.external_array_type() != kExternalUint8ClampedArray &&
           key_type->Is(shifted_int32_ranges_[k]) && byte_length <= kMaxInt) {
         // JSLoadProperty(typed-array, int32)
         Handle<FixedTypedArrayBase> elements =
             Handle<FixedTypedArrayBase>::cast(handle(array->elements()));
         Node* buffer = jsgraph()->PointerConstant(elements->external_pointer());
         Node* length = jsgraph()->Constant(byte_length);
         Node* context = NodeProperties::GetContextInput(node);
         Node* effect = NodeProperties::GetEffectInput(node);
         Node* control = NodeProperties::GetControlInput(node);
         // Convert to a number first.
         if (!value_type->Is(Type::Number())) {
           Reduction number_reduction = ReduceJSToNumberInput(value);
           if (number_reduction.Changed()) {
             value = number_reduction.replacement();
           } else {
             Node* frame_state_for_to_number =
                 NodeProperties::GetFrameStateInput(node, 1);
             value = effect =
                 graph()->NewNode(javascript()->ToNumber(), value, context,
                                  frame_state_for_to_number, effect, control);
           }
         }
         // For integer-typed arrays, convert to the integer type.
-        if (TypeOf(access.machine_type()) == kTypeInt32 &&
+        if (access.machine_type().semantic() == MachineSemantic::kInt32 &&
             !value_type->Is(Type::Signed32())) {
           value = graph()->NewNode(simplified()->NumberToInt32(), value);
-        } else if (TypeOf(access.machine_type()) == kTypeUint32 &&
+        } else if (access.machine_type().semantic() ==
+                       MachineSemantic::kUint32 &&
                    !value_type->Is(Type::Unsigned32())) {
           value = graph()->NewNode(simplified()->NumberToUint32(), value);
         }
         // Check if we can avoid the bounds check.
         if (key_type->Min() >= 0 && key_type->Max() < array->length_value()) {
           RelaxControls(node);
           node->ReplaceInput(0, buffer);
           DCHECK_EQ(key, node->InputAt(1));
           node->ReplaceInput(2, value);
           node->ReplaceInput(3, effect);
@@ skipping 65 matching lines @@
           graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()),
                            r.left(), effect, control);
 
       // Loop through the {object}s prototype chain looking for the {prototype}.
       Node* loop = control =
           graph()->NewNode(common()->Loop(2), control, control);
 
       Node* loop_effect = effect =
           graph()->NewNode(common()->EffectPhi(2), effect, effect, loop);
 
-      Node* loop_object_map = graph()->NewNode(common()->Phi(kMachAnyTagged, 2),
-                                               object_map, r.left(), loop);
+      Node* loop_object_map =
+          graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                           object_map, r.left(), loop);
 
 
       Node* object_prototype = effect = graph()->NewNode(
           simplified()->LoadField(AccessBuilder::ForMapPrototype()),
           loop_object_map, loop_effect, control);
 
       // Check if object prototype is equal to function prototype.
       Node* eq_proto =
           graph()->NewNode(simplified()->ReferenceEqual(r.right_type()),
                            object_prototype, prototype);
@@ skipping 22 matching lines @@
       loop_effect->ReplaceInput(1, effect);
       loop_object_map->ReplaceInput(1, load_object_map);
       loop->ReplaceInput(1, control);
 
       control =
           graph()->NewNode(common()->Merge(2), if_eq_proto, if_null_proto);
       effect = graph()->NewNode(common()->EffectPhi(2), e_eq_proto,
                                 e_null_proto, control);
 
 
-      Node* result = graph()->NewNode(common()->Phi(kTypeBool, 2),
-                                      jsgraph()->TrueConstant(),
-                                      jsgraph()->FalseConstant(), control);
+      Node* result = graph()->NewNode(
+          common()->Phi(MachineRepresentation::kTagged, 2),
+          jsgraph()->TrueConstant(), jsgraph()->FalseConstant(), control);
 
       if (if_is_smi != nullptr) {
         DCHECK(e_is_smi != nullptr);
         control = graph()->NewNode(common()->Merge(2), if_is_smi, control);
         effect =
             graph()->NewNode(common()->EffectPhi(2), e_is_smi, effect, control);
-        result = graph()->NewNode(common()->Phi(kTypeBool, 2),
-                                  jsgraph()->FalseConstant(), result, control);
+        result =
+            graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                             jsgraph()->FalseConstant(), result, control);
       }
       ReplaceWithValue(node, result, effect, control);
       return Changed(result);
     }
   }
 
   return NoChange();
 }
 
 
@@ skipping 118 matching lines @@
               context, context, eglobal);
           rglobal = eglobal = graph()->NewNode(
               javascript()->LoadContext(0, Context::GLOBAL_PROXY_INDEX, true),
               native_context, native_context, eglobal);
         }
       }
 
       control = graph()->NewNode(common()->Merge(2), if_convert, if_global);
       effect =
           graph()->NewNode(common()->EffectPhi(2), econvert, eglobal, control);
-      receiver = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), rconvert,
-                                  rglobal, control);
+      receiver =
+          graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                           rconvert, rglobal, control);
     }
   }
   ReplaceWithValue(node, receiver, effect, control);
   return Changed(receiver);
 }
 
 
 namespace {
 
 // Maximum instance size for which allocations will be inlined.
@@ skipping 847 matching lines @@
       cache_array_false1 = efalse1 = graph()->NewNode(
           simplified()->LoadField(
               AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache()),
           object_map_enum_cache, efalse1, if_false1);
     }
 
     if_true0 = graph()->NewNode(common()->Merge(2), if_true1, if_false1);
     etrue0 =
         graph()->NewNode(common()->EffectPhi(2), etrue1, efalse1, if_true0);
     cache_array_true0 =
-        graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_array_true1,
-                         cache_array_false1, if_true0);
+        graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                         cache_array_true1, cache_array_false1, if_true0);
 
     cache_type_true0 = cache_type;
   }
 
   Node* if_false0 = graph()->NewNode(common()->IfFalse(), branch0);
   Node* cache_array_false0;
   Node* cache_length_false0;
   Node* cache_type_false0;
   Node* efalse0;
   {
     // FixedArray case.
     Node* receiver_instance_type = efalse0 = graph()->NewNode(
         simplified()->LoadField(AccessBuilder::ForMapInstanceType()),
         receiver_map, effect, if_false0);
 
     cache_type_false0 = graph()->NewNode(
-        common()->Select(kMachAnyTagged, BranchHint::kFalse),
+        common()->Select(MachineRepresentation::kTagged, BranchHint::kFalse),
         graph()->NewNode(machine()->Word32Equal(), receiver_instance_type,
                          jsgraph()->Uint32Constant(JS_PROXY_TYPE)),
         jsgraph()->ZeroConstant(),  // Zero indicagtes proxy.
         jsgraph()->OneConstant());  // One means slow check.
 
     cache_array_false0 = cache_type;
     cache_length_false0 = efalse0 = graph()->NewNode(
         simplified()->LoadField(AccessBuilder::ForFixedArrayLength()),
         cache_array_false0, efalse0, if_false0);
   }
 
   control = graph()->NewNode(common()->Merge(2), if_true0, if_false0);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue0, efalse0, control);
   Node* cache_array =
-      graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_array_true0,
-                       cache_array_false0, control);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                       cache_array_true0, cache_array_false0, control);
   Node* cache_length =
-      graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_length_true0,
-                       cache_length_false0, control);
-  cache_type = graph()->NewNode(common()->Phi(kMachAnyTagged, 2),
-                                cache_type_true0, cache_type_false0, control);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                       cache_length_true0, cache_length_false0, control);
+  cache_type =
+      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                       cache_type_true0, cache_type_false0, control);
 
   for (auto edge : node->use_edges()) {
     Node* const use = edge.from();
     if (NodeProperties::IsEffectEdge(edge)) {
       edge.UpdateTo(effect);
       Revisit(use);
     } else {
       if (NodeProperties::IsControlEdge(edge)) {
         if (use->opcode() == IrOpcode::kIfSuccess) {
           Replace(use, control);
@@ skipping 92 matching lines @@
       // {receiver} (does the ToName conversion implicitly).
       vfalse1 = efalse1 = graph()->NewNode(
           javascript()->CallRuntime(Runtime::kForInFilter, 2), receiver, key,
           context, frame_state, effect, if_false1);
       if_false1 = graph()->NewNode(common()->IfSuccess(), vfalse1);
     }
 
     if_false0 = graph()->NewNode(common()->Merge(2), if_true1, if_false1);
     efalse0 =
         graph()->NewNode(common()->EffectPhi(2), etrue1, efalse1, if_false0);
-    vfalse0 = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), vtrue1,
-                               vfalse1, if_false0);
+    vfalse0 = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                               vtrue1, vfalse1, if_false0);
   }
 
   control = graph()->NewNode(common()->Merge(2), if_true0, if_false0);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue0, efalse0, control);
   ReplaceWithValue(node, node, effect, control);
   node->ReplaceInput(0, vtrue0);
   node->ReplaceInput(1, vfalse0);
   node->ReplaceInput(2, control);
   node->TrimInputCount(3);
-  NodeProperties::ChangeOp(node, common()->Phi(kMachAnyTagged, 2));
+  NodeProperties::ChangeOp(node,
+                           common()->Phi(MachineRepresentation::kTagged, 2));
   return Changed(node);
 }
 
 
 Reduction JSTypedLowering::ReduceJSForInStep(Node* node) {
   DCHECK_EQ(IrOpcode::kJSForInStep, node->opcode());
   node->ReplaceInput(1, jsgraph()->Int32Constant(1));
   NodeProperties::ChangeOp(node, machine()->Int32Add());
   return Changed(node);
 }
@@ skipping 300 matching lines @@
 }
 
 
 CompilationDependencies* JSTypedLowering::dependencies() const {
   return dependencies_;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8