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_
|