Add MachineSignature, which is an encapsulation of the machine types for...

Add MachineSignature, which is an encapsulation of the machine types for parameters and return values in a graph.

This utility will be used to simplify Linkage and fix representation inference
to work with graphs where parameters and return values are something other
than tagged. It will also make testing representation inference a lot
easier, since we can then exactly nail down the machine types of parameters
and returns.

This CL also adds c-signature.h, which demonstrates how to convert C function
signatures into MachineSignatures. The CSignatures will be used in tests to
make it easier and simpler to codegen tests.

R=jarin@chromium.org
BUG=

Review URL: https://codereview.chromium.org/515173002

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23490 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/compiler/change-lowering.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "src/compiler/change-lowering.h"
+#include "src/compiler/machine-operator.h"
 
 #include "src/compiler/js-graph.h"
 

src/compiler/linkage-impl.h

@@ -21,8 +21,7 @@ class LinkageHelper {
   }
 
   static inline LinkageLocation WordRegisterLocation(Register reg) {
-    return LinkageLocation(MachineOperatorBuilder::pointer_rep(),
-                           Register::ToAllocationIndex(reg));
+    return LinkageLocation(kMachPtr, Register::ToAllocationIndex(reg));
   }
 
   static LinkageLocation UnconstrainedRegister(MachineType rep) {
@@ -180,8 +179,7 @@ class LinkageHelper {
     int index = 0;
     locations[index++] =
         TaggedRegisterLocation(LinkageTraits::ReturnValueReg());
-    locations[index++] = LinkageHelper::UnconstrainedRegister(
-        MachineOperatorBuilder::pointer_rep());
+    locations[index++] = LinkageHelper::UnconstrainedRegister(kMachPtr);
     // TODO(dcarney): test with lots of parameters.
     int i = 0;
     for (; i < LinkageTraits::CRegisterParametersLength() && i < num_params;

src/compiler/linkage.h

@@ -9,7 +9,7 @@
 
 #include "src/code-stubs.h"
 #include "src/compiler/frame.h"
-#include "src/compiler/machine-operator.h"
+#include "src/compiler/machine-type.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operator.h"
 #include "src/zone.h"

src/compiler/machine-operator.h

@@ -31,7 +31,7 @@ struct StoreRepresentation {
 // for generating code to run on architectures such as ia32, x64, arm, etc.
 class MachineOperatorBuilder {
  public:
-  explicit MachineOperatorBuilder(Zone* zone, MachineType word = pointer_rep())
+  explicit MachineOperatorBuilder(Zone* zone, MachineType word = kMachPtr)
       : zone_(zone), word_(word) {
     CHECK(word == kRepWord32 || word == kRepWord64);
   }
@@ -156,10 +156,6 @@ class MachineOperatorBuilder {
   inline bool is64() const { return word_ == kRepWord64; }
   inline MachineType word() const { return word_; }
 
-  static inline MachineType pointer_rep() {
-    return kPointerSize == 8 ? kRepWord64 : kRepWord32;
-  }
-
 #undef WORD_SIZE
 #undef UNOP
 #undef BINOP

src/compiler/machine-type.h

@@ -108,6 +108,32 @@ inline int ElementSizeOf(MachineType machine_type) {
   }
 }
 
+// Describes the inputs and outputs of a function or call in terms of machine
+// types.
+class MachineSignature {
+ public:
+  MachineSignature(uint8_t return_count, uint16_t param_count,
+                   MachineType* reps)
+      : return_count_(return_count), param_count_(param_count), reps_(reps) {}
+
+  int GetReturnCount() const { return return_count_; }
+  int GetParamCount() const { return param_count_; }
+
+  MachineType GetParameterType(int index) const {
+    DCHECK(index >= 0 && index < param_count_);
+    return reps_[return_count_ + index];
+  }
+
+  MachineType GetReturnType(int index = 0) const {
+    DCHECK(index >= 0 && index < return_count_);
+    return reps_[index];
+  }
+
+ protected:
+  uint8_t return_count_;
+  uint16_t param_count_;
+  MachineType* reps_;
+};
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

src/compiler/raw-machine-assembler.h

@@ -47,7 +47,7 @@ class RawMachineAssembler : public GraphBuilder,
 
   RawMachineAssembler(Graph* graph,
                       MachineCallDescriptorBuilder* call_descriptor_builder,
-                      MachineType word = MachineOperatorBuilder::pointer_rep());
+                      MachineType word = kMachPtr);
   virtual ~RawMachineAssembler() {}
 
   Isolate* isolate() const { return zone()->isolate(); }

src/compiler/simplified-operator-reducer.cc

@@ -4,6 +4,7 @@
 
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/js-graph.h"
+#include "src/compiler/machine-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/simplified-operator-reducer.h"
 

src/compiler/structured-machine-assembler.h

@@ -63,7 +63,7 @@ class StructuredMachineAssembler
 
   StructuredMachineAssembler(
       Graph* graph, MachineCallDescriptorBuilder* call_descriptor_builder,
-      MachineType word = MachineOperatorBuilder::pointer_rep());
+      MachineType word = kMachPtr);
   virtual ~StructuredMachineAssembler() {}
 
   Isolate* isolate() const { return zone()->isolate(); }

test/cctest/cctest.gyp

@@ -44,6 +44,7 @@
       ],
       'sources': [  ### gcmole(all) ###
         '<(generated_file)',
+        'compiler/c-signature.h',
         'compiler/codegen-tester.cc',
         'compiler/codegen-tester.h',
         'compiler/function-tester.h',

test/cctest/compiler/c-signature.h

+// 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.
+
+#ifndef V8_COMPILER_C_SIGNATURE_H_
+#define V8_COMPILER_C_SIGNATURE_H_
+
+#include "src/compiler/machine-type.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+template <typename T>
+inline MachineType MachineTypeForC() {
+  CHECK(false);  // Instantiated with invalid type.
+  return kMachNone;
+}
+
+template <>
+inline MachineType MachineTypeForC<void>() {
+  return kMachNone;
+}
+
+template <>
+inline MachineType MachineTypeForC<int8_t>() {
+  return kMachInt8;
+}
+
+template <>
+inline MachineType MachineTypeForC<uint8_t>() {
+  return kMachUint8;
+}
+
+template <>
+inline MachineType MachineTypeForC<int16_t>() {
+  return kMachInt16;
+}
+
+template <>
+inline MachineType MachineTypeForC<uint16_t>() {
+  return kMachUint16;
+}
+
+template <>
+inline MachineType MachineTypeForC<int32_t>() {
+  return kMachInt32;
+}
+
+template <>
+inline MachineType MachineTypeForC<uint32_t>() {
+  return kMachUint32;
+}
+
+template <>
+inline MachineType MachineTypeForC<int64_t>() {
+  return kMachInt64;
+}
+
+template <>
+inline MachineType MachineTypeForC<uint64_t>() {
+  return kMachUint64;
+}
+
+template <>
+inline MachineType MachineTypeForC<double>() {
+  return kMachFloat64;
+}
+
+template <>
+inline MachineType MachineTypeForC<Object*>() {
+  return kMachAnyTagged;
+}
+
+template <typename Ret, uint16_t kParamCount>
+class CSignatureOf : public MachineSignature {
+ protected:
+  MachineType storage_[1 + kParamCount];
+
+  CSignatureOf()
+      : MachineSignature(MachineTypeForC<Ret>() != kMachNone ? 1 : 0,
+                         kParamCount,
+                         reinterpret_cast<MachineType*>(&storage_)) {
+    if (return_count_ == 1) storage_[0] = MachineTypeForC<Ret>();
+  }
+  void Set(int index, MachineType type) {
+    DCHECK(index >= 0 && index < kParamCount);
+    reps_[return_count_ + index] = type;
+  }
+};
+
+// Helper classes for instantiating Signature objects to be callable from C.
+template <typename Ret>
+class CSignature0 : public CSignatureOf<Ret, 0> {
+ public:
+  CSignature0() : CSignatureOf<Ret, 0>() {}
+};
+
+template <typename Ret, typename P1>
+class CSignature1 : public CSignatureOf<Ret, 1> {
+ public:
+  CSignature1() : CSignatureOf<Ret, 1>() {
+    this->Set(0, MachineTypeForC<P1>());
+  }
+};
+
+template <typename Ret, typename P1, typename P2>
+class CSignature2 : public CSignatureOf<Ret, 2> {
+ public:
+  CSignature2() : CSignatureOf<Ret, 2>() {
+    this->Set(0, MachineTypeForC<P1>());
+    this->Set(1, MachineTypeForC<P2>());
+  }
+};
+
+template <typename Ret, typename P1, typename P2, typename P3>
+class CSignature3 : public CSignatureOf<Ret, 3> {
+ public:
+  CSignature3() : CSignatureOf<Ret, 3>() {
+    this->Set(0, MachineTypeForC<P1>());
+    this->Set(1, MachineTypeForC<P2>());
+    this->Set(2, MachineTypeForC<P3>());
+  }
+};
+
+static const CSignature2<int32_t, int32_t, int32_t> int32_int32_to_int32;
+static const CSignature2<uint32_t, uint32_t, uint32_t> uint32_uint32_to_uint32;
+static const CSignature2<double, double, double> float64_float64_to_float64;
+}
+}
+}  // namespace v8::internal::compiler
+
+#endif  // V8_COMPILER_C_SIGNATURE_H_

test/cctest/compiler/codegen-tester.h

@@ -30,7 +30,7 @@ class MachineAssemblerTester : public HandleAndZoneScope,
         MachineAssembler(new (main_zone()) Graph(main_zone()),
                          ToCallDescriptorBuilder(main_zone(), return_type, p0,
                                                  p1, p2, p3, p4),
-                         MachineOperatorBuilder::pointer_rep()) {}
+                         kMachPtr) {}
 
   Node* LoadFromPointer(void* address, MachineType rep, int32_t offset = 0) {
     return this->Load(rep, this->PointerConstant(address),

test/cctest/compiler/instruction-selector-tester.h

@@ -40,7 +40,7 @@ class InstructionSelectorTester : public HandleAndZoneScope,
             new (main_zone()) Graph(main_zone()),
             new (main_zone()) MachineCallDescriptorBuilder(
                 kMachInt32, kParameterCount, BuildParameterArray(main_zone())),
-            MachineOperatorBuilder::pointer_rep()) {}
+            kMachPtr) {}
 
   void SelectInstructions(CpuFeature feature) {
     SelectInstructions(InstructionSelector::Features(feature));

test/cctest/compiler/test-run-machops.cc

@@ -3534,10 +3534,9 @@ TEST(RunCallSeven) {
     RawMachineAssemblerTester<int32_t> m;
     Node** args = NULL;
     MachineType* arg_types = NULL;
-    Node* function =
-        call_direct ? m.PointerConstant(function_address)
-                    : m.LoadFromPointer(&function_address,
-                                        MachineOperatorBuilder::pointer_rep());
+    Node* function = call_direct
+                         ? m.PointerConstant(function_address)
+                         : m.LoadFromPointer(&function_address, kMachPtr);
     m.Return(m.CallC(function, kMachInt32, arg_types, args, 0));
 
     CHECK_EQ(7, m.Call());
@@ -3554,10 +3553,9 @@ TEST(RunCallUnaryMinus) {
     RawMachineAssemblerTester<int32_t> m(kMachInt32);
     Node* args[] = {m.Parameter(0)};
     MachineType arg_types[] = {kMachInt32};
-    Node* function =
-        call_direct ? m.PointerConstant(function_address)
-                    : m.LoadFromPointer(&function_address,
-                                        MachineOperatorBuilder::pointer_rep());
+    Node* function = call_direct
+                         ? m.PointerConstant(function_address)
+                         : m.LoadFromPointer(&function_address, kMachPtr);
     m.Return(m.CallC(function, kMachInt32, arg_types, args, 1));
 
     FOR_INT32_INPUTS(i) {
@@ -3577,10 +3575,9 @@ TEST(RunCallAPlusTwoB) {
     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
     Node* args[] = {m.Parameter(0), m.Parameter(1)};
     MachineType arg_types[] = {kMachInt32, kMachInt32};
-    Node* function =
-        call_direct ? m.PointerConstant(function_address)
-                    : m.LoadFromPointer(&function_address,
-                                        MachineOperatorBuilder::pointer_rep());
+    Node* function = call_direct
+                         ? m.PointerConstant(function_address)
+                         : m.LoadFromPointer(&function_address, kMachPtr);
     m.Return(m.CallC(function, kMachInt32, arg_types, args, 2));
 
     FOR_INT32_INPUTS(i) {
@@ -3819,8 +3816,7 @@ TEST(RunLoadStoreTruncation) {
 
 static void IntPtrCompare(intptr_t left, intptr_t right) {
   for (int test = 0; test < 7; test++) {
-    RawMachineAssemblerTester<bool> m(MachineOperatorBuilder::pointer_rep(),
-                                      MachineOperatorBuilder::pointer_rep());
+    RawMachineAssemblerTester<bool> m(kMachPtr, kMachPtr);
     Node* p0 = m.Parameter(0);
     Node* p1 = m.Parameter(1);
     Node* res = NULL;

test/cctest/compiler/test-simplified-lowering.cc

@@ -72,9 +72,8 @@ FieldAccess ForJSObjectProperties() {
 
 FieldAccess ForArrayBufferBackingStore() {
   FieldAccess access = {
-      kTaggedBase,                           JSArrayBuffer::kBackingStoreOffset,
-      Handle<Name>(),                        Type::UntaggedPtr(),
-      MachineOperatorBuilder::pointer_rep(),
+      kTaggedBase,         JSArrayBuffer::kBackingStoreOffset, Handle<Name>(),
+      Type::UntaggedPtr(), kMachPtr,
   };
   return access;
 }

test/cctest/compiler/test-structured-ifbuilder-fuzzer.cc

@@ -267,9 +267,7 @@ class IfBuilderModel {
 class IfBuilderGenerator : public StructuredMachineAssemblerTester<int32_t> {
  public:
   IfBuilderGenerator()
-      : StructuredMachineAssemblerTester<int32_t>(
-            MachineOperatorBuilder::pointer_rep(),
-            MachineOperatorBuilder::pointer_rep()),
+      : StructuredMachineAssemblerTester<int32_t>(kMachPtr, kMachPtr),
         var_(NewVariable(Int32Constant(kInitalVar))),
         c_(this),
         m_(this->zone()),

test/cctest/compiler/test-structured-machine-assembler.cc

@@ -878,9 +878,8 @@ TEST(RunSimpleExpressionVariable1) {
 class QuicksortHelper : public StructuredMachineAssemblerTester<int32_t> {
  public:
   QuicksortHelper()
-      : StructuredMachineAssemblerTester<int32_t>(
-            MachineOperatorBuilder::pointer_rep(), kMachInt32,
-            MachineOperatorBuilder::pointer_rep(), kMachInt32),
+      : StructuredMachineAssemblerTester<int32_t>(kMachPtr, kMachInt32,
+                                                  kMachPtr, kMachInt32),
         input_(NULL),
         stack_limit_(NULL),
         one_(Int32Constant(1)),