*** old/src/cpu/sparc/vm/templateInterpreterGenerator_sparc.cpp	Thu Dec 17 17:52:00 2015
--- new/src/cpu/sparc/vm/templateInterpreterGenerator_sparc.cpp	Thu Dec 17 17:52:00 2015

*** 24,36 ****
--- 24,36 ----
  
  #include "precompiled.hpp"
  #include "asm/macroAssembler.hpp"
  #include "interpreter/bytecodeHistogram.hpp"
  #include "interpreter/interpreter.hpp"
  #include "interpreter/interpreterGenerator.hpp"
  #include "interpreter/interpreterRuntime.hpp"
  #include "interpreter/interp_masm.hpp"
+ #include "interpreter/templateInterpreterGenerator.hpp"
  #include "interpreter/templateTable.hpp"
  #include "oops/arrayOop.hpp"
  #include "oops/methodData.hpp"
  #include "oops/method.hpp"
  #include "oops/oop.inline.hpp"

*** 45,73 ****
--- 45,72 ----
  #include "runtime/timer.hpp"
  #include "runtime/vframeArray.hpp"
  #include "utilities/debug.hpp"
  #include "utilities/macros.hpp"
  
  #ifndef CC_INTERP
  #ifndef FAST_DISPATCH
  #define FAST_DISPATCH 1
  #endif
  #undef FAST_DISPATCH
  
  
  // Generation of Interpreter
  //
! // The TemplateInterpreterGenerator generates the interpreter into Interpreter::_code.
  
  
  #define __ _masm->
  
  
  //----------------------------------------------------------------------------------------------------
  
  
! void TemplateInterpreterGenerator::save_native_result(void) {
    // result potentially in O0/O1: save it across calls
    const Address& l_tmp = InterpreterMacroAssembler::l_tmp;
  
    // result potentially in F0/F1: save it across calls
    const Address& d_tmp = InterpreterMacroAssembler::d_tmp;

*** 79,89 ****
--- 78,88 ----
  #else
    __ std(O0, l_tmp);
  #endif
  }
  
! void TemplateInterpreterGenerator::restore_native_result(void) {
    const Address& l_tmp = InterpreterMacroAssembler::l_tmp;
    const Address& d_tmp = InterpreterMacroAssembler::d_tmp;
  
    // Restore any method result value
    __ ldf(FloatRegisterImpl::D, d_tmp, F0);

*** 291,301 ****
--- 290,300 ----
  //       so we have a 'sticky' overflow test
  //
  // Lmethod: method
  // ??: invocation counter
  //
! void TemplateInterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {
    // Note: In tiered we increment either counters in MethodCounters* or in
    // MDO depending if we're profiling or not.
    const Register G3_method_counters = G3_scratch;
    Label done;
  

*** 722,732 ****
--- 721,731 ----
    }
  
  }
  
  // Method entry for java.lang.ref.Reference.get.
! address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {
  #if INCLUDE_ALL_GCS
    // Code: _aload_0, _getfield, _areturn
    // parameter size = 1
    //
    // The code that gets generated by this routine is split into 2 parts:

*** 805,815 ****
--- 804,814 ----
  
  /**
   * Method entry for static native methods:
   *   int java.util.zip.CRC32.update(int crc, int b)
   */
! address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
  
    if (UseCRC32Intrinsics) {
      address entry = __ pc();
  
      Label L_slow_path;

*** 849,859 ****
--- 848,858 ----
  /**
   * Method entry for static native methods:
   *   int java.util.zip.CRC32.updateBytes(int crc, byte[] b, int off, int len)
   *   int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len)
   */
! address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
  
    if (UseCRC32Intrinsics) {
      address entry = __ pc();
  
      Label L_slow_path;

*** 901,917 ****
--- 900,925 ----
      return entry;
    }
    return NULL;
  }
   
+ // Not supported
+ address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
+   return NULL;
+ }
+ 
+ // Not supported
+ address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) {
+   return NULL;
+ }
  //
  // Interpreter stub for calling a native method. (asm interpreter)
  // This sets up a somewhat different looking stack for calling the native method
  // than the typical interpreter frame setup.
  //
  
! address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
    address entry = __ pc();
  
    // the following temporary registers are used during frame creation
    const Register Gtmp1 = G3_scratch ;
    const Register Gtmp2 = G1_scratch;

*** 1334,1344 ****
--- 1342,1352 ----
    return entry;
  }
  
  
  // Generic method entry to (asm) interpreter
! address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
    address entry = __ pc();
  
    bool inc_counter  = UseCompiler || CountCompiledCalls || LogTouchedMethods;
  
    // the following temporary registers are used during frame creation

*** 1741,1758 ****
--- 1749,1758 ----
    generate_and_dispatch(t);
  }
  
  // --------------------------------------------------------------------------------
  
  
  InterpreterGenerator::InterpreterGenerator(StubQueue* code)
   : TemplateInterpreterGenerator(code) {
     generate_all(); // down here so it can be "virtual"
  }
  
  // --------------------------------------------------------------------------------
  
  // Non-product code
  #ifndef PRODUCT
  address TemplateInterpreterGenerator::generate_trace_code(TosState state) {
    address entry = __ pc();
  

*** 1827,1832 ****
--- 1827,1831 ----
    __ load_ptr_contents(stop_at, G4_scratch);
    __ cmp(G3_scratch, G4_scratch);
    __ breakpoint_trap(Assembler::equal, Assembler::icc);
  }
  #endif // not PRODUCT
  #endif // !CC_INTERP