[turbofan] Renames variables in machine-graph-verifier.cc to make them consistent.

src/compiler/machine-graph-verifier.cc

 // Copyright 2016 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/machine-graph-verifier.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node.h"
 #include "src/compiler/schedule.h"
 #include "src/zone/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
 class MachineRepresentationInferrer {
  public:
   MachineRepresentationInferrer(Schedule const* schedule, Graph const* graph,
                                 Linkage* linkage, Zone* zone)
       : schedule_(schedule),
         linkage_(linkage),
-        representation_vector_(graph->NodeCount(), zone) {
+        representation_vector_(graph->NodeCount(), MachineRepresentation::kNone,
+                               zone) {
     Run();
   }
 
   MachineRepresentation GetRepresentation(Node const* node) const {
     return representation_vector_.at(node->id());
   }
 
  private:
   MachineRepresentation GetProjectionType(Node const* projection) {
     size_t index = ProjectionIndexOf(projection->op());
@@ skipping 188 matching lines @@
     }
   }
 
   Schedule const* const schedule_;
   Linkage const* const linkage_;
   ZoneVector<MachineRepresentation> representation_vector_;
 };
 
 class MachineRepresentationChecker {
  public:
-  MachineRepresentationChecker(Schedule const* const schedule,
-                               MachineRepresentationInferrer const* const typer)
-      : schedule_(schedule), typer_(typer) {}
+  MachineRepresentationChecker(
+      Schedule const* const schedule,
+      MachineRepresentationInferrer const* const inferrer)
+      : schedule_(schedule), inferrer_(inferrer) {}
 
   void Run() {
     BasicBlockVector const* blocks = schedule_->all_blocks();
     for (BasicBlock* block : *blocks) {
       for (size_t i = 0; i <= block->NodeCount(); ++i) {
         Node const* node =
             i < block->NodeCount() ? block->NodeAt(i) : block->control_input();
         if (node == nullptr) {
           DCHECK_EQ(block->NodeCount(), i);
           break;
         }
         switch (node->opcode()) {
           case IrOpcode::kCall:
           case IrOpcode::kTailCall:
             CheckCallInputs(node);
             break;
           case IrOpcode::kChangeBitToTagged:
             CHECK_EQ(MachineRepresentation::kBit,
-                     typer_->GetRepresentation(node->InputAt(0)));
+                     inferrer_->GetRepresentation(node->InputAt(0)));
             break;
           case IrOpcode::kChangeTaggedToBit:
             CHECK_EQ(MachineRepresentation::kTagged,
-                     typer_->GetRepresentation(node->InputAt(0)));
+                     inferrer_->GetRepresentation(node->InputAt(0)));
             break;
           case IrOpcode::kRoundInt64ToFloat64:
           case IrOpcode::kRoundUint64ToFloat64:
           case IrOpcode::kRoundInt64ToFloat32:
           case IrOpcode::kRoundUint64ToFloat32:
           case IrOpcode::kTruncateInt64ToInt32:
             CheckValueInputForInt64Op(node, 0);
             break;
           case IrOpcode::kBitcastWordToTagged:
           case IrOpcode::kBitcastWordToTaggedSigned:
@@ skipping 10 matching lines @@
           case IrOpcode::kChangeFloat64ToUint32:
           case IrOpcode::kRoundFloat64ToInt32:
           case IrOpcode::kFloat64ExtractLowWord32:
           case IrOpcode::kFloat64ExtractHighWord32:
           case IrOpcode::kBitcastFloat64ToInt64:
             CheckValueInputForFloat64Op(node, 0);
             break;
           case IrOpcode::kWord64Equal:
             CheckValueInputIsTaggedOrPointer(node, 0);
             CheckValueInputRepresentationIs(
-                node, 1, typer_->GetRepresentation(node->InputAt(0)));
+                node, 1, inferrer_->GetRepresentation(node->InputAt(0)));
             break;
           case IrOpcode::kInt64LessThan:
           case IrOpcode::kInt64LessThanOrEqual:
           case IrOpcode::kUint64LessThan:
           case IrOpcode::kUint64LessThanOrEqual:
             CheckValueInputForInt64Op(node, 0);
             CheckValueInputForInt64Op(node, 1);
             break;
           case IrOpcode::kInt32x4ExtractLane:
             CheckValueInputRepresentationIs(node, 0,
@@ skipping 89 matching lines @@
               case MachineRepresentation::kTaggedPointer:
               case MachineRepresentation::kTaggedSigned:
                 CheckValueInputIsTagged(node, 2);
                 break;
               default:
                 CheckValueInputRepresentationIs(
                     node, 2, AtomicStoreRepresentationOf(node->op()));
             }
             break;
           case IrOpcode::kPhi:
-            switch (typer_->GetRepresentation(node)) {
+            switch (inferrer_->GetRepresentation(node)) {
               case MachineRepresentation::kTagged:
               case MachineRepresentation::kTaggedPointer:
               case MachineRepresentation::kTaggedSigned:
                 for (int i = 0; i < node->op()->ValueInputCount(); ++i) {
                   CheckValueInputIsTagged(node, i);
                 }
                 break;
               default:
                 for (int i = 0; i < node->op()->ValueInputCount(); ++i) {
                   CheckValueInputRepresentationIs(
-                      node, i, typer_->GetRepresentation(node));
+                      node, i, inferrer_->GetRepresentation(node));
                 }
                 break;
             }
             break;
           case IrOpcode::kBranch:
           case IrOpcode::kSwitch:
             CheckValueInputForInt32Op(node, 0);
             break;
           case IrOpcode::kReturn:
             // TODO(epertoso): use the linkage to determine which tipe we
@@ skipping 12 matching lines @@
             break;
         }
       }
     }
   }
 
  private:
   void CheckValueInputRepresentationIs(Node const* node, int index,
                                        MachineRepresentation representation) {
     Node const* input = node->InputAt(index);
-    if (typer_->GetRepresentation(input) != representation) {
+    if (inferrer_->GetRepresentation(input) != representation) {
       std::stringstream str;
       str << "TypeError: node #" << node->id() << ":" << *node->op()
           << " uses node #" << input->id() << ":" << *input->op()
           << " which doesn't have a " << MachineReprToString(representation)
           << " representation.";
       FATAL(str.str().c_str());
     }
   }
 
   void CheckValueInputIsTagged(Node const* node, int index) {
     Node const* input = node->InputAt(index);
-    switch (typer_->GetRepresentation(input)) {
+    switch (inferrer_->GetRepresentation(input)) {
       case MachineRepresentation::kTagged:
       case MachineRepresentation::kTaggedPointer:
       case MachineRepresentation::kTaggedSigned:
         return;
       default:
         break;
     }
     std::ostringstream str;
     str << "TypeError: node #" << node->id() << ":" << *node->op()
         << " uses node #" << input->id() << ":" << *input->op()
         << " which doesn't have a tagged representation.";
     FATAL(str.str().c_str());
   }
 
   void CheckValueInputIsTaggedOrPointer(Node const* node, int index) {
     Node const* input = node->InputAt(index);
-    switch (typer_->GetRepresentation(input)) {
+    switch (inferrer_->GetRepresentation(input)) {
       case MachineRepresentation::kTagged:
       case MachineRepresentation::kTaggedPointer:
       case MachineRepresentation::kTaggedSigned:
         return;
       default:
         break;
     }
-    if (typer_->GetRepresentation(input) !=
+    if (inferrer_->GetRepresentation(input) !=
         MachineType::PointerRepresentation()) {
       std::ostringstream str;
       str << "TypeError: node #" << node->id() << ":" << *node->op()
           << " uses node #" << input->id() << ":" << *input->op()
           << " which doesn't have a tagged or pointer representation.";
       FATAL(str.str().c_str());
     }
   }
 
   void CheckValueInputForInt32Op(Node const* node, int index) {
     Node const* input = node->InputAt(index);
-    switch (typer_->GetRepresentation(input)) {
+    switch (inferrer_->GetRepresentation(input)) {
       case MachineRepresentation::kBit:
       case MachineRepresentation::kWord8:
       case MachineRepresentation::kWord16:
       case MachineRepresentation::kWord32:
         return;
       case MachineRepresentation::kNone: {
         std::ostringstream str;
         str << "TypeError: node #" << input->id() << ":" << *input->op()
             << " is untyped.";
         FATAL(str.str().c_str());
         break;
       }
       default:
         break;
     }
     std::ostringstream str;
     str << "TypeError: node #" << node->id() << ":" << *node->op()
         << " uses node #" << input->id() << ":" << *input->op()
         << " which doesn't have an int32-compatible representation.";
     FATAL(str.str().c_str());
   }
 
   void CheckValueInputForInt64Op(Node const* node, int index) {
     Node const* input = node->InputAt(index);
-    switch (typer_->GetRepresentation(input)) {
+    switch (inferrer_->GetRepresentation(input)) {
       case MachineRepresentation::kWord64:
         return;
       case MachineRepresentation::kNone: {
         std::ostringstream str;
         str << "TypeError: node #" << input->id() << ":" << *input->op()
             << " is untyped.";
         FATAL(str.str().c_str());
         break;
       }
 
       default:
         break;
     }
     std::ostringstream str;
     str << "TypeError: node #" << node->id() << ":" << *node->op()
         << " uses node #" << input->id() << ":" << *input->op()
         << " which doesn't have a kWord64 representation.";
     FATAL(str.str().c_str());
   }
 
   void CheckValueInputForFloat32Op(Node const* node, int index) {
     Node const* input = node->InputAt(index);
-    if (MachineRepresentation::kFloat32 == typer_->GetRepresentation(input)) {
+    if (MachineRepresentation::kFloat32 ==
+        inferrer_->GetRepresentation(input)) {
       return;
     }
     std::ostringstream str;
     str << "TypeError: node #" << node->id() << ":" << *node->op()
         << " uses node #" << input->id() << ":" << *input->op()
         << " which doesn't have a kFloat32 representation.";
     FATAL(str.str().c_str());
   }
 
   void CheckValueInputForFloat64Op(Node const* node, int index) {
     Node const* input = node->InputAt(index);
-    if (MachineRepresentation::kFloat64 == typer_->GetRepresentation(input)) {
+    if (MachineRepresentation::kFloat64 ==
+        inferrer_->GetRepresentation(input)) {
       return;
     }
     std::ostringstream str;
     str << "TypeError: node #" << node->id() << ":" << *node->op()
         << " uses node #" << input->id() << ":" << *input->op()
         << " which doesn't have a kFloat64 representation.";
     FATAL(str.str().c_str());
   }
 
   void CheckCallInputs(Node const* node) {
     CallDescriptor const* desc = CallDescriptorOf(node->op());
     std::ostringstream str;
     bool should_log_error = false;
     for (size_t i = 0; i < desc->InputCount(); ++i) {
       Node const* input = node->InputAt(static_cast<int>(i));
-      MachineRepresentation const input_type = typer_->GetRepresentation(input);
+      MachineRepresentation const input_type =
+          inferrer_->GetRepresentation(input);
       MachineRepresentation const expected_input_type =
           desc->GetInputType(i).representation();
       if (!IsCompatible(expected_input_type, input_type)) {
         if (!should_log_error) {
           should_log_error = true;
           str << "TypeError: node #" << node->id() << ":" << *node->op()
               << " has wrong type for:" << std::endl;
         } else {
           str << std::endl;
         }
@@ skipping 59 matching lines @@
                 actual == MachineRepresentation::kWord8 ||
                 actual == MachineRepresentation::kWord16 ||
                 actual == MachineRepresentation::kWord32);
       case MachineRepresentation::kNone:
         UNREACHABLE();
     }
     return false;
   }
 
   Schedule const* const schedule_;
-  MachineRepresentationInferrer const* const typer_;
+  MachineRepresentationInferrer const* const inferrer_;
 };
 
 }  // namespace
 
 void MachineGraphVerifier::Run(Graph* graph, Schedule const* const schedule,
                                Linkage* linkage, Zone* temp_zone) {
   MachineRepresentationInferrer representation_inferrer(schedule, graph,
                                                         linkage, temp_zone);
   MachineRepresentationChecker checker(schedule, &representation_inferrer);
   checker.Run();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8