[turbofan] Some javascript operators are globally shared singletons.

src/compiler/ast-graph-builder.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
@@ skipping 57 matching lines @@
   Node* inner = BuildLocalFunctionContext(outer, closure);
 
   // Push top-level function scope for the function body.
   ContextScope top_context(this, scope, inner);
 
   // Build the arguments object if it is used.
   BuildArgumentsObject(scope->arguments());
 
   // Emit tracing call if requested to do so.
   if (FLAG_trace) {
-    NewNode(javascript()->Runtime(Runtime::kTraceEnter, 0));
+    NewNode(javascript()->CallRuntime(
+        CallRuntimeParameters(Runtime::kTraceEnter, 0)));

[Michael Starzinger, 2014/09/29 15:24:06]

I think we should continue to let the factory method materialize the
CallRuntimeParameters (and friends) for us instead of doing it explicitly.
Otherwise readability of these call-sites suffers.

[Benedikt Meurer, 2014/09/30 04:44:05]

Done.

   }
 
   // Visit implicit declaration of the function name.
   if (scope->is_function_scope() && scope->function() != NULL) {
     VisitVariableDeclaration(scope->function());
   }
 
   // Visit declarations within the function scope.
   VisitDeclarations(scope->declarations());
 
   // TODO(mstarzinger): This should do an inlined stack check.
-  Node* node = NewNode(javascript()->Runtime(Runtime::kStackGuard, 0));
+  Node* node = NewNode(javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kStackGuard, 0)));
   PrepareFrameState(node, BailoutId::FunctionEntry());
 
   // Visit statements in the function body.
   VisitStatements(info()->function()->body());
   if (HasStackOverflow()) return false;
 
   // Emit tracing call if requested to do so.
   if (FLAG_trace) {
     // TODO(mstarzinger): Only traces implicit return.
     Node* return_value = jsgraph()->UndefinedConstant();
-    NewNode(javascript()->Runtime(Runtime::kTraceExit, 1), return_value);
+    NewNode(javascript()->CallRuntime(
+                CallRuntimeParameters(Runtime::kTraceExit, 1)),
+            return_value);
   }
 
   // Return 'undefined' in case we can fall off the end.
   Node* control = NewNode(common()->Return(), jsgraph()->UndefinedConstant());
   UpdateControlDependencyToLeaveFunction(control);
 
   // Finish the basic structure of the graph.
   environment()->UpdateControlDependency(exit_control());
   graph()->SetEnd(NewNode(common()->End()));
 
