Line data    Source code

       1             : // Copyright 2015 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_SIGNATURE_H_
       6             : #define V8_SIGNATURE_H_
       7             : 
       8             : #include "src/base/iterator.h"
       9             : #include "src/zone/zone.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : // Describes the inputs and outputs of a function or call.
      15             : template <typename T>
      16             : class Signature : public ZoneObject {
      17             :  public:
      18             :   Signature(size_t return_count, size_t parameter_count, const T* reps)
      19             :       : return_count_(return_count),
      20             :         parameter_count_(parameter_count),
      21     4528426 :         reps_(reps) {}
      22             : 
      23             :   size_t return_count() const { return return_count_; }
      24             :   size_t parameter_count() const { return parameter_count_; }
      25             : 
      26             :   T GetParam(size_t index) const {
      27             :     DCHECK(index < parameter_count_);
      28    43658246 :     return reps_[return_count_ + index];
      29             :   }
      30             : 
      31             :   T GetReturn(size_t index = 0) const {
      32             :     DCHECK(index < return_count_);
      33    12101611 :     return reps_[index];
      34             :   }
      35             : 
      36             :   // Iteration support.
      37             :   base::iterator_range<const T*> parameters() const {
      38       95313 :     return {reps_ + return_count_, reps_ + return_count_ + parameter_count_};
      39             :   }
      40             :   base::iterator_range<const T*> returns() const {
      41        8694 :     return {reps_, reps_ + return_count_};
      42             :   }
      43             :   base::iterator_range<const T*> all() const {
      44       66272 :     return {reps_, reps_ + return_count_ + parameter_count_};
      45             :   }
      46             : 
      47         258 :   bool Equals(const Signature* that) const {
      48          96 :     if (this == that) return true;
      49          96 :     if (this->parameter_count() != that->parameter_count()) return false;
      50          66 :     if (this->return_count() != that->return_count()) return false;
      51          66 :     size_t size = this->return_count() + this->parameter_count();
      52         156 :     for (size_t i = 0; i < size; i++) {
      53         105 :       if (this->reps_[i] != that->reps_[i]) return false;
      54             :     }
      55             :     return true;
      56             :   }
      57             : 
      58             :   // For incrementally building signatures.
      59             :   class Builder {
      60             :    public:
      61             :     Builder(Zone* zone, size_t return_count, size_t parameter_count)
      62             :         : return_count_(return_count),
      63             :           parameter_count_(parameter_count),
      64             :           zone_(zone),
      65             :           rcursor_(0),
      66             :           pcursor_(0),
      67             :           buffer_(zone->NewArray<T>(
      68     8800179 :               static_cast<int>(return_count + parameter_count))) {}
      69             : 
      70             :     const size_t return_count_;
      71             :     const size_t parameter_count_;
      72             : 
      73             :     void AddReturn(T val) {
      74             :       DCHECK(rcursor_ < return_count_);
      75     4297263 :       buffer_[rcursor_++] = val;
      76             :     }
      77             :     void AddParam(T val) {
      78             :       DCHECK(pcursor_ < parameter_count_);
      79    14919215 :       buffer_[return_count_ + pcursor_++] = val;
      80             :     }
      81     4400070 :     Signature<T>* Build() {
      82             :       DCHECK(rcursor_ == return_count_);
      83             :       DCHECK(pcursor_ == parameter_count_);
      84    13200252 :       return new (zone_) Signature<T>(return_count_, parameter_count_, buffer_);
      85             :     }
      86             : 
      87             :    private:
      88             :     Zone* zone_;
      89             :     size_t rcursor_;
      90             :     size_t pcursor_;
      91             :     T* buffer_;
      92             :   };
      93             : 
      94             :  protected:
      95             :   size_t return_count_;
      96             :   size_t parameter_count_;
      97             :   const T* reps_;
      98             : };
      99             : 
     100             : }  // namespace internal
     101             : }  // namespace v8
     102             : 
     103             : #endif  // V8_SIGNATURE_H_