Convert Linkage to use MachineSignature.

src/compiler/machine-type.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_MACHINE_TYPE_H_
 #define V8_COMPILER_MACHINE_TYPE_H_
 
 #include "src/globals.h"
+#include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 class OStream;
 
 namespace compiler {
 
 // Machine-level types and representations.
 // TODO(titzer): Use the real type system instead of MachineType.
@@ skipping 82 matching lines @@
     case kRepFloat64:
       return 8;
     case kRepTagged:
       return kPointerSize;
     default:
       UNREACHABLE();
       return kPointerSize;
   }
 }
 
-// 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)
+  Signature(uint8_t return_count, uint16_t param_count, T* reps)

[Benedikt Meurer, 2014/09/02 08:37:41]

The Chrome Coding Style says: "Use unsigned integer types (preferably size_t)
for object and allocation sizes, object counts, array and pointer offsets,
vector indices, and so on. The signed types are incorrect and unsafe for these
purposes. (Integer overflow behavior for signed types is undefined in the C and
C++ standards, while the behavior is defined for unsigned types.) The C++ STL is
a guide here: they use size_t and foo::size_type for very good reasons.", and
esp. "Interfaces (function prototypes) for these uses should use size_t, even if
the underlying storage is a smaller unsigned type (e.g. as a space
optimization)."

So please use size_t for the interface, and DCHECK the range if you use uintX_t
for internal representation.

See http://www.chromium.org/developers/coding-style

[titzer, 2014/09/02 12:13:53]

Done.

       : return_count_(return_count), param_count_(param_count), reps_(reps) {}
 
-  int GetReturnCount() const { return return_count_; }
-  int GetParamCount() const { return param_count_; }
+  int ReturnCount() const { return return_count_; }

[Benedikt Meurer, 2014/09/02 08:37:42]

size_t return_count() const { return return_count_; }

[titzer, 2014/09/02 12:13:53]

Done.

+  int ParamCount() const { return param_count_; }

[Benedikt Meurer, 2014/09/02 08:37:42]

size_t param_count() const { return param_count_; }

[titzer, 2014/09/02 12:13:53]

Done.

 
-  MachineType GetParameterType(int index) const {
+  T GetParam(int index) const {

[Benedikt Meurer, 2014/09/02 08:37:41]

size_t for index

[titzer, 2014/09/02 12:13:53]

Done.

     DCHECK(index >= 0 && index < param_count_);

[Benedikt Meurer, 2014/09/02 08:37:41]

DCHECK_LT(index, param_count());

[titzer, 2014/09/02 12:13:52]

Done.

     return reps_[return_count_ + index];

[Benedikt Meurer, 2014/09/02 08:37:42]

reps_[return_count() + index]

[titzer, 2014/09/02 12:13:53]

This is mostly personal preference, but inside the class it's fine to use the
private members directly.

   }
 
-  MachineType GetReturnType(int index = 0) const {
+  T GetReturn(int index = 0) const {

[Benedikt Meurer, 2014/09/02 08:37:42]

size_t for index

[titzer, 2014/09/02 12:13:53]

Done.

     DCHECK(index >= 0 && index < return_count_);

[Benedikt Meurer, 2014/09/02 08:37:42]

DCHECK_LT(index, return_count());

[titzer, 2014/09/02 12:13:53]

Done.

     return reps_[index];
   }
 
+  // For incrementally building signatures.
+  class Builder {
+   public:
+    Builder(Zone* zone, int return_count, int param_count)
+        : return_count_(return_count),
+          param_count_(param_count),
+          zone_(zone),
+          rcursor_(0),
+          pcursor_(0),
+          buffer_(zone->NewArray<T>(return_count + param_count)) {}
+
+    const int return_count_;

[Benedikt Meurer, 2014/09/02 08:37:42]

size_t

[titzer, 2014/09/02 12:13:52]

Done.

+    const int param_count_;

[Benedikt Meurer, 2014/09/02 08:37:42]

size_t

[titzer, 2014/09/02 12:13:52]

Done.

+
+    void AddReturn(T val) {
+      DCHECK_LT(rcursor_, return_count_);
+      buffer_[rcursor_++] = val;
+    }
+    void AddParam(T val) {
+      DCHECK_LT(pcursor_, param_count_);
+      buffer_[return_count_ + pcursor_++] = val;
+    }
+    Signature<T>* Build() {
+      DCHECK_EQ(rcursor_, return_count_);
+      DCHECK_EQ(pcursor_, param_count_);
+      return new (zone_) Signature<T>(return_count_, param_count_, buffer_);
+    }
+
+   private:
+    Zone* zone_;
+    int rcursor_;
+    int pcursor_;
+    T* buffer_;
+  };
+
  protected:
   uint8_t return_count_;
   uint16_t param_count_;
-  MachineType* reps_;
+  T* reps_;
 };
+
+typedef Signature<MachineType> MachineSignature;
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_MACHINE_TYPE_H_