@@ skipping 255 matching lines @@
     case Variable::PARAMETER:
     case Variable::LOCAL:
       if (hole_init) {
         Node* value = jsgraph()->TheHoleConstant();
         environment()->Bind(variable, value);
       }
       break;
     case Variable::CONTEXT:
       if (hole_init) {
         Node* value = jsgraph()->TheHoleConstant();
-        const Operator* op = javascript()->StoreContext(0, variable->index());
+        const Operator* op =
+            javascript()->StoreContext(ContextAccess(0, variable->index()));
         NewNode(op, current_context(), value);
       }
       break;
     case Variable::LOOKUP:
       UNIMPLEMENTED();
   }
 }
 
 
 void AstGraphBuilder::VisitFunctionDeclaration(FunctionDeclaration* decl) {
@@ skipping 11 matching lines @@
     case Variable::PARAMETER:
     case Variable::LOCAL: {
       VisitForValue(decl->fun());
       Node* value = environment()->Pop();
       environment()->Bind(variable, value);
       break;
     }
     case Variable::CONTEXT: {
       VisitForValue(decl->fun());
       Node* value = environment()->Pop();
-      const Operator* op = javascript()->StoreContext(0, variable->index());
+      const Operator* op =
+          javascript()->StoreContext(ContextAccess(0, variable->index()));
       NewNode(op, current_context(), value);
       break;
     }
     case Variable::LOOKUP:
       UNIMPLEMENTED();
   }
 }
 
 
 void AstGraphBuilder::VisitModuleDeclaration(ModuleDeclaration* decl) {
@@ skipping 215 matching lines @@
         NewNode(javascript()->StrictEqual(), obj, jsgraph()->NullConstant());
     is_null.If(is_null_cond);
     is_null.Then();
     is_null.Else();
     // Convert object to jsobject.
     // PrepareForBailoutForId(stmt->PrepareId(), TOS_REG);
     obj = NewNode(javascript()->ToObject(), obj);
     environment()->Push(obj);
     // TODO(dcarney): should do a fast enum cache check here to skip runtime.
     environment()->Push(obj);
-    Node* cache_type = ProcessArguments(
-        javascript()->Runtime(Runtime::kGetPropertyNamesFast, 1), 1);
+    Node* cache_type =
+        ProcessArguments(javascript()->CallRuntime(CallRuntimeParameters(
+                             Runtime::kGetPropertyNamesFast, 1)),
+                         1);
     // TODO(dcarney): these next runtime calls should be removed in favour of
     //                a few simplified instructions.
     environment()->Push(obj);
     environment()->Push(cache_type);
     Node* cache_pair =
-        ProcessArguments(javascript()->Runtime(Runtime::kForInInit, 2), 2);
+        ProcessArguments(javascript()->CallRuntime(
+                             CallRuntimeParameters(Runtime::kForInInit, 2)),
+                         2);
     // cache_type may have been replaced.
     Node* cache_array = NewNode(common()->Projection(0), cache_pair);
     cache_type = NewNode(common()->Projection(1), cache_pair);
     environment()->Push(cache_type);
     environment()->Push(cache_array);
-    Node* cache_length = ProcessArguments(
-        javascript()->Runtime(Runtime::kForInCacheArrayLength, 2), 2);
+    Node* cache_length =
+        ProcessArguments(javascript()->CallRuntime(CallRuntimeParameters(
+                             Runtime::kForInCacheArrayLength, 2)),
+                         2);
     {
       // TODO(dcarney): this check is actually supposed to be for the
       //                empty enum case only.
       IfBuilder have_no_properties(this);
       Node* empty_array_cond = NewNode(javascript()->StrictEqual(),
                                        cache_length, jsgraph()->ZeroConstant());
       have_no_properties.If(empty_array_cond);
       have_no_properties.Then();
       // Pop obj and skip loop.
       environment()->Pop();
@@ skipping 16 matching lines @@
         for_loop.BreakUnless(exit_cond);
         // TODO(dcarney): this runtime call should be a handful of
         //                simplified instructions that
         //                basically produce
         //                    value = array[index]
         environment()->Push(obj);
         environment()->Push(cache_array);
         environment()->Push(cache_type);
         environment()->Push(index);
         Node* pair =
-            ProcessArguments(javascript()->Runtime(Runtime::kForInNext, 4), 4);
+            ProcessArguments(javascript()->CallRuntime(
+                                 CallRuntimeParameters(Runtime::kForInNext, 4)),
+                             4);
         Node* value = NewNode(common()->Projection(0), pair);
         Node* should_filter = NewNode(common()->Projection(1), pair);
         environment()->Push(value);
         {
           // Test if FILTER_KEY needs to be called.
           IfBuilder test_should_filter(this);
           Node* should_filter_cond =
               NewNode(javascript()->StrictEqual(), should_filter,
                       jsgraph()->TrueConstant());
           test_should_filter.If(should_filter_cond);
           test_should_filter.Then();
           value = environment()->Pop();
           Node* builtins = BuildLoadBuiltinsObject();
           Node* function = BuildLoadObjectField(
               builtins,
               JSBuiltinsObject::OffsetOfFunctionWithId(Builtins::FILTER_KEY));
           // Callee.
           environment()->Push(function);
           // Receiver.
           environment()->Push(obj);
           // Args.
           environment()->Push(value);
           // result is either the string key or Smi(0) indicating the property
           // is gone.
           Node* res = ProcessArguments(
-              javascript()->Call(3, NO_CALL_FUNCTION_FLAGS), 3);
+              javascript()->CallFunction(
+                  CallFunctionParameters(3, NO_CALL_FUNCTION_FLAGS)),
+              3);
           // TODO(jarin): provide real bailout id.
           PrepareFrameState(res, BailoutId::None());
           Node* property_missing = NewNode(javascript()->StrictEqual(), res,
                                            jsgraph()->ZeroConstant());
           {
             IfBuilder is_property_missing(this);
             is_property_missing.If(property_missing);
             is_property_missing.Then();
             // Inc counter and continue.
             Node* index_inc =
@@ skipping 45 matching lines @@
 }
 
 
 void AstGraphBuilder::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   UNREACHABLE();
 }
 
 
 void AstGraphBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) {
   // TODO(turbofan): Do we really need a separate reloc-info for this?
-  Node* node = NewNode(javascript()->Runtime(Runtime::kDebugBreak, 0));
+  Node* node = NewNode(javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kDebugBreak, 0)));
   PrepareFrameState(node, stmt->DebugBreakId());
 }
 
 
 void AstGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
   Node* context = current_context();
 
   // Build a new shared function info if we cannot find one in the baseline
   // code. We also have a stack overflow if the recursive compilation did.
   Handle<SharedFunctionInfo> shared_info =
       SearchSharedFunctionInfo(info()->shared_info()->code(), expr);
   if (shared_info.is_null()) {
     shared_info = Compiler::BuildFunctionInfo(expr, info()->script(), info());
     CHECK(!shared_info.is_null());  // TODO(mstarzinger): Set stack overflow?
   }
 
   // Create node to instantiate a new closure.
   Node* info = jsgraph()->Constant(shared_info);
   Node* pretenure = expr->pretenure() ? jsgraph()->TrueConstant()
                                       : jsgraph()->FalseConstant();
-  const Operator* op = javascript()->Runtime(Runtime::kNewClosure, 3);
+  const Operator* op =
+      javascript()->CallRuntime(CallRuntimeParameters(Runtime::kNewClosure, 3));
   Node* value = NewNode(op, context, info, pretenure);
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitClassLiteral(ClassLiteral* expr) {
   // TODO(arv): Implement.
   UNREACHABLE();
 }
 
@@ skipping 31 matching lines @@
 
 void AstGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
   Node* closure = GetFunctionClosure();
 
   // Create node to materialize a regular expression literal.
   Node* literals_array =
       BuildLoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* literal_index = jsgraph()->Constant(expr->literal_index());
   Node* pattern = jsgraph()->Constant(expr->pattern());
   Node* flags = jsgraph()->Constant(expr->flags());
