[turbofan] Propagate representation information from call descriptors in SimplifiedLowering.

src/compiler/simplified-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/compiler/simplified-lowering.h"
 
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 396 matching lines @@
     } else {
       // Propagate {use} of the phi to value inputs, and 0 to control.
       MachineType use_type =
           static_cast<MachineType>((use & kTypeMask) | output);
       for (int i = 0; i < node->InputCount(); i++) {
         ProcessInput(node, i, i < values ? use_type : 0);
       }
     }
   }
 
+  void VisitCall(Node* node, SimplifiedLowering* lowering) {
+    const CallDescriptor* desc = OpParameter<const CallDescriptor*>(node->op());
+    const MachineSignature* sig = desc->GetMachineSignature();
+    int params = static_cast<int>(sig->parameter_count());
+    // Propagate representation information from call descriptor.
+    for (int i = 0; i < node->InputCount(); i++) {
+      if (i == 0) {
+        // The target of the call.
+        ProcessInput(node, i, 0);
+      } else if ((i - 1) < params) {
+        ProcessInput(node, i, sig->GetParam(i - 1));
+      } else {
+        ProcessInput(node, i, 0);
+      }
+    }
+
+    SetOutput(node, desc->GetMachineSignature()->GetReturn());
+  }
+
   void VisitStateValues(Node* node) {
     if (phase_ == PROPAGATE) {
       for (int i = 0; i < node->InputCount(); i++) {
         Enqueue(node->InputAt(i), kTypeAny);
       }
     } else {
       Zone* zone = jsgraph_->zone();
       ZoneVector<MachineType>* types =
           new (zone->New(sizeof(ZoneVector<MachineType>)))
               ZoneVector<MachineType>(node->InputCount(), zone);
@@ skipping 99 matching lines @@
         Enqueue(NodeProperties::GetControlInput(node, 0));
         break;
       case IrOpcode::kSwitch:
         ProcessInput(node, 0, kRepWord32);
         Enqueue(NodeProperties::GetControlInput(node, 0));
         break;
       case IrOpcode::kSelect:
         return VisitSelect(node, use, lowering);
       case IrOpcode::kPhi:
         return VisitPhi(node, use, lowering);
+      case IrOpcode::kCall:
+        return VisitCall(node, lowering);
 
 //------------------------------------------------------------------
 // JavaScript operators.
 //------------------------------------------------------------------
 // For now, we assume that all JS operators were too complex to lower
 // to Simplified and that they will always require tagged value inputs
 // and produce tagged value outputs.
 // TODO(turbofan): it might be possible to lower some JSOperators here,
 // but that responsibility really lies in the typed lowering phase.
 #define DEFINE_JS_CASE(x) case IrOpcode::k##x:
@@ skipping 1087 matching lines @@
 
 void SimplifiedLowering::DoStringLessThanOrEqual(Node* node) {
   node->set_op(machine()->IntLessThanOrEqual());
   node->ReplaceInput(0, StringComparison(node, true));
   node->ReplaceInput(1, jsgraph()->SmiConstant(EQUAL));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8