24 globals_(0, info->zone()),
26 execution_context_(
NULL) {
71 ContextScope top_context(
this, scope, inner);
83 VisitVariableDeclaration(scope->
function());
94 VisitStatements(
info()->
function()->body());
95 if (HasStackOverflow())
return false;
122 Property*
property = expr->AsProperty();
125 (
property ==
NULL) ?
VARIABLE : (property->key()->IsPropertyName())
135 Code* unoptimized_code, FunctionLiteral* expr) {
136 int start_position = expr->start_position();
140 Object* obj = rinfo->target_object();
141 if (obj->IsSharedFunctionInfo()) {
160 Node* control_dependency)
162 parameters_count_(scope->num_parameters() + 1),
163 locals_count_(scope->num_stack_slots()),
164 parameters_node_(
NULL),
172 values()->push_back(receiver);
179 values()->push_back(parameter);
191 parameters_count_(copy.parameters_count_),
192 locals_count_(copy.locals_count_),
193 parameters_node_(copy.parameters_node_),
194 locals_node_(copy.locals_node_),
195 stack_node_(copy.stack_node_) {}
199 int offset,
int count) {
200 bool should_update =
false;
201 Node** env_values = (count == 0) ?
NULL : &values()->at(offset);
202 if (*state_values ==
NULL || (*state_values)->InputCount() != count) {
203 should_update =
true;
205 DCHECK(
static_cast<size_t>(offset + count) <= values()->
size());
206 for (
int i = 0;
i < count;
i++) {
207 if ((*state_values)->InputAt(
i) != env_values[
i]) {
208 should_update =
true;
215 (*state_values) =
graph()->
NewNode(op, count, env_values);
222 UpdateStateValues(¶meters_node_, 0, parameters_count());
223 UpdateStateValues(&locals_node_, parameters_count(), locals_count());
224 UpdateStateValues(&stack_node_, parameters_count() + locals_count(),
229 return graph()->
NewNode(op, parameters_node_, locals_node_, stack_node_,
231 builder()->
jsgraph()->UndefinedConstant());
237 : kind_(kind), owner_(own), outer_(own->
ast_context()) {
238 owner()->set_ast_context(
this);
245 AstGraphBuilder::AstContext::~AstContext() {
246 owner()->set_ast_context(outer_);
250 AstGraphBuilder::AstEffectContext::~AstEffectContext() {
255 AstGraphBuilder::AstValueContext::~AstValueContext() {
260 AstGraphBuilder::AstTestContext::~AstTestContext() {
265 void AstGraphBuilder::AstEffectContext::ProduceValue(Node* value) {
270 void AstGraphBuilder::AstValueContext::ProduceValue(Node* value) {
275 void AstGraphBuilder::AstTestContext::ProduceValue(Node* value) {
280 Node* AstGraphBuilder::AstEffectContext::ConsumeValue() {
return NULL; }
283 Node* AstGraphBuilder::AstValueContext::ConsumeValue() {
288 Node* AstGraphBuilder::AstTestContext::ConsumeValue() {
293 AstGraphBuilder::BreakableScope* AstGraphBuilder::BreakableScope::FindBreakable(
294 BreakableStatement* target) {
295 BreakableScope* current =
this;
296 while (current !=
NULL && current->target_ != target) {
297 owner_->environment()->Drop(current->drop_extra_);
298 current = current->next_;
305 void AstGraphBuilder::BreakableScope::BreakTarget(BreakableStatement* stmt) {
306 FindBreakable(stmt)->control_->Break();
310 void AstGraphBuilder::BreakableScope::ContinueTarget(BreakableStatement* stmt) {
311 FindBreakable(stmt)->control_->Continue();
324 for (
int i = 0;
i < exprs->length(); ++
i) {
331 AstValueContext for_value(
this);
332 if (!HasStackOverflow()) {
339 AstEffectContext for_effect(
this);
340 if (!HasStackOverflow()) {
347 AstTestContext for_condition(
this);
348 if (!HasStackOverflow()) {
354 void AstGraphBuilder::VisitVariableDeclaration(VariableDeclaration* decl) {
355 Variable* variable = decl->proxy()->var();
387 void AstGraphBuilder::VisitFunctionDeclaration(FunctionDeclaration* decl) {
388 Variable* variable = decl->proxy()->var();
389 switch (variable->location()) {
391 Handle<SharedFunctionInfo>
function =
394 if (
function.is_null())
return SetStackOverflow();
419 void AstGraphBuilder::VisitModuleDeclaration(ModuleDeclaration* decl) {
424 void AstGraphBuilder::VisitImportDeclaration(ImportDeclaration* decl) {
429 void AstGraphBuilder::VisitExportDeclaration(ExportDeclaration* decl) {
434 void AstGraphBuilder::VisitModuleLiteral(ModuleLiteral* modl) {
UNREACHABLE(); }
437 void AstGraphBuilder::VisitModuleVariable(ModuleVariable* modl) {
442 void AstGraphBuilder::VisitModulePath(ModulePath* modl) {
UNREACHABLE(); }
445 void AstGraphBuilder::VisitModuleUrl(ModuleUrl* modl) {
UNREACHABLE(); }
448 void AstGraphBuilder::VisitBlock(Block* stmt) {
449 BlockBuilder block(
this);
450 BreakableScope scope(
this, stmt, &block, 0);
451 if (stmt->labels() !=
NULL) block.BeginBlock();
452 if (stmt->scope() ==
NULL) {
454 VisitStatements(stmt->statements());
459 ContextScope scope(
this, stmt->scope(), context);
463 VisitStatements(stmt->statements());
465 if (stmt->labels() !=
NULL) block.EndBlock();
469 void AstGraphBuilder::VisitModuleStatement(ModuleStatement* stmt) {
474 void AstGraphBuilder::VisitExpressionStatement(ExpressionStatement* stmt) {
479 void AstGraphBuilder::VisitEmptyStatement(EmptyStatement* stmt) {
484 void AstGraphBuilder::VisitIfStatement(IfStatement* stmt) {
485 IfBuilder compare_if(
this);
488 compare_if.If(condition);
490 Visit(stmt->then_statement());
492 Visit(stmt->else_statement());
497 void AstGraphBuilder::VisitContinueStatement(ContinueStatement* stmt) {
499 breakable()->ContinueTarget(stmt->target());
504 void AstGraphBuilder::VisitBreakStatement(BreakStatement* stmt) {
506 breakable()->BreakTarget(stmt->target());
511 void AstGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) {
519 void AstGraphBuilder::VisitWithStatement(WithStatement* stmt) {
524 ContextScope scope(
this, stmt->scope(), context);
525 Visit(stmt->statement());
529 void AstGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
530 ZoneList<CaseClause*>* clauses = stmt->cases();
531 SwitchBuilder compare_switch(
this, clauses->length());
532 BreakableScope scope(
this, stmt, &compare_switch, 0);
533 compare_switch.BeginSwitch();
534 int default_index = -1;
541 for (
int i = 0;
i < clauses->length();
i++) {
542 CaseClause* clause = clauses->at(
i);
545 if (clause->is_default()) {
555 Node* condition =
NewNode(op, tag, label);
556 compare_switch.BeginLabel(
i, condition);
560 compare_switch.EndLabel();
565 if (default_index >= 0) {
566 compare_switch.DefaultAt(default_index);
570 for (
int i = 0;
i < clauses->length();
i++) {
571 CaseClause* clause = clauses->at(
i);
572 compare_switch.BeginCase(
i);
573 VisitStatements(clause->statements());
574 compare_switch.EndCase();
577 compare_switch.EndSwitch();
581 void AstGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
582 LoopBuilder while_loop(
this);
583 while_loop.BeginLoop();
585 while_loop.EndBody();
588 while_loop.BreakUnless(condition);
589 while_loop.EndLoop();
593 void AstGraphBuilder::VisitWhileStatement(WhileStatement* stmt) {
594 LoopBuilder while_loop(
this);
595 while_loop.BeginLoop();
598 while_loop.BreakUnless(condition);
600 while_loop.EndBody();
601 while_loop.EndLoop();
605 void AstGraphBuilder::VisitForStatement(ForStatement* stmt) {
606 LoopBuilder for_loop(
this);
608 for_loop.BeginLoop();
609 if (stmt->cond() !=
NULL) {
612 for_loop.BreakUnless(condition);
622 void AstGraphBuilder::VisitForInStatement(ForInStatement* stmt) {
626 IfBuilder is_undefined(
this);
627 Node* is_undefined_cond =
629 is_undefined.If(is_undefined_cond);
633 IfBuilder is_null(
this);
636 is_null.If(is_null_cond);
646 javascript()->Runtime(Runtime::kGetPropertyNamesFast, 1), 1);
654 Node* cache_array =
NewNode(
common()->Projection(0), cache_pair);
659 javascript()->Runtime(Runtime::kForInCacheArrayLength, 2), 2);
663 IfBuilder have_no_properties(
this);
665 cache_length,
jsgraph()->ZeroConstant());
666 have_no_properties.If(empty_array_cond);
667 have_no_properties.Then();
670 have_no_properties.Else();
678 LoopBuilder for_loop(
this);
679 for_loop.BeginLoop();
686 for_loop.BreakUnless(exit_cond);
698 Node* should_filter =
NewNode(
common()->Projection(1), pair);
702 IfBuilder test_should_filter(
this);
703 Node* should_filter_cond =
706 test_should_filter.If(should_filter_cond);
707 test_should_filter.Then();
728 IfBuilder is_property_missing(
this);
729 is_property_missing.If(property_missing);
730 is_property_missing.Then();
738 is_property_missing.Else();
739 is_property_missing.End();
743 test_should_filter.Else();
744 test_should_filter.End();
761 have_no_properties.End();
769 void AstGraphBuilder::VisitForOfStatement(ForOfStatement* stmt) {
776 void AstGraphBuilder::VisitTryCatchStatement(TryCatchStatement* stmt) {
781 void AstGraphBuilder::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
786 void AstGraphBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) {
793 void AstGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
798 Handle<SharedFunctionInfo> shared_info =
800 if (shared_info.is_null()) {
802 CHECK(!shared_info.is_null());
810 Node* value =
NewNode(op, context,
info, pretenure);
815 void AstGraphBuilder::VisitClassLiteral(ClassLiteral* expr) {
821 void AstGraphBuilder::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
826 void AstGraphBuilder::VisitConditional(Conditional* expr) {
827 IfBuilder compare_if(
this);
830 compare_if.If(condition);
832 Visit(expr->then_expression());
834 Visit(expr->else_expression());
840 void AstGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
846 void AstGraphBuilder::VisitLiteral(Literal* expr) {
852 void AstGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
856 Node* literals_array =
863 Node* literal =
NewNode(op, literals_array, literal_index, pattern,
flags);
868 void AstGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
872 expr->BuildConstantProperties(
isolate());
873 Node* literals_array =
879 Node* literal =
NewNode(op, literals_array, literal_index, constants,
flags);
888 expr->CalculateEmitStore(
zone());
891 AccessorTable accessor_table(
zone());
892 for (
int i = 0;
i < expr->properties()->length();
i++) {
893 ObjectLiteral::Property*
property = expr->properties()->at(
i);
894 if (property->IsCompileTimeValue())
continue;
896 Literal* key =
property->key();
897 switch (property->kind()) {
900 case ObjectLiteral::Property::MATERIALIZED_LITERAL:
903 case ObjectLiteral::Property::COMPUTED: {
906 if (key->value()->IsInternalizedString()) {
907 if (property->emit_store()) {
925 if (property->emit_store()) {
928 NewNode(op, receiver, key, value, strict);
932 case ObjectLiteral::Property::PROTOTYPE: {
937 if (property->emit_store()) {
943 case ObjectLiteral::Property::GETTER:
944 accessor_table.lookup(key)->second->getter =
property->value();
946 case ObjectLiteral::Property::SETTER:
947 accessor_table.lookup(key)->second->setter =
property->value();
954 for (AccessorTable::Iterator it = accessor_table.begin();
955 it != accessor_table.end(); ++it) {
965 Node* call =
NewNode(op, literal,
name, getter, setter, attr);
970 if (expr->has_function()) {
979 void AstGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
983 expr->BuildConstantElements(
isolate());
984 Node* literals_array =
990 Node* literal =
NewNode(op, literals_array, literal_index, constants,
flags);
999 for (
int i = 0;
i < expr->values()->length();
i++) {
1000 Expression* subexpr = expr->values()->at(
i);
1020 Property*
property = expr->AsProperty();
1024 switch (assign_type) {
1026 Variable* var = expr->AsVariableProxy()->var();
1037 MakeUnique(property->key()->AsLiteral()->AsPropertyName());
1061 void AstGraphBuilder::VisitAssignment(Assignment* expr) {
1062 DCHECK(expr->target()->IsValidReferenceExpression());
1065 Property*
property = expr->target()->AsProperty();
1069 switch (assign_type) {
1085 if (expr->is_compound()) {
1086 Node* old_value =
NULL;
1087 switch (assign_type) {
1089 Variable* variable = expr->target()->AsVariableProxy()->var();
1096 MakeUnique(property->key()->AsLiteral()->AsPropertyName());
1113 Node* value =
BuildBinaryOp(left, right, expr->binary_op());
1122 switch (assign_type) {
1124 Variable* variable = expr->target()->AsVariableProxy()->var();
1126 expr->AssignmentId());
1132 MakeUnique(property->key()->AsLiteral()->AsPropertyName());
1152 void AstGraphBuilder::VisitYield(Yield* expr) {
1162 void AstGraphBuilder::VisitThrow(
Throw* expr) {
1166 Node* value =
NewNode(op, exception);
1171 void AstGraphBuilder::VisitProperty(Property* expr) {
1173 if (expr->key()->IsPropertyName()) {
1176 Unique<Name>
name =
MakeUnique(expr->key()->AsLiteral()->AsPropertyName());
1190 void AstGraphBuilder::VisitCall(Call* expr) {
1191 Expression* callee = expr->expression();
1192 Call::CallType call_type = expr->GetCallType(
isolate());
1197 Node* receiver_value =
NULL;
1198 Node* callee_value =
NULL;
1199 bool possibly_eval =
false;
1200 switch (call_type) {
1201 case Call::GLOBAL_CALL: {
1202 Variable* variable = callee->AsVariableProxy()->var();
1207 case Call::LOOKUP_SLOT_CALL: {
1208 Variable* variable = callee->AsVariableProxy()->var();
1217 case Call::PROPERTY_CALL: {
1218 Property*
property = callee->AsProperty();
1221 if (property->key()->IsPropertyName()) {
1223 MakeUnique(property->key()->AsLiteral()->AsPropertyName());
1238 case Call::POSSIBLY_EVAL_CALL:
1239 possibly_eval =
true;
1241 case Call::OTHER_CALL:
1254 ZoneList<Expression*>* args = expr->arguments();
1259 if (possibly_eval && args->length() > 0) {
1260 int arg_count = args->length();
1271 const Operator* op =
1273 Node* pair =
NewNode(op, callee, source, receiver, strict, position);
1275 Node* new_receiver =
NewNode(
common()->Projection(1), pair);
1290 void AstGraphBuilder::VisitCallNew(CallNew* expr) {
1294 ZoneList<Expression*>* args = expr->arguments();
1332 void AstGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
1337 if (expr->is_jsruntime()) {
1338 DCHECK(
function ==
NULL && expr->name()->length() > 0);
1355 void AstGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
1356 switch (expr->op()) {
1371 void AstGraphBuilder::VisitCountOperation(CountOperation* expr) {
1372 DCHECK(expr->expression()->IsValidReferenceExpression());
1375 Property*
property = expr->expression()->AsProperty();
1383 Node* old_value =
NULL;
1384 int stack_depth = -1;
1385 switch (assign_type) {
1387 Variable* variable = expr->expression()->AsVariableProxy()->var();
1396 MakeUnique(property->key()->AsLiteral()->AsPropertyName());
1428 switch (assign_type) {
1430 Variable* variable = expr->expression()->AsVariableProxy()->var();
1433 expr->AssignmentId());
1440 MakeUnique(property->key()->AsLiteral()->AsPropertyName());
1467 void AstGraphBuilder::VisitBinaryOperation(BinaryOperation* expr) {
1468 switch (expr->op()) {
1487 void AstGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
1489 switch (expr->op()) {
1496 case Token::EQ_STRICT:
1499 case Token::NE_STRICT:
1514 case Token::INSTANCEOF:
1528 Node* value =
NewNode(op, left, right);
1534 void AstGraphBuilder::VisitThisFunction(ThisFunction* expr) {
1540 void AstGraphBuilder::VisitSuperReference(SuperReference* expr) {
1545 void AstGraphBuilder::VisitCaseClause(CaseClause* expr) {
UNREACHABLE(); }
1550 AstVisitor::VisitDeclarations(declarations);
1551 if (
globals()->is_empty())
return;
1567 if (stmt ==
NULL)
return;
1574 BreakableScope scope(
this, stmt, loop, drop_extra);
1575 Visit(stmt->
body());
1581 if (expr->expression()->IsVariableProxy()) {
1584 Variable* variable = expr->expression()->AsVariableProxy()->var();
1587 }
else if (expr->expression()->IsProperty()) {
1588 Property*
property = expr->expression()->AsProperty();
1611 if (expr->expression()->IsVariableProxy()) {
1614 Variable* variable = expr->expression()->AsVariableProxy()->var();
1637 Visit(expr->right());
1643 bool is_logical_and = expr->op() ==
Token::AND;
1649 if (is_logical_and) {
1651 Visit(expr->right());
1656 if (!is_logical_and) {
1658 Visit(expr->right());
1670 for (
int i = arity - 1;
i >= 0; --
i) {
1673 Node* value =
NewNode(op, arity, all);
1680 if (heap_slots <= 0)
return context;
1685 Node* local_context =
NewNode(op, closure);
1690 for (
int i = 0;
i < num_parameters;
i++) {
1699 NewNode(op, local_context, parameter);
1702 return local_context;
1707 if (arguments ==
NULL)
return NULL;
1712 Node*
object =
NewNode(op, callee);
1728 hole_check.
If(check);
1743 hole_check.
If(check);
1764 Node* node =
NewNode(op, global);
1774 if (value->op() == the_hole->op()) {
1776 }
else if (value->opcode() == IrOpcode::kPhi) {
1782 if (value->op() == the_hole->op()) {
1784 }
else if (value->opcode() == IrOpcode::kPhi) {
1815 ? Runtime::kLoadLookupSlot
1816 : Runtime::kLoadLookupSlotNoReferenceError;
1865 Node* store =
NewNode(op, global, value);
1875 if (current->op() != the_hole->op()) {
1881 }
else if (
mode ==
LET && op != Token::INIT_LET) {
1887 if (current->op() == the_hole->op()) {
1889 }
else if (value->opcode() == IrOpcode::kPhi) {
1892 }
else if (
mode ==
CONST && op != Token::INIT_CONST) {
1910 }
else if (
mode ==
LET && op != Token::INIT_LET) {
1916 }
else if (
mode ==
CONST && op != Token::INIT_CONST) {
1958 return NewNode(load_op, context);
1972 return NewNode(op, variable_name);
1982 case Token::BIT_AND:
1985 case Token::BIT_XOR:
2016 return NewNode(js_op, left, right);
2026 node,
environment()->Checkpoint(ast_id, combine));
virtual void Accept(AstVisitor *v)=0
static BailoutId FunctionEntry()
int num_parameters() const
int num_heap_slots() const
static bool IsCompileTimeValue(Expression *expression)
static Handle< SharedFunctionInfo > BuildFunctionInfo(FunctionLiteral *node, Handle< Script > script, CompilationInfo *outer)
virtual bool IsValidReferenceExpression() const
static const int kBuiltinsOffset
static int OffsetOfFunctionWithId(Builtins::JavaScript id)
static const int kLiteralsOffset
int num_parameters() const
VariableDeclaration * function() const
int ContextChainLength(Scope *scope)
bool is_function_scope() const
ZoneList< Declaration * > * declarations()
Variable * arguments() const
Variable * parameter(int index) const
int start_position() const
Handle< String > name() const
bool binding_needs_init() const
VariableMode mode() const
bool IsStackAllocated() const
Location location() const
MaybeAssignedFlag maybe_assigned() const
bool IsContextSlot() const
Node * Checkpoint(BailoutId ast_id, OutputFrameStateCombine combine)
Environment(AstGraphBuilder *builder, Scope *scope, Node *control_dependency)
void Bind(Variable *variable, Node *node)
int parameters_count() const
void UpdateStateValues(Node **state_values, int offset, int count)
AstGraphBuilder * builder() const
void Poke(int depth, Node *node)
Node * Lookup(Variable *variable)
void VisitIfNotNull(Statement *stmt)
Node * BuildHoleCheckSilent(Node *value, Node *for_hole, Node *not_hole)
Scope * current_scope() const
Node * BuildVariableDelete(Variable *var)
void VisitForInAssignment(Expression *expr, Node *value)
SetOncePointer< Node > function_closure_
Node * BuildToBoolean(Node *value)
SetOncePointer< Node > function_context_
Environment * environment()
Node * BuildVariableLoad(Variable *var, BailoutId bailout_id, ContextualMode mode=CONTEXTUAL)
Node * BuildArgumentsObject(Variable *arguments)
void VisitDelete(UnaryOperation *expr)
virtual BaseEnvironment * CopyEnvironment(BaseEnvironment *env)
void VisitIterationBody(IterationStatement *stmt, LoopBuilder *loop, int)
void VisitComma(BinaryOperation *expr)
Node * BuildLoadBuiltinsObject()
virtual void VisitDeclarations(ZoneList< Declaration * > *declarations)
void VisitTypeof(UnaryOperation *expr)
Node * BuildHoleCheckThrow(Node *value, Variable *var, Node *not_hole)
AstContext * ast_context() const
void VisitVoid(UnaryOperation *expr)
Node * ProcessArguments(const Operator *op, int arity)
void VisitForValues(ZoneList< Expression * > *exprs)
Node * BuildLoadObjectField(Node *object, int offset)
Node * BuildLocalFunctionContext(Node *context, Node *closure)
Node * GetFunctionClosure()
AstGraphBuilder(CompilationInfo *info, JSGraph *jsgraph)
Node * GetFunctionContext()
void VisitForValueOrNull(Expression *expr)
void PrepareFrameState(Node *node, BailoutId ast_id, OutputFrameStateCombine combine=kIgnoreOutput)
BreakableScope * breakable() const
void VisitForEffect(Expression *expr)
Node * BuildLoadGlobalObject()
void VisitLogicalExpression(BinaryOperation *expr)
void VisitForTest(Expression *expr)
void VisitNot(UnaryOperation *expr)
ZoneList< Handle< Object > > * globals()
JSOperatorBuilder * javascript()
void VisitForValue(Expression *expr)
Node * BuildThrowReferenceError(Variable *var)
Node * BuildVariableAssignment(Variable *var, Node *value, Token::Value op, BailoutId bailout_id)
void VisitCallJSRuntime(CallRuntime *expr)
Node * BuildBinaryOp(Node *left, Node *right, Token::Value op)
Node * NewNode(const Operator *op)
Node * NewNode(const Operator *op, int input_count, Node **inputs)
Node * UndefinedConstant()
Node * Constant(Handle< Object > value)
const Operator * BitwiseOr()
const Operator * CreateWithContext()
const Operator * GreaterThan()
const Operator * InstanceOf()
const Operator * StrictEqual()
const Operator * StrictNotEqual()
const Operator * ShiftRightLogical()
const Operator * Subtract()
const Operator * CreateBlockContext()
const Operator * LoadNamed(Unique< Name > name, ContextualMode contextual_mode=NOT_CONTEXTUAL)
const Operator * Runtime(Runtime::FunctionId function, int arguments)
const Operator * ShiftLeft()
const Operator * LoadContext(uint16_t depth, uint32_t index, bool immutable)
const Operator * Multiply()
const Operator * ShiftRight()
const Operator * BitwiseXor()
const Operator * CallNew(int arguments)
const Operator * GreaterThanOrEqual()
const Operator * HasProperty()
const Operator * StoreContext(uint16_t depth, uint32_t index)
const Operator * BitwiseAnd()
const Operator * NotEqual()
const Operator * DeleteProperty(StrictMode strict_mode)
const Operator * Divide()
const Operator * CreateFunctionContext()
const Operator * LessThanOrEqual()
const Operator * Call(int arguments, CallFunctionFlags flags)
const Operator * Modulus()
const Operator * StoreNamed(StrictMode strict_mode, Unique< Name > name)
const Operator * LessThan()
static Node * GetFrameStateInput(Node *node)
static void ReplaceFrameStateInput(Node *node, Node *frame_state)
static bool HasFrameStateInput(const Operator *op)
Environment * CopyAsUnreachable()
void UpdateControlDependency(Node *dependency)
CommonOperatorBuilder * common()
Isolate * isolate() const
Node * current_context() const
Node * exit_control() const
void UpdateControlDependencyToLeaveFunction(Node *exit)
Unique< T > MakeUnique(Handle< T > object)
CommonOperatorBuilder * common() const
void set_current_context(Node *context)
void set_environment(Environment *env)
enable harmony numeric enable harmony object literal extensions Optimize object size
enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long enable alignment of csp to bytes on platforms which prefer the register to always be expose gc extension under the specified name show built in functions in stack traces use random jit cookie to mask large constants minimum length for automatic enable preparsing CPU profiler sampling interval in microseconds trace out of bounds accesses to external arrays default size of stack region v8 is allowed to maximum length of function source code printed in a stack trace min size of a semi the new space consists of two semi spaces print one trace line following each garbage collection do not print trace line after scavenger collection print cumulative GC statistics in name
enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long mode(MIPS only)") DEFINE_BOOL(enable_always_align_csp
enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction pairs(ARM only)") DEFINE_BOOL(enable_unaligned_accesses
enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long enable alignment of csp to bytes on platforms which prefer the register to always be NULL
#define DCHECK(condition)
#define DCHECK_EQ(v1, v2)
MachineType TypeOf(MachineType machine_type)
static LhsKind DetermineLhsKind(Expression *expr)
static Handle< SharedFunctionInfo > SearchSharedFunctionInfo(Code *unoptimized_code, FunctionLiteral *expr)
int ToNumber(Register reg)
Debugger support for the V8 JavaScript engine.
static Handle< Value > Throw(Isolate *isolate, const char *message)