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             :   constexpr Signature(size_t return_count, size_t parameter_count,
      19             :                       const T* reps)
      20             :       : return_count_(return_count),
      21             :         parameter_count_(parameter_count),
      22     7026412 :         reps_(reps) {}
      23             : 
      24             :   size_t return_count() const { return return_count_; }
      25             :   size_t parameter_count() const { return parameter_count_; }
      26             : 
      27             :   T GetParam(size_t index) const {
      28             :     DCHECK(index < parameter_count_);
      29   228005960 :     return reps_[return_count_ + index];
      30             :   }
      31             : 
      32             :   T GetReturn(size_t index = 0) const {
      33             :     DCHECK(index < return_count_);
      34    10977720 :     return reps_[index];
      35             :   }
      36             : 
      37             :   // Iteration support.
      38             :   base::iterator_range<const T*> parameters() const {
      39      415921 :     return {reps_ + return_count_, reps_ + return_count_ + parameter_count_};
      40             :   }
      41             :   base::iterator_range<const T*> returns() const {
      42        9120 :     return {reps_, reps_ + return_count_};
      43             :   }
      44             :   base::iterator_range<const T*> all() const {
      45      310688 :     return {reps_, reps_ + return_count_ + parameter_count_};
      46             :   }
      47             : 
      48      393685 :   bool Equals(const Signature* that) const {
      49      131265 :     if (this == that) return true;
      50      131265 :     if (this->parameter_count() != that->parameter_count()) return false;
      51      131155 :     if (this->return_count() != that->return_count()) return false;
      52      131105 :     size_t size = this->return_count() + this->parameter_count();
      53      507315 :     for (size_t i = 0; i < size; i++) {
      54      376270 :       if (this->reps_[i] != that->reps_[i]) return false;
      55             :     }
      56             :     return true;
      57             :   }
      58             : 
      59             :   // For incrementally building signatures.
      60             :   class Builder {
      61             :    public:
      62             :     Builder(Zone* zone, size_t return_count, size_t parameter_count)
      63             :         : return_count_(return_count),
      64             :           parameter_count_(parameter_count),
      65             :           zone_(zone),
      66             :           rcursor_(0),
      67             :           pcursor_(0),
      68             :           buffer_(zone->NewArray<T>(
      69    11944586 :               static_cast<int>(return_count + parameter_count))) {}
      70             : 
      71             :     const size_t return_count_;
      72             :     const size_t parameter_count_;
      73             : 
      74             :     void AddReturn(T val) {
      75             :       DCHECK(rcursor_ < return_count_);
      76     5507773 :       buffer_[rcursor_++] = val;
      77             :     }
      78             :     void AddParam(T val) {
      79             :       DCHECK(pcursor_ < parameter_count_);
      80    19615966 :       buffer_[return_count_ + pcursor_++] = val;
      81             :     }
      82     5972290 :     Signature<T>* Build() {
      83             :       DCHECK(rcursor_ == return_count_);
      84             :       DCHECK(pcursor_ == parameter_count_);
      85    17916972 :       return new (zone_) Signature<T>(return_count_, parameter_count_, buffer_);
      86             :     }
      87             : 
      88             :    private:
      89             :     Zone* zone_;
      90             :     size_t rcursor_;
      91             :     size_t pcursor_;
      92             :     T* buffer_;
      93             :   };
      94             : 
      95             :  protected:
      96             :   size_t return_count_;
      97             :   size_t parameter_count_;
      98             :   const T* reps_;
      99             : };
     100             : 
     101             : }  // namespace internal
     102             : }  // namespace v8
     103             : 
     104             : #endif  // V8_SIGNATURE_H_