src/hotspot/share/c1/c1_LIRAssembler.cpp

*** 604,618 ****
        Unimplemented();
        break;
    }
  }
  
! void LIR_Assembler::add_std_entry_info(int pc_offset, bool no_receiver) {
!   // FIXME: build different oompaps/stack/locals according to no_receiver.
    flush_debug_info(pc_offset);
    DebugInformationRecorder* debug_info = compilation()->debug_info_recorder();
!   OopMap* oop_map = new OopMap(0, 0); // FIXME
    debug_info->add_safepoint(pc_offset, oop_map);
    DebugToken* locvals = debug_info->create_scope_values(NULL); // FIXME is this needed (for Java debugging to work properly??)
    DebugToken* expvals = debug_info->create_scope_values(NULL); // FIXME is this needed (for Java debugging to work properly??)
    DebugToken* monvals = debug_info->create_monitor_values(NULL); // FIXME: need testing with synchronized method
    bool reexecute = false;
--- 604,622 ----
        Unimplemented();
        break;
    }
  }
  
! void LIR_Assembler::add_scalarized_entry_info(int pc_offset) {
    flush_debug_info(pc_offset);
    DebugInformationRecorder* debug_info = compilation()->debug_info_recorder();
!   // The VEP and VVEP(RO) of a C1-compiled method call buffer_value_args_xxx()
!   // before doing any argument shuffling. This call may cause GC. When GC happens,
!   // all the parameters are still as passed by the caller, so we just use
!   // map->set_include_argument_oops() inside frame::sender_for_compiled_frame(RegisterMap* map).
!   // There's no need to build a GC map here.
!   OopMap* oop_map = new OopMap(0, 0);
    debug_info->add_safepoint(pc_offset, oop_map);
    DebugToken* locvals = debug_info->create_scope_values(NULL); // FIXME is this needed (for Java debugging to work properly??)
    DebugToken* expvals = debug_info->create_scope_values(NULL); // FIXME is this needed (for Java debugging to work properly??)
    DebugToken* monvals = debug_info->create_monitor_values(NULL); // FIXME: need testing with synchronized method
    bool reexecute = false;
*** 621,645 ****
    bool is_method_handle_invoke = false;
    debug_info->describe_scope(pc_offset, methodHandle(), method(), 0, reexecute, rethrow_exception, is_method_handle_invoke, return_oop, false, locvals, expvals, monvals);
    debug_info->end_safepoint(pc_offset);
  }
  
  void LIR_Assembler::emit_std_entries() {
    offsets()->set_value(CodeOffsets::OSR_Entry, _masm->offset());
  
    const CompiledEntrySignature* ces = compilation()->compiled_entry_signature();
    if (ces->has_scalarized_args()) {
      assert(ValueTypePassFieldsAsArgs && method()->get_Method()->has_scalarized_args(), "must be");
-     add_std_entry_info(emit_std_entry(CodeOffsets::Verified_Entry, ces), false);
  
      bool has_value_ro_entry = false;
      if (ces->has_value_recv() && ces->num_value_args() > 1) {
!       // We need a separate entry for value_ro
        has_value_ro_entry = true;
!       add_std_entry_info(emit_std_entry(CodeOffsets::Verified_Value_Entry_RO, ces), true);
      }
      emit_std_entry(CodeOffsets::Verified_Value_Entry, NULL);
      if (!has_value_ro_entry) {
        if (ces->has_value_recv()) {
          assert(ces->num_value_args() == 1, "must be");
          offsets()->set_value(CodeOffsets::Verified_Value_Entry_RO,
                               offsets()->value(CodeOffsets::Verified_Value_Entry));
--- 625,668 ----
    bool is_method_handle_invoke = false;
    debug_info->describe_scope(pc_offset, methodHandle(), method(), 0, reexecute, rethrow_exception, is_method_handle_invoke, return_oop, false, locvals, expvals, monvals);
    debug_info->end_safepoint(pc_offset);
  }
  
+ // Emit VEP (and VVEP/VEP_RO if necessary)
  void LIR_Assembler::emit_std_entries() {
    offsets()->set_value(CodeOffsets::OSR_Entry, _masm->offset());
  
    const CompiledEntrySignature* ces = compilation()->compiled_entry_signature();
+ 
+   _masm->align(CodeEntryAlignment);
+   offsets()->set_value(CodeOffsets::Entry, _masm->offset());
+   if (needs_icache(compilation()->method())) {
+     check_icache();
+   }
+ 
    if (ces->has_scalarized_args()) {
      assert(ValueTypePassFieldsAsArgs && method()->get_Method()->has_scalarized_args(), "must be");
  
      bool has_value_ro_entry = false;
      if (ces->has_value_recv() && ces->num_value_args() > 1) {
!       // VVEP(RO) = pack all value parameters, except the <this> object.
        has_value_ro_entry = true;
!       add_scalarized_entry_info(emit_std_entry(CodeOffsets::Verified_Value_Entry_RO, ces));
!     }
! 
!     // VEP = pack all value parameters
!     _masm->align(CodeEntryAlignment);
!     add_scalarized_entry_info(emit_std_entry(CodeOffsets::Verified_Entry, ces));
! 
!     _masm->align(CodeEntryAlignment);
!     offsets()->set_value(CodeOffsets::Value_Entry, _masm->offset());
!     if (needs_icache(compilation()->method())) {
!       check_icache();
      }
+     // VVEP = all value parameters are already passed as refs, so no need for packing.
      emit_std_entry(CodeOffsets::Verified_Value_Entry, NULL);
+ 
      if (!has_value_ro_entry) {
        if (ces->has_value_recv()) {
          assert(ces->num_value_args() == 1, "must be");
          offsets()->set_value(CodeOffsets::Verified_Value_Entry_RO,
                               offsets()->value(CodeOffsets::Verified_Value_Entry));
*** 656,669 ****
      offsets()->set_value(CodeOffsets::Verified_Value_Entry_RO, offset);
    }
  }
  
  int LIR_Assembler::emit_std_entry(CodeOffsets::Entries entry, const CompiledEntrySignature* ces) {
-   _masm->align(CodeEntryAlignment);
-   if (needs_icache(compilation()->method())) {
-     check_icache();
-   }
    offsets()->set_value(entry, _masm->offset());
    switch (entry) {
    case CodeOffsets::Verified_Entry:
      return _masm->verified_entry(ces, initial_frame_size_in_bytes(), bang_size_in_bytes(), _verified_value_entry);
    case CodeOffsets::Verified_Value_Entry_RO:
--- 679,688 ----