*** old/src/share/vm/interpreter/templateInterpreter.cpp	Thu Dec 17 17:52:19 2015
--- new/src/share/vm/interpreter/templateInterpreter.cpp	Thu Dec 17 17:52:19 2015

*** 23,36 ****
--- 23,36 ----
   */
  
  #include "precompiled.hpp"
  #include "code/codeCacheExtensions.hpp"
  #include "interpreter/interpreter.hpp"
  #include "interpreter/interpreterGenerator.hpp"
  #include "interpreter/interpreterRuntime.hpp"
  #include "interpreter/interp_masm.hpp"
  #include "interpreter/templateInterpreter.hpp"
+ #include "interpreter/templateInterpreterGenerator.hpp"
  #include "interpreter/templateTable.hpp"
  
  #ifndef CC_INTERP
  
  # define __ _masm->

*** 57,67 ****
--- 57,67 ----
        code_size *= 2;
      }
  #endif
      _code = new StubQueue(new InterpreterCodeletInterface, code_size, NULL,
                            "Interpreter");
!     TemplateInterpreterGenerator g(_code);
    }
    if (PrintInterpreter) {
      if (CodeCacheExtensions::saving_generated_interpreter() &&
          CodeCacheExtensions::use_pregenerated_interpreter()) {
        ResourceMark rm;

*** 220,229 ****
--- 220,230 ----
  address    TemplateInterpreter::_wentry_point[DispatchTable::length];
  
  TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
    _unimplemented_bytecode    = NULL;
    _illegal_bytecode_sequence = NULL;
+   generate_all();
  }
  
  static const BasicType types[Interpreter::number_of_result_handlers] = {
    T_BOOLEAN,
    T_CHAR   ,

*** 390,400 ****
--- 391,401 ----
  
  
  
  #define method_entry(kind)                                              \
        { CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \
-         Interpreter::_entry_table[Interpreter::kind] = ((InterpreterGenerator*)this)->generate_method_entry(Interpreter::kind); \
        }
  
        // all non-native method kinds
        method_entry(zerolocals)
        method_entry(zerolocals_synchronized)

*** 717,722 ****
--- 718,808 ----
    } else {
      return AbstractInterpreter::bytecode_should_reexecute(code);
    }
  }
  
+ InterpreterCodelet* TemplateInterpreter::codelet_containing(address pc) {
+   return (InterpreterCodelet*)_code->stub_containing(pc);
+ }
+ 
+ // Generate method entries
+ address TemplateInterpreterGenerator::generate_method_entry(
+                                         AbstractInterpreter::MethodKind kind) {
+   // determine code generation flags
+   bool native = false;
+   bool synchronized = false;
+   address entry_point = NULL;
+ 
+   switch (kind) {
+   case Interpreter::zerolocals             :                                          break;
+   case Interpreter::zerolocals_synchronized:                synchronized = true;      break;
+   case Interpreter::native                 : native = true;                           break;
+   case Interpreter::native_synchronized    : native = true; synchronized = true;      break;
+   case Interpreter::empty                  : break;
+   case Interpreter::accessor               : break;
+   case Interpreter::abstract               : entry_point = generate_abstract_entry(); break;
+ 
+   case Interpreter::java_lang_math_sin     : // fall thru
+   case Interpreter::java_lang_math_cos     : // fall thru
+   case Interpreter::java_lang_math_tan     : // fall thru
+   case Interpreter::java_lang_math_abs     : // fall thru
+   case Interpreter::java_lang_math_log     : // fall thru
+   case Interpreter::java_lang_math_log10   : // fall thru
+   case Interpreter::java_lang_math_sqrt    : // fall thru
+   case Interpreter::java_lang_math_pow     : // fall thru
+   case Interpreter::java_lang_math_exp     : entry_point = generate_math_entry(kind);      break;
+   case Interpreter::java_lang_ref_reference_get
+                                            : entry_point = generate_Reference_get_entry(); break;
+   case Interpreter::java_util_zip_CRC32_update
+                                            : native = true; entry_point = generate_CRC32_update_entry();  break;
+   case Interpreter::java_util_zip_CRC32_updateBytes
+                                            : // fall thru
+   case Interpreter::java_util_zip_CRC32_updateByteBuffer
+                                            : native = true; entry_point = generate_CRC32_updateBytes_entry(kind); break;
+   case Interpreter::java_util_zip_CRC32C_updateBytes
+                                            : // fall thru
+   case Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer
+                                            : entry_point = generate_CRC32C_updateBytes_entry(kind); break;
+ #if defined(TARGET_ARCH_x86) && !defined(_LP64)
+   // On x86_32 platforms, a special entry is generated for the following four methods.
+   // On other platforms the normal entry is used to enter these methods.
+   case Interpreter::java_lang_Float_intBitsToFloat
+                                            : native = true; entry_point = generate_Float_intBitsToFloat_entry(); break;
+   case Interpreter::java_lang_Float_floatToRawIntBits
+                                            : native = true; entry_point = generate_Float_floatToRawIntBits_entry(); break;
+   case Interpreter::java_lang_Double_longBitsToDouble
+                                            : native = true; entry_point = generate_Double_longBitsToDouble_entry(); break;
+   case Interpreter::java_lang_Double_doubleToRawLongBits
+                                            : native = true; entry_point = generate_Double_doubleToRawLongBits_entry(); break;
+ #else
+   case Interpreter::java_lang_Float_intBitsToFloat:
+   case Interpreter::java_lang_Float_floatToRawIntBits:
+   case Interpreter::java_lang_Double_longBitsToDouble:
+   case Interpreter::java_lang_Double_doubleToRawLongBits:
+     native = true;
+     break;
+ #endif // defined(TARGET_ARCH_x86) && !defined(_LP64)
+   default:
+     fatal("unexpected method kind: %d", kind);
+     break;
+   }
+ 
+   if (entry_point) {
+     return entry_point;
+   }
+ 
+   // We expect the normal and native entry points to be generated first so we can reuse them.
+   if (native) {
+     entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
+     if (entry_point == NULL) {
+       entry_point = generate_native_entry(synchronized);
+     }
+   } else {
+     entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);
+     if (entry_point == NULL) {
+       entry_point = generate_normal_entry(synchronized);
+     }
+   }
+ 
+   return entry_point;
+ }
  #endif // !CC_INTERP