src/cpu/x86/vm/macroAssembler_x86.cpp

*** 764,779 ****
  
  void MacroAssembler::set_last_Java_frame(Register last_java_sp,
                                           Register last_java_fp,
                                           address  last_java_pc) {
    // determine last_java_sp register
!   if (!last_java_sp->is_valid()) {
      last_java_sp = rsp;
    }
  
    // last_java_fp is optional
!   if (last_java_fp->is_valid()) {
      movptr(Address(r15_thread, JavaThread::last_Java_fp_offset()),
             last_java_fp);
    }
  
    // last_java_pc is optional
--- 764,779 ----
  
  void MacroAssembler::set_last_Java_frame(Register last_java_sp,
                                           Register last_java_fp,
                                           address  last_java_pc) {
    // determine last_java_sp register
!   if (!last_java_sp.is_valid()) {
      last_java_sp = rsp;
    }
  
    // last_java_fp is optional
!   if (last_java_fp.is_valid()) {
      movptr(Address(r15_thread, JavaThread::last_Java_fp_offset()),
             last_java_fp);
    }
  
    // last_java_pc is optional
*** 2498,2517 ****
                                    Register last_java_sp,
                                    address  entry_point,
                                    int      number_of_arguments,
                                    bool     check_exceptions) {
    // determine java_thread register
!   if (!java_thread->is_valid()) {
  #ifdef _LP64
      java_thread = r15_thread;
  #else
      java_thread = rdi;
      get_thread(java_thread);
  #endif // LP64
    }
    // determine last_java_sp register
!   if (!last_java_sp->is_valid()) {
      last_java_sp = rsp;
    }
    // debugging support
    assert(number_of_arguments >= 0   , "cannot have negative number of arguments");
    LP64_ONLY(assert(java_thread == r15_thread, "unexpected register"));
--- 2498,2517 ----
                                    Register last_java_sp,
                                    address  entry_point,
                                    int      number_of_arguments,
                                    bool     check_exceptions) {
    // determine java_thread register
!   if (!java_thread.is_valid()) {
  #ifdef _LP64
      java_thread = r15_thread;
  #else
      java_thread = rdi;
      get_thread(java_thread);
  #endif // LP64
    }
    // determine last_java_sp register
!   if (!last_java_sp.is_valid()) {
      last_java_sp = rsp;
    }
    // debugging support
    assert(number_of_arguments >= 0   , "cannot have negative number of arguments");
    LP64_ONLY(assert(java_thread == r15_thread, "unexpected register"));
*** 2585,2595 ****
      bind(ok);
  #endif // LP64
    }
  
    // get oop result if there is one and reset the value in the thread
!   if (oop_result->is_valid()) {
      get_vm_result(oop_result, java_thread);
    }
  }
  
  void MacroAssembler::call_VM_helper(Register oop_result, address entry_point, int number_of_arguments, bool check_exceptions) {
--- 2585,2595 ----
      bind(ok);
  #endif // LP64
    }
  
    // get oop result if there is one and reset the value in the thread
!   if (oop_result.is_valid()) {
      get_vm_result(oop_result, java_thread);
    }
  }
  
  void MacroAssembler::call_VM_helper(Register oop_result, address entry_point, int number_of_arguments, bool check_exceptions) {
*** 3788,3798 ****
    pusha();
  }
  
  void MacroAssembler::reset_last_Java_frame(Register java_thread, bool clear_fp, bool clear_pc) {
    // determine java_thread register
!   if (!java_thread->is_valid()) {
      java_thread = rdi;
      get_thread(java_thread);
    }
    // we must set sp to zero to clear frame
    movptr(Address(java_thread, JavaThread::last_Java_sp_offset()), NULL_WORD);
--- 3788,3798 ----
    pusha();
  }
  
  void MacroAssembler::reset_last_Java_frame(Register java_thread, bool clear_fp, bool clear_pc) {
    // determine java_thread register
!   if (!java_thread.is_valid()) {
      java_thread = rdi;
      get_thread(java_thread);
    }
    // we must set sp to zero to clear frame
    movptr(Address(java_thread, JavaThread::last_Java_sp_offset()), NULL_WORD);
*** 3844,3865 ****
  void MacroAssembler::set_last_Java_frame(Register java_thread,
                                           Register last_java_sp,
                                           Register last_java_fp,
                                           address  last_java_pc) {
    // determine java_thread register
!   if (!java_thread->is_valid()) {
      java_thread = rdi;
      get_thread(java_thread);
    }
    // determine last_java_sp register
!   if (!last_java_sp->is_valid()) {
      last_java_sp = rsp;
    }
  
    // last_java_fp is optional
  
!   if (last_java_fp->is_valid()) {
      movptr(Address(java_thread, JavaThread::last_Java_fp_offset()), last_java_fp);
    }
  
    // last_java_pc is optional
  
--- 3844,3865 ----
  void MacroAssembler::set_last_Java_frame(Register java_thread,
                                           Register last_java_sp,
                                           Register last_java_fp,
                                           address  last_java_pc) {
    // determine java_thread register
!   if (!java_thread.is_valid()) {
      java_thread = rdi;
      get_thread(java_thread);
    }
    // determine last_java_sp register
!   if (!last_java_sp.is_valid()) {
      last_java_sp = rsp;
    }
  
    // last_java_fp is optional
  
!   if (last_java_fp.is_valid()) {
      movptr(Address(java_thread, JavaThread::last_Java_fp_offset()), last_java_fp);
    }
  
    // last_java_pc is optional
  
*** 3879,3889 ****
  void MacroAssembler::shrptr(Register dst, int imm8) {
    LP64_ONLY(shrq(dst, imm8)) NOT_LP64(shrl(dst, imm8));
  }
  
  void MacroAssembler::sign_extend_byte(Register reg) {
!   if (LP64_ONLY(true ||) (VM_Version::is_P6() && reg->has_byte_register())) {
      movsbl(reg, reg); // movsxb
    } else {
      shll(reg, 24);
      sarl(reg, 24);
    }
--- 3879,3889 ----
  void MacroAssembler::shrptr(Register dst, int imm8) {
    LP64_ONLY(shrq(dst, imm8)) NOT_LP64(shrl(dst, imm8));
  }
  
  void MacroAssembler::sign_extend_byte(Register reg) {
!   if (LP64_ONLY(true ||) (VM_Version::is_P6() && reg.has_byte_register())) {
      movsbl(reg, reg); // movsxb
    } else {
      shll(reg, 24);
      sarl(reg, 24);
    }
*** 4532,4559 ****
  
  void MacroAssembler::incr_allocated_bytes(Register thread,
                                            Register var_size_in_bytes,
                                            int con_size_in_bytes,
                                            Register t1) {
!   if (!thread->is_valid()) {
  #ifdef _LP64
      thread = r15_thread;
  #else
!     assert(t1->is_valid(), "need temp reg");
      thread = t1;
      get_thread(thread);
  #endif
    }
  
  #ifdef _LP64
!   if (var_size_in_bytes->is_valid()) {
      addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes);
    } else {
      addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes);
    }
  #else
!   if (var_size_in_bytes->is_valid()) {
      addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes);
    } else {
      addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes);
    }
    adcl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())+4), 0);
--- 4532,4559 ----
  
  void MacroAssembler::incr_allocated_bytes(Register thread,
                                            Register var_size_in_bytes,
                                            int con_size_in_bytes,
                                            Register t1) {
!   if (!thread.is_valid()) {
  #ifdef _LP64
      thread = r15_thread;
  #else
!     assert(t1.is_valid(), "need temp reg");
      thread = t1;
      get_thread(thread);
  #endif
    }
  
  #ifdef _LP64
!   if (var_size_in_bytes.is_valid()) {
      addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes);
    } else {
      addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes);
    }
  #else
!   if (var_size_in_bytes.is_valid()) {
      addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes);
    } else {
      addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes);
    }
    adcl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())+4), 0);
*** 5148,5158 ****
    // Pass register number to verify_oop_subroutine
    const char* b = NULL;
    {
      ResourceMark rm;
      stringStream ss;
!     ss.print("verify_oop: %s: %s", reg->name(), s);
      b = code_string(ss.as_string());
    }
    BLOCK_COMMENT("verify_oop {");
  #ifdef _LP64
    push(rscratch1);                    // save r10, trashed by movptr()
--- 5148,5158 ----
    // Pass register number to verify_oop_subroutine
    const char* b = NULL;
    {
      ResourceMark rm;
      stringStream ss;
!     ss.print("verify_oop: %s: %s", reg.name(), s);
      b = code_string(ss.as_string());
    }
    BLOCK_COMMENT("verify_oop {");
  #ifdef _LP64
    push(rscratch1);                    // save r10, trashed by movptr()