-  const Operator* op =
-      javascript()->Runtime(Runtime::kMaterializeRegExpLiteral, 4);
+  const Operator* op = javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kMaterializeRegExpLiteral, 4));
   Node* literal = NewNode(op, literals_array, literal_index, pattern, flags);
   ast_context()->ProduceValue(literal);
 }
 
 
 void AstGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
   Node* closure = GetFunctionClosure();
 
   // Create node to deep-copy the literal boilerplate.
   expr->BuildConstantProperties(isolate());
   Node* literals_array =
       BuildLoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* literal_index = jsgraph()->Constant(expr->literal_index());
   Node* constants = jsgraph()->Constant(expr->constant_properties());
   Node* flags = jsgraph()->Constant(expr->ComputeFlags());
-  const Operator* op = javascript()->Runtime(Runtime::kCreateObjectLiteral, 4);
+  const Operator* op = javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kCreateObjectLiteral, 4));
   Node* literal = NewNode(op, literals_array, literal_index, constants, flags);
 
   // The object is expected on the operand stack during computation of the
   // property values and is the value of the entire expression.
   environment()->Push(literal);
 
   // Mark all computed expressions that are bound to a key that is shadowed by
   // a later occurrence of the same key. For the marked expressions, no store
   // code is emitted.
   expr->CalculateEmitStore(zone());
@@ skipping 12 matching lines @@
         DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
       // Fall through.
       case ObjectLiteral::Property::COMPUTED: {
         // It is safe to use [[Put]] here because the boilerplate already
         // contains computed properties with an uninitialized value.
         if (key->value()->IsInternalizedString()) {
           if (property->emit_store()) {
             VisitForValue(property->value());
             Node* value = environment()->Pop();
             Unique<Name> name = MakeUnique(key->AsPropertyName());
-            Node* store = NewNode(javascript()->StoreNamed(strict_mode(), name),
+            Node* store = NewNode(javascript()->StoreNamed(StoreNamedParameters(
+                                      strict_mode(), name)),
                                   literal, value);
             PrepareFrameState(store, key->id());
           } else {
             VisitForEffect(property->value());
           }
           break;
         }
         environment()->Push(literal);  // Duplicate receiver.
         VisitForValue(property->key());
         VisitForValue(property->value());
         Node* value = environment()->Pop();
         Node* key = environment()->Pop();
         Node* receiver = environment()->Pop();
         if (property->emit_store()) {
           Node* strict = jsgraph()->Constant(SLOPPY);
-          const Operator* op = javascript()->Runtime(Runtime::kSetProperty, 4);
+          const Operator* op = javascript()->CallRuntime(
+              CallRuntimeParameters(Runtime::kSetProperty, 4));
           NewNode(op, receiver, key, value, strict);
         }
         break;
       }
       case ObjectLiteral::Property::PROTOTYPE: {
         environment()->Push(literal);  // Duplicate receiver.
         VisitForValue(property->value());
         Node* value = environment()->Pop();
         Node* receiver = environment()->Pop();
         if (property->emit_store()) {
-          const Operator* op = javascript()->Runtime(Runtime::kSetPrototype, 2);
+          const Operator* op = javascript()->CallRuntime(
+              CallRuntimeParameters(Runtime::kSetPrototype, 2));
           NewNode(op, receiver, value);
         }
         break;
       }
       case ObjectLiteral::Property::GETTER:
         accessor_table.lookup(key)->second->getter = property->value();
         break;
       case ObjectLiteral::Property::SETTER:
         accessor_table.lookup(key)->second->setter = property->value();
         break;
     }
   }
 
   // Create nodes to define accessors, using only a single call to the runtime
   // for each pair of corresponding getters and setters.
   for (AccessorTable::Iterator it = accessor_table.begin();
        it != accessor_table.end(); ++it) {
     VisitForValue(it->first);
     VisitForValueOrNull(it->second->getter);
     VisitForValueOrNull(it->second->setter);
     Node* setter = environment()->Pop();
     Node* getter = environment()->Pop();
     Node* name = environment()->Pop();
     Node* attr = jsgraph()->Constant(NONE);
-    const Operator* op =
-        javascript()->Runtime(Runtime::kDefineAccessorPropertyUnchecked, 5);
+    const Operator* op = javascript()->CallRuntime(
+        CallRuntimeParameters(Runtime::kDefineAccessorPropertyUnchecked, 5));
     Node* call = NewNode(op, literal, name, getter, setter, attr);
     PrepareFrameState(call, it->first->id());
   }
 
   // Transform literals that contain functions to fast properties.
   if (expr->has_function()) {
-    const Operator* op = javascript()->Runtime(Runtime::kToFastProperties, 1);
+    const Operator* op = javascript()->CallRuntime(
+        CallRuntimeParameters(Runtime::kToFastProperties, 1));
     NewNode(op, literal);
   }
 
   ast_context()->ProduceValue(environment()->Pop());
 }
 
 
 void AstGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
   Node* closure = GetFunctionClosure();
 
   // Create node to deep-copy the literal boilerplate.
   expr->BuildConstantElements(isolate());
   Node* literals_array =
       BuildLoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* literal_index = jsgraph()->Constant(expr->literal_index());
   Node* constants = jsgraph()->Constant(expr->constant_elements());
   Node* flags = jsgraph()->Constant(expr->ComputeFlags());
-  const Operator* op = javascript()->Runtime(Runtime::kCreateArrayLiteral, 4);
+  const Operator* op = javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kCreateArrayLiteral, 4));
   Node* literal = NewNode(op, literals_array, literal_index, constants, flags);
 
   // The array and the literal index are both expected on the operand stack
   // during computation of the element values.
   environment()->Push(literal);
   environment()->Push(literal_index);
 
   // Create nodes to evaluate all the non-constant subexpressions and to store
   // them into the newly cloned array.
   for (int i = 0; i < expr->values()->length(); i++) {
@@ skipping 28 matching lines @@
       BuildVariableAssignment(var, value, Token::ASSIGN, BailoutId::None());
       break;
     }
     case NAMED_PROPERTY: {
       environment()->Push(value);
       VisitForValue(property->obj());
       Node* object = environment()->Pop();
       value = environment()->Pop();
       Unique<Name> name =
           MakeUnique(property->key()->AsLiteral()->AsPropertyName());
-      Node* store =
-          NewNode(javascript()->StoreNamed(strict_mode(), name), object, value);
+      Node* store = NewNode(
+          javascript()->StoreNamed(StoreNamedParameters(strict_mode(), name)),
+          object, value);
       // TODO(jarin) Fill in the correct bailout id.
       PrepareFrameState(store, BailoutId::None());
       break;
     }
     case KEYED_PROPERTY: {
       environment()->Push(value);
       VisitForValue(property->obj());
       VisitForValue(property->key());
       Node* key = environment()->Pop();
       Node* object = environment()->Pop();
@@ skipping 37 matching lines @@
     switch (assign_type) {
       case VARIABLE: {
         Variable* variable = expr->target()->AsVariableProxy()->var();
         old_value = BuildVariableLoad(variable, expr->target()->id());
         break;
       }
       case NAMED_PROPERTY: {
         Node* object = environment()->Top();
         Unique<Name> name =
             MakeUnique(property->key()->AsLiteral()->AsPropertyName());
-        old_value = NewNode(javascript()->LoadNamed(name), object);
+        old_value =
+            NewNode(javascript()->LoadNamed(LoadNamedParameters(name)), object);
         PrepareFrameState(old_value, property->LoadId(), kPushOutput);
         break;
       }
       case KEYED_PROPERTY: {
         Node* key = environment()->Top();
         Node* object = environment()->Peek(1);
         old_value = NewNode(javascript()->LoadProperty(), object, key);
         PrepareFrameState(old_value, property->LoadId(), kPushOutput);
         break;
       }
@@ skipping 15 matching lines @@
     case VARIABLE: {
       Variable* variable = expr->target()->AsVariableProxy()->var();
       BuildVariableAssignment(variable, value, expr->op(),
                               expr->AssignmentId());
       break;
     }
     case NAMED_PROPERTY: {
       Node* object = environment()->Pop();
       Unique<Name> name =
           MakeUnique(property->key()->AsLiteral()->AsPropertyName());
-      Node* store =
-          NewNode(javascript()->StoreNamed(strict_mode(), name), object, value);
+      Node* store = NewNode(
+          javascript()->StoreNamed(StoreNamedParameters(strict_mode(), name)),
+          object, value);
       PrepareFrameState(store, expr->AssignmentId());
       break;
     }
     case KEYED_PROPERTY: {
       Node* key = environment()->Pop();
       Node* object = environment()->Pop();
       Node* store = NewNode(javascript()->StoreProperty(strict_mode()), object,
                             key, value);
       PrepareFrameState(store, expr->AssignmentId());
       break;
@@ skipping 10 matching lines @@
   environment()->Pop();
   environment()->Pop();
   // TODO(turbofan): VisitYield
   ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
 }
 
 
 void AstGraphBuilder::VisitThrow(Throw* expr) {
   VisitForValue(expr->exception());
   Node* exception = environment()->Pop();
-  const Operator* op = javascript()->Runtime(Runtime::kThrow, 1);
+  const Operator* op =
+      javascript()->CallRuntime(CallRuntimeParameters(Runtime::kThrow, 1));
   Node* value = NewNode(op, exception);
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitProperty(Property* expr) {
   Node* value;
   if (expr->key()->IsPropertyName()) {
     VisitForValue(expr->obj());
     Node* object = environment()->Pop();
     Unique<Name> name = MakeUnique(expr->key()->AsLiteral()->AsPropertyName());
-    value = NewNode(javascript()->LoadNamed(name), object);
+    value = NewNode(javascript()->LoadNamed(LoadNamedParameters(name)), object);
   } else {
     VisitForValue(expr->obj());
     VisitForValue(expr->key());
     Node* key = environment()->Pop();
     Node* object = environment()->Pop();
     value = NewNode(javascript()->LoadProperty(), object, key);
   }
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
@@ skipping 13 matching lines @@
     case Call::GLOBAL_CALL: {
       Variable* variable = callee->AsVariableProxy()->var();
       callee_value = BuildVariableLoad(variable, expr->expression()->id());
       receiver_value = jsgraph()->UndefinedConstant();
       break;
     }
     case Call::LOOKUP_SLOT_CALL: {
       Variable* variable = callee->AsVariableProxy()->var();
       DCHECK(variable->location() == Variable::LOOKUP);
       Node* name = jsgraph()->Constant(variable->name());
-      const Operator* op = javascript()->Runtime(Runtime::kLoadLookupSlot, 2);
+      const Operator* op = javascript()->CallRuntime(
+          CallRuntimeParameters(Runtime::kLoadLookupSlot, 2));
       Node* pair = NewNode(op, current_context(), name);
       callee_value = NewNode(common()->Projection(0), pair);
       receiver_value = NewNode(common()->Projection(1), pair);
       break;
     }
     case Call::PROPERTY_CALL: {
       Property* property = callee->AsProperty();
       VisitForValue(property->obj());
       Node* object = environment()->Top();
       if (property->key()->IsPropertyName()) {
         Unique<Name> name =
             MakeUnique(property->key()->AsLiteral()->AsPropertyName());
-        callee_value = NewNode(javascript()->LoadNamed(name), object);
+        callee_value =
+            NewNode(javascript()->LoadNamed(LoadNamedParameters(name)), object);
       } else {
         VisitForValue(property->key());
         Node* key = environment()->Pop();
         callee_value = NewNode(javascript()->LoadProperty(), object, key);
       }
       PrepareFrameState(callee_value, property->LoadId(), kPushOutput);
       receiver_value = environment()->Pop();
       // Note that a PROPERTY_CALL requires the receiver to be wrapped into an
       // object for sloppy callees. This could also be modeled explicitly here,
       // thereby obsoleting the need for a flag to the call operator.
@@ skipping 26 matching lines @@
 
     // Extract callee and source string from the environment.
     Node* callee = environment()->Peek(arg_count + 1);
     Node* source = environment()->Peek(arg_count - 1);
 
     // Create node to ask for help resolving potential eval call. This will
     // provide a fully resolved callee and the corresponding receiver.
     Node* receiver = environment()->Lookup(info()->scope()->receiver());
     Node* strict = jsgraph()->Constant(strict_mode());
     Node* position = jsgraph()->Constant(info()->scope()->start_position());
-    const Operator* op =
-        javascript()->Runtime(Runtime::kResolvePossiblyDirectEval, 5);
+    const Operator* op = javascript()->CallRuntime(
+        CallRuntimeParameters(Runtime::kResolvePossiblyDirectEval, 5));
     Node* pair = NewNode(op, callee, source, receiver, strict, position);
     Node* new_callee = NewNode(common()->Projection(0), pair);
     Node* new_receiver = NewNode(common()->Projection(1), pair);
 
     // Patch callee and receiver on the environment.
     environment()->Poke(arg_count + 1, new_callee);
     environment()->Poke(arg_count + 0, new_receiver);
   }
 
   // Create node to perform the function call.
-  const Operator* call = javascript()->Call(args->length() + 2, flags);
+  const Operator* call = javascript()->CallFunction(
+      CallFunctionParameters(args->length() + 2, flags));
   Node* value = ProcessArguments(call, args->length() + 2);
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCallNew(CallNew* expr) {
   VisitForValue(expr->expression());
 
   // Evaluate all arguments to the construct call.
   ZoneList<Expression*>* args = expr->arguments();
   VisitForValues(args);
 
   // Create node to perform the construct call.
-  const Operator* call = javascript()->CallNew(args->length() + 1);
+  const Operator* call = javascript()->CallConstruct(args->length() + 1);
   Node* value = ProcessArguments(call, args->length() + 1);
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCallJSRuntime(CallRuntime* expr) {
   Handle<String> name = expr->name();
 
   // The callee and the receiver both have to be pushed onto the operand stack
   // before arguments are being evaluated.
   CallFunctionFlags flags = NO_CALL_FUNCTION_FLAGS;
   Node* receiver_value = BuildLoadBuiltinsObject();
   Unique<String> unique = MakeUnique(name);
-  Node* callee_value = NewNode(javascript()->LoadNamed(unique), receiver_value);
+  Node* callee_value = NewNode(
+      javascript()->LoadNamed(LoadNamedParameters(unique)), receiver_value);
   // TODO(jarin): Find/create a bailout id to deoptimize to (crankshaft
   // refuses to optimize functions with jsruntime calls).
   PrepareFrameState(callee_value, BailoutId::None(), kPushOutput);
   environment()->Push(callee_value);
   environment()->Push(receiver_value);
 
   // Evaluate all arguments to the JS runtime call.
   ZoneList<Expression*>* args = expr->arguments();
   VisitForValues(args);
 
   // Create node to perform the JS runtime call.
-  const Operator* call = javascript()->Call(args->length() + 2, flags);
+  const Operator* call = javascript()->CallFunction(
+      CallFunctionParameters(args->length() + 2, flags));
   Node* value = ProcessArguments(call, args->length() + 2);
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
   const Runtime::Function* function = expr->function();
 
   // Handle calls to runtime functions implemented in JavaScript separately as
   // the call follows JavaScript ABI and the callee is statically unknown.
   if (expr->is_jsruntime()) {
     DCHECK(function == NULL && expr->name()->length() > 0);
     return VisitCallJSRuntime(expr);
   }
 
   // Evaluate all arguments to the runtime call.
   ZoneList<Expression*>* args = expr->arguments();
   VisitForValues(args);
 
   // Create node to perform the runtime call.
   Runtime::FunctionId functionId = function->function_id;
-  const Operator* call = javascript()->Runtime(functionId, args->length());
+  const Operator* call = javascript()->CallRuntime(
+      CallRuntimeParameters(functionId, args->length()));
   Node* value = ProcessArguments(call, args->length());
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::DELETE:
       return VisitDelete(expr);
@@ skipping 28 matching lines @@
       Variable* variable = expr->expression()->AsVariableProxy()->var();
       old_value = BuildVariableLoad(variable, expr->expression()->id());
       stack_depth = 0;
       break;
     }
     case NAMED_PROPERTY: {
       VisitForValue(property->obj());
       Node* object = environment()->Top();
       Unique<Name> name =
           MakeUnique(property->key()->AsLiteral()->AsPropertyName());
-      old_value = NewNode(javascript()->LoadNamed(name), object);
+      old_value =
+          NewNode(javascript()->LoadNamed(LoadNamedParameters(name)), object);
       PrepareFrameState(old_value, property->LoadId(), kPushOutput);
       stack_depth = 1;
       break;
     }
     case KEYED_PROPERTY: {
       VisitForValue(property->obj());
       VisitForValue(property->key());
       Node* key = environment()->Top();
       Node* object = environment()->Peek(1);
       old_value = NewNode(javascript()->LoadProperty(), object, key);
@@ skipping 23 matching lines @@
       environment()->Push(value);
       BuildVariableAssignment(variable, value, expr->op(),
                               expr->AssignmentId());
       environment()->Pop();
       break;
     }
     case NAMED_PROPERTY: {
       Node* object = environment()->Pop();
       Unique<Name> name =
           MakeUnique(property->key()->AsLiteral()->AsPropertyName());
-      Node* store =
-          NewNode(javascript()->StoreNamed(strict_mode(), name), object, value);
+      Node* store = NewNode(
+          javascript()->StoreNamed(StoreNamedParameters(strict_mode(), name)),
+          object, value);
       environment()->Push(value);
       PrepareFrameState(store, expr->AssignmentId());
       environment()->Pop();
       break;
     }
     case KEYED_PROPERTY: {
       Node* key = environment()->Pop();
       Node* object = environment()->Pop();
       Node* store = NewNode(javascript()->StoreProperty(strict_mode()), object,
                             key, value);
@@ skipping 97 matching lines @@
   AstVisitor::VisitDeclarations(declarations);
   if (globals()->is_empty()) return;
   Handle<FixedArray> data =
       isolate()->factory()->NewFixedArray(globals()->length(), TENURED);
   for (int i = 0; i < globals()->length(); ++i) data->set(i, *globals()->at(i));
   int encoded_flags = DeclareGlobalsEvalFlag::encode(info()->is_eval()) |
                       DeclareGlobalsNativeFlag::encode(info()->is_native()) |
                       DeclareGlobalsStrictMode::encode(strict_mode());
   Node* flags = jsgraph()->Constant(encoded_flags);
   Node* pairs = jsgraph()->Constant(data);
-  const Operator* op = javascript()->Runtime(Runtime::kDeclareGlobals, 3);
+  const Operator* op = javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kDeclareGlobals, 3));
   NewNode(op, current_context(), pairs, flags);
   globals()->Rewind(0);
 }
 
 
 void AstGraphBuilder::VisitIfNotNull(Statement* stmt) {
   if (stmt == NULL) return;
   Visit(stmt);
 }
 
@@ skipping 86 matching lines @@
     environment()->Pop();
     Visit(expr->right());
   } else if (ast_context()->IsEffect()) {
     environment()->Pop();
   }
   compare_if.End();
   ast_context()->ReplaceValue();
 }
 
 
+StrictMode AstGraphBuilder::strict_mode() const {
+  return info()->strict_mode();
+}
+
+
 Node* AstGraphBuilder::ProcessArguments(const Operator* op, int arity) {
   DCHECK(environment()->stack_height() >= arity);
   Node** all = info()->zone()->NewArray<Node*>(arity);
   for (int i = arity - 1; i >= 0; --i) {
     all[i] = environment()->Pop();
   }
   Node* value = NewNode(op, arity, all);
   return value;
 }
 
@@ skipping 11 matching lines @@
   // Copy parameters into context if necessary.
   int num_parameters = info()->scope()->num_parameters();
   for (int i = 0; i < num_parameters; i++) {
     Variable* variable = info()->scope()->parameter(i);
     if (!variable->IsContextSlot()) continue;
     // Temporary parameter node. The parameter indices are shifted by 1
     // (receiver is parameter index -1 but environment index 0).
     Node* parameter = NewNode(common()->Parameter(i + 1), graph()->start());
     // Context variable (at bottom of the context chain).
     DCHECK_EQ(0, info()->scope()->ContextChainLength(variable->scope()));
-    const Operator* op = javascript()->StoreContext(0, variable->index());
+    const Operator* op =
+        javascript()->StoreContext(ContextAccess(0, variable->index()));
     NewNode(op, local_context, parameter);
   }
 
   return local_context;
 }
 
 
 Node* AstGraphBuilder::BuildArgumentsObject(Variable* arguments) {
   if (arguments == NULL) return NULL;
 
   // Allocate and initialize a new arguments object.
   Node* callee = GetFunctionClosure();
-  const Operator* op = javascript()->Runtime(Runtime::kNewArguments, 1);
+  const Operator* op = javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kNewArguments, 1));
   Node* object = NewNode(op, callee);
 
   // Assign the object to the arguments variable.
   DCHECK(arguments->IsContextSlot() || arguments->IsStackAllocated());
   // This should never lazy deopt, so it is fine to send invalid bailout id.
   BuildVariableAssignment(arguments, object, Token::ASSIGN, BailoutId::None());
 
   return object;
 }
 
@@ skipping 31 matching lines @@
 Node* AstGraphBuilder::BuildVariableLoad(Variable* variable,
                                          BailoutId bailout_id,
                                          ContextualMode contextual_mode) {
   Node* the_hole = jsgraph()->TheHoleConstant();
   VariableMode mode = variable->mode();
   switch (variable->location()) {
     case Variable::UNALLOCATED: {
       // Global var, const, or let variable.
       Node* global = BuildLoadGlobalObject();
       Unique<Name> name = MakeUnique(variable->name());
-      const Operator* op = javascript()->LoadNamed(name, contextual_mode);
+      const Operator* op =
+          javascript()->LoadNamed(LoadNamedParameters(name, contextual_mode));
       Node* node = NewNode(op, global);
       PrepareFrameState(node, bailout_id, kPushOutput);
       return node;
     }
     case Variable::PARAMETER:
     case Variable::LOCAL: {
       // Local var, const, or let variable.
       Node* value = environment()->Lookup(variable);
       if (mode == CONST_LEGACY) {
         // Perform check for uninitialized legacy const variables.
@@ skipping 10 matching lines @@
         } else if (value->opcode() == IrOpcode::kPhi) {
           value = BuildHoleCheckThrow(value, variable, value);
         }
       }
       return value;
     }
     case Variable::CONTEXT: {
       // Context variable (potentially up the context chain).
       int depth = current_scope()->ContextChainLength(variable->scope());
       bool immutable = variable->maybe_assigned() == kNotAssigned;
-      const Operator* op =
-          javascript()->LoadContext(depth, variable->index(), immutable);
+      const Operator* op = javascript()->LoadContext(
+          ContextAccess(depth, variable->index(), immutable));
       Node* value = NewNode(op, current_context());
       // TODO(titzer): initialization checks are redundant for already
       // initialized immutable context loads, but only specialization knows.
       // Maybe specializer should be a parameter to the graph builder?
       if (mode == CONST_LEGACY) {
         // Perform check for uninitialized legacy const variables.
         Node* undefined = jsgraph()->UndefinedConstant();
         value = BuildHoleCheckSilent(value, undefined, value);
       } else if (mode == LET || mode == CONST) {
         // Perform check for uninitialized let/const variables.
         value = BuildHoleCheckThrow(value, variable, value);
       }
       return value;
     }
     case Variable::LOOKUP: {
       // Dynamic lookup of context variable (anywhere in the chain).
       Node* name = jsgraph()->Constant(variable->name());
       Runtime::FunctionId function_id =
           (contextual_mode == CONTEXTUAL)
               ? Runtime::kLoadLookupSlot
               : Runtime::kLoadLookupSlotNoReferenceError;
-      const Operator* op = javascript()->Runtime(function_id, 2);
+      const Operator* op =
+          javascript()->CallRuntime(CallRuntimeParameters(function_id, 2));
       Node* pair = NewNode(op, current_context(), name);
       return NewNode(common()->Projection(0), pair);
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 Node* AstGraphBuilder::BuildVariableDelete(Variable* variable) {
   switch (variable->location()) {
     case Variable::UNALLOCATED: {
       // Global var, const, or let variable.
       Node* global = BuildLoadGlobalObject();
       Node* name = jsgraph()->Constant(variable->name());
       const Operator* op = javascript()->DeleteProperty(strict_mode());
       return NewNode(op, global, name);
     }
     case Variable::PARAMETER:
     case Variable::LOCAL:
     case Variable::CONTEXT:
       // Local var, const, or let variable or context variable.
       return variable->is_this() ? jsgraph()->TrueConstant()
                                  : jsgraph()->FalseConstant();
     case Variable::LOOKUP: {
       // Dynamic lookup of context variable (anywhere in the chain).
       Node* name = jsgraph()->Constant(variable->name());
-      const Operator* op = javascript()->Runtime(Runtime::kDeleteLookupSlot, 2);
+      const Operator* op = javascript()->CallRuntime(
+          CallRuntimeParameters(Runtime::kDeleteLookupSlot, 2));
       return NewNode(op, current_context(), name);
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 Node* AstGraphBuilder::BuildVariableAssignment(Variable* variable, Node* value,
                                                Token::Value op,
                                                BailoutId bailout_id) {
   Node* the_hole = jsgraph()->TheHoleConstant();
   VariableMode mode = variable->mode();
   switch (variable->location()) {
     case Variable::UNALLOCATED: {
       // Global var, const, or let variable.
       Node* global = BuildLoadGlobalObject();
       Unique<Name> name = MakeUnique(variable->name());
-      const Operator* op = javascript()->StoreNamed(strict_mode(), name);
+      const Operator* op =
+          javascript()->StoreNamed(StoreNamedParameters(strict_mode(), name));
       Node* store = NewNode(op, global, value);
       PrepareFrameState(store, bailout_id);
       return store;
     }
     case Variable::PARAMETER:
     case Variable::LOCAL:
       // Local var, const, or let variable.
       if (mode == CONST_LEGACY && op == Token::INIT_CONST_LEGACY) {
         // Perform an initialization check for legacy const variables.
         Node* current = environment()->Lookup(variable);
@@ skipping 19 matching lines @@
         UNREACHABLE();
       }
       environment()->Bind(variable, value);
       return value;
     case Variable::CONTEXT: {
       // Context variable (potentially up the context chain).
       int depth = current_scope()->ContextChainLength(variable->scope());
       if (mode == CONST_LEGACY && op == Token::INIT_CONST_LEGACY) {
         // Perform an initialization check for legacy const variables.
         const Operator* op =
-            javascript()->LoadContext(depth, variable->index(), false);
+            javascript()->LoadContext(ContextAccess(depth, variable->index()));
         Node* current = NewNode(op, current_context());
         value = BuildHoleCheckSilent(current, value, current);
       } else if (mode == CONST_LEGACY && op != Token::INIT_CONST_LEGACY) {
         // Non-initializing assignments to legacy const is ignored.
         return value;
       } else if (mode == LET && op != Token::INIT_LET) {
         // Perform an initialization check for let declared variables.
         const Operator* op =
-            javascript()->LoadContext(depth, variable->index(), false);
+            javascript()->LoadContext(ContextAccess(depth, variable->index()));
         Node* current = NewNode(op, current_context());
         value = BuildHoleCheckThrow(current, variable, value);
       } else if (mode == CONST && op != Token::INIT_CONST) {
         // All assignments to const variables are early errors.
         UNREACHABLE();
       }
-      const Operator* op = javascript()->StoreContext(depth, variable->index());
+      const Operator* op =
+          javascript()->StoreContext(ContextAccess(depth, variable->index()));
       return NewNode(op, current_context(), value);
     }
     case Variable::LOOKUP: {
       // Dynamic lookup of context variable (anywhere in the chain).
       Node* name = jsgraph()->Constant(variable->name());
       Node* strict = jsgraph()->Constant(strict_mode());
       // TODO(mstarzinger): Use Runtime::kInitializeLegacyConstLookupSlot for
       // initializations of const declarations.
-      const Operator* op = javascript()->Runtime(Runtime::kStoreLookupSlot, 4);
+      const Operator* op = javascript()->CallRuntime(
+          CallRuntimeParameters(Runtime::kStoreLookupSlot, 4));
       return NewNode(op, value, current_context(), name, strict);
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 Node* AstGraphBuilder::BuildLoadObjectField(Node* object, int offset) {
   // TODO(sigurds) Use simplified load here once it is ready.
   Node* field_load = NewNode(jsgraph()->machine()->Load(kMachAnyTagged), object,
                              jsgraph()->Int32Constant(offset - kHeapObjectTag));
   return field_load;
 }
 
 
 Node* AstGraphBuilder::BuildLoadBuiltinsObject() {
   Node* global = BuildLoadGlobalObject();
   Node* builtins =
       BuildLoadObjectField(global, JSGlobalObject::kBuiltinsOffset);
   return builtins;
 }
 
 
 Node* AstGraphBuilder::BuildLoadGlobalObject() {
   Node* context = GetFunctionContext();
-  const Operator* load_op =
-      javascript()->LoadContext(0, Context::GLOBAL_OBJECT_INDEX, true);
+  const Operator* load_op = javascript()->LoadContext(
+      ContextAccess(0, Context::GLOBAL_OBJECT_INDEX, true));
   return NewNode(load_op, context);
 }
 
 
 Node* AstGraphBuilder::BuildToBoolean(Node* value) {
   // TODO(mstarzinger): Possible optimization is to NOP for boolean values.
   return NewNode(javascript()->ToBoolean(), value);
 }
 
 
 Node* AstGraphBuilder::BuildThrowReferenceError(Variable* variable) {
   // TODO(mstarzinger): Should be unified with the VisitThrow implementation.
   Node* variable_name = jsgraph()->Constant(variable->name());
-  const Operator* op = javascript()->Runtime(Runtime::kThrowReferenceError, 1);
+  const Operator* op = javascript()->CallRuntime(
+      CallRuntimeParameters(Runtime::kThrowReferenceError, 1));
   return NewNode(op, variable_name);
 }
 
 
 Node* AstGraphBuilder::BuildBinaryOp(Node* left, Node* right, Token::Value op) {
   const Operator* js_op;
   switch (op) {
     case Token::BIT_OR:
       js_op = javascript()->BitwiseOr();
       break;
@@ skipping 41 matching lines @@
     DCHECK(NodeProperties::GetFrameStateInput(node)->opcode() ==
            IrOpcode::kDead);
     NodeProperties::ReplaceFrameStateInput(
         node, environment()->Checkpoint(ast_id, combine));
   }
 }
 
 }
 }
 }  // namespace v8::internal::compiler