src/ast.h - Issue 9221011: Collect AstNode type information

Unified Diff: src/ast.h

Issue 9221011: Collect AstNode type information (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Created 8 years, 11 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 side-by-side diff with in-line comments

Download patch

Index: src/ast.h

diff --git a/src/ast.h b/src/ast.h

index 9b90d816d93ab3a54c9c571f81c70d1722621ee6..78e7153d302aeecc07b02ad8415eb624146a18eb 100644

--- a/src/ast.h

+++ b/src/ast.h

@@ -1,4 +1,4 @@

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

@@ -120,6 +120,83 @@ typedef ZoneList<Handle<Object> > ZoneObjectList;

virtual AstNode::Type node_type() const { return AstNode::k##type; } \

+class AstNodeType {

+ public:

+ enum FlagIndex {

+ kIfStatement = 0,

+ kContinueStatement,

+ kBreakStatement,

+ kReturnStatement,

+ kWithStatement,

+ kSwitchStatement,

+ kDoWhileStatement,

+ kWhileStatement,

+ kForStatement,

+ kForInStatement,

+ kTryCatchStatement,

+ kTryFinallyStatement,

+ kDebuggerStatement,

+ kFunctionLiteral,

+ kSharedFunctionInfoLiteral,

+ kConditional,

+ kRegExpLiteral,

+ kObjectLiteral,

+ kArrayLiteral,

+ kThrow,

+ kProperty,

+ kCall,

+ kCallNew,

+ kCallRuntime,

+ kThisFunction

+ };

+ typedef int Flag;

Sven Panne 2012/01/17 13:46:58 Drive-by comment: One could use EnumSet<FlagIndex>

+ static const Flag kIfStatementMask = (1 << kIfStatement);

+ static const Flag kContinueStatementMask = (1 << kContinueStatement);

+ static const Flag kBreakStatementMask = (1 << kBreakStatement);

+ static const Flag kReturnStatementMask = (1 << kReturnStatement);

+ static const Flag kWithStatementMask = (1 << kWithStatement);

+ static const Flag kSwitchStatementMask = (1 << kSwitchStatement);

+ static const Flag kDoWhileStatementMask = (1 << kDoWhileStatement);

+ static const Flag kWhileStatementMask = (1 << kWhileStatement);

+ static const Flag kForStatementMask = (1 << kForStatement);

+ static const Flag kForInStatementMask = (1 << kForInStatement);

+ static const Flag kTryCatchStatementMask = (1 << kTryCatchStatement);

+ static const Flag kTryFinallyStatementMask = (1 << kTryFinallyStatement);

+ static const Flag kDebuggerStatementMask = (1 << kDebuggerStatement);

+ static const Flag kFunctionLiteralMask = (1 << kFunctionLiteral);

+ static const Flag kSharedFunctionInfoLiteralMask =

+ (1 << kSharedFunctionInfoLiteral);

+ static const Flag kConditionalMask = (1 << kConditional);

+ static const Flag kRegExpLiteralMask = (1 << kRegExpLiteral);

+ static const Flag kObjectLiteralMask = (1 << kObjectLiteral);

+ static const Flag kArrayLiteralMask = (1 << kArrayLiteral);

+ static const Flag kThrowMask = (1 << kThrow);

+ static const Flag kPropertyMask = (1 << kProperty);

+ static const Flag kCallMask = (1 << kCall);

+ static const Flag kCallNewMask = (1 << kCallNew);

+ static const Flag kCallRuntimeMask = (1 << kCallRuntime);

+ static const Flag kThisFunctionMask = (1 << kThisFunction);

+ static const Flag kContainsBackEdgesMask =

+ kDoWhileStatementMask |

+ kWhileStatementMask |

+ kForStatementMask |

+ kForInStatementMask;

+ static const Flag kContainsCallsMask =

+ kCallMask | kCallNewMask | kCallRuntimeMask;

+ static const Flag kPreventsOptimizationMask =

+ kWithStatementMask |

+ kForInStatementMask |

+ kTryCatchStatementMask |

+ kTryFinallyStatementMask |

+ kDebuggerStatementMask |

+ kSharedFunctionInfoLiteral;

+};

class AstNode: public ZoneObject {

public:

#define DECLARE_TYPE_ENUM(type) k##type,

@@ -167,6 +244,10 @@ class AstNode: public ZoneObject {

// True if the node is simple enough for us to inline calls containing it.

virtual bool IsInlineable() const = 0;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const {

+ *node_count += 1;

+ }

static int Count() { return Isolate::Current()->ast_node_count(); }

static void ResetIds() { Isolate::Current()->set_ast_node_id(0); }

@@ -369,6 +450,7 @@ class Block: public BreakableStatement {

DECLARE_NODE_TYPE(Block)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

void AddStatement(Statement* statement) { statements_.Add(statement); }

@@ -409,6 +491,7 @@ class Declaration: public AstNode {

VariableMode mode() const { return mode_; }

FunctionLiteral* fun() const { return fun_; } // may be NULL

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

Scope* scope() const { return scope_; }

private:

@@ -484,6 +567,7 @@ class DoWhileStatement: public IterationStatement {

int BackEdgeId() const { return back_edge_id_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Expression* cond_;

@@ -517,6 +601,7 @@ class WhileStatement: public IterationStatement {

may_have_function_literal_ = value;

}

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

// Bailout support.

virtual int ContinueId() const { return EntryId(); }

@@ -576,6 +661,7 @@ class ForStatement: public IterationStatement {

Variable* loop_variable() { return loop_variable_; }

void set_loop_variable(Variable* var) { loop_variable_ = var; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Statement* init_;

@@ -609,6 +695,7 @@ class ForInStatement: public IterationStatement {

Expression* each() const { return each_; }

Expression* enumerable() const { return enumerable_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

// Bailout support.

int AssignmentId() const { return assignment_id_; }

@@ -630,6 +717,7 @@ class ExpressionStatement: public Statement {

DECLARE_NODE_TYPE(ExpressionStatement)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

void set_expression(Expression* e) { expression_ = e; }

Expression* expression() const { return expression_; }

@@ -648,6 +736,7 @@ class ContinueStatement: public Statement {

IterationStatement* target() const { return target_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

IterationStatement* target_;

@@ -663,6 +752,7 @@ class BreakStatement: public Statement {

BreakableStatement* target() const { return target_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

BreakableStatement* target_;

@@ -678,6 +768,7 @@ class ReturnStatement: public Statement {

Expression* expression() const { return expression_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Expression* expression_;

@@ -695,6 +786,7 @@ class WithStatement: public Statement {

Statement* statement() const { return statement_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Expression* expression_;

@@ -767,6 +859,7 @@ class SwitchStatement: public BreakableStatement {

Expression* tag() const { return tag_; }

ZoneList<CaseClause*>* cases() const { return cases_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Expression* tag_;

@@ -796,6 +889,7 @@ class IfStatement: public Statement {

DECLARE_NODE_TYPE(IfStatement)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

bool HasThenStatement() const { return !then_statement()->IsEmpty(); }

bool HasElseStatement() const { return !else_statement()->IsEmpty(); }

@@ -885,7 +979,7 @@ class TryCatchStatement: public TryStatement {

Scope* scope() { return scope_; }

Variable* variable() { return variable_; }

Block* catch_block() const { return catch_block_; }

- virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Scope* scope_;

@@ -903,7 +997,7 @@ class TryFinallyStatement: public TryStatement {

DECLARE_NODE_TYPE(TryFinallyStatement)

Block* finally_block() const { return finally_block_; }

- virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Block* finally_block_;

@@ -914,6 +1008,7 @@ class DebuggerStatement: public Statement {

public:

DECLARE_NODE_TYPE(DebuggerStatement)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

};

@@ -922,6 +1017,7 @@ class EmptyStatement: public Statement {

DECLARE_NODE_TYPE(EmptyStatement)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

};

@@ -1077,6 +1173,8 @@ class ObjectLiteral: public MaterializedLiteral {

kHasFunction = 1 << 1

};

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Handle<FixedArray> constant_properties_;

ZoneList<Property*>* properties_;

@@ -1101,6 +1199,8 @@ class RegExpLiteral: public MaterializedLiteral {

Handle<String> pattern() const { return pattern_; }

Handle<String> flags() const { return flags_; }

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Handle<String> pattern_;

Handle<String> flags_;

@@ -1129,6 +1229,8 @@ class ArrayLiteral: public MaterializedLiteral {

// Return an AST id for an element that is used in simulate instructions.

int GetIdForElement(int i) { return first_element_id_ + i; }

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Handle<FixedArray> constant_elements_;

ZoneList<Expression*>* values_;

@@ -1206,6 +1308,7 @@ class Property: public Expression {

virtual bool IsValidLeftHandSide() { return true; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

Expression* obj() const { return obj_; }

Expression* key() const { return key_; }

@@ -1253,6 +1356,7 @@ class Call: public Expression {

DECLARE_NODE_TYPE(Call)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

Expression* expression() const { return expression_; }

ZoneList<Expression*>* arguments() const { return arguments_; }

@@ -1308,6 +1412,7 @@ class CallNew: public Expression {

DECLARE_NODE_TYPE(CallNew)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

Expression* expression() const { return expression_; }

ZoneList<Expression*>* arguments() const { return arguments_; }

@@ -1338,6 +1443,7 @@ class CallRuntime: public Expression {

DECLARE_NODE_TYPE(CallRuntime)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

Handle<String> name() const { return name_; }

const Runtime::Function* function() const { return function_; }

@@ -1373,6 +1479,7 @@ class UnaryOperation: public Expression {

DECLARE_NODE_TYPE(UnaryOperation)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

virtual bool ResultOverwriteAllowed();

@@ -1412,6 +1519,7 @@ class BinaryOperation: public Expression {

DECLARE_NODE_TYPE(BinaryOperation)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

virtual bool ResultOverwriteAllowed();

@@ -1465,6 +1573,7 @@ class CountOperation: public Expression {

virtual void MarkAsStatement() { is_prefix_ = true; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

void RecordTypeFeedback(TypeFeedbackOracle* oracle);

virtual bool IsMonomorphic() { return is_monomorphic_; }

@@ -1510,6 +1619,7 @@ class CompareOperation: public Expression {

virtual int position() const { return pos_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

// Type feedback information.

void RecordTypeFeedback(TypeFeedbackOracle* oracle);

@@ -1553,6 +1663,7 @@ class Conditional: public Expression {

DECLARE_NODE_TYPE(Conditional)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

Expression* condition() const { return condition_; }

Expression* then_expression() const { return then_expression_; }

@@ -1586,6 +1697,7 @@ class Assignment: public Expression {

DECLARE_NODE_TYPE(Assignment)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }

@@ -1645,6 +1757,7 @@ class Throw: public Expression {

Expression* exception() const { return exception_; }

virtual int position() const { return pos_; }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Expression* exception_;

@@ -1732,11 +1845,15 @@ class FunctionLiteral: public Expression {

bool pretenure() { return Pretenure::decode(bitfield_); }

void set_pretenure() { bitfield_ |= Pretenure::encode(true); }

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

bool has_duplicate_parameters() {

return HasDuplicateParameters::decode(bitfield_);

}

+ bool ShouldSelfOptimize();

+ int AstNodeCount();

private:

Handle<String> name_;

Scope* scope_;

@@ -1772,6 +1889,7 @@ class SharedFunctionInfoLiteral: public Expression {

return shared_function_info_;

}

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

private:

Handle<SharedFunctionInfo> shared_function_info_;

@@ -1783,6 +1901,7 @@ class ThisFunction: public Expression {

explicit ThisFunction(Isolate* isolate) : Expression(isolate) {}

DECLARE_NODE_TYPE(ThisFunction)

virtual bool IsInlineable() const;

+ virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;

};

« no previous file with comments | « no previous file | src/ast.cc » ('j') | no next file with comments »