[Interpreter] Add support for JS runtime calls.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/compiler.h"
 #include "src/interpreter/control-flow-builders.h"
 #include "src/objects.h"
 #include "src/parser.h"
@@ skipping 1424 matching lines @@
 }
 
 
 void BytecodeGenerator::VisitProperty(Property* expr) {
   Register obj = VisitForRegisterValue(expr->obj());
   VisitPropertyLoad(obj, expr);
 }
 
 
 Register BytecodeGenerator::VisitArguments(ZoneList<Expression*>* args) {
+  if (args->length() == 0) {
+    return Register();
+  }
+
   // Visit arguments and place in a contiguous block of temporary
   // registers.  Return the first temporary register corresponding to
   // the first argument.
   //
   // NB the caller may have already called
   // PrepareForConsecutiveAllocations() with args->length() + N. The
   // second call here will be a no-op provided there have been N or
   // less calls to NextConsecutiveRegister(). Otherwise, the arguments
   // here will be consecutive, but they will not be consecutive with
   // earlier consecutive allocations made by the caller.
@@ skipping 59 matching lines @@
     case Call::NAMED_SUPER_PROPERTY_CALL:
     case Call::KEYED_SUPER_PROPERTY_CALL:
     case Call::LOOKUP_SLOT_CALL:
     case Call::SUPER_CALL:
     case Call::POSSIBLY_EVAL_CALL:
       UNIMPLEMENTED();
   }
 
   // Evaluate all arguments to the function call and store in sequential
   // registers.
-  if (args->length() > 0) {
-    Register arg = VisitArguments(args);
-    CHECK(arg.index() == receiver.index() + 1);
-  }
+  Register arg = VisitArguments(args);
+  CHECK(args->length() == 0 || arg.index() == receiver.index() + 1);
 
   // TODO(rmcilroy): Deal with possible direct eval here?
   // TODO(rmcilroy): Use CallIC to allow call type feedback.
   builder()->Call(callee, receiver, args->length());
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitCallNew(CallNew* expr) {
   Register constructor = execution_result()->NewRegister();
   VisitForAccumulatorValue(expr->expression());
   builder()->StoreAccumulatorInRegister(constructor);
 
   ZoneList<Expression*>* args = expr->arguments();
-  if (args->length() > 0) {
-    Register first_arg = VisitArguments(args);
-    builder()->New(constructor, first_arg, args->length());
-  } else {
-    // The second argument here will be ignored as there are zero
-    // arguments. Using the constructor register avoids avoid
-    // allocating a temporary just to fill the operands.
-    builder()->New(constructor, constructor, 0);
-  }
+  Register first_arg = VisitArguments(args);
+  builder()->New(constructor, first_arg, args->length());
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitCallRuntime(CallRuntime* expr) {
+  ZoneList<Expression*>* args = expr->arguments();
+  Register receiver;
   if (expr->is_jsruntime()) {
-    UNIMPLEMENTED();
+    // Allocate a register for the receiver and load it with undefined.
+    execution_result()->PrepareForConsecutiveAllocations(args->length() + 1);
+    receiver = execution_result()->NextConsecutiveRegister();
+    builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
   }
+  // Evaluate all arguments to the runtime call.
+  Register first_arg = VisitArguments(args);
 
-  // TODO(rmcilroy): support multiple return values.
-  DCHECK_LE(expr->function()->result_size, 1);
-  Runtime::FunctionId function_id = expr->function()->function_id;
-
-  // Evaluate all arguments to the runtime call.
-  ZoneList<Expression*>* args = expr->arguments();
-  Register first_arg;
-  if (args->length() > 0) {
-    first_arg = VisitArguments(args);
+  if (expr->is_jsruntime()) {
+    DCHECK(args->length() == 0 || first_arg.index() == receiver.index() + 1);
+    builder()->CallJSRuntime(expr->context_index(), receiver, args->length());
   } else {
-    // Allocation here is just to fullfil the requirement that there
-    // is a register operand for the start of the arguments though
-    // there are zero when this is generated.
-    first_arg = execution_result()->NewRegister();

[oth, 2015/11/02 10:49:58]

This may be the only spot that requires an unchecked register (?) as CallRuntime
needs a lead register and only has a single register operand.

We have a valid known register that doesn't entail any extra state in the other
cases (VisitCallNew has the contructor, VisitCallRuntime for JS Runtime call has
the receiver.

One alternative approach would be to have a method that gets the first valid
register (local, parameter, or a temporary: GetArbitraryRegisterOperand(). This
method would only be used if args->length() == 0 and most times would not entail
an additional temporary. The register would always appear valid to the bytecode
array builder.

Or we could have a MayReg8 operand which could be an invalid register. As you
mentioned this would remove the ability to combine the length == 0 check with
the invalid register check.

[rmcilroy, 2015/11/03 17:10:47]

There are two spots which need this - CallRuntime (here) and CallNew (which was
previously using the constructor register twice in these circumstances).

I've reworked it to remove the RegisterValidityCheck enum and instead have a
kMaybeReg8 which always accepts '0' as a valid operand, and do the actual check
that this only happens for arg_count == 0 in
BytecodeArrayBuilder::CallRuntime/CallNew. 

PTAL, thanks.

+    // TODO(rmcilroy): support multiple return values.
+    DCHECK_LE(expr->function()->result_size, 1);
+    Runtime::FunctionId function_id = expr->function()->function_id;
+    builder()->CallRuntime(function_id, first_arg, args->length());
   }
-  builder()->CallRuntime(function_id, first_arg, args->length());
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitVoid(UnaryOperation* expr) {
   VisitForEffect(expr->expression());
   builder()->LoadUndefined();
   execution_result()->SetResultInAccumulator();
 }
 
@@ skipping 543 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8