[interpreter] Add basic framework for bytecode handler code generation.

src/compiler/linkage-impl.h

 // 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.
 
 #ifndef V8_COMPILER_LINKAGE_IMPL_H_
 #define V8_COMPILER_LINKAGE_IMPL_H_
 
 #include "src/code-stubs.h"
+#include "src/compiler/interpreter-assembler.h"
 #include "src/compiler/osr.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // TODO(titzer): replace uses of int with size_t in LinkageHelper.
 template <typename LinkageTraits>
 class LinkageHelper {
  public:
@@ skipping 207 matching lines @@
         msig,                                     // machine_sig
         locations.Build(),                        // location_sig
         0,                                        // js_parameter_count
         Operator::kNoProperties,                  // properties
         LinkageTraits::CCalleeSaveRegisters(),    // callee-saved registers
         LinkageTraits::CCalleeSaveFPRegisters(),  // callee-saved fp regs
         CallDescriptor::kNoFlags,                 // flags
         "c-call");
   }
 
-  static CallDescriptor* GetInterpreterDispatchDescriptor(
-      Zone* zone, const MachineSignature* msig) {
-    DCHECK_EQ(0, msig->parameter_count());
-    LocationSignature::Builder locations(zone, msig->return_count(),
-                                         msig->parameter_count());
-    AddReturnLocations(&locations);
+  static CallDescriptor* GetInterpreterDispatchDescriptor(Zone* zone,
+                                                          bool will_return) {
+    int return_count = will_return ? 1 : 0;
+    MachineSignature::Builder types(zone, return_count, 2);
+    LocationSignature::Builder locations(zone, return_count, 2);
+
+    // Add registers for fixed parameters passed via interpreter dispatch.
+    DCHECK_EQ(0, InterpreterAssembler::kBytecodePointerParameter);

[Michael Starzinger, 2015/07/17 13:20:59]

Would it make sense to move these constant (i.e. kBytecodePointerParameter an
friends) into linkage? Then we wouldn't need to include the
interpreter-assembler.h file here, but turn it around. I consider linkage.h to
be at a lower conceptual level compared to the interpreter-assembler.h file.

[rmcilroy, 2015/07/21 11:13:21]

Works for me. Done.

+    types.AddParam(kMachPtr);
+    locations.AddParam(regloc(LinkageTraits::InterpreterBytecodePointerReg()));
+
+    DCHECK_EQ(1, InterpreterAssembler::kDispatchTablePointerParameter);
+    types.AddParam(kMachPtr);
+    locations.AddParam(regloc(LinkageTraits::InterpreterDispatchTableReg()));
+
+    if (will_return) {

[Michael Starzinger, 2015/07/17 13:20:58]

The boolean "will_return" flag here makes me nervous, I need to think more about
this one. Benedikt might have opinions about that as well.

[rmcilroy, 2015/07/21 11:13:21]

Based on a suggestion from @danno I reworked this such that the return bytecode
will jump to an InterpreterExitTrampoline to avoid having to do an explicit
return here. The builtins are still (very much) WIP but you can get an idea of
how this will work in https://codereview.chromium.org/1245133002/).

Is this better?

[Michael Starzinger, 2015/07/21 13:51:45]

Acknowledged. Yep, much better, I like.

+      types.AddReturn(kMachAnyTagged);
+      AddReturnLocations(&locations);
+    }
+
     LinkageLocation target_loc = LinkageLocation::AnyRegister();
     return new (zone) CallDescriptor(          // --
         CallDescriptor::kInterpreterDispatch,  // kind
         kMachNone,                             // target MachineType
         target_loc,                            // target location
-        msig,                                  // machine_sig
+        types.Build(),                         // machine_sig
         locations.Build(),                     // location_sig
         0,                                     // js_parameter_count
         Operator::kNoProperties,               // properties
         kNoCalleeSaved,                        // callee-saved registers
         kNoCalleeSaved,                        // callee-saved fp regs
         CallDescriptor::kSupportsTailCalls,    // flags
         "interpreter-dispatch");
   }
 
   static LinkageLocation regloc(Register reg) {
@@ skipping 57 matching lines @@
     int parameter_index = 1 + index;  // skip index 0, which is the target.
     return incoming_->GetInputLocation(parameter_index);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_