src/hotspot/share/interpreter/templateInterpreterGenerator.cpp

*** 76,86 ****
                   generate_trace_code(atos),
                   generate_trace_code(itos),
                   generate_trace_code(ltos),
                   generate_trace_code(ftos),
                   generate_trace_code(dtos),
-                  generate_trace_code(qtos),
                   generate_trace_code(vtos)
                   );
    }
  #endif // !PRODUCT
  
--- 76,85 ----
*** 98,117 ****
                     generate_return_entry_for(atos, i, index_size),
                     return_itos,
                     generate_return_entry_for(ltos, i, index_size),
                     generate_return_entry_for(ftos, i, index_size),
                     generate_return_entry_for(dtos, i, index_size),
-                    generate_return_entry_for(qtos, i, index_size),
                     generate_return_entry_for(vtos, i, index_size)
                     );
      }
    }
  
    { CodeletMark cm(_masm, "invoke return entry points");
      // These states are in order specified in TosState, except btos/ztos/ctos/stos are
      // really the same as itos since there is no top of stack optimization for these types
!     const TosState states[] = {itos, itos, itos, itos, itos, ltos, ftos, dtos, atos, qtos, vtos, ilgl};
      const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic);
      const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface);
      const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic);
  
      for (int i = 0; i < Interpreter::number_of_return_addrs; i++) {
--- 97,115 ----
                     generate_return_entry_for(atos, i, index_size),
                     return_itos,
                     generate_return_entry_for(ltos, i, index_size),
                     generate_return_entry_for(ftos, i, index_size),
                     generate_return_entry_for(dtos, i, index_size),
                     generate_return_entry_for(vtos, i, index_size)
                     );
      }
    }
  
    { CodeletMark cm(_masm, "invoke return entry points");
      // These states are in order specified in TosState, except btos/ztos/ctos/stos are
      // really the same as itos since there is no top of stack optimization for these types
!     const TosState states[] = {itos, itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos, ilgl};
      const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic);
      const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface);
      const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic);
  
      for (int i = 0; i < Interpreter::number_of_return_addrs; i++) {
*** 133,143 ****
                   generate_earlyret_entry_for(atos),
                   generate_earlyret_entry_for(itos),
                   generate_earlyret_entry_for(ltos),
                   generate_earlyret_entry_for(ftos),
                   generate_earlyret_entry_for(dtos),
-                  generate_earlyret_entry_for(qtos),
                   generate_earlyret_entry_for(vtos)
                   );
    }
  
    { CodeletMark cm(_masm, "result handlers for native calls");
--- 131,140 ----
*** 164,174 ****
                   generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                   generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                   generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                   generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                   generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
-                  generate_safept_entry_for(qtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                   generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint))
                   );
    }
  
    { CodeletMark cm(_masm, "exception handling");
--- 161,170 ----
*** 254,264 ****
                     generate_deopt_entry_for(atos, i),
                     deopt_itos, /* itos */
                     generate_deopt_entry_for(ltos, i),
                     generate_deopt_entry_for(ftos, i),
                     generate_deopt_entry_for(dtos, i),
-                    generate_deopt_entry_for(qtos, i),
                     generate_deopt_entry_for(vtos, i)
                     );
      }
      address return_continuation = Interpreter::_normal_table.entry(Bytecodes::_return).entry(vtos);
      vmassert(return_continuation != NULL, "return entry not generated yet");
--- 250,259 ----
*** 298,308 ****
  }
  
  
  void TemplateInterpreterGenerator::set_unimplemented(int i) {
    address e = _unimplemented_bytecode;
!   EntryPoint entry(e, e, e, e, e, e, e, e, e, e, e);
    Interpreter::_normal_table.set_entry(i, entry);
    Interpreter::_wentry_point[i] = _unimplemented_bytecode;
  }
  
  
--- 293,303 ----
  }
  
  
  void TemplateInterpreterGenerator::set_unimplemented(int i) {
    address e = _unimplemented_bytecode;
!   EntryPoint entry(e, e, e, e, e, e, e, e, e, e);
    Interpreter::_normal_table.set_entry(i, entry);
    Interpreter::_wentry_point[i] = _unimplemented_bytecode;
  }
  
  
*** 318,343 ****
    address aep = _illegal_bytecode_sequence;
    address iep = _illegal_bytecode_sequence;
    address lep = _illegal_bytecode_sequence;
    address fep = _illegal_bytecode_sequence;
    address dep = _illegal_bytecode_sequence;
-   address qep = _illegal_bytecode_sequence;
    address vep = _unimplemented_bytecode;
    address wep = _unimplemented_bytecode;
    // code for short & wide version of bytecode
    if (Bytecodes::is_defined(code)) {
      Template* t = TemplateTable::template_for(code);
      assert(t->is_valid(), "just checking");
!     set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, qep, vep);
    }
    if (Bytecodes::wide_is_defined(code)) {
      Template* t = TemplateTable::template_for_wide(code);
      assert(t->is_valid(), "just checking");
      set_wide_entry_point(t, wep);
    }
    // set entry points
!   EntryPoint entry(bep, zep, cep, sep, aep, iep, lep, fep, dep, qep, vep);
    Interpreter::_normal_table.set_entry(code, entry);
    Interpreter::_wentry_point[code] = wep;
  }
  
  
--- 313,337 ----
    address aep = _illegal_bytecode_sequence;
    address iep = _illegal_bytecode_sequence;
    address lep = _illegal_bytecode_sequence;
    address fep = _illegal_bytecode_sequence;
    address dep = _illegal_bytecode_sequence;
    address vep = _unimplemented_bytecode;
    address wep = _unimplemented_bytecode;
    // code for short & wide version of bytecode
    if (Bytecodes::is_defined(code)) {
      Template* t = TemplateTable::template_for(code);
      assert(t->is_valid(), "just checking");
!     set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep);
    }
    if (Bytecodes::wide_is_defined(code)) {
      Template* t = TemplateTable::template_for_wide(code);
      assert(t->is_valid(), "just checking");
      set_wide_entry_point(t, wep);
    }
    // set entry points
!   EntryPoint entry(bep, zep, cep, sep, aep, iep, lep, fep, dep, vep);
    Interpreter::_normal_table.set_entry(code, entry);
    Interpreter::_wentry_point[code] = wep;
  }
  
  
*** 346,356 ****
    assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions");
    wep = __ pc(); generate_and_dispatch(t);
  }
  
  
! void TemplateInterpreterGenerator::set_short_entry_points(Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& qep, address& vep) {
    assert(t->is_valid(), "template must exist");
    switch (t->tos_in()) {
      case btos:
      case ztos:
      case ctos:
--- 340,350 ----
    assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions");
    wep = __ pc(); generate_and_dispatch(t);
  }
  
  
! void TemplateInterpreterGenerator::set_short_entry_points(Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& vep) {
    assert(t->is_valid(), "template must exist");
    switch (t->tos_in()) {
      case btos:
      case ztos:
      case ctos:
*** 360,372 ****
      case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break;
      case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break;
      case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break;
      case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break;
      case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break;
!     case qtos: vep = __ pc(); __ pop(qtos); qep = __ pc(); generate_and_dispatch(t); break;
!     case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, qep, vep);     break;
!     case ptos: vep = __ pc(); __ pop(ptos); aep = __ pc(); qep = __ pc(); generate_and_dispatch(t); break;
      default  : ShouldNotReachHere();                                                 break;
    }
  }
  
  
--- 354,364 ----
      case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break;
      case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break;
      case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break;
      case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break;
      case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break;
!     case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep);     break;
      default  : ShouldNotReachHere();                                                 break;
    }
  }