1 /*
   2  * Copyright (c) 2003, 2019, 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_COPY_SPARC_HPP
  26 #define CPU_SPARC_COPY_SPARC_HPP
  27 
  28 // Inline functions for memory copy and fill.
  29 
  30 static void pd_conjoint_words(const HeapWord* from, HeapWord* to, size_t count) {
  31   (void)memmove(to, from, count * HeapWordSize);
  32 }
  33 
  34 static void pd_disjoint_words(const 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(const 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(const HeapWord* from, HeapWord* to, size_t count) {
  69   (void)memmove(to, from, count * HeapWordSize);
  70 }
  71 
  72 static void pd_aligned_disjoint_words(const HeapWord* from, HeapWord* to, size_t count) {
  73   pd_disjoint_words(from, to, count);
  74 }
  75 
  76 static void pd_conjoint_bytes(const void* from, void* to, size_t count) {
  77   (void)memmove(to, from, count);
  78 }
  79 
  80 static void pd_conjoint_bytes_atomic(const void* from, void* to, size_t count) {
  81   (void)memmove(to, from, count);
  82 }
  83 
  84 static void pd_conjoint_jshorts_atomic(const 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(const 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(const jlong* from, jlong* to, size_t count) {
 117   assert(BytesPerLong == BytesPerOop, "jlongs and oops must be the same size");
 118   pd_conjoint_oops_atomic((const oop*)from, (oop*)to, count);
 119 }
 120 
 121 static void pd_conjoint_oops_atomic(const oop* from, oop* to, size_t count) {
 122   // Do better than this: inline memmove body  NEEDS CLEANUP
 123   if (from > to) {
 124     while (count-- > 0) {
 125       // Copy forwards
 126       *to++ = *from++;
 127     }
 128   } else {
 129     from += count - 1;
 130     to   += count - 1;
 131     while (count-- > 0) {
 132       // Copy backwards
 133       *to-- = *from--;
 134     }
 135   }
 136 }
 137 
 138 static void pd_arrayof_conjoint_bytes(const HeapWord* from, HeapWord* to, size_t count) {
 139   pd_conjoint_bytes_atomic(from, to, count);
 140 }
 141 
 142 static void pd_arrayof_conjoint_jshorts(const HeapWord* from, HeapWord* to, size_t count) {
 143   pd_conjoint_jshorts_atomic((const jshort*)from, (jshort*)to, count);
 144 }
 145 
 146 static void pd_arrayof_conjoint_jints(const HeapWord* from, HeapWord* to, size_t count) {
 147   pd_conjoint_jints_atomic((const jint*)from, (jint*)to, count);
 148 }
 149 
 150 static void pd_arrayof_conjoint_jlongs(const HeapWord* from, HeapWord* to, size_t count) {
 151   pd_conjoint_jlongs_atomic((const jlong*)from, (jlong*)to, count);
 152 }
 153 
 154 static void pd_arrayof_conjoint_oops(const HeapWord* from, HeapWord* to, size_t count) {
 155   pd_conjoint_oops_atomic((const oop*)from, (oop*)to, count);
 156 }
 157 
 158 static void pd_fill_to_words(HeapWord* tohw, size_t count, juint value) {
 159   guarantee(mask_bits((uintptr_t)tohw, right_n_bits(LogBytesPerLong)) == 0,
 160          "unaligned fill words");
 161   julong* to = (julong*)tohw;
 162   julong  v  = ((julong)value << 32) | value;
 163   while (count-- > 0) {
 164     *to++ = v;
 165   }
 166 }
 167 
 168 typedef void (*_zero_Fn)(HeapWord* to, size_t count);
 169 
 170 // Only used for heap objects, so align_object_offset.
 171 // All other platforms pd_fill_to_aligned_words simply calls pd_fill_to_words, don't
 172 // know why this one is different.
 173 static void pd_fill_to_aligned_words(HeapWord* tohw, size_t count, juint value) {
 174   assert(MinObjAlignmentInBytes >= BytesPerLong, "need alternate implementation");
 175 
 176   if (value == 0 && UseBlockZeroing &&
 177       (count > (size_t)(BlockZeroingLowLimit >> LogHeapWordSize))) {
 178    // Call it only when block zeroing is used
 179    ((_zero_Fn)StubRoutines::zero_aligned_words())(tohw, count);
 180   } else {
 181    julong* to = (julong*)tohw;
 182    julong  v  = ((julong)value << 32) | value;
 183    // If count is odd, odd will be equal to 1 on 32-bit platform
 184    // and be equal to 0 on 64-bit platform.
 185    size_t odd = count % (BytesPerLong / HeapWordSize) ;
 186 
 187    size_t aligned_count = align_object_offset(count - odd) / HeapWordsPerLong;
 188    julong* end = ((julong*)tohw) + aligned_count - 1;
 189    while (to <= end) {
 190      DEBUG_ONLY(count -= BytesPerLong / HeapWordSize ;)
 191      *to++ = v;
 192    }
 193    assert(count == odd, "bad bounds on loop filling to aligned words");
 194    if (odd) {
 195      *((juint*)to) = value;
 196 
 197    }
 198   }
 199 }
 200 
 201 static void pd_fill_to_bytes(void* to, size_t count, jubyte value) {
 202   (void)memset(to, value, count);
 203 }
 204 
 205 static void pd_zero_to_words(HeapWord* tohw, size_t count) {
 206   pd_fill_to_words(tohw, count, 0);
 207 }
 208 
 209 static void pd_zero_to_bytes(void* to, size_t count) {
 210   (void)memset(to, 0, count);
 211 }
 212 
 213 #endif // CPU_SPARC_COPY_SPARC_HPP