From 6c5c823830727de8165839db866ca90fd3dddd77 Mon Sep 17 00:00:00 2001 From: "vitalyr@chromium.org" Date: Mon, 4 Apr 2011 06:29:02 +0000 Subject: [PATCH] Support placement new syntax for zone objects and start using it in the parser. Review URL: http://codereview.chromium.org/6771058 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@7489 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/parser.cc | 245 ++++++++++++++++++++++++++++++--------------------------- src/parser.h | 5 ++ src/zone-inl.h | 4 + src/zone.h | 1 + 4 files changed, 138 insertions(+), 117 deletions(-) diff --git a/src/parser.cc b/src/parser.cc index e85206e..22d4d3f 100644 --- a/src/parser.cc +++ b/src/parser.cc @@ -88,12 +88,13 @@ class PositionStack { RegExpBuilder::RegExpBuilder() - : pending_empty_(false), - characters_(NULL), - terms_(), - alternatives_() + : zone_(Isolate::Current()->zone()), + pending_empty_(false), + characters_(NULL), + terms_(), + alternatives_() #ifdef DEBUG - , last_added_(ADD_NONE) + , last_added_(ADD_NONE) #endif {} @@ -101,7 +102,7 @@ RegExpBuilder::RegExpBuilder() void RegExpBuilder::FlushCharacters() { pending_empty_ = false; if (characters_ != NULL) { - RegExpTree* atom = new RegExpAtom(characters_->ToConstVector()); + RegExpTree* atom = new(zone()) RegExpAtom(characters_->ToConstVector()); characters_ = NULL; text_.Add(atom); LAST(ADD_ATOM); @@ -117,7 +118,7 @@ void RegExpBuilder::FlushText() { } else if (num_text == 1) { terms_.Add(text_.last()); } else { - RegExpText* text = new RegExpText(); + RegExpText* text = new(zone()) RegExpText(); for (int i = 0; i < num_text; i++) text_.Get(i)->AppendToText(text); terms_.Add(text); @@ -178,7 +179,7 @@ void RegExpBuilder::FlushTerms() { } else if (num_terms == 1) { alternative = terms_.last(); } else { - alternative = new RegExpAlternative(terms_.GetList()); + alternative = new(zone()) RegExpAlternative(terms_.GetList()); } alternatives_.Add(alternative); terms_.Clear(); @@ -195,7 +196,7 @@ RegExpTree* RegExpBuilder::ToRegExp() { if (num_alternatives == 1) { return alternatives_.last(); } - return new RegExpDisjunction(alternatives_.GetList()); + return new(zone()) RegExpDisjunction(alternatives_.GetList()); } @@ -214,11 +215,11 @@ void RegExpBuilder::AddQuantifierToAtom(int min, int num_chars = char_vector.length(); if (num_chars > 1) { Vector prefix = char_vector.SubVector(0, num_chars - 1); - text_.Add(new RegExpAtom(prefix)); + text_.Add(new(zone()) RegExpAtom(prefix)); char_vector = char_vector.SubVector(num_chars - 1, num_chars); } characters_ = NULL; - atom = new RegExpAtom(char_vector); + atom = new(zone()) RegExpAtom(char_vector); FlushText(); } else if (text_.length() > 0) { ASSERT(last_added_ == ADD_ATOM); @@ -241,7 +242,7 @@ void RegExpBuilder::AddQuantifierToAtom(int min, UNREACHABLE(); return; } - terms_.Add(new RegExpQuantifier(min, max, type, atom)); + terms_.Add(new(zone()) RegExpQuantifier(min, max, type, atom)); LAST(ADD_TERM); } @@ -408,7 +409,7 @@ unsigned* ScriptDataImpl::ReadAddress(int position) { Scope* Parser::NewScope(Scope* parent, Scope::Type type, bool inside_with) { - Scope* result = new Scope(parent, type); + Scope* result = new(zone()) Scope(parent, type); result->Initialize(inside_with); return result; } @@ -601,7 +602,7 @@ FunctionLiteral* Parser::ParseProgram(Handle source, HistogramTimerScope timer(isolate()->counters()->parse()); isolate()->counters()->total_parse_size()->Increment(source->length()); - fni_ = new FuncNameInferrer(); + fni_ = new(zone()) FuncNameInferrer(); // Initialize parser state. source->TryFlatten(); @@ -652,7 +653,7 @@ FunctionLiteral* Parser::DoParseProgram(Handle source, CheckOctalLiteral(beg_loc, scanner().location().end_pos, &ok); } if (ok) { - result = new FunctionLiteral( + result = new(zone()) FunctionLiteral( no_name, top_scope_, body, @@ -713,7 +714,7 @@ FunctionLiteral* Parser::ParseLazy(CompilationInfo* info, ASSERT(target_stack_ == NULL); Handle name(String::cast(shared_info->name())); - fni_ = new FuncNameInferrer(); + fni_ = new(zone()) FuncNameInferrer(); fni_->PushEnclosingName(name); mode_ = PARSE_EAGERLY; @@ -1252,7 +1253,7 @@ Statement* Parser::ParseStatement(ZoneStringList* labels, bool* ok) { // one must take great care not to treat it as a // fall-through. It is much easier just to wrap the entire // try-statement in a statement block and put the labels there - Block* result = new Block(labels, 1, false); + Block* result = new(zone()) Block(labels, 1, false); Target target(&this->target_stack_, result); TryStatement* statement = ParseTryStatement(CHECK_OK); if (statement) { @@ -1350,13 +1351,13 @@ VariableProxy* Parser::Declare(Handle name, // a performance issue since it may lead to repeated // Runtime::DeclareContextSlot() calls. VariableProxy* proxy = top_scope_->NewUnresolved(name, inside_with()); - top_scope_->AddDeclaration(new Declaration(proxy, mode, fun)); + top_scope_->AddDeclaration(new(zone()) Declaration(proxy, mode, fun)); // For global const variables we bind the proxy to a variable. if (mode == Variable::CONST && top_scope_->is_global_scope()) { ASSERT(resolve); // should be set by all callers Variable::Kind kind = Variable::NORMAL; - var = new Variable(top_scope_, name, Variable::CONST, true, kind); + var = new(zone()) Variable(top_scope_, name, Variable::CONST, true, kind); } // If requested and we have a local variable, bind the proxy to the variable @@ -1444,10 +1445,11 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) { // TODO(1240846): It's weird that native function declarations are // introduced dynamically when we meet their declarations, whereas // other functions are setup when entering the surrounding scope. - SharedFunctionInfoLiteral* lit = new SharedFunctionInfoLiteral(shared); + SharedFunctionInfoLiteral* lit = + new(zone()) SharedFunctionInfoLiteral(shared); VariableProxy* var = Declare(name, Variable::VAR, NULL, true, CHECK_OK); - return new ExpressionStatement( - new Assignment(Token::INIT_VAR, var, lit, RelocInfo::kNoPosition)); + return new(zone()) ExpressionStatement(new(zone()) Assignment( + Token::INIT_VAR, var, lit, RelocInfo::kNoPosition)); } @@ -1479,7 +1481,7 @@ Block* Parser::ParseBlock(ZoneStringList* labels, bool* ok) { // (ECMA-262, 3rd, 12.2) // // Construct block expecting 16 statements. - Block* result = new Block(labels, 16, false); + Block* result = new(zone()) Block(labels, 16, false); Target target(&this->target_stack_, result); Expect(Token::LBRACE, CHECK_OK); while (peek() != Token::RBRACE) { @@ -1549,7 +1551,7 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN, // is inside an initializer block, it is ignored. // // Create new block with one expected declaration. - Block* block = new Block(NULL, 1, true); + Block* block = new(zone()) Block(NULL, 1, true); VariableProxy* last_var = NULL; // the last variable declared int nvars = 0; // the number of variables declared do { @@ -1650,7 +1652,8 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN, if (top_scope_->is_global_scope()) { // Compute the arguments for the runtime call. ZoneList* arguments = new ZoneList(3); - arguments->Add(new Literal(name)); // we have at least 1 parameter + // We have at least 1 parameter. + arguments->Add(new(zone()) Literal(name)); CallRuntime* initialize; if (is_const) { @@ -1662,7 +1665,7 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN, // Note that the function does different things depending on // the number of arguments (1 or 2). initialize = - new CallRuntime( + new(zone()) CallRuntime( isolate()->factory()->InitializeConstGlobal_symbol(), Runtime::FunctionForId(Runtime::kInitializeConstGlobal), arguments); @@ -1686,13 +1689,13 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN, // Note that the function does different things depending on // the number of arguments (2 or 3). initialize = - new CallRuntime( + new(zone()) CallRuntime( isolate()->factory()->InitializeVarGlobal_symbol(), Runtime::FunctionForId(Runtime::kInitializeVarGlobal), arguments); } - block->AddStatement(new ExpressionStatement(initialize)); + block->AddStatement(new(zone()) ExpressionStatement(initialize)); } // Add an assignment node to the initialization statement block if @@ -1707,8 +1710,11 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN, // the top context for variables). Sigh... if (value != NULL) { Token::Value op = (is_const ? Token::INIT_CONST : Token::INIT_VAR); - Assignment* assignment = new Assignment(op, last_var, value, position); - if (block) block->AddStatement(new ExpressionStatement(assignment)); + Assignment* assignment = + new(zone()) Assignment(op, last_var, value, position); + if (block) { + block->AddStatement(new(zone()) ExpressionStatement(assignment)); + } } if (fni_ != NULL) fni_->Leave(); @@ -1774,7 +1780,7 @@ Statement* Parser::ParseExpressionOrLabelledStatement(ZoneStringList* labels, // Parsed expression statement. ExpectSemicolon(CHECK_OK); - return new ExpressionStatement(expr); + return new(zone()) ExpressionStatement(expr); } @@ -1794,7 +1800,7 @@ IfStatement* Parser::ParseIfStatement(ZoneStringList* labels, bool* ok) { } else { else_statement = EmptyStatement(); } - return new IfStatement(condition, then_statement, else_statement); + return new(zone()) IfStatement(condition, then_statement, else_statement); } @@ -1824,7 +1830,7 @@ Statement* Parser::ParseContinueStatement(bool* ok) { return NULL; } ExpectSemicolon(CHECK_OK); - return new ContinueStatement(target); + return new(zone()) ContinueStatement(target); } @@ -1859,7 +1865,7 @@ Statement* Parser::ParseBreakStatement(ZoneStringList* labels, bool* ok) { return NULL; } ExpectSemicolon(CHECK_OK); - return new BreakStatement(target); + return new(zone()) BreakStatement(target); } @@ -1880,7 +1886,7 @@ Statement* Parser::ParseReturnStatement(bool* ok) { if (!top_scope_->is_function_scope()) { Handle type = isolate()->factory()->illegal_return_symbol(); Expression* throw_error = NewThrowSyntaxError(type, Handle::null()); - return new ExpressionStatement(throw_error); + return new(zone()) ExpressionStatement(throw_error); } Token::Value tok = peek(); @@ -1889,12 +1895,12 @@ Statement* Parser::ParseReturnStatement(bool* ok) { tok == Token::RBRACE || tok == Token::EOS) { ExpectSemicolon(CHECK_OK); - return new ReturnStatement(GetLiteralUndefined()); + return new(zone()) ReturnStatement(GetLiteralUndefined()); } Expression* expr = ParseExpression(true, CHECK_OK); ExpectSemicolon(CHECK_OK); - return new ReturnStatement(expr); + return new(zone()) ReturnStatement(expr); } @@ -1915,21 +1921,21 @@ Block* Parser::WithHelper(Expression* obj, // Create resulting block with two statements. // 1: Evaluate the with expression. // 2: The try-finally block evaluating the body. - Block* result = new Block(NULL, 2, false); + Block* result = new(zone()) Block(NULL, 2, false); if (result != NULL) { - result->AddStatement(new WithEnterStatement(obj, is_catch_block)); + result->AddStatement(new(zone()) WithEnterStatement(obj, is_catch_block)); // Create body block. - Block* body = new Block(NULL, 1, false); + Block* body = new(zone()) Block(NULL, 1, false); body->AddStatement(stat); // Create exit block. - Block* exit = new Block(NULL, 1, false); - exit->AddStatement(new WithExitStatement()); + Block* exit = new(zone()) Block(NULL, 1, false); + exit->AddStatement(new(zone()) WithExitStatement()); // Return a try-finally statement. - TryFinallyStatement* wrapper = new TryFinallyStatement(body, exit); + TryFinallyStatement* wrapper = new(zone()) TryFinallyStatement(body, exit); wrapper->set_escaping_targets(collector.targets()); result->AddStatement(wrapper); } @@ -1986,7 +1992,7 @@ CaseClause* Parser::ParseCaseClause(bool* default_seen_ptr, bool* ok) { statements->Add(stat); } - return new CaseClause(label, statements, pos); + return new(zone()) CaseClause(label, statements, pos); } @@ -1995,7 +2001,7 @@ SwitchStatement* Parser::ParseSwitchStatement(ZoneStringList* labels, // SwitchStatement :: // 'switch' '(' Expression ')' '{' CaseClause* '}' - SwitchStatement* statement = new SwitchStatement(labels); + SwitchStatement* statement = new(zone()) SwitchStatement(labels); Target target(&this->target_stack_, statement); Expect(Token::SWITCH, CHECK_OK); @@ -2031,7 +2037,7 @@ Statement* Parser::ParseThrowStatement(bool* ok) { Expression* exception = ParseExpression(true, CHECK_OK); ExpectSemicolon(CHECK_OK); - return new ExpressionStatement(new Throw(exception, pos)); + return new(zone()) ExpressionStatement(new(zone()) Throw(exception, pos)); } @@ -2095,9 +2101,10 @@ TryStatement* Parser::ParseTryStatement(bool* ok) { // executing the finally block. catch_var = top_scope_->NewTemporary(isolate()->factory()->catch_var_symbol()); - Literal* name_literal = new Literal(name); - VariableProxy* catch_var_use = new VariableProxy(catch_var); - Expression* obj = new CatchExtensionObject(name_literal, catch_var_use); + Literal* name_literal = new(zone()) Literal(name); + VariableProxy* catch_var_use = new(zone()) VariableProxy(catch_var); + Expression* obj = + new(zone()) CatchExtensionObject(name_literal, catch_var_use); { Target target(&this->target_stack_, &catch_collector); catch_block = WithHelper(obj, NULL, true, CHECK_OK); } @@ -2121,11 +2128,11 @@ TryStatement* Parser::ParseTryStatement(bool* ok) { // 'try { try { } catch { } } finally { }' if (catch_block != NULL && finally_block != NULL) { - VariableProxy* catch_var_defn = new VariableProxy(catch_var); + VariableProxy* catch_var_defn = new(zone()) VariableProxy(catch_var); TryCatchStatement* statement = - new TryCatchStatement(try_block, catch_var_defn, catch_block); + new(zone()) TryCatchStatement(try_block, catch_var_defn, catch_block); statement->set_escaping_targets(collector.targets()); - try_block = new Block(NULL, 1, false); + try_block = new(zone()) Block(NULL, 1, false); try_block->AddStatement(statement); catch_block = NULL; } @@ -2133,12 +2140,13 @@ TryStatement* Parser::ParseTryStatement(bool* ok) { TryStatement* result = NULL; if (catch_block != NULL) { ASSERT(finally_block == NULL); - VariableProxy* catch_var_defn = new VariableProxy(catch_var); - result = new TryCatchStatement(try_block, catch_var_defn, catch_block); + VariableProxy* catch_var_defn = new(zone()) VariableProxy(catch_var); + result = + new(zone()) TryCatchStatement(try_block, catch_var_defn, catch_block); result->set_escaping_targets(collector.targets()); } else { ASSERT(finally_block != NULL); - result = new TryFinallyStatement(try_block, finally_block); + result = new(zone()) TryFinallyStatement(try_block, finally_block); // Add the jump targets of the try block and the catch block. for (int i = 0; i < collector.targets()->length(); i++) { catch_collector.AddTarget(collector.targets()->at(i)); @@ -2156,7 +2164,7 @@ DoWhileStatement* Parser::ParseDoWhileStatement(ZoneStringList* labels, // 'do' Statement 'while' '(' Expression ')' ';' lexical_scope_->AddLoop(); - DoWhileStatement* loop = new DoWhileStatement(labels); + DoWhileStatement* loop = new(zone()) DoWhileStatement(labels); Target target(&this->target_stack_, loop); Expect(Token::DO, CHECK_OK); @@ -2189,7 +2197,7 @@ WhileStatement* Parser::ParseWhileStatement(ZoneStringList* labels, bool* ok) { // 'while' '(' Expression ')' Statement lexical_scope_->AddLoop(); - WhileStatement* loop = new WhileStatement(labels); + WhileStatement* loop = new(zone()) WhileStatement(labels); Target target(&this->target_stack_, loop); Expect(Token::WHILE, CHECK_OK); @@ -2219,7 +2227,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { Block* variable_statement = ParseVariableDeclarations(false, &each, CHECK_OK); if (peek() == Token::IN && each != NULL) { - ForInStatement* loop = new ForInStatement(labels); + ForInStatement* loop = new(zone()) ForInStatement(labels); Target target(&this->target_stack_, loop); Expect(Token::IN, CHECK_OK); @@ -2228,7 +2236,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { Statement* body = ParseStatement(NULL, CHECK_OK); loop->Initialize(each, enumerable, body); - Block* result = new Block(NULL, 2, false); + Block* result = new(zone()) Block(NULL, 2, false); result->AddStatement(variable_statement); result->AddStatement(loop); // Parsed for-in loop w/ variable/const declaration. @@ -2249,7 +2257,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { isolate()->factory()->invalid_lhs_in_for_in_symbol(); expression = NewThrowReferenceError(type); } - ForInStatement* loop = new ForInStatement(labels); + ForInStatement* loop = new(zone()) ForInStatement(labels); Target target(&this->target_stack_, loop); Expect(Token::IN, CHECK_OK); @@ -2262,13 +2270,13 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { return loop; } else { - init = new ExpressionStatement(expression); + init = new(zone()) ExpressionStatement(expression); } } } // Standard 'for' loop - ForStatement* loop = new ForStatement(labels); + ForStatement* loop = new(zone()) ForStatement(labels); Target target(&this->target_stack_, loop); // Parsed initializer at this point. @@ -2284,7 +2292,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { Statement* next = NULL; if (peek() != Token::RPAREN) { Expression* exp = ParseExpression(true, CHECK_OK); - next = new ExpressionStatement(exp); + next = new(zone()) ExpressionStatement(exp); } Expect(Token::RPAREN, CHECK_OK); @@ -2305,7 +2313,7 @@ Expression* Parser::ParseExpression(bool accept_IN, bool* ok) { Expect(Token::COMMA, CHECK_OK); int position = scanner().location().beg_pos; Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK); - result = new BinaryOperation(Token::COMMA, result, right, position); + result = new(zone()) BinaryOperation(Token::COMMA, result, right, position); } return result; } @@ -2377,7 +2385,7 @@ Expression* Parser::ParseAssignmentExpression(bool accept_IN, bool* ok) { fni_->Leave(); } - return new Assignment(op, expression, right, pos); + return new(zone()) Assignment(op, expression, right, pos); } @@ -2399,7 +2407,7 @@ Expression* Parser::ParseConditionalExpression(bool accept_IN, bool* ok) { Expect(Token::COLON, CHECK_OK); int right_position = scanner().peek_location().beg_pos; Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK); - return new Conditional(expression, left, right, + return new(zone()) Conditional(expression, left, right, left_position, right_position); } @@ -2487,12 +2495,12 @@ Expression* Parser::ParseBinaryExpression(int prec, bool accept_IN, bool* ok) { x = NewCompareNode(cmp, x, y, position); if (cmp != op) { // The comparison was negated - add a NOT. - x = new UnaryOperation(Token::NOT, x); + x = new(zone()) UnaryOperation(Token::NOT, x); } } else { // We have a "normal" binary operation. - x = new BinaryOperation(op, x, y, position); + x = new(zone()) BinaryOperation(op, x, y, position); } } } @@ -2509,15 +2517,15 @@ Expression* Parser::NewCompareNode(Token::Value op, bool is_strict = (op == Token::EQ_STRICT); Literal* x_literal = x->AsLiteral(); if (x_literal != NULL && x_literal->IsNull()) { - return new CompareToNull(is_strict, y); + return new(zone()) CompareToNull(is_strict, y); } Literal* y_literal = y->AsLiteral(); if (y_literal != NULL && y_literal->IsNull()) { - return new CompareToNull(is_strict, x); + return new(zone()) CompareToNull(is_strict, x); } } - return new CompareOperation(op, x, y, position); + return new(zone()) CompareOperation(op, x, y, position); } @@ -2564,7 +2572,7 @@ Expression* Parser::ParseUnaryExpression(bool* ok) { } } - return new UnaryOperation(op, expression); + return new(zone()) UnaryOperation(op, expression); } else if (Token::IsCountOp(op)) { op = Next(); @@ -2585,8 +2593,9 @@ Expression* Parser::ParseUnaryExpression(bool* ok) { } int position = scanner().location().beg_pos; - IncrementOperation* increment = new IncrementOperation(op, expression); - return new CountOperation(true /* prefix */, increment, position); + IncrementOperation* increment = + new(zone()) IncrementOperation(op, expression); + return new(zone()) CountOperation(true /* prefix */, increment, position); } else { return ParsePostfixExpression(ok); @@ -2618,8 +2627,10 @@ Expression* Parser::ParsePostfixExpression(bool* ok) { Token::Value next = Next(); int position = scanner().location().beg_pos; - IncrementOperation* increment = new IncrementOperation(next, expression); - expression = new CountOperation(false /* postfix */, increment, position); + IncrementOperation* increment = + new(zone()) IncrementOperation(next, expression); + expression = + new(zone()) CountOperation(false /* postfix */, increment, position); } return expression; } @@ -2642,7 +2653,7 @@ Expression* Parser::ParseLeftHandSideExpression(bool* ok) { Consume(Token::LBRACK); int pos = scanner().location().beg_pos; Expression* index = ParseExpression(true, CHECK_OK); - result = new Property(result, index, pos); + result = new(zone()) Property(result, index, pos); Expect(Token::RBRACK, CHECK_OK); break; } @@ -2680,7 +2691,7 @@ Expression* Parser::ParseLeftHandSideExpression(bool* ok) { Consume(Token::PERIOD); int pos = scanner().location().beg_pos; Handle name = ParseIdentifierName(CHECK_OK); - result = new Property(result, new Literal(name), pos); + result = new(zone()) Property(result, new(zone()) Literal(name), pos); if (fni_ != NULL) fni_->PushLiteralName(name); break; } @@ -2716,7 +2727,7 @@ Expression* Parser::ParseNewPrefix(PositionStack* stack, bool* ok) { if (!stack->is_empty()) { int last = stack->pop(); - result = new CallNew(result, new ZoneList(0), last); + result = new(zone()) CallNew(result, new ZoneList(0), last); } return result; } @@ -2761,7 +2772,7 @@ Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack, Consume(Token::LBRACK); int pos = scanner().location().beg_pos; Expression* index = ParseExpression(true, CHECK_OK); - result = new Property(result, index, pos); + result = new(zone()) Property(result, index, pos); Expect(Token::RBRACK, CHECK_OK); break; } @@ -2769,7 +2780,7 @@ Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack, Consume(Token::PERIOD); int pos = scanner().location().beg_pos; Handle name = ParseIdentifierName(CHECK_OK); - result = new Property(result, new Literal(name), pos); + result = new(zone()) Property(result, new(zone()) Literal(name), pos); if (fni_ != NULL) fni_->PushLiteralName(name); break; } @@ -2797,7 +2808,7 @@ DebuggerStatement* Parser::ParseDebuggerStatement(bool* ok) { Expect(Token::DEBUGGER, CHECK_OK); ExpectSemicolon(CHECK_OK); - return new DebuggerStatement(); + return new(zone()) DebuggerStatement(); } @@ -2866,17 +2877,17 @@ Expression* Parser::ParsePrimaryExpression(bool* ok) { case Token::NULL_LITERAL: Consume(Token::NULL_LITERAL); - result = new Literal(isolate()->factory()->null_value()); + result = new(zone()) Literal(isolate()->factory()->null_value()); break; case Token::TRUE_LITERAL: Consume(Token::TRUE_LITERAL); - result = new Literal(isolate()->factory()->true_value()); + result = new(zone()) Literal(isolate()->factory()->true_value()); break; case Token::FALSE_LITERAL: Consume(Token::FALSE_LITERAL); - result = new Literal(isolate()->factory()->false_value()); + result = new(zone()) Literal(isolate()->factory()->false_value()); break; case Token::IDENTIFIER: @@ -2901,7 +2912,7 @@ Expression* Parser::ParsePrimaryExpression(bool* ok) { case Token::STRING: { Consume(Token::STRING); Handle symbol = GetSymbol(CHECK_OK); - result = new Literal(symbol); + result = new(zone()) Literal(symbol); if (fni_ != NULL) fni_->PushLiteralName(symbol); break; } @@ -3028,7 +3039,7 @@ Expression* Parser::ParseArrayLiteral(bool* ok) { literals->set_map(isolate()->heap()->fixed_cow_array_map()); } - return new ArrayLiteral(literals, values, + return new(zone()) ArrayLiteral(literals, values, literal_index, is_simple, depth); } @@ -3306,7 +3317,7 @@ ObjectLiteral::Property* Parser::ParseObjectLiteralGetSet(bool is_getter, // Allow any number of parameters for compatiabilty with JSC. // Specification only allows zero parameters for get and one for set. ObjectLiteral::Property* property = - new ObjectLiteral::Property(is_getter, value); + new(zone()) ObjectLiteral::Property(is_getter, value); return property; } else { ReportUnexpectedToken(next); @@ -3372,7 +3383,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) { } // Failed to parse as get/set property, so it's just a property // called "get" or "set". - key = new Literal(id); + key = new(zone()) Literal(id); break; } case Token::STRING: { @@ -3384,7 +3395,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) { key = NewNumberLiteral(index); break; } - key = new Literal(string); + key = new(zone()) Literal(string); break; } case Token::NUMBER: { @@ -3399,7 +3410,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) { if (Token::IsKeyword(next)) { Consume(next); Handle string = GetSymbol(CHECK_OK); - key = new Literal(string); + key = new(zone()) Literal(string); } else { // Unexpected token. Token::Value next = Next(); @@ -3413,7 +3424,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) { Expression* value = ParseAssignmentExpression(true, CHECK_OK); ObjectLiteral::Property* property = - new ObjectLiteral::Property(key, value); + new(zone()) ObjectLiteral::Property(key, value); // Mark object literals that contain function literals and pretenure the // literal so it can be added as a constant function property. @@ -3452,7 +3463,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) { &is_simple, &fast_elements, &depth); - return new ObjectLiteral(constant_properties, + return new(zone()) ObjectLiteral(constant_properties, properties, literal_index, is_simple, @@ -3477,7 +3488,7 @@ Expression* Parser::ParseRegExpLiteral(bool seen_equal, bool* ok) { Handle js_flags = NextLiteralString(TENURED); Next(); - return new RegExpLiteral(js_pattern, js_flags, literal_index); + return new(zone()) RegExpLiteral(js_pattern, js_flags, literal_index); } @@ -3580,9 +3591,9 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle var_name, VariableProxy* fproxy = top_scope_->NewUnresolved(function_name, inside_with()); fproxy->BindTo(fvar); - body->Add(new ExpressionStatement( - new Assignment(Token::INIT_CONST, fproxy, - new ThisFunction(), + body->Add(new(zone()) ExpressionStatement( + new(zone()) Assignment(Token::INIT_CONST, fproxy, + new(zone()) ThisFunction(), RelocInfo::kNoPosition))); } @@ -3676,7 +3687,7 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle var_name, } FunctionLiteral* function_literal = - new FunctionLiteral(name, + new(zone()) FunctionLiteral(name, top_scope_, body, materialized_literal_count, @@ -3738,7 +3749,7 @@ Expression* Parser::ParseV8Intrinsic(bool* ok) { } // We have a valid intrinsics call or a call to a builtin. - return new CallRuntime(name, function, args); + return new(zone()) CallRuntime(name, function, args); } @@ -3793,12 +3804,12 @@ void Parser::ExpectSemicolon(bool* ok) { Literal* Parser::GetLiteralUndefined() { - return new Literal(isolate()->factory()->undefined_value()); + return new(zone()) Literal(isolate()->factory()->undefined_value()); } Literal* Parser::GetLiteralTheHole() { - return new Literal(isolate()->factory()->the_hole_value()); + return new(zone()) Literal(isolate()->factory()->the_hole_value()); } @@ -3946,7 +3957,7 @@ void Parser::RegisterTargetUse(BreakTarget* target, Target* stop) { Literal* Parser::NewNumberLiteral(double number) { - return new Literal(isolate()->factory()->NewNumber(number, TENURED)); + return new(zone()) Literal(isolate()->factory()->NewNumber(number, TENURED)); } @@ -3993,9 +4004,9 @@ Expression* Parser::NewThrowError(Handle constructor, TENURED); ZoneList* args = new ZoneList(2); - args->Add(new Literal(type)); - args->Add(new Literal(array)); - return new Throw(new CallRuntime(constructor, NULL, args), + args->Add(new(zone()) Literal(type)); + args->Add(new(zone()) Literal(array)); + return new(zone()) Throw(new(zone()) CallRuntime(constructor, NULL, args), scanner().location().beg_pos); } @@ -4318,13 +4329,13 @@ RegExpTree* RegExpParser::ParseDisjunction() { // Build result of subexpression. if (type == CAPTURE) { - RegExpCapture* capture = new RegExpCapture(body, capture_index); + RegExpCapture* capture = new(zone()) RegExpCapture(body, capture_index); captures_->at(capture_index - 1) = capture; body = capture; } else if (type != GROUPING) { ASSERT(type == POSITIVE_LOOKAHEAD || type == NEGATIVE_LOOKAHEAD); bool is_positive = (type == POSITIVE_LOOKAHEAD); - body = new RegExpLookahead(body, + body = new(zone()) RegExpLookahead(body, is_positive, end_capture_index - capture_index, capture_index); @@ -4347,10 +4358,10 @@ RegExpTree* RegExpParser::ParseDisjunction() { Advance(); if (multiline_) { builder->AddAssertion( - new RegExpAssertion(RegExpAssertion::START_OF_LINE)); + new(zone()) RegExpAssertion(RegExpAssertion::START_OF_LINE)); } else { builder->AddAssertion( - new RegExpAssertion(RegExpAssertion::START_OF_INPUT)); + new(zone()) RegExpAssertion(RegExpAssertion::START_OF_INPUT)); set_contains_anchor(); } continue; @@ -4360,7 +4371,7 @@ RegExpTree* RegExpParser::ParseDisjunction() { RegExpAssertion::Type type = multiline_ ? RegExpAssertion::END_OF_LINE : RegExpAssertion::END_OF_INPUT; - builder->AddAssertion(new RegExpAssertion(type)); + builder->AddAssertion(new(zone()) RegExpAssertion(type)); continue; } case '.': { @@ -4368,7 +4379,7 @@ RegExpTree* RegExpParser::ParseDisjunction() { // everything except \x0a, \x0d, \u2028 and \u2029 ZoneList* ranges = new ZoneList(2); CharacterRange::AddClassEscape('.', ranges); - RegExpTree* atom = new RegExpCharacterClass(ranges, false); + RegExpTree* atom = new(zone()) RegExpCharacterClass(ranges, false); builder->AddAtom(atom); break; } @@ -4401,7 +4412,7 @@ RegExpTree* RegExpParser::ParseDisjunction() { captures_->Add(NULL); } // Store current state and begin new disjunction parsing. - stored_state = new RegExpParserState(stored_state, + stored_state = new(zone()) RegExpParserState(stored_state, type, captures_started()); builder = stored_state->builder(); @@ -4421,12 +4432,12 @@ RegExpTree* RegExpParser::ParseDisjunction() { case 'b': Advance(2); builder->AddAssertion( - new RegExpAssertion(RegExpAssertion::BOUNDARY)); + new(zone()) RegExpAssertion(RegExpAssertion::BOUNDARY)); continue; case 'B': Advance(2); builder->AddAssertion( - new RegExpAssertion(RegExpAssertion::NON_BOUNDARY)); + new(zone()) RegExpAssertion(RegExpAssertion::NON_BOUNDARY)); continue; // AtomEscape :: // CharacterClassEscape @@ -4438,7 +4449,7 @@ RegExpTree* RegExpParser::ParseDisjunction() { Advance(2); ZoneList* ranges = new ZoneList(2); CharacterRange::AddClassEscape(c, ranges); - RegExpTree* atom = new RegExpCharacterClass(ranges, false); + RegExpTree* atom = new(zone()) RegExpCharacterClass(ranges, false); builder->AddAtom(atom); break; } @@ -4454,7 +4465,7 @@ RegExpTree* RegExpParser::ParseDisjunction() { builder->AddEmpty(); break; } - RegExpTree* atom = new RegExpBackReference(capture); + RegExpTree* atom = new(zone()) RegExpBackReference(capture); builder->AddAtom(atom); break; } @@ -4972,7 +4983,7 @@ RegExpTree* RegExpParser::ParseCharacterClass() { ranges->Add(CharacterRange::Everything()); is_negated = !is_negated; } - return new RegExpCharacterClass(ranges, is_negated); + return new(zone()) RegExpCharacterClass(ranges, is_negated); } diff --git a/src/parser.h b/src/parser.h index 74cb049..78faea1 100644 --- a/src/parser.h +++ b/src/parser.h @@ -280,6 +280,9 @@ class RegExpBuilder: public ZoneObject { void FlushCharacters(); void FlushText(); void FlushTerms(); + Zone* zone() { return zone_; } + + Zone* zone_; bool pending_empty_; ZoneList* characters_; BufferedZoneList terms_; @@ -389,6 +392,7 @@ class RegExpParser { }; Isolate* isolate() { return isolate_; } + Zone* zone() { return isolate_->zone(); } uc32 current() { return current_; } bool has_more() { return has_more_; } @@ -453,6 +457,7 @@ class Parser { }; Isolate* isolate() { return isolate_; } + Zone* zone() { return isolate_->zone(); } // Called by ParseProgram after setting up the scanner. FunctionLiteral* DoParseProgram(Handle source, diff --git a/src/zone-inl.h b/src/zone-inl.h index 516fc4a..17e83dc 100644 --- a/src/zone-inl.h +++ b/src/zone-inl.h @@ -97,6 +97,10 @@ void* ZoneObject::operator new(size_t size) { return ZONE->New(static_cast(size)); } +void* ZoneObject::operator new(size_t size, Zone* zone) { + return zone->New(static_cast(size)); +} + inline void* ZoneListAllocationPolicy::New(int size) { return ZONE->New(size); diff --git a/src/zone.h b/src/zone.h index 13b55c4..9efe4f5 100644 --- a/src/zone.h +++ b/src/zone.h @@ -133,6 +133,7 @@ class ZoneObject { public: // Allocate a new ZoneObject of 'size' bytes in the Zone. inline void* operator new(size_t size); + inline void* operator new(size_t size, Zone* zone); // Ideally, the delete operator should be private instead of // public, but unfortunately the compiler sometimes synthesizes -- 2.7.4