Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1752)

Side by Side Diff: src/ast.h

Issue 650073002: vector-based ICs did not update type feedback counts correctly. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Ports. Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright 2012 the V8 project authors. All rights reserved. 1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #ifndef V8_AST_H_ 5 #ifndef V8_AST_H_
6 #define V8_AST_H_ 6 #define V8_AST_H_
7 7
8 #include "src/v8.h" 8 #include "src/v8.h"
9 9
10 #include "src/assembler.h" 10 #include "src/assembler.h"
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after
150 template<class> friend class AstNodeFactory; 150 template<class> friend class AstNodeFactory;
151 151
152 152
153 enum AstPropertiesFlag { 153 enum AstPropertiesFlag {
154 kDontSelfOptimize, 154 kDontSelfOptimize,
155 kDontSoftInline, 155 kDontSoftInline,
156 kDontCache 156 kDontCache
157 }; 157 };
158 158
159 159
160 class FeedbackVectorRequirements {
161 public:
162 FeedbackVectorRequirements(int slots, int ic_slots)
163 : slots_(slots), ic_slots_(ic_slots) {}
164
165 int slots() const { return slots_; }
166 int ic_slots() const { return ic_slots_; }
167
168 private:
169 int slots_;
170 int ic_slots_;
171 };
172
173
160 class AstProperties FINAL BASE_EMBEDDED { 174 class AstProperties FINAL BASE_EMBEDDED {
161 public: 175 public:
162 class Flags : public EnumSet<AstPropertiesFlag, int> {}; 176 class Flags : public EnumSet<AstPropertiesFlag, int> {};
163 177
164 AstProperties() : node_count_(0), feedback_slots_(0) {} 178 AstProperties() : node_count_(0), feedback_slots_(0), ic_feedback_slots_(0) {}
165 179
166 Flags* flags() { return &flags_; } 180 Flags* flags() { return &flags_; }
167 int node_count() { return node_count_; } 181 int node_count() { return node_count_; }
168 void add_node_count(int count) { node_count_ += count; } 182 void add_node_count(int count) { node_count_ += count; }
169 183
170 int feedback_slots() const { return feedback_slots_; } 184 int feedback_slots() const { return feedback_slots_; }
171 void increase_feedback_slots(int count) { 185 void increase_feedback_slots(int count) {
172 feedback_slots_ += count; 186 feedback_slots_ += count;
173 } 187 }
174 188
189 int ic_feedback_slots() const { return ic_feedback_slots_; }
190 void increase_ic_feedback_slots(int count) { ic_feedback_slots_ += count; }
191
175 private: 192 private:
176 Flags flags_; 193 Flags flags_;
177 int node_count_; 194 int node_count_;
178 int feedback_slots_; 195 int feedback_slots_;
196 int ic_feedback_slots_;
179 }; 197 };
180 198
181 199
182 class AstNode: public ZoneObject { 200 class AstNode: public ZoneObject {
183 public: 201 public:
184 // For generating IDs for AstNodes. 202 // For generating IDs for AstNodes.
185 class IdGen { 203 class IdGen {
186 public: 204 public:
187 IdGen() : id_(BailoutId::FirstUsable().ToInt()) {} 205 IdGen() : id_(BailoutId::FirstUsable().ToInt()) {}
188 206
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
230 248
231 virtual TargetCollector* AsTargetCollector() { return NULL; } 249 virtual TargetCollector* AsTargetCollector() { return NULL; }
232 virtual BreakableStatement* AsBreakableStatement() { return NULL; } 250 virtual BreakableStatement* AsBreakableStatement() { return NULL; }
233 virtual IterationStatement* AsIterationStatement() { return NULL; } 251 virtual IterationStatement* AsIterationStatement() { return NULL; }
234 virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; } 252 virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
235 253
236 // The interface for feedback slots, with default no-op implementations for 254 // The interface for feedback slots, with default no-op implementations for
237 // node types which don't actually have this. Note that this is conceptually 255 // node types which don't actually have this. Note that this is conceptually
238 // not really nice, but multiple inheritance would introduce yet another 256 // not really nice, but multiple inheritance would introduce yet another
239 // vtable entry per node, something we don't want for space reasons. 257 // vtable entry per node, something we don't want for space reasons.
240 virtual int ComputeFeedbackSlotCount() { 258 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
241 UNREACHABLE(); 259 return FeedbackVectorRequirements(0, 0);
242 return 0;
243 } 260 }
244 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { UNREACHABLE(); } 261 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { UNREACHABLE(); }
262 virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) {
263 UNREACHABLE();
264 }
245 265
246 private: 266 private:
247 // Hidden to prevent accidental usage. It would have to load the 267 // Hidden to prevent accidental usage. It would have to load the
248 // current zone from the TLS. 268 // current zone from the TLS.
249 void* operator new(size_t size); 269 void* operator new(size_t size);
250 270
251 friend class CaseClause; // Generates AST IDs. 271 friend class CaseClause; // Generates AST IDs.
252 272
253 int position_; 273 int position_;
254 }; 274 };
(...skipping 685 matching lines...) Expand 10 before | Expand all | Expand 10 after
940 960
941 class ForInStatement FINAL : public ForEachStatement { 961 class ForInStatement FINAL : public ForEachStatement {
942 public: 962 public:
943 DECLARE_NODE_TYPE(ForInStatement) 963 DECLARE_NODE_TYPE(ForInStatement)
944 964
945 Expression* enumerable() const { 965 Expression* enumerable() const {
946 return subject(); 966 return subject();
947 } 967 }
948 968
949 // Type feedback information. 969 // Type feedback information.
950 virtual int ComputeFeedbackSlotCount() { return 1; } 970 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
971 return FeedbackVectorRequirements(1, 0);
972 }
951 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 973 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) {
952 for_in_feedback_slot_ = slot; 974 for_in_feedback_slot_ = slot;
953 } 975 }
954 976
955 FeedbackVectorSlot ForInFeedbackSlot() { 977 FeedbackVectorSlot ForInFeedbackSlot() {
956 DCHECK(!for_in_feedback_slot_.IsInvalid()); 978 DCHECK(!for_in_feedback_slot_.IsInvalid());
957 return for_in_feedback_slot_; 979 return for_in_feedback_slot_;
958 } 980 }
959 981
960 enum ForInType { FAST_FOR_IN, SLOW_FOR_IN }; 982 enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
(...skipping 726 matching lines...) Expand 10 before | Expand all | Expand 10 after
1687 void set_is_assigned() { is_assigned_ = true; } 1709 void set_is_assigned() { is_assigned_ = true; }
1688 1710
1689 bool is_resolved() const { return is_resolved_; } 1711 bool is_resolved() const { return is_resolved_; }
1690 void set_is_resolved() { is_resolved_ = true; } 1712 void set_is_resolved() { is_resolved_ = true; }
1691 1713
1692 Interface* interface() const { return interface_; } 1714 Interface* interface() const { return interface_; }
1693 1715
1694 // Bind this proxy to the variable var. Interfaces must match. 1716 // Bind this proxy to the variable var. Interfaces must match.
1695 void BindTo(Variable* var); 1717 void BindTo(Variable* var);
1696 1718
1697 virtual int ComputeFeedbackSlotCount() { return FLAG_vector_ics ? 1 : 0; } 1719 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
1698 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 1720 return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
1721 }
1722 virtual void SetFirstICFeedbackSlot(FeedbackVectorICSlot slot) {
1699 variable_feedback_slot_ = slot; 1723 variable_feedback_slot_ = slot;
1700 } 1724 }
1701 1725
1702 FeedbackVectorSlot VariableFeedbackSlot() { return variable_feedback_slot_; } 1726 FeedbackVectorICSlot VariableFeedbackSlot() {
1727 return variable_feedback_slot_;
1728 }
1703 1729
1704 protected: 1730 protected:
1705 VariableProxy(Zone* zone, Variable* var, int position, IdGen* id_gen); 1731 VariableProxy(Zone* zone, Variable* var, int position, IdGen* id_gen);
1706 1732
1707 VariableProxy(Zone* zone, const AstRawString* name, bool is_this, 1733 VariableProxy(Zone* zone, const AstRawString* name, bool is_this,
1708 Interface* interface, int position, IdGen* id_gen); 1734 Interface* interface, int position, IdGen* id_gen);
1709 1735
1710 union { 1736 union {
1711 const AstRawString* raw_name_; // if !is_resolved_ 1737 const AstRawString* raw_name_; // if !is_resolved_
1712 Variable* var_; // if is_resolved_ 1738 Variable* var_; // if is_resolved_
1713 }; 1739 };
1714 Interface* interface_; 1740 Interface* interface_;
1715 FeedbackVectorSlot variable_feedback_slot_; 1741 FeedbackVectorICSlot variable_feedback_slot_;
1716 bool is_this_ : 1; 1742 bool is_this_ : 1;
1717 bool is_assigned_ : 1; 1743 bool is_assigned_ : 1;
1718 bool is_resolved_ : 1; 1744 bool is_resolved_ : 1;
1719 }; 1745 };
1720 1746
1721 1747
1722 class Property FINAL : public Expression { 1748 class Property FINAL : public Expression {
1723 public: 1749 public:
1724 DECLARE_NODE_TYPE(Property) 1750 DECLARE_NODE_TYPE(Property)
1725 1751
(...skipping 24 matching lines...) Expand all
1750 } 1776 }
1751 void set_is_uninitialized(bool b) { is_uninitialized_ = b; } 1777 void set_is_uninitialized(bool b) { is_uninitialized_ = b; }
1752 void set_is_string_access(bool b) { is_string_access_ = b; } 1778 void set_is_string_access(bool b) { is_string_access_ = b; }
1753 void mark_for_call() { is_for_call_ = true; } 1779 void mark_for_call() { is_for_call_ = true; }
1754 bool IsForCall() { return is_for_call_; } 1780 bool IsForCall() { return is_for_call_; }
1755 1781
1756 bool IsSuperAccess() { 1782 bool IsSuperAccess() {
1757 return obj()->IsSuperReference(); 1783 return obj()->IsSuperReference();
1758 } 1784 }
1759 1785
1760 virtual int ComputeFeedbackSlotCount() { return FLAG_vector_ics ? 1 : 0; } 1786 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
1761 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 1787 return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
1788 }
1789 virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) {
1762 property_feedback_slot_ = slot; 1790 property_feedback_slot_ = slot;
1763 } 1791 }
1764 1792
1765 FeedbackVectorSlot PropertyFeedbackSlot() const { 1793 FeedbackVectorICSlot PropertyFeedbackSlot() const {
1766 return property_feedback_slot_; 1794 return property_feedback_slot_;
1767 } 1795 }
1768 1796
1769 protected: 1797 protected:
1770 Property(Zone* zone, Expression* obj, Expression* key, int pos, IdGen* id_gen) 1798 Property(Zone* zone, Expression* obj, Expression* key, int pos, IdGen* id_gen)
1771 : Expression(zone, pos, num_ids(), id_gen), 1799 : Expression(zone, pos, num_ids(), id_gen),
1772 obj_(obj), 1800 obj_(obj),
1773 key_(key), 1801 key_(key),
1774 property_feedback_slot_(FeedbackVectorSlot::Invalid()), 1802 property_feedback_slot_(FeedbackVectorICSlot::Invalid()),
1775 is_for_call_(false), 1803 is_for_call_(false),
1776 is_uninitialized_(false), 1804 is_uninitialized_(false),
1777 is_string_access_(false) {} 1805 is_string_access_(false) {}
1778 1806
1779 static int num_ids() { return 2; } 1807 static int num_ids() { return 2; }
1780 int base_id() const { return Expression::base_id() + Expression::num_ids(); } 1808 int base_id() const { return Expression::base_id() + Expression::num_ids(); }
1781 1809
1782 private: 1810 private:
1783 Expression* obj_; 1811 Expression* obj_;
1784 Expression* key_; 1812 Expression* key_;
1785 FeedbackVectorSlot property_feedback_slot_; 1813 FeedbackVectorICSlot property_feedback_slot_;
1786 1814
1787 SmallMapList receiver_types_; 1815 SmallMapList receiver_types_;
1788 bool is_for_call_ : 1; 1816 bool is_for_call_ : 1;
1789 bool is_uninitialized_ : 1; 1817 bool is_uninitialized_ : 1;
1790 bool is_string_access_ : 1; 1818 bool is_string_access_ : 1;
1791 }; 1819 };
1792 1820
1793 1821
1794 class Call FINAL : public Expression { 1822 class Call FINAL : public Expression {
1795 public: 1823 public:
1796 DECLARE_NODE_TYPE(Call) 1824 DECLARE_NODE_TYPE(Call)
1797 1825
1798 Expression* expression() const { return expression_; } 1826 Expression* expression() const { return expression_; }
1799 ZoneList<Expression*>* arguments() const { return arguments_; } 1827 ZoneList<Expression*>* arguments() const { return arguments_; }
1800 1828
1801 // Type feedback information. 1829 // Type feedback information.
1802 virtual int ComputeFeedbackSlotCount() { return 1; } 1830 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
1803 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 1831 return FeedbackVectorRequirements(0, 1);
1832 }
1833 virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) {
1804 call_feedback_slot_ = slot; 1834 call_feedback_slot_ = slot;
1805 } 1835 }
1806 1836
1807 bool HasCallFeedbackSlot() const { return !call_feedback_slot_.IsInvalid(); } 1837 bool HasCallFeedbackSlot() const { return !call_feedback_slot_.IsInvalid(); }
1808 FeedbackVectorSlot CallFeedbackSlot() const { return call_feedback_slot_; } 1838 FeedbackVectorICSlot CallFeedbackSlot() const { return call_feedback_slot_; }
1809 1839
1810 virtual SmallMapList* GetReceiverTypes() OVERRIDE { 1840 virtual SmallMapList* GetReceiverTypes() OVERRIDE {
1811 if (expression()->IsProperty()) { 1841 if (expression()->IsProperty()) {
1812 return expression()->AsProperty()->GetReceiverTypes(); 1842 return expression()->AsProperty()->GetReceiverTypes();
1813 } 1843 }
1814 return NULL; 1844 return NULL;
1815 } 1845 }
1816 1846
1817 virtual bool IsMonomorphic() OVERRIDE { 1847 virtual bool IsMonomorphic() OVERRIDE {
1818 if (expression()->IsProperty()) { 1848 if (expression()->IsProperty()) {
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
1861 // Used to assert that the FullCodeGenerator records the return site. 1891 // Used to assert that the FullCodeGenerator records the return site.
1862 bool return_is_recorded_; 1892 bool return_is_recorded_;
1863 #endif 1893 #endif
1864 1894
1865 protected: 1895 protected:
1866 Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments, 1896 Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
1867 int pos, IdGen* id_gen) 1897 int pos, IdGen* id_gen)
1868 : Expression(zone, pos, num_ids(), id_gen), 1898 : Expression(zone, pos, num_ids(), id_gen),
1869 expression_(expression), 1899 expression_(expression),
1870 arguments_(arguments), 1900 arguments_(arguments),
1871 call_feedback_slot_(FeedbackVectorSlot::Invalid()) { 1901 call_feedback_slot_(FeedbackVectorICSlot::Invalid()) {
1872 if (expression->IsProperty()) { 1902 if (expression->IsProperty()) {
1873 expression->AsProperty()->mark_for_call(); 1903 expression->AsProperty()->mark_for_call();
1874 } 1904 }
1875 } 1905 }
1876 1906
1877 static int num_ids() { return 2; } 1907 static int num_ids() { return 2; }
1878 int base_id() const { return Expression::base_id() + Expression::num_ids(); } 1908 int base_id() const { return Expression::base_id() + Expression::num_ids(); }
1879 1909
1880 private: 1910 private:
1881 Expression* expression_; 1911 Expression* expression_;
1882 ZoneList<Expression*>* arguments_; 1912 ZoneList<Expression*>* arguments_;
1883 Handle<JSFunction> target_; 1913 Handle<JSFunction> target_;
1884 Handle<Cell> cell_; 1914 Handle<Cell> cell_;
1885 Handle<AllocationSite> allocation_site_; 1915 Handle<AllocationSite> allocation_site_;
1886 FeedbackVectorSlot call_feedback_slot_; 1916 FeedbackVectorICSlot call_feedback_slot_;
1887 }; 1917 };
1888 1918
1889 1919
1890 class CallNew FINAL : public Expression { 1920 class CallNew FINAL : public Expression {
1891 public: 1921 public:
1892 DECLARE_NODE_TYPE(CallNew) 1922 DECLARE_NODE_TYPE(CallNew)
1893 1923
1894 Expression* expression() const { return expression_; } 1924 Expression* expression() const { return expression_; }
1895 ZoneList<Expression*>* arguments() const { return arguments_; } 1925 ZoneList<Expression*>* arguments() const { return arguments_; }
1896 1926
1897 // Type feedback information. 1927 // Type feedback information.
1898 virtual int ComputeFeedbackSlotCount() { 1928 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
1899 return FLAG_pretenuring_call_new ? 2 : 1; 1929 return FeedbackVectorRequirements(FLAG_pretenuring_call_new ? 2 : 1, 0);
1900 } 1930 }
1901 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 1931 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) {
1902 callnew_feedback_slot_ = slot; 1932 callnew_feedback_slot_ = slot;
1903 } 1933 }
1904 1934
1905 FeedbackVectorSlot CallNewFeedbackSlot() { return callnew_feedback_slot_; } 1935 FeedbackVectorSlot CallNewFeedbackSlot() { return callnew_feedback_slot_; }
1906 FeedbackVectorSlot AllocationSiteFeedbackSlot() { 1936 FeedbackVectorSlot AllocationSiteFeedbackSlot() {
1907 DCHECK(FLAG_pretenuring_call_new); 1937 DCHECK(FLAG_pretenuring_call_new);
1908 return CallNewFeedbackSlot().next(); 1938 return CallNewFeedbackSlot().next();
1909 } 1939 }
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
1949 public: 1979 public:
1950 DECLARE_NODE_TYPE(CallRuntime) 1980 DECLARE_NODE_TYPE(CallRuntime)
1951 1981
1952 Handle<String> name() const { return raw_name_->string(); } 1982 Handle<String> name() const { return raw_name_->string(); }
1953 const AstRawString* raw_name() const { return raw_name_; } 1983 const AstRawString* raw_name() const { return raw_name_; }
1954 const Runtime::Function* function() const { return function_; } 1984 const Runtime::Function* function() const { return function_; }
1955 ZoneList<Expression*>* arguments() const { return arguments_; } 1985 ZoneList<Expression*>* arguments() const { return arguments_; }
1956 bool is_jsruntime() const { return function_ == NULL; } 1986 bool is_jsruntime() const { return function_ == NULL; }
1957 1987
1958 // Type feedback information. 1988 // Type feedback information.
1959 virtual int ComputeFeedbackSlotCount() { 1989 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
1960 return (FLAG_vector_ics && is_jsruntime()) ? 1 : 0; 1990 return FeedbackVectorRequirements(
1991 0, (FLAG_vector_ics && is_jsruntime()) ? 1 : 0);
1961 } 1992 }
1962 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 1993 virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) {
1963 callruntime_feedback_slot_ = slot; 1994 callruntime_feedback_slot_ = slot;
1964 } 1995 }
1965 1996
1966 FeedbackVectorSlot CallRuntimeFeedbackSlot() { 1997 FeedbackVectorICSlot CallRuntimeFeedbackSlot() {
1967 return callruntime_feedback_slot_; 1998 return callruntime_feedback_slot_;
1968 } 1999 }
1969 2000
1970 TypeFeedbackId CallRuntimeFeedbackId() const { 2001 TypeFeedbackId CallRuntimeFeedbackId() const {
1971 return TypeFeedbackId(base_id() + 0); 2002 return TypeFeedbackId(base_id() + 0);
1972 } 2003 }
1973 2004
1974 protected: 2005 protected:
1975 CallRuntime(Zone* zone, const AstRawString* name, 2006 CallRuntime(Zone* zone, const AstRawString* name,
1976 const Runtime::Function* function, 2007 const Runtime::Function* function,
1977 ZoneList<Expression*>* arguments, int pos, IdGen* id_gen) 2008 ZoneList<Expression*>* arguments, int pos, IdGen* id_gen)
1978 : Expression(zone, pos, num_ids(), id_gen), 2009 : Expression(zone, pos, num_ids(), id_gen),
1979 raw_name_(name), 2010 raw_name_(name),
1980 function_(function), 2011 function_(function),
1981 arguments_(arguments), 2012 arguments_(arguments),
1982 callruntime_feedback_slot_(FeedbackVectorSlot::Invalid()) {} 2013 callruntime_feedback_slot_(FeedbackVectorICSlot::Invalid()) {}
1983 2014
1984 static int num_ids() { return 1; } 2015 static int num_ids() { return 1; }
1985 int base_id() const { return Expression::base_id() + Expression::num_ids(); } 2016 int base_id() const { return Expression::base_id() + Expression::num_ids(); }
1986 2017
1987 private: 2018 private:
1988 const AstRawString* raw_name_; 2019 const AstRawString* raw_name_;
1989 const Runtime::Function* function_; 2020 const Runtime::Function* function_;
1990 ZoneList<Expression*>* arguments_; 2021 ZoneList<Expression*>* arguments_;
1991 FeedbackVectorSlot callruntime_feedback_slot_; 2022 FeedbackVectorICSlot callruntime_feedback_slot_;
1992 }; 2023 };
1993 2024
1994 2025
1995 class UnaryOperation FINAL : public Expression { 2026 class UnaryOperation FINAL : public Expression {
1996 public: 2027 public:
1997 DECLARE_NODE_TYPE(UnaryOperation) 2028 DECLARE_NODE_TYPE(UnaryOperation)
1998 2029
1999 Token::Value op() const { return op_; } 2030 Token::Value op() const { return op_; }
2000 Expression* expression() const { return expression_; } 2031 Expression* expression() const { return expression_; }
2001 2032
(...skipping 292 matching lines...) Expand 10 before | Expand all | Expand 10 after
2294 int index() const { 2325 int index() const {
2295 DCHECK_EQ(kDelegating, yield_kind()); 2326 DCHECK_EQ(kDelegating, yield_kind());
2296 return index_; 2327 return index_;
2297 } 2328 }
2298 void set_index(int index) { 2329 void set_index(int index) {
2299 DCHECK_EQ(kDelegating, yield_kind()); 2330 DCHECK_EQ(kDelegating, yield_kind());
2300 index_ = index; 2331 index_ = index;
2301 } 2332 }
2302 2333
2303 // Type feedback information. 2334 // Type feedback information.
2304 virtual int ComputeFeedbackSlotCount() { 2335 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
2305 return (FLAG_vector_ics && yield_kind() == kDelegating) ? 3 : 0; 2336 return FeedbackVectorRequirements(
2337 0, (FLAG_vector_ics && yield_kind() == kDelegating) ? 3 : 0);
2306 } 2338 }
2307 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 2339 virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) {
2308 yield_first_feedback_slot_ = slot; 2340 yield_first_feedback_slot_ = slot;
2309 } 2341 }
2310 2342
2311 FeedbackVectorSlot KeyedLoadFeedbackSlot() { 2343 FeedbackVectorICSlot KeyedLoadFeedbackSlot() {
2312 return yield_first_feedback_slot_; 2344 return yield_first_feedback_slot_;
2313 } 2345 }
2314 2346
2315 FeedbackVectorSlot DoneFeedbackSlot() { 2347 FeedbackVectorICSlot DoneFeedbackSlot() {
2316 return KeyedLoadFeedbackSlot().next(); 2348 return KeyedLoadFeedbackSlot().next();
2317 } 2349 }
2318 2350
2319 FeedbackVectorSlot ValueFeedbackSlot() { return DoneFeedbackSlot().next(); } 2351 FeedbackVectorICSlot ValueFeedbackSlot() { return DoneFeedbackSlot().next(); }
2320 2352
2321 protected: 2353 protected:
2322 Yield(Zone* zone, Expression* generator_object, Expression* expression, 2354 Yield(Zone* zone, Expression* generator_object, Expression* expression,
2323 Kind yield_kind, int pos, IdGen* id_gen) 2355 Kind yield_kind, int pos, IdGen* id_gen)
2324 : Expression(zone, pos, 0, id_gen), 2356 : Expression(zone, pos, 0, id_gen),
2325 generator_object_(generator_object), 2357 generator_object_(generator_object),
2326 expression_(expression), 2358 expression_(expression),
2327 yield_kind_(yield_kind), 2359 yield_kind_(yield_kind),
2328 index_(-1), 2360 index_(-1),
2329 yield_first_feedback_slot_(FeedbackVectorSlot::Invalid()) {} 2361 yield_first_feedback_slot_(FeedbackVectorICSlot::Invalid()) {}
2330 2362
2331 private: 2363 private:
2332 Expression* generator_object_; 2364 Expression* generator_object_;
2333 Expression* expression_; 2365 Expression* expression_;
2334 Kind yield_kind_; 2366 Kind yield_kind_;
2335 int index_; 2367 int index_;
2336 FeedbackVectorSlot yield_first_feedback_slot_; 2368 FeedbackVectorICSlot yield_first_feedback_slot_;
2337 }; 2369 };
2338 2370
2339 2371
2340 class Throw FINAL : public Expression { 2372 class Throw FINAL : public Expression {
2341 public: 2373 public:
2342 DECLARE_NODE_TYPE(Throw) 2374 DECLARE_NODE_TYPE(Throw)
2343 2375
2344 Expression* exception() const { return exception_; } 2376 Expression* exception() const { return exception_; }
2345 2377
2346 protected: 2378 protected:
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after
2476 } 2508 }
2477 2509
2478 int ast_node_count() { return ast_properties_.node_count(); } 2510 int ast_node_count() { return ast_properties_.node_count(); }
2479 AstProperties::Flags* flags() { return ast_properties_.flags(); } 2511 AstProperties::Flags* flags() { return ast_properties_.flags(); }
2480 void set_ast_properties(AstProperties* ast_properties) { 2512 void set_ast_properties(AstProperties* ast_properties) {
2481 ast_properties_ = *ast_properties; 2513 ast_properties_ = *ast_properties;
2482 } 2514 }
2483 int slot_count() { 2515 int slot_count() {
2484 return ast_properties_.feedback_slots(); 2516 return ast_properties_.feedback_slots();
2485 } 2517 }
2518 int ic_slot_count() { return ast_properties_.ic_feedback_slots(); }
2486 bool dont_optimize() { return dont_optimize_reason_ != kNoReason; } 2519 bool dont_optimize() { return dont_optimize_reason_ != kNoReason; }
2487 BailoutReason dont_optimize_reason() { return dont_optimize_reason_; } 2520 BailoutReason dont_optimize_reason() { return dont_optimize_reason_; }
2488 void set_dont_optimize_reason(BailoutReason reason) { 2521 void set_dont_optimize_reason(BailoutReason reason) {
2489 dont_optimize_reason_ = reason; 2522 dont_optimize_reason_ = reason;
2490 } 2523 }
2491 2524
2492 protected: 2525 protected:
2493 FunctionLiteral(Zone* zone, const AstRawString* name, 2526 FunctionLiteral(Zone* zone, const AstRawString* name,
2494 AstValueFactory* ast_value_factory, Scope* scope, 2527 AstValueFactory* ast_value_factory, Scope* scope,
2495 ZoneList<Statement*>* body, int materialized_literal_count, 2528 ZoneList<Statement*>* body, int materialized_literal_count,
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after
2614 public: 2647 public:
2615 DECLARE_NODE_TYPE(SuperReference) 2648 DECLARE_NODE_TYPE(SuperReference)
2616 2649
2617 VariableProxy* this_var() const { return this_var_; } 2650 VariableProxy* this_var() const { return this_var_; }
2618 2651
2619 TypeFeedbackId HomeObjectFeedbackId() { 2652 TypeFeedbackId HomeObjectFeedbackId() {
2620 return TypeFeedbackId(base_id() + 0); 2653 return TypeFeedbackId(base_id() + 0);
2621 } 2654 }
2622 2655
2623 // Type feedback information. 2656 // Type feedback information.
2624 virtual int ComputeFeedbackSlotCount() { return FLAG_vector_ics ? 1 : 0; } 2657 virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
2625 virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { 2658 return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
2659 }
2660 virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) {
2626 homeobject_feedback_slot_ = slot; 2661 homeobject_feedback_slot_ = slot;
2627 } 2662 }
2628 2663
2629 FeedbackVectorSlot HomeObjectFeedbackSlot() { 2664 FeedbackVectorICSlot HomeObjectFeedbackSlot() {
2630 DCHECK(!FLAG_vector_ics || !homeobject_feedback_slot_.IsInvalid()); 2665 DCHECK(!FLAG_vector_ics || !homeobject_feedback_slot_.IsInvalid());
2631 return homeobject_feedback_slot_; 2666 return homeobject_feedback_slot_;
2632 } 2667 }
2633 2668
2634 protected: 2669 protected:
2635 SuperReference(Zone* zone, VariableProxy* this_var, int pos, IdGen* id_gen) 2670 SuperReference(Zone* zone, VariableProxy* this_var, int pos, IdGen* id_gen)
2636 : Expression(zone, pos, num_ids(), id_gen), 2671 : Expression(zone, pos, num_ids(), id_gen),
2637 this_var_(this_var), 2672 this_var_(this_var),
2638 homeobject_feedback_slot_(FeedbackVectorSlot::Invalid()) { 2673 homeobject_feedback_slot_(FeedbackVectorICSlot::Invalid()) {
2639 DCHECK(this_var->is_this()); 2674 DCHECK(this_var->is_this());
2640 } 2675 }
2641 2676
2642 static int num_ids() { return 1; } 2677 static int num_ids() { return 1; }
2643 int base_id() const { return Expression::base_id() + Expression::num_ids(); } 2678 int base_id() const { return Expression::base_id() + Expression::num_ids(); }
2644 2679
2645 private: 2680 private:
2646 VariableProxy* this_var_; 2681 VariableProxy* this_var_;
2647 FeedbackVectorSlot homeobject_feedback_slot_; 2682 FeedbackVectorICSlot homeobject_feedback_slot_;
2648 }; 2683 };
2649 2684
2650 2685
2651 #undef DECLARE_NODE_TYPE 2686 #undef DECLARE_NODE_TYPE
2652 2687
2653 2688
2654 // ---------------------------------------------------------------------------- 2689 // ----------------------------------------------------------------------------
2655 // Regular expressions 2690 // Regular expressions
2656 2691
2657 2692
(...skipping 443 matching lines...) Expand 10 before | Expand all | Expand 10 after
3101 void increase_node_count() { properties_.add_node_count(1); } 3136 void increase_node_count() { properties_.add_node_count(1); }
3102 void add_flag(AstPropertiesFlag flag) { properties_.flags()->Add(flag); } 3137 void add_flag(AstPropertiesFlag flag) { properties_.flags()->Add(flag); }
3103 void set_dont_crankshaft_reason(BailoutReason reason) { 3138 void set_dont_crankshaft_reason(BailoutReason reason) {
3104 dont_crankshaft_reason_ = reason; 3139 dont_crankshaft_reason_ = reason;
3105 } 3140 }
3106 void set_dont_turbofan_reason(BailoutReason reason) { 3141 void set_dont_turbofan_reason(BailoutReason reason) {
3107 dont_turbofan_reason_ = reason; 3142 dont_turbofan_reason_ = reason;
3108 } 3143 }
3109 3144
3110 void add_slot_node(AstNode* slot_node) { 3145 void add_slot_node(AstNode* slot_node) {
3111 int count = slot_node->ComputeFeedbackSlotCount(); 3146 FeedbackVectorRequirements reqs = slot_node->ComputeFeedbackRequirements();
3112 if (count > 0) { 3147 if (reqs.slots() > 0) {
3113 slot_node->SetFirstFeedbackSlot( 3148 slot_node->SetFirstFeedbackSlot(
3114 FeedbackVectorSlot(properties_.feedback_slots())); 3149 FeedbackVectorSlot(properties_.feedback_slots()));
3115 properties_.increase_feedback_slots(count); 3150 properties_.increase_feedback_slots(reqs.slots());
3151 }
3152 if (reqs.ic_slots() > 0) {
3153 slot_node->SetFirstFeedbackICSlot(
3154 FeedbackVectorICSlot(properties_.ic_feedback_slots()));
3155 properties_.increase_ic_feedback_slots(reqs.ic_slots());
3116 } 3156 }
3117 } 3157 }
3118 3158
3119 AstProperties properties_; 3159 AstProperties properties_;
3120 BailoutReason dont_crankshaft_reason_; 3160 BailoutReason dont_crankshaft_reason_;
3121 BailoutReason dont_turbofan_reason_; 3161 BailoutReason dont_turbofan_reason_;
3122 }; 3162 };
3123 3163
3124 3164
3125 class AstNullVisitor BASE_EMBEDDED { 3165 class AstNullVisitor BASE_EMBEDDED {
(...skipping 489 matching lines...) Expand 10 before | Expand all | Expand 10 after
3615 Zone* zone_; 3655 Zone* zone_;
3616 Visitor visitor_; 3656 Visitor visitor_;
3617 AstValueFactory* ast_value_factory_; 3657 AstValueFactory* ast_value_factory_;
3618 AstNode::IdGen* id_gen_; 3658 AstNode::IdGen* id_gen_;
3619 }; 3659 };
3620 3660
3621 3661
3622 } } // namespace v8::internal 3662 } } // namespace v8::internal
3623 3663
3624 #endif // V8_AST_H_ 3664 #endif // V8_AST_H_
OLDNEW
« no previous file with comments | « src/arm64/lithium-codegen-arm64.cc ('k') | src/ast.cc » ('j') | src/ic/ic.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698