*** old/src/share/vm/interpreter/cppInterpreter.hpp	Thu Dec 17 17:52:17 2015
--- new/src/share/vm/interpreter/cppInterpreter.hpp	Thu Dec 17 17:52:17 2015

*** 24,107 ****
--- 24,70 ----
  
  #ifndef SHARE_VM_INTERPRETER_CPPINTERPRETER_HPP
  #define SHARE_VM_INTERPRETER_CPPINTERPRETER_HPP
  
  #include "interpreter/abstractInterpreter.hpp"
  
  #ifdef CC_INTERP
  
+ class InterpreterCodelet;
+ 
  // This file contains the platform-independent parts
  // of the c++ interpreter
  
  class CppInterpreter: public AbstractInterpreter {
    friend class VMStructs;
    friend class Interpreter; // contains()
    friend class InterpreterGenerator; // result handlers
    friend class CppInterpreterGenerator; // result handlers
   public:
  
  
   protected:
  
    // tosca result -> stack result
    static address    _tosca_to_stack[number_of_result_handlers];  // converts tosca to C++ interpreter stack result
    // stack result -> stack result
    static address    _stack_to_stack[number_of_result_handlers];  // pass result between C++ interpreter calls
    // stack result -> native abi result
    static address    _stack_to_native_abi[number_of_result_handlers];  // converts C++ interpreter results to native abi
  
    // this is to allow frame and only frame to use contains().
    friend class      frame;
  
   public:
    // Initialization/debugging
    static void       initialize();
    // this only returns whether a pc is within generated code for the interpreter.
  
!   // This is a moderately dubious interface for the c++ interpreter. Only
!   // These are moderately dubious interfaces for the c++ interpreter. Only
    // frame code and debug.cpp should be using it.
    static bool       contains(address pc);
+   static InterpreterCodelet* codelet_containing(address pc);
  
   public:
  
  
    // No displatch table to switch so no need for these to do anything special
    static void notice_safepoints() {}
    static void ignore_safepoints() {}
  
    static address    native_result_to_tosca()                    { return (address)_native_abi_to_tosca; } // aka result handler
    static address    tosca_result_to_stack()                     { return (address)_tosca_to_stack; }
    static address    stack_result_to_stack()                     { return (address)_stack_to_stack; }
    static address    stack_result_to_native()                    { return (address)_stack_to_native_abi; }
  
    static address    native_result_to_tosca(int index)           { return _native_abi_to_tosca[index]; } // aka result handler
    static address    tosca_result_to_stack(int index)            { return _tosca_to_stack[index]; }
    static address    stack_result_to_stack(int index)            { return _stack_to_stack[index]; }
    static address    stack_result_to_native(int index)           { return _stack_to_native_abi[index]; }
  
    static address    return_entry  (TosState state, int length, Bytecodes::Code code);
    static address    deopt_entry   (TosState state, int length);
  
  #ifdef TARGET_ARCH_x86
  # include "cppInterpreter_x86.hpp"
  #endif
  #ifdef TARGET_ARCH_sparc
  # include "cppInterpreter_sparc.hpp"
  #endif
+   static void invoke_method(Method* method, address entry_point, TRAPS);
+   static void invoke_osr(Method* method,
+                          address   entry_point,
+                          address   osr_buf,
+                          TRAPS);
  #ifdef TARGET_ARCH_zero
  # include "cppInterpreter_zero.hpp"
  #endif
  #ifdef TARGET_ARCH_arm
  # include "cppInterpreter_arm.hpp"
  #endif
  #ifdef TARGET_ARCH_ppc
  # include "cppInterpreter_ppc.hpp"
  #endif
  #ifdef TARGET_ARCH_aarch64
  # include "cppInterpreter_aarch64.hpp"
  #endif
  
  
  };
  
  #endif // CC_INTERP