[turbofan] Add MachineType to LinkageLocation

test/cctest/compiler/test-run-native-calls.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/assembler.h"
 #include "src/codegen.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/machine-type.h"
 #include "src/register-configuration.h"
@@ skipping 121 matching lines @@
 
   LinkageLocation Next(MachineType type) {
     if (IsFloatingPoint(type.representation())) {
       // Allocate a floating point register/stack location.
       if (fp_offset < fp_count) {
         int code = fp_regs[fp_offset++];
 #if V8_TARGET_ARCH_ARM
         // TODO(bbudge) Modify wasm linkage to allow use of all float regs.
         if (type.representation() == MachineRepresentation::kFloat32) code *= 2;
 #endif
-        return LinkageLocation::ForRegister(code);
+        return LinkageLocation::ForRegister(code, type);
       } else {
         int offset = -1 - stack_offset;
         stack_offset += StackWords(type);
-        return LinkageLocation::ForCallerFrameSlot(offset);
+        return LinkageLocation::ForCallerFrameSlot(offset, type);
       }
     } else {
       // Allocate a general purpose register/stack location.
       if (gp_offset < gp_count) {
-        return LinkageLocation::ForRegister(gp_regs[gp_offset++]);
+        return LinkageLocation::ForRegister(gp_regs[gp_offset++], type);
       } else {
         int offset = -1 - stack_offset;
         stack_offset += StackWords(type);
-        return LinkageLocation::ForCallerFrameSlot(offset);
+        return LinkageLocation::ForCallerFrameSlot(offset, type);
       }
     }
   }
   int StackWords(MachineType type) {
     int size = 1 << ElementSizeLog2Of(type.representation());
     return size <= kPointerSize ? 1 : size / kPointerSize;
   }
   void Reset() {
     fp_offset = 0;
     gp_offset = 0;
@@ skipping 27 matching lines @@
     const RegList kCalleeSaveRegisters = 0;
     const RegList kCalleeSaveFPRegisters = 0;
 
     MachineType target_type = MachineType::AnyTagged();
     LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
     int stack_param_count = params.stack_offset;
     return new (zone) CallDescriptor(       // --
         CallDescriptor::kCallCodeObject,    // kind
         target_type,                        // target MachineType
         target_loc,                         // target location
-        msig,                               // machine_sig
         locations.Build(),                  // location_sig
         stack_param_count,                  // stack_parameter_count
         compiler::Operator::kNoProperties,  // properties
         kCalleeSaveRegisters,               // callee-saved registers
         kCalleeSaveFPRegisters,             // callee-saved fp regs
         CallDescriptor::kUseNativeStack,    // flags
         "c-call");
   }
 
  private:
@@ skipping 50 matching lines @@
     OFStream os(stdout);
     code->Disassemble(name, os);
   }
 #endif
   return code;
 }
 
 
 Handle<Code> WrapWithCFunction(Handle<Code> inner, CallDescriptor* desc) {
   Zone zone(inner->GetIsolate()->allocator());
-  MachineSignature* msig =
-      const_cast<MachineSignature*>(desc->GetMachineSignature());
-  int param_count = static_cast<int>(msig->parameter_count());
+  int param_count = static_cast<int>(desc->ParameterCount());
   GraphAndBuilders caller(&zone);
   {
     GraphAndBuilders& b = caller;
     Node* start = b.graph()->NewNode(b.common()->Start(param_count + 3));
     b.graph()->SetStart(start);
     Node* target = b.graph()->NewNode(b.common()->HeapConstant(inner));
 
     // Add arguments to the call.
     Node** args = zone.NewArray<Node*>(param_count + 3);
     int index = 0;
     args[index++] = target;
     for (int i = 0; i < param_count; i++) {
       args[index] = b.graph()->NewNode(b.common()->Parameter(i), start);
       index++;
     }
     args[index++] = start;  // effect.
     args[index++] = start;  // control.
 
     // Build the call and return nodes.
     Node* call =
         b.graph()->NewNode(b.common()->Call(desc), param_count + 3, args);
     Node* ret = b.graph()->NewNode(b.common()->Return(), call, call, start);
     b.graph()->SetEnd(ret);
   }
 
+  MachineSignature* msig = desc->GetMachineSignature(&zone);
   CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, msig);
 
   return CompileGraph("wrapper", cdesc, caller.graph());
 }
 
 
 template <typename CType>
 class ArgsBuffer {
  public:
   static const int kMaxParamCount = 64;
@@ skipping 100 matching lines @@
   float64 base = -111.25 * seed_;
   for (int j = 0; j < count_ && j < kMaxParamCount; j++) {
     input[j] = 256 + base + j + seed_ * 13;
   }
   output = std::numeric_limits<float64>::quiet_NaN();
   seed_++;
 }
 
 
 int ParamCount(CallDescriptor* desc) {
-  return static_cast<int>(desc->GetMachineSignature()->parameter_count());
+  return static_cast<int>(desc->ParameterCount());
 }
 
 
 template <typename CType>
 class Computer {
  public:
   static void Run(CallDescriptor* desc,
                   void (*build)(CallDescriptor*, RawMachineAssembler&),
                   CType (*compute)(CallDescriptor*, CType* inputs),
                   int seed = 1) {
@@ skipping 98 matching lines @@
     b.graph()->SetStart(start);
     Node* p0 = b.graph()->NewNode(b.common()->Parameter(0), start);
     Node* p1 = b.graph()->NewNode(b.common()->Parameter(1), start);
     Node* add = b.graph()->NewNode(b.machine()->Int32Sub(), p0, p1);
     Node* ret = b.graph()->NewNode(b.common()->Return(), add, start, start);
     b.graph()->SetEnd(ret);
   }
 
   Handle<Code> inner_code = CompileGraph("Int32Sub", desc, inner.graph());
   Handle<Code> wrapper = WrapWithCFunction(inner_code, desc);
-  MachineSignature* msig =
-      const_cast<MachineSignature*>(desc->GetMachineSignature());
+  MachineSignature* msig = desc->GetMachineSignature(&zone);
   CodeRunner<int32_t> runnable(isolate, wrapper,
                                CSignature::FromMachine(&zone, msig));
 
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*i) -
                                               static_cast<uint32_t>(*j));
       int32_t result = runnable.Call(*i, *j);
       CHECK_EQ(expected, result);
     }
@@ skipping 653 matching lines @@
   TestStackSlot(MachineType::Float32(), magic);
 }
 
 TEST(RunStackSlotFloat64) {
   double magic = 3456.375;
   TestStackSlot(MachineType::Float64(), magic);
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8