1 /*
   2  * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef CPU_SPARC_VM_COPY_SPARC_HPP
  26 #define CPU_SPARC_VM_COPY_SPARC_HPP
  27 
  28 // Inline functions for memory copy and fill.
  29 
  30 static void pd_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
  31   (void)memmove(to, from, count * HeapWordSize);
  32 }
  33 
  34 static void pd_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
  35   switch (count) {
  36   case 8:  to[7] = from[7];
  37   case 7:  to[6] = from[6];
  38   case 6:  to[5] = from[5];
  39   case 5:  to[4] = from[4];
  40   case 4:  to[3] = from[3];
  41   case 3:  to[2] = from[2];
  42   case 2:  to[1] = from[1];
  43   case 1:  to[0] = from[0];
  44   case 0:  break;
  45   default: (void)memcpy(to, from, count * HeapWordSize);
  46            break;
  47   }
  48 }
  49 
  50 static void pd_disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count) {
  51   switch (count) {
  52   case 8:  to[7] = from[7];
  53   case 7:  to[6] = from[6];
  54   case 6:  to[5] = from[5];
  55   case 5:  to[4] = from[4];
  56   case 4:  to[3] = from[3];
  57   case 3:  to[2] = from[2];
  58   case 2:  to[1] = from[1];
  59   case 1:  to[0] = from[0];
  60   case 0:  break;
  61   default: while (count-- > 0) {
  62              *to++ = *from++;
  63            }
  64            break;
  65   }
  66 }
  67 
  68 static void pd_aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
  69   (void)memmove(to, from, count * HeapWordSize);
  70 }
  71 
  72 static void pd_aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
  73   pd_disjoint_words(from, to, count);
  74 }
  75 
  76 static void pd_conjoint_bytes(void* from, void* to, size_t count) {
  77   (void)memmove(to, from, count);
  78 }
  79 
  80 static void pd_conjoint_bytes_atomic(void* from, void* to, size_t count) {
  81   (void)memmove(to, from, count);
  82 }
  83 
  84 static void pd_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) {
  85   if (from > to) {
  86     while (count-- > 0) {
  87       // Copy forwards
  88       *to++ = *from++;
  89     }
  90   } else {
  91     from += count - 1;
  92     to   += count - 1;
  93     while (count-- > 0) {
  94       // Copy backwards
  95       *to-- = *from--;
  96     }
  97   }
  98 }
  99 
 100 static void pd_conjoint_jints_atomic(jint* from, jint* to, size_t count) {
 101   if (from > to) {
 102     while (count-- > 0) {
 103       // Copy forwards
 104       *to++ = *from++;
 105     }
 106   } else {
 107     from += count - 1;
 108     to   += count - 1;
 109     while (count-- > 0) {
 110       // Copy backwards
 111       *to-- = *from--;
 112     }
 113   }
 114 }
 115 
 116 static void pd_conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) {
 117 #ifdef _LP64
 118   assert(BytesPerLong == BytesPerOop, "jlongs and oops must be the same size");
 119   pd_conjoint_oops_atomic((oop*)from, (oop*)to, count);
 120 #else
 121   // Guarantee use of ldd/std via some asm code, because compiler won't.
 122   // See solaris_sparc.il.
 123   _Copy_conjoint_jlongs_atomic(from, to, count);
 124 #endif
 125 }
 126 
 127 static void pd_conjoint_oops_atomic(oop* from, oop* to, size_t count) {
 128   // Do better than this: inline memmove body  NEEDS CLEANUP
 129   if (from > to) {
 130     while (count-- > 0) {
 131       // Copy forwards
 132       *to++ = *from++;
 133     }
 134   } else {
 135     from += count - 1;
 136     to   += count - 1;
 137     while (count-- > 0) {
 138       // Copy backwards
 139       *to-- = *from--;
 140     }
 141   }
 142 }
 143 
 144 static void pd_arrayof_conjoint_bytes(HeapWord* from, HeapWord* to, size_t count) {
 145   pd_conjoint_bytes_atomic(from, to, count);
 146 }
 147 
 148 static void pd_arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count) {
 149   pd_conjoint_jshorts_atomic((jshort*)from, (jshort*)to, count);
 150 }
 151 
 152 static void pd_arrayof_conjoint_jints(HeapWord* from, HeapWord* to, size_t count) {
 153   pd_conjoint_jints_atomic((jint*)from, (jint*)to, count);
 154 }
 155 
 156 static void pd_arrayof_conjoint_jlongs(HeapWord* from, HeapWord* to, size_t count) {
 157   pd_conjoint_jlongs_atomic((jlong*)from, (jlong*)to, count);
 158 }
 159 
 160 static void pd_arrayof_conjoint_oops(HeapWord* from, HeapWord* to, size_t count) {
 161   pd_conjoint_oops_atomic((oop*)from, (oop*)to, count);
 162 }
 163 
 164 static void pd_fill_to_words(HeapWord* tohw, size_t count, juint value) {
 165 #ifdef _LP64
 166   guarantee(mask_bits((uintptr_t)tohw, right_n_bits(LogBytesPerLong)) == 0,
 167          "unaligned fill words");
 168   julong* to = (julong*)tohw;
 169   julong  v  = ((julong)value << 32) | value;
 170   while (count-- > 0) {
 171     *to++ = v;
 172   }
 173 #else // _LP64
 174   juint* to = (juint*)tohw;
 175   while (count-- > 0) {
 176     *to++ = value;
 177   }
 178 #endif // _LP64
 179 }
 180 
 181 typedef void (*_zero_Fn)(HeapWord* to, size_t count);
 182 
 183 // Only used for heap objects, so align_object_offset.
 184 // All other platforms pd_fill_to_aligned_words simply calls pd_fill_to_words, don't
 185 // know why this one is different.
 186 static void pd_fill_to_aligned_words(HeapWord* tohw, size_t count, juint value) {
 187   assert(MinObjAlignmentInBytes >= BytesPerLong, "need alternate implementation");
 188 
 189   if (value == 0 && UseBlockZeroing &&
 190       (count > (size_t)(BlockZeroingLowLimit >> LogHeapWordSize))) {
 191    // Call it only when block zeroing is used
 192    ((_zero_Fn)StubRoutines::zero_aligned_words())(tohw, count);
 193   } else {
 194    julong* to = (julong*)tohw;
 195    julong  v  = ((julong)value << 32) | value;
 196    // If count is odd, odd will be equal to 1 on 32-bit platform
 197    // and be equal to 0 on 64-bit platform.
 198    size_t odd = count % (BytesPerLong / HeapWordSize) ;
 199 
 200    size_t aligned_count = align_object_offset(count - odd) / HeapWordsPerLong;
 201    julong* end = ((julong*)tohw) + aligned_count - 1;
 202    while (to <= end) {
 203      DEBUG_ONLY(count -= BytesPerLong / HeapWordSize ;)
 204      *to++ = v;
 205    }
 206    assert(count == odd, "bad bounds on loop filling to aligned words");
 207    if (odd) {
 208      *((juint*)to) = value;
 209 
 210    }
 211   }
 212 }
 213 
 214 static void pd_fill_to_bytes(void* to, size_t count, jubyte value) {
 215   (void)memset(to, value, count);
 216 }
 217 
 218 static void pd_zero_to_words(HeapWord* tohw, size_t count) {
 219   pd_fill_to_words(tohw, count, 0);
 220 }
 221 
 222 static void pd_zero_to_bytes(void* to, size_t count) {
 223   (void)memset(to, 0, count);
 224 }
 225 
 226 #endif // CPU_SPARC_VM_COPY_SPARC_HPP