[Interpreter] Add function literal support.

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 <stack>
 
 #include "src/compiler.h"
 #include "src/interpreter/control-flow-builders.h"
@@ skipping 427 matching lines @@
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitDebuggerStatement(DebuggerStatement* stmt) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
-  UNIMPLEMENTED();
+  // Find or build a shared function info.
+  Handle<SharedFunctionInfo> shared_info =
+      Compiler::GetSharedFunctionInfo(expr, info()->script(), info());
+  CHECK(!shared_info.is_null());  // TODO(rmcilroy): Set stack overflow?

[Michael Starzinger, 2015/10/09 13:19:00]

Yeah, that same check in the AstGraphBuilder bothers me every time I see it. I
finally need to dig into whether this can ever happen, and if so, write a repro
for that. Let me know if it ever happens to hit you, I'd be interested. :)

[rmcilroy, 2015/10/12 17:00:15]

Yeah I've never seen this myself. I'll let you know if I ever hit it.

+
+  builder()
+      ->LoadLiteral(shared_info)
+      .CreateClosure(expr->pretenure() ? TENURED : NOT_TENURED);
 }
 
 
 void BytecodeGenerator::VisitClassLiteral(ClassLiteral* expr) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitNativeFunctionLiteral(
     NativeFunctionLiteral* expr) {
@@ skipping 264 matching lines @@
     }
     case Call::GLOBAL_CALL: {
       // Receiver is undefined for global calls.
       builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       // Load callee as a global variable.
       VariableProxy* proxy = callee_expr->AsVariableProxy();
       VisitVariableLoad(proxy->var(), proxy->VariableFeedbackSlot());
       builder()->StoreAccumulatorInRegister(callee);
       break;
     }
+    case Call::OTHER_CALL: {
+      Visit(callee_expr);
+      builder()->StoreAccumulatorInRegister(callee);
+      builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);

[Michael Starzinger, 2015/10/09 13:19:00]

nit: I don't think it matters much, since we don't have any deoptimization yet,
but could we store the receiver before we evaluate the {callee_expr}? Or is
there a particular reason for this order? It shouldn't matter but I would feel
more comfortable setting the receiver register first.

[Michael Starzinger, 2015/10/09 13:28:01]

Actually, I just checked again and we already in full-codegen don't have the
receiver on the operand stack here. So my comment is completely without basis.
Please disregard, sorry for the noise.

[rmcilroy, 2015/10/12 17:00:15]

It doesn't actually matter which way round this goes, I was just following the
evaluation order of ASTGraphBuilder which does it. Swapped it around in any
case.

+      break;
+    }
     case Call::LOOKUP_SLOT_CALL:
     case Call::SUPER_CALL:
     case Call::POSSIBLY_EVAL_CALL:
-    case Call::OTHER_CALL:
       UNIMPLEMENTED();
   }
 
   // Evaluate all arguments to the function call and store in sequential
   // registers.
   ZoneList<Expression*>* args = expr->arguments();
   for (int i = 0; i < args->length(); ++i) {
     Visit(args->at(i));
     Register arg = temporary_register_scope.NewRegister();
     DCHECK(arg.index() - i == receiver.index() + 1);
@@ skipping 191 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8