Convert Linkage to use MachineSignature.

src/compiler/machine-type.h

Index: src/compiler/machine-type.h
diff --git a/src/compiler/machine-type.h b/src/compiler/machine-type.h
index 22513d984d6d6e00f0be7fa26345493be3af0d9e..771350b99d7490c07bf3dfbe2a318ee84d4c17d2 100644
--- a/src/compiler/machine-type.h
+++ b/src/compiler/machine-type.h
@@ -7,6 +7,7 @@
 
 #include "src/base/bits.h"
 #include "src/globals.h"
+#include "src/zone.h"
 
 namespace v8 {
 namespace internal {
@@ -109,32 +110,71 @@ inline int ElementSizeOf(MachineType machine_type) {
   }
 }
 
-// Describes the inputs and outputs of a function or call in terms of machine
-// types.
-class MachineSignature {
+// Describes the inputs and outputs of a function or call.
+template <typename T>
+class Signature : public ZoneObject {
  public:
-  MachineSignature(uint8_t return_count, uint16_t param_count,
-                   MachineType* reps)
-      : return_count_(return_count), param_count_(param_count), reps_(reps) {}
+  Signature(size_t return_count, size_t parameter_count, T* reps)
+      : return_count_(return_count),
+        parameter_count_(parameter_count),
+        reps_(reps) {}
 
-  int GetReturnCount() const { return return_count_; }
-  int GetParamCount() const { return param_count_; }
+  size_t return_count() const { return return_count_; }
+  size_t parameter_count() const { return parameter_count_; }
 
-  MachineType GetParameterType(int index) const {
-    DCHECK(index >= 0 && index < param_count_);
+  T GetParam(size_t index) const {
+    DCHECK(index < parameter_count_);
     return reps_[return_count_ + index];
   }
 
-  MachineType GetReturnType(int index = 0) const {
-    DCHECK(index >= 0 && index < return_count_);
+  T GetReturn(size_t index = 0) const {
+    DCHECK(index < return_count_);
     return reps_[index];
   }
 
+  // For incrementally building signatures.
+  class Builder {
+   public:
+    Builder(Zone* zone, size_t return_count, size_t parameter_count)
+        : return_count_(return_count),
+          parameter_count_(parameter_count),
+          zone_(zone),
+          rcursor_(0),
+          pcursor_(0),
+          buffer_(zone->NewArray<T>(
+              static_cast<int>(return_count + parameter_count))) {}
+
+    const size_t return_count_;
+    const size_t parameter_count_;
+
+    void AddReturn(T val) {
+      DCHECK(rcursor_ < return_count_);
+      buffer_[rcursor_++] = val;
+    }
+    void AddParam(T val) {
+      DCHECK(pcursor_ < parameter_count_);
+      buffer_[return_count_ + pcursor_++] = val;
+    }
+    Signature<T>* Build() {
+      DCHECK(rcursor_ == return_count_);
+      DCHECK(pcursor_ == parameter_count_);
+      return new (zone_) Signature<T>(return_count_, parameter_count_, buffer_);
+    }
+
+   private:
+    Zone* zone_;
+    size_t rcursor_;
+    size_t pcursor_;
+    T* buffer_;
+  };
+
  protected:
-  uint8_t return_count_;
-  uint16_t param_count_;
-  MachineType* reps_;
+  size_t return_count_;
+  size_t parameter_count_;
+  T* reps_;
 };
+
+typedef Signature<MachineType> MachineSignature;
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8