src/cpu/x86/vm/stubGenerator_x86_32.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ----
  /*
!  * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
*** 953,972 ****
      __ push(rsi);
      __ push(rdi);
      __ movptr(from , Address(rsp, 12+ 4));
      __ movptr(to   , Address(rsp, 12+ 8));
      __ movl(count, Address(rsp, 12+ 12));
      if (t == T_OBJECT) {
        __ testl(count, count);
        __ jcc(Assembler::zero, L_0_count);
        gen_write_ref_array_pre_barrier(to, count);
        __ mov(saved_to, to);          // save 'to'
      }
  
-     *entry = __ pc(); // Entry point from conjoint arraycopy stub.
-     BLOCK_COMMENT("Entry:");
- 
      __ subptr(to, from); // to --> to_from
      __ cmpl(count, 2<<shift); // Short arrays (< 8 bytes) copy by element
      __ jcc(Assembler::below, L_copy_4_bytes); // use unsigned cmp
      if (!UseUnalignedLoadStores && !aligned && (t == T_BYTE || t == T_SHORT)) {
        // align source address at 4 bytes address boundary
--- 953,975 ----
      __ push(rsi);
      __ push(rdi);
      __ movptr(from , Address(rsp, 12+ 4));
      __ movptr(to   , Address(rsp, 12+ 8));
      __ movl(count, Address(rsp, 12+ 12));
+ 
+     if (entry != NULL) {
+       *entry = __ pc(); // Entry point from conjoint arraycopy stub.
+       BLOCK_COMMENT("Entry:");
+     }
+ 
      if (t == T_OBJECT) {
        __ testl(count, count);
        __ jcc(Assembler::zero, L_0_count);
        gen_write_ref_array_pre_barrier(to, count);
        __ mov(saved_to, to);          // save 'to'
      }
  
      __ subptr(to, from); // to --> to_from
      __ cmpl(count, 2<<shift); // Short arrays (< 8 bytes) copy by element
      __ jcc(Assembler::below, L_copy_4_bytes); // use unsigned cmp
      if (!UseUnalignedLoadStores && !aligned && (t == T_BYTE || t == T_SHORT)) {
        // align source address at 4 bytes address boundary
*** 1116,1149 ****
      __ push(rsi);
      __ push(rdi);
      __ movptr(src  , Address(rsp, 12+ 4));   // from
      __ movptr(dst  , Address(rsp, 12+ 8));   // to
      __ movl2ptr(count, Address(rsp, 12+12)); // count
-     if (t == T_OBJECT) {
-        gen_write_ref_array_pre_barrier(dst, count);
-     }
  
      if (entry != NULL) {
        *entry = __ pc(); // Entry point from generic arraycopy stub.
        BLOCK_COMMENT("Entry:");
      }
  
!     if (t == T_OBJECT) {
!       __ testl(count, count);
!       __ jcc(Assembler::zero, L_0_count);
!     }
      __ mov(from, src);
      __ mov(to  , dst);
  
!     // arrays overlap test
      RuntimeAddress nooverlap(nooverlap_target);
      __ cmpptr(dst, src);
      __ lea(end, Address(src, count, sf, 0)); // src + count * elem_size
      __ jump_cc(Assembler::belowEqual, nooverlap);
      __ cmpptr(dst, end);
      __ jump_cc(Assembler::aboveEqual, nooverlap);
  
      // copy from high to low
      __ cmpl(count, 2<<shift); // Short arrays (< 8 bytes) copy by element
      __ jcc(Assembler::below, L_copy_4_bytes); // use unsigned cmp
      if (t == T_BYTE || t == T_SHORT) {
        // Align the end of destination array at 4 bytes address boundary
--- 1119,1152 ----
      __ push(rsi);
      __ push(rdi);
      __ movptr(src  , Address(rsp, 12+ 4));   // from
      __ movptr(dst  , Address(rsp, 12+ 8));   // to
      __ movl2ptr(count, Address(rsp, 12+12)); // count
  
      if (entry != NULL) {
        *entry = __ pc(); // Entry point from generic arraycopy stub.
        BLOCK_COMMENT("Entry:");
      }
  
!     // nooverlap_target expects arguments in rsi and rdi.
      __ mov(from, src);
      __ mov(to  , dst);
  
!     // arrays overlap test: dispatch to disjoint stub if necessary.
      RuntimeAddress nooverlap(nooverlap_target);
      __ cmpptr(dst, src);
      __ lea(end, Address(src, count, sf, 0)); // src + count * elem_size
      __ jump_cc(Assembler::belowEqual, nooverlap);
      __ cmpptr(dst, end);
      __ jump_cc(Assembler::aboveEqual, nooverlap);
  
+     if (t == T_OBJECT) {
+       __ testl(count, count);
+       __ jcc(Assembler::zero, L_0_count);
+        gen_write_ref_array_pre_barrier(dst, count);
+     }
+ 
      // copy from high to low
      __ cmpl(count, 2<<shift); // Short arrays (< 8 bytes) copy by element
      __ jcc(Assembler::below, L_copy_4_bytes); // use unsigned cmp
      if (t == T_BYTE || t == T_SHORT) {
        // Align the end of destination array at 4 bytes address boundary
*** 1459,1470 ****
--- 1462,1475 ----
      // Load up:
      __ movptr(from,     from_arg);
      __ movptr(to,         to_arg);
      __ movl2ptr(length, length_arg);
  
+     if (entry != NULL) {
        *entry = __ pc(); // Entry point from generic arraycopy stub.
        BLOCK_COMMENT("Entry:");
+     }
  
      //---------------------------------------------------------------
      // Assembler stub will be used for this call to arraycopy
      // if the two arrays are subtypes of Object[] but the
      // destination array type is not equal to or a supertype