1 /* 2 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. 3 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 */ 24 25 /* 26 * @test 27 * @bug 8235385 28 * @summary Crash on aarch64 JDK due to long offset 29 * 30 * @modules jdk.unsupported/sun.misc 31 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation compiler.unsafe.MisalignedAccesses 32 */ 33 34 package compiler.unsafe; 35 36 import org.testng.annotations.Test; 37 38 import java.lang.reflect.Field; 39 40 import static org.testng.Assert.*; 41 42 public class MisalignedAccesses { 43 static final int ITERS = Integer.getInteger("iters", 1); 44 45 static final sun.misc.Unsafe UNSAFE; 46 47 static final long BYTE_ARRAY_OFFSET; 48 49 static final byte[] byteArray = new byte[4096]; 50 51 static { 52 try { 53 Field f = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); 54 f.setAccessible(true); 55 UNSAFE = (sun.misc.Unsafe) f.get(null); 56 } catch (Exception e) { 57 throw new RuntimeException("Unable to get Unsafe instance.", e); 58 } 59 BYTE_ARRAY_OFFSET = UNSAFE.arrayBaseOffset(byte[].class); 60 } 61 62 @Test testBytes()63 static long testBytes() { 64 long sum = 0; 65 sum += UNSAFE.getByte(byteArray, 1 + BYTE_ARRAY_OFFSET); 66 sum += UNSAFE.getByte(byteArray, 38 + BYTE_ARRAY_OFFSET); 67 sum += UNSAFE.getByte(byteArray, 75 + BYTE_ARRAY_OFFSET); 68 sum += UNSAFE.getByte(byteArray, 112 + BYTE_ARRAY_OFFSET); 69 sum += UNSAFE.getByte(byteArray, 149 + BYTE_ARRAY_OFFSET); 70 sum += UNSAFE.getByte(byteArray, 186 + BYTE_ARRAY_OFFSET); 71 sum += UNSAFE.getByte(byteArray, 223 + BYTE_ARRAY_OFFSET); 72 sum += UNSAFE.getByte(byteArray, 260 + BYTE_ARRAY_OFFSET); 73 sum += UNSAFE.getByte(byteArray, 297 + BYTE_ARRAY_OFFSET); 74 sum += UNSAFE.getByte(byteArray, 334 + BYTE_ARRAY_OFFSET); 75 sum += UNSAFE.getByte(byteArray, 371 + BYTE_ARRAY_OFFSET); 76 sum += UNSAFE.getByte(byteArray, 408 + BYTE_ARRAY_OFFSET); 77 sum += UNSAFE.getByte(byteArray, 445 + BYTE_ARRAY_OFFSET); 78 sum += UNSAFE.getByte(byteArray, 482 + BYTE_ARRAY_OFFSET); 79 sum += UNSAFE.getByte(byteArray, 519 + BYTE_ARRAY_OFFSET); 80 sum += UNSAFE.getByte(byteArray, 556 + BYTE_ARRAY_OFFSET); 81 sum += UNSAFE.getByte(byteArray, 593 + BYTE_ARRAY_OFFSET); 82 sum += UNSAFE.getByte(byteArray, 630 + BYTE_ARRAY_OFFSET); 83 sum += UNSAFE.getByte(byteArray, 667 + BYTE_ARRAY_OFFSET); 84 sum += UNSAFE.getByte(byteArray, 704 + BYTE_ARRAY_OFFSET); 85 sum += UNSAFE.getByte(byteArray, 741 + BYTE_ARRAY_OFFSET); 86 sum += UNSAFE.getByte(byteArray, 778 + BYTE_ARRAY_OFFSET); 87 sum += UNSAFE.getByte(byteArray, 815 + BYTE_ARRAY_OFFSET); 88 sum += UNSAFE.getByte(byteArray, 852 + BYTE_ARRAY_OFFSET); 89 sum += UNSAFE.getByte(byteArray, 889 + BYTE_ARRAY_OFFSET); 90 sum += UNSAFE.getByte(byteArray, 926 + BYTE_ARRAY_OFFSET); 91 sum += UNSAFE.getByte(byteArray, 963 + BYTE_ARRAY_OFFSET); 92 sum += UNSAFE.getByte(byteArray, 1000 + BYTE_ARRAY_OFFSET); 93 sum += UNSAFE.getByte(byteArray, 1037 + BYTE_ARRAY_OFFSET); 94 sum += UNSAFE.getByte(byteArray, 1074 + BYTE_ARRAY_OFFSET); 95 sum += UNSAFE.getByte(byteArray, 1111 + BYTE_ARRAY_OFFSET); 96 sum += UNSAFE.getByte(byteArray, 1148 + BYTE_ARRAY_OFFSET); 97 sum += UNSAFE.getByte(byteArray, 1185 + BYTE_ARRAY_OFFSET); 98 sum += UNSAFE.getByte(byteArray, 1222 + BYTE_ARRAY_OFFSET); 99 sum += UNSAFE.getByte(byteArray, 1259 + BYTE_ARRAY_OFFSET); 100 sum += UNSAFE.getByte(byteArray, 1296 + BYTE_ARRAY_OFFSET); 101 sum += UNSAFE.getByte(byteArray, 1333 + BYTE_ARRAY_OFFSET); 102 sum += UNSAFE.getByte(byteArray, 1370 + BYTE_ARRAY_OFFSET); 103 sum += UNSAFE.getByte(byteArray, 1407 + BYTE_ARRAY_OFFSET); 104 sum += UNSAFE.getByte(byteArray, 1444 + BYTE_ARRAY_OFFSET); 105 sum += UNSAFE.getByte(byteArray, 1481 + BYTE_ARRAY_OFFSET); 106 sum += UNSAFE.getByte(byteArray, 1518 + BYTE_ARRAY_OFFSET); 107 sum += UNSAFE.getByte(byteArray, 1555 + BYTE_ARRAY_OFFSET); 108 sum += UNSAFE.getByte(byteArray, 1592 + BYTE_ARRAY_OFFSET); 109 sum += UNSAFE.getByte(byteArray, 1629 + BYTE_ARRAY_OFFSET); 110 sum += UNSAFE.getByte(byteArray, 1666 + BYTE_ARRAY_OFFSET); 111 sum += UNSAFE.getByte(byteArray, 1703 + BYTE_ARRAY_OFFSET); 112 sum += UNSAFE.getByte(byteArray, 1740 + BYTE_ARRAY_OFFSET); 113 sum += UNSAFE.getByte(byteArray, 1777 + BYTE_ARRAY_OFFSET); 114 sum += UNSAFE.getByte(byteArray, 1814 + BYTE_ARRAY_OFFSET); 115 sum += UNSAFE.getByte(byteArray, 1851 + BYTE_ARRAY_OFFSET); 116 sum += UNSAFE.getByte(byteArray, 1888 + BYTE_ARRAY_OFFSET); 117 sum += UNSAFE.getByte(byteArray, 1925 + BYTE_ARRAY_OFFSET); 118 sum += UNSAFE.getByte(byteArray, 1962 + BYTE_ARRAY_OFFSET); 119 sum += UNSAFE.getByte(byteArray, 1999 + BYTE_ARRAY_OFFSET); 120 sum += UNSAFE.getByte(byteArray, 2036 + BYTE_ARRAY_OFFSET); 121 sum += UNSAFE.getByte(byteArray, 2073 + BYTE_ARRAY_OFFSET); 122 sum += UNSAFE.getByte(byteArray, 2110 + BYTE_ARRAY_OFFSET); 123 sum += UNSAFE.getByte(byteArray, 2147 + BYTE_ARRAY_OFFSET); 124 sum += UNSAFE.getByte(byteArray, 2184 + BYTE_ARRAY_OFFSET); 125 sum += UNSAFE.getByte(byteArray, 2221 + BYTE_ARRAY_OFFSET); 126 sum += UNSAFE.getByte(byteArray, 2258 + BYTE_ARRAY_OFFSET); 127 sum += UNSAFE.getByte(byteArray, 2295 + BYTE_ARRAY_OFFSET); 128 sum += UNSAFE.getByte(byteArray, 2332 + BYTE_ARRAY_OFFSET); 129 sum += UNSAFE.getByte(byteArray, 2369 + BYTE_ARRAY_OFFSET); 130 sum += UNSAFE.getByte(byteArray, 2406 + BYTE_ARRAY_OFFSET); 131 sum += UNSAFE.getByte(byteArray, 2443 + BYTE_ARRAY_OFFSET); 132 sum += UNSAFE.getByte(byteArray, 2480 + BYTE_ARRAY_OFFSET); 133 sum += UNSAFE.getByte(byteArray, 2517 + BYTE_ARRAY_OFFSET); 134 sum += UNSAFE.getByte(byteArray, 2554 + BYTE_ARRAY_OFFSET); 135 sum += UNSAFE.getByte(byteArray, 2591 + BYTE_ARRAY_OFFSET); 136 sum += UNSAFE.getByte(byteArray, 2628 + BYTE_ARRAY_OFFSET); 137 sum += UNSAFE.getByte(byteArray, 2665 + BYTE_ARRAY_OFFSET); 138 sum += UNSAFE.getByte(byteArray, 2702 + BYTE_ARRAY_OFFSET); 139 sum += UNSAFE.getByte(byteArray, 2739 + BYTE_ARRAY_OFFSET); 140 sum += UNSAFE.getByte(byteArray, 2776 + BYTE_ARRAY_OFFSET); 141 sum += UNSAFE.getByte(byteArray, 2813 + BYTE_ARRAY_OFFSET); 142 sum += UNSAFE.getByte(byteArray, 2850 + BYTE_ARRAY_OFFSET); 143 sum += UNSAFE.getByte(byteArray, 2887 + BYTE_ARRAY_OFFSET); 144 sum += UNSAFE.getByte(byteArray, 2924 + BYTE_ARRAY_OFFSET); 145 sum += UNSAFE.getByte(byteArray, 2961 + BYTE_ARRAY_OFFSET); 146 sum += UNSAFE.getByte(byteArray, 2998 + BYTE_ARRAY_OFFSET); 147 sum += UNSAFE.getByte(byteArray, 3035 + BYTE_ARRAY_OFFSET); 148 sum += UNSAFE.getByte(byteArray, 3072 + BYTE_ARRAY_OFFSET); 149 sum += UNSAFE.getByte(byteArray, 3109 + BYTE_ARRAY_OFFSET); 150 sum += UNSAFE.getByte(byteArray, 3146 + BYTE_ARRAY_OFFSET); 151 sum += UNSAFE.getByte(byteArray, 3183 + BYTE_ARRAY_OFFSET); 152 sum += UNSAFE.getByte(byteArray, 3220 + BYTE_ARRAY_OFFSET); 153 sum += UNSAFE.getByte(byteArray, 3257 + BYTE_ARRAY_OFFSET); 154 sum += UNSAFE.getByte(byteArray, 3294 + BYTE_ARRAY_OFFSET); 155 sum += UNSAFE.getByte(byteArray, 3331 + BYTE_ARRAY_OFFSET); 156 sum += UNSAFE.getByte(byteArray, 3368 + BYTE_ARRAY_OFFSET); 157 sum += UNSAFE.getByte(byteArray, 3405 + BYTE_ARRAY_OFFSET); 158 sum += UNSAFE.getByte(byteArray, 3442 + BYTE_ARRAY_OFFSET); 159 sum += UNSAFE.getByte(byteArray, 3479 + BYTE_ARRAY_OFFSET); 160 sum += UNSAFE.getByte(byteArray, 3516 + BYTE_ARRAY_OFFSET); 161 sum += UNSAFE.getByte(byteArray, 3553 + BYTE_ARRAY_OFFSET); 162 sum += UNSAFE.getByte(byteArray, 3590 + BYTE_ARRAY_OFFSET); 163 sum += UNSAFE.getByte(byteArray, 3627 + BYTE_ARRAY_OFFSET); 164 sum += UNSAFE.getByte(byteArray, 3664 + BYTE_ARRAY_OFFSET); 165 sum += UNSAFE.getByte(byteArray, 3701 + BYTE_ARRAY_OFFSET); 166 sum += UNSAFE.getByte(byteArray, 3738 + BYTE_ARRAY_OFFSET); 167 sum += UNSAFE.getByte(byteArray, 3775 + BYTE_ARRAY_OFFSET); 168 sum += UNSAFE.getByte(byteArray, 3812 + BYTE_ARRAY_OFFSET); 169 sum += UNSAFE.getByte(byteArray, 3849 + BYTE_ARRAY_OFFSET); 170 sum += UNSAFE.getByte(byteArray, 3886 + BYTE_ARRAY_OFFSET); 171 sum += UNSAFE.getByte(byteArray, 3923 + BYTE_ARRAY_OFFSET); 172 sum += UNSAFE.getByte(byteArray, 3960 + BYTE_ARRAY_OFFSET); 173 sum += UNSAFE.getByte(byteArray, 3997 + BYTE_ARRAY_OFFSET); 174 return sum; 175 } 176 177 @Test testShorts()178 static long testShorts() { 179 long sum = 0; 180 sum += UNSAFE.getShort(byteArray, 1 + BYTE_ARRAY_OFFSET); 181 sum += UNSAFE.getShort(byteArray, 38 + BYTE_ARRAY_OFFSET); 182 sum += UNSAFE.getShort(byteArray, 75 + BYTE_ARRAY_OFFSET); 183 sum += UNSAFE.getShort(byteArray, 112 + BYTE_ARRAY_OFFSET); 184 sum += UNSAFE.getShort(byteArray, 149 + BYTE_ARRAY_OFFSET); 185 sum += UNSAFE.getShort(byteArray, 186 + BYTE_ARRAY_OFFSET); 186 sum += UNSAFE.getShort(byteArray, 223 + BYTE_ARRAY_OFFSET); 187 sum += UNSAFE.getShort(byteArray, 260 + BYTE_ARRAY_OFFSET); 188 sum += UNSAFE.getShort(byteArray, 297 + BYTE_ARRAY_OFFSET); 189 sum += UNSAFE.getShort(byteArray, 334 + BYTE_ARRAY_OFFSET); 190 sum += UNSAFE.getShort(byteArray, 371 + BYTE_ARRAY_OFFSET); 191 sum += UNSAFE.getShort(byteArray, 408 + BYTE_ARRAY_OFFSET); 192 sum += UNSAFE.getShort(byteArray, 445 + BYTE_ARRAY_OFFSET); 193 sum += UNSAFE.getShort(byteArray, 482 + BYTE_ARRAY_OFFSET); 194 sum += UNSAFE.getShort(byteArray, 519 + BYTE_ARRAY_OFFSET); 195 sum += UNSAFE.getShort(byteArray, 556 + BYTE_ARRAY_OFFSET); 196 sum += UNSAFE.getShort(byteArray, 593 + BYTE_ARRAY_OFFSET); 197 sum += UNSAFE.getShort(byteArray, 630 + BYTE_ARRAY_OFFSET); 198 sum += UNSAFE.getShort(byteArray, 667 + BYTE_ARRAY_OFFSET); 199 sum += UNSAFE.getShort(byteArray, 704 + BYTE_ARRAY_OFFSET); 200 sum += UNSAFE.getShort(byteArray, 741 + BYTE_ARRAY_OFFSET); 201 sum += UNSAFE.getShort(byteArray, 778 + BYTE_ARRAY_OFFSET); 202 sum += UNSAFE.getShort(byteArray, 815 + BYTE_ARRAY_OFFSET); 203 sum += UNSAFE.getShort(byteArray, 852 + BYTE_ARRAY_OFFSET); 204 sum += UNSAFE.getShort(byteArray, 889 + BYTE_ARRAY_OFFSET); 205 sum += UNSAFE.getShort(byteArray, 926 + BYTE_ARRAY_OFFSET); 206 sum += UNSAFE.getShort(byteArray, 963 + BYTE_ARRAY_OFFSET); 207 sum += UNSAFE.getShort(byteArray, 1000 + BYTE_ARRAY_OFFSET); 208 sum += UNSAFE.getShort(byteArray, 1037 + BYTE_ARRAY_OFFSET); 209 sum += UNSAFE.getShort(byteArray, 1074 + BYTE_ARRAY_OFFSET); 210 sum += UNSAFE.getShort(byteArray, 1111 + BYTE_ARRAY_OFFSET); 211 sum += UNSAFE.getShort(byteArray, 1148 + BYTE_ARRAY_OFFSET); 212 sum += UNSAFE.getShort(byteArray, 1185 + BYTE_ARRAY_OFFSET); 213 sum += UNSAFE.getShort(byteArray, 1222 + BYTE_ARRAY_OFFSET); 214 sum += UNSAFE.getShort(byteArray, 1259 + BYTE_ARRAY_OFFSET); 215 sum += UNSAFE.getShort(byteArray, 1296 + BYTE_ARRAY_OFFSET); 216 sum += UNSAFE.getShort(byteArray, 1333 + BYTE_ARRAY_OFFSET); 217 sum += UNSAFE.getShort(byteArray, 1370 + BYTE_ARRAY_OFFSET); 218 sum += UNSAFE.getShort(byteArray, 1407 + BYTE_ARRAY_OFFSET); 219 sum += UNSAFE.getShort(byteArray, 1444 + BYTE_ARRAY_OFFSET); 220 sum += UNSAFE.getShort(byteArray, 1481 + BYTE_ARRAY_OFFSET); 221 sum += UNSAFE.getShort(byteArray, 1518 + BYTE_ARRAY_OFFSET); 222 sum += UNSAFE.getShort(byteArray, 1555 + BYTE_ARRAY_OFFSET); 223 sum += UNSAFE.getShort(byteArray, 1592 + BYTE_ARRAY_OFFSET); 224 sum += UNSAFE.getShort(byteArray, 1629 + BYTE_ARRAY_OFFSET); 225 sum += UNSAFE.getShort(byteArray, 1666 + BYTE_ARRAY_OFFSET); 226 sum += UNSAFE.getShort(byteArray, 1703 + BYTE_ARRAY_OFFSET); 227 sum += UNSAFE.getShort(byteArray, 1740 + BYTE_ARRAY_OFFSET); 228 sum += UNSAFE.getShort(byteArray, 1777 + BYTE_ARRAY_OFFSET); 229 sum += UNSAFE.getShort(byteArray, 1814 + BYTE_ARRAY_OFFSET); 230 sum += UNSAFE.getShort(byteArray, 1851 + BYTE_ARRAY_OFFSET); 231 sum += UNSAFE.getShort(byteArray, 1888 + BYTE_ARRAY_OFFSET); 232 sum += UNSAFE.getShort(byteArray, 1925 + BYTE_ARRAY_OFFSET); 233 sum += UNSAFE.getShort(byteArray, 1962 + BYTE_ARRAY_OFFSET); 234 sum += UNSAFE.getShort(byteArray, 1999 + BYTE_ARRAY_OFFSET); 235 sum += UNSAFE.getShort(byteArray, 2036 + BYTE_ARRAY_OFFSET); 236 sum += UNSAFE.getShort(byteArray, 2073 + BYTE_ARRAY_OFFSET); 237 sum += UNSAFE.getShort(byteArray, 2110 + BYTE_ARRAY_OFFSET); 238 sum += UNSAFE.getShort(byteArray, 2147 + BYTE_ARRAY_OFFSET); 239 sum += UNSAFE.getShort(byteArray, 2184 + BYTE_ARRAY_OFFSET); 240 sum += UNSAFE.getShort(byteArray, 2221 + BYTE_ARRAY_OFFSET); 241 sum += UNSAFE.getShort(byteArray, 2258 + BYTE_ARRAY_OFFSET); 242 sum += UNSAFE.getShort(byteArray, 2295 + BYTE_ARRAY_OFFSET); 243 sum += UNSAFE.getShort(byteArray, 2332 + BYTE_ARRAY_OFFSET); 244 sum += UNSAFE.getShort(byteArray, 2369 + BYTE_ARRAY_OFFSET); 245 sum += UNSAFE.getShort(byteArray, 2406 + BYTE_ARRAY_OFFSET); 246 sum += UNSAFE.getShort(byteArray, 2443 + BYTE_ARRAY_OFFSET); 247 sum += UNSAFE.getShort(byteArray, 2480 + BYTE_ARRAY_OFFSET); 248 sum += UNSAFE.getShort(byteArray, 2517 + BYTE_ARRAY_OFFSET); 249 sum += UNSAFE.getShort(byteArray, 2554 + BYTE_ARRAY_OFFSET); 250 sum += UNSAFE.getShort(byteArray, 2591 + BYTE_ARRAY_OFFSET); 251 sum += UNSAFE.getShort(byteArray, 2628 + BYTE_ARRAY_OFFSET); 252 sum += UNSAFE.getShort(byteArray, 2665 + BYTE_ARRAY_OFFSET); 253 sum += UNSAFE.getShort(byteArray, 2702 + BYTE_ARRAY_OFFSET); 254 sum += UNSAFE.getShort(byteArray, 2739 + BYTE_ARRAY_OFFSET); 255 sum += UNSAFE.getShort(byteArray, 2776 + BYTE_ARRAY_OFFSET); 256 sum += UNSAFE.getShort(byteArray, 2813 + BYTE_ARRAY_OFFSET); 257 sum += UNSAFE.getShort(byteArray, 2850 + BYTE_ARRAY_OFFSET); 258 sum += UNSAFE.getShort(byteArray, 2887 + BYTE_ARRAY_OFFSET); 259 sum += UNSAFE.getShort(byteArray, 2924 + BYTE_ARRAY_OFFSET); 260 sum += UNSAFE.getShort(byteArray, 2961 + BYTE_ARRAY_OFFSET); 261 sum += UNSAFE.getShort(byteArray, 2998 + BYTE_ARRAY_OFFSET); 262 sum += UNSAFE.getShort(byteArray, 3035 + BYTE_ARRAY_OFFSET); 263 sum += UNSAFE.getShort(byteArray, 3072 + BYTE_ARRAY_OFFSET); 264 sum += UNSAFE.getShort(byteArray, 3109 + BYTE_ARRAY_OFFSET); 265 sum += UNSAFE.getShort(byteArray, 3146 + BYTE_ARRAY_OFFSET); 266 sum += UNSAFE.getShort(byteArray, 3183 + BYTE_ARRAY_OFFSET); 267 sum += UNSAFE.getShort(byteArray, 3220 + BYTE_ARRAY_OFFSET); 268 sum += UNSAFE.getShort(byteArray, 3257 + BYTE_ARRAY_OFFSET); 269 sum += UNSAFE.getShort(byteArray, 3294 + BYTE_ARRAY_OFFSET); 270 sum += UNSAFE.getShort(byteArray, 3331 + BYTE_ARRAY_OFFSET); 271 sum += UNSAFE.getShort(byteArray, 3368 + BYTE_ARRAY_OFFSET); 272 sum += UNSAFE.getShort(byteArray, 3405 + BYTE_ARRAY_OFFSET); 273 sum += UNSAFE.getShort(byteArray, 3442 + BYTE_ARRAY_OFFSET); 274 sum += UNSAFE.getShort(byteArray, 3479 + BYTE_ARRAY_OFFSET); 275 sum += UNSAFE.getShort(byteArray, 3516 + BYTE_ARRAY_OFFSET); 276 sum += UNSAFE.getShort(byteArray, 3553 + BYTE_ARRAY_OFFSET); 277 sum += UNSAFE.getShort(byteArray, 3590 + BYTE_ARRAY_OFFSET); 278 sum += UNSAFE.getShort(byteArray, 3627 + BYTE_ARRAY_OFFSET); 279 sum += UNSAFE.getShort(byteArray, 3664 + BYTE_ARRAY_OFFSET); 280 sum += UNSAFE.getShort(byteArray, 3701 + BYTE_ARRAY_OFFSET); 281 sum += UNSAFE.getShort(byteArray, 3738 + BYTE_ARRAY_OFFSET); 282 sum += UNSAFE.getShort(byteArray, 3775 + BYTE_ARRAY_OFFSET); 283 sum += UNSAFE.getShort(byteArray, 3812 + BYTE_ARRAY_OFFSET); 284 sum += UNSAFE.getShort(byteArray, 3849 + BYTE_ARRAY_OFFSET); 285 sum += UNSAFE.getShort(byteArray, 3886 + BYTE_ARRAY_OFFSET); 286 sum += UNSAFE.getShort(byteArray, 3923 + BYTE_ARRAY_OFFSET); 287 sum += UNSAFE.getShort(byteArray, 3960 + BYTE_ARRAY_OFFSET); 288 sum += UNSAFE.getShort(byteArray, 3997 + BYTE_ARRAY_OFFSET); 289 return sum; 290 } 291 292 @Test testInts()293 static long testInts() { 294 long sum = 0; 295 sum += UNSAFE.getInt(byteArray, 1 + BYTE_ARRAY_OFFSET); 296 sum += UNSAFE.getInt(byteArray, 38 + BYTE_ARRAY_OFFSET); 297 sum += UNSAFE.getInt(byteArray, 75 + BYTE_ARRAY_OFFSET); 298 sum += UNSAFE.getInt(byteArray, 112 + BYTE_ARRAY_OFFSET); 299 sum += UNSAFE.getInt(byteArray, 149 + BYTE_ARRAY_OFFSET); 300 sum += UNSAFE.getInt(byteArray, 186 + BYTE_ARRAY_OFFSET); 301 sum += UNSAFE.getInt(byteArray, 223 + BYTE_ARRAY_OFFSET); 302 sum += UNSAFE.getInt(byteArray, 260 + BYTE_ARRAY_OFFSET); 303 sum += UNSAFE.getInt(byteArray, 297 + BYTE_ARRAY_OFFSET); 304 sum += UNSAFE.getInt(byteArray, 334 + BYTE_ARRAY_OFFSET); 305 sum += UNSAFE.getInt(byteArray, 371 + BYTE_ARRAY_OFFSET); 306 sum += UNSAFE.getInt(byteArray, 408 + BYTE_ARRAY_OFFSET); 307 sum += UNSAFE.getInt(byteArray, 445 + BYTE_ARRAY_OFFSET); 308 sum += UNSAFE.getInt(byteArray, 482 + BYTE_ARRAY_OFFSET); 309 sum += UNSAFE.getInt(byteArray, 519 + BYTE_ARRAY_OFFSET); 310 sum += UNSAFE.getInt(byteArray, 556 + BYTE_ARRAY_OFFSET); 311 sum += UNSAFE.getInt(byteArray, 593 + BYTE_ARRAY_OFFSET); 312 sum += UNSAFE.getInt(byteArray, 630 + BYTE_ARRAY_OFFSET); 313 sum += UNSAFE.getInt(byteArray, 667 + BYTE_ARRAY_OFFSET); 314 sum += UNSAFE.getInt(byteArray, 704 + BYTE_ARRAY_OFFSET); 315 sum += UNSAFE.getInt(byteArray, 741 + BYTE_ARRAY_OFFSET); 316 sum += UNSAFE.getInt(byteArray, 778 + BYTE_ARRAY_OFFSET); 317 sum += UNSAFE.getInt(byteArray, 815 + BYTE_ARRAY_OFFSET); 318 sum += UNSAFE.getInt(byteArray, 852 + BYTE_ARRAY_OFFSET); 319 sum += UNSAFE.getInt(byteArray, 889 + BYTE_ARRAY_OFFSET); 320 sum += UNSAFE.getInt(byteArray, 926 + BYTE_ARRAY_OFFSET); 321 sum += UNSAFE.getInt(byteArray, 963 + BYTE_ARRAY_OFFSET); 322 sum += UNSAFE.getInt(byteArray, 1000 + BYTE_ARRAY_OFFSET); 323 sum += UNSAFE.getInt(byteArray, 1037 + BYTE_ARRAY_OFFSET); 324 sum += UNSAFE.getInt(byteArray, 1074 + BYTE_ARRAY_OFFSET); 325 sum += UNSAFE.getInt(byteArray, 1111 + BYTE_ARRAY_OFFSET); 326 sum += UNSAFE.getInt(byteArray, 1148 + BYTE_ARRAY_OFFSET); 327 sum += UNSAFE.getInt(byteArray, 1185 + BYTE_ARRAY_OFFSET); 328 sum += UNSAFE.getInt(byteArray, 1222 + BYTE_ARRAY_OFFSET); 329 sum += UNSAFE.getInt(byteArray, 1259 + BYTE_ARRAY_OFFSET); 330 sum += UNSAFE.getInt(byteArray, 1296 + BYTE_ARRAY_OFFSET); 331 sum += UNSAFE.getInt(byteArray, 1333 + BYTE_ARRAY_OFFSET); 332 sum += UNSAFE.getInt(byteArray, 1370 + BYTE_ARRAY_OFFSET); 333 sum += UNSAFE.getInt(byteArray, 1407 + BYTE_ARRAY_OFFSET); 334 sum += UNSAFE.getInt(byteArray, 1444 + BYTE_ARRAY_OFFSET); 335 sum += UNSAFE.getInt(byteArray, 1481 + BYTE_ARRAY_OFFSET); 336 sum += UNSAFE.getInt(byteArray, 1518 + BYTE_ARRAY_OFFSET); 337 sum += UNSAFE.getInt(byteArray, 1555 + BYTE_ARRAY_OFFSET); 338 sum += UNSAFE.getInt(byteArray, 1592 + BYTE_ARRAY_OFFSET); 339 sum += UNSAFE.getInt(byteArray, 1629 + BYTE_ARRAY_OFFSET); 340 sum += UNSAFE.getInt(byteArray, 1666 + BYTE_ARRAY_OFFSET); 341 sum += UNSAFE.getInt(byteArray, 1703 + BYTE_ARRAY_OFFSET); 342 sum += UNSAFE.getInt(byteArray, 1740 + BYTE_ARRAY_OFFSET); 343 sum += UNSAFE.getInt(byteArray, 1777 + BYTE_ARRAY_OFFSET); 344 sum += UNSAFE.getInt(byteArray, 1814 + BYTE_ARRAY_OFFSET); 345 sum += UNSAFE.getInt(byteArray, 1851 + BYTE_ARRAY_OFFSET); 346 sum += UNSAFE.getInt(byteArray, 1888 + BYTE_ARRAY_OFFSET); 347 sum += UNSAFE.getInt(byteArray, 1925 + BYTE_ARRAY_OFFSET); 348 sum += UNSAFE.getInt(byteArray, 1962 + BYTE_ARRAY_OFFSET); 349 sum += UNSAFE.getInt(byteArray, 1999 + BYTE_ARRAY_OFFSET); 350 sum += UNSAFE.getInt(byteArray, 2036 + BYTE_ARRAY_OFFSET); 351 sum += UNSAFE.getInt(byteArray, 2073 + BYTE_ARRAY_OFFSET); 352 sum += UNSAFE.getInt(byteArray, 2110 + BYTE_ARRAY_OFFSET); 353 sum += UNSAFE.getInt(byteArray, 2147 + BYTE_ARRAY_OFFSET); 354 sum += UNSAFE.getInt(byteArray, 2184 + BYTE_ARRAY_OFFSET); 355 sum += UNSAFE.getInt(byteArray, 2221 + BYTE_ARRAY_OFFSET); 356 sum += UNSAFE.getInt(byteArray, 2258 + BYTE_ARRAY_OFFSET); 357 sum += UNSAFE.getInt(byteArray, 2295 + BYTE_ARRAY_OFFSET); 358 sum += UNSAFE.getInt(byteArray, 2332 + BYTE_ARRAY_OFFSET); 359 sum += UNSAFE.getInt(byteArray, 2369 + BYTE_ARRAY_OFFSET); 360 sum += UNSAFE.getInt(byteArray, 2406 + BYTE_ARRAY_OFFSET); 361 sum += UNSAFE.getInt(byteArray, 2443 + BYTE_ARRAY_OFFSET); 362 sum += UNSAFE.getInt(byteArray, 2480 + BYTE_ARRAY_OFFSET); 363 sum += UNSAFE.getInt(byteArray, 2517 + BYTE_ARRAY_OFFSET); 364 sum += UNSAFE.getInt(byteArray, 2554 + BYTE_ARRAY_OFFSET); 365 sum += UNSAFE.getInt(byteArray, 2591 + BYTE_ARRAY_OFFSET); 366 sum += UNSAFE.getInt(byteArray, 2628 + BYTE_ARRAY_OFFSET); 367 sum += UNSAFE.getInt(byteArray, 2665 + BYTE_ARRAY_OFFSET); 368 sum += UNSAFE.getInt(byteArray, 2702 + BYTE_ARRAY_OFFSET); 369 sum += UNSAFE.getInt(byteArray, 2739 + BYTE_ARRAY_OFFSET); 370 sum += UNSAFE.getInt(byteArray, 2776 + BYTE_ARRAY_OFFSET); 371 sum += UNSAFE.getInt(byteArray, 2813 + BYTE_ARRAY_OFFSET); 372 sum += UNSAFE.getInt(byteArray, 2850 + BYTE_ARRAY_OFFSET); 373 sum += UNSAFE.getInt(byteArray, 2887 + BYTE_ARRAY_OFFSET); 374 sum += UNSAFE.getInt(byteArray, 2924 + BYTE_ARRAY_OFFSET); 375 sum += UNSAFE.getInt(byteArray, 2961 + BYTE_ARRAY_OFFSET); 376 sum += UNSAFE.getInt(byteArray, 2998 + BYTE_ARRAY_OFFSET); 377 sum += UNSAFE.getInt(byteArray, 3035 + BYTE_ARRAY_OFFSET); 378 sum += UNSAFE.getInt(byteArray, 3072 + BYTE_ARRAY_OFFSET); 379 sum += UNSAFE.getInt(byteArray, 3109 + BYTE_ARRAY_OFFSET); 380 sum += UNSAFE.getInt(byteArray, 3146 + BYTE_ARRAY_OFFSET); 381 sum += UNSAFE.getInt(byteArray, 3183 + BYTE_ARRAY_OFFSET); 382 sum += UNSAFE.getInt(byteArray, 3220 + BYTE_ARRAY_OFFSET); 383 sum += UNSAFE.getInt(byteArray, 3257 + BYTE_ARRAY_OFFSET); 384 sum += UNSAFE.getInt(byteArray, 3294 + BYTE_ARRAY_OFFSET); 385 sum += UNSAFE.getInt(byteArray, 3331 + BYTE_ARRAY_OFFSET); 386 sum += UNSAFE.getInt(byteArray, 3368 + BYTE_ARRAY_OFFSET); 387 sum += UNSAFE.getInt(byteArray, 3405 + BYTE_ARRAY_OFFSET); 388 sum += UNSAFE.getInt(byteArray, 3442 + BYTE_ARRAY_OFFSET); 389 sum += UNSAFE.getInt(byteArray, 3479 + BYTE_ARRAY_OFFSET); 390 sum += UNSAFE.getInt(byteArray, 3516 + BYTE_ARRAY_OFFSET); 391 sum += UNSAFE.getInt(byteArray, 3553 + BYTE_ARRAY_OFFSET); 392 sum += UNSAFE.getInt(byteArray, 3590 + BYTE_ARRAY_OFFSET); 393 sum += UNSAFE.getInt(byteArray, 3627 + BYTE_ARRAY_OFFSET); 394 sum += UNSAFE.getInt(byteArray, 3664 + BYTE_ARRAY_OFFSET); 395 sum += UNSAFE.getInt(byteArray, 3701 + BYTE_ARRAY_OFFSET); 396 sum += UNSAFE.getInt(byteArray, 3738 + BYTE_ARRAY_OFFSET); 397 sum += UNSAFE.getInt(byteArray, 3775 + BYTE_ARRAY_OFFSET); 398 sum += UNSAFE.getInt(byteArray, 3812 + BYTE_ARRAY_OFFSET); 399 sum += UNSAFE.getInt(byteArray, 3849 + BYTE_ARRAY_OFFSET); 400 sum += UNSAFE.getInt(byteArray, 3886 + BYTE_ARRAY_OFFSET); 401 sum += UNSAFE.getInt(byteArray, 3923 + BYTE_ARRAY_OFFSET); 402 sum += UNSAFE.getInt(byteArray, 3960 + BYTE_ARRAY_OFFSET); 403 sum += UNSAFE.getInt(byteArray, 3997 + BYTE_ARRAY_OFFSET); 404 return sum; 405 } 406 407 @Test testLongs()408 static long testLongs() { 409 long sum = 0; 410 sum += UNSAFE.getLong(byteArray, 1 + BYTE_ARRAY_OFFSET); 411 sum += UNSAFE.getLong(byteArray, 38 + BYTE_ARRAY_OFFSET); 412 sum += UNSAFE.getLong(byteArray, 75 + BYTE_ARRAY_OFFSET); 413 sum += UNSAFE.getLong(byteArray, 112 + BYTE_ARRAY_OFFSET); 414 sum += UNSAFE.getLong(byteArray, 149 + BYTE_ARRAY_OFFSET); 415 sum += UNSAFE.getLong(byteArray, 186 + BYTE_ARRAY_OFFSET); 416 sum += UNSAFE.getLong(byteArray, 223 + BYTE_ARRAY_OFFSET); 417 sum += UNSAFE.getLong(byteArray, 260 + BYTE_ARRAY_OFFSET); 418 sum += UNSAFE.getLong(byteArray, 297 + BYTE_ARRAY_OFFSET); 419 sum += UNSAFE.getLong(byteArray, 334 + BYTE_ARRAY_OFFSET); 420 sum += UNSAFE.getLong(byteArray, 371 + BYTE_ARRAY_OFFSET); 421 sum += UNSAFE.getLong(byteArray, 408 + BYTE_ARRAY_OFFSET); 422 sum += UNSAFE.getLong(byteArray, 445 + BYTE_ARRAY_OFFSET); 423 sum += UNSAFE.getLong(byteArray, 482 + BYTE_ARRAY_OFFSET); 424 sum += UNSAFE.getLong(byteArray, 519 + BYTE_ARRAY_OFFSET); 425 sum += UNSAFE.getLong(byteArray, 556 + BYTE_ARRAY_OFFSET); 426 sum += UNSAFE.getLong(byteArray, 593 + BYTE_ARRAY_OFFSET); 427 sum += UNSAFE.getLong(byteArray, 630 + BYTE_ARRAY_OFFSET); 428 sum += UNSAFE.getLong(byteArray, 667 + BYTE_ARRAY_OFFSET); 429 sum += UNSAFE.getLong(byteArray, 704 + BYTE_ARRAY_OFFSET); 430 sum += UNSAFE.getLong(byteArray, 741 + BYTE_ARRAY_OFFSET); 431 sum += UNSAFE.getLong(byteArray, 778 + BYTE_ARRAY_OFFSET); 432 sum += UNSAFE.getLong(byteArray, 815 + BYTE_ARRAY_OFFSET); 433 sum += UNSAFE.getLong(byteArray, 852 + BYTE_ARRAY_OFFSET); 434 sum += UNSAFE.getLong(byteArray, 889 + BYTE_ARRAY_OFFSET); 435 sum += UNSAFE.getLong(byteArray, 926 + BYTE_ARRAY_OFFSET); 436 sum += UNSAFE.getLong(byteArray, 963 + BYTE_ARRAY_OFFSET); 437 sum += UNSAFE.getLong(byteArray, 1000 + BYTE_ARRAY_OFFSET); 438 sum += UNSAFE.getLong(byteArray, 1037 + BYTE_ARRAY_OFFSET); 439 sum += UNSAFE.getLong(byteArray, 1074 + BYTE_ARRAY_OFFSET); 440 sum += UNSAFE.getLong(byteArray, 1111 + BYTE_ARRAY_OFFSET); 441 sum += UNSAFE.getLong(byteArray, 1148 + BYTE_ARRAY_OFFSET); 442 sum += UNSAFE.getLong(byteArray, 1185 + BYTE_ARRAY_OFFSET); 443 sum += UNSAFE.getLong(byteArray, 1222 + BYTE_ARRAY_OFFSET); 444 sum += UNSAFE.getLong(byteArray, 1259 + BYTE_ARRAY_OFFSET); 445 sum += UNSAFE.getLong(byteArray, 1296 + BYTE_ARRAY_OFFSET); 446 sum += UNSAFE.getLong(byteArray, 1333 + BYTE_ARRAY_OFFSET); 447 sum += UNSAFE.getLong(byteArray, 1370 + BYTE_ARRAY_OFFSET); 448 sum += UNSAFE.getLong(byteArray, 1407 + BYTE_ARRAY_OFFSET); 449 sum += UNSAFE.getLong(byteArray, 1444 + BYTE_ARRAY_OFFSET); 450 sum += UNSAFE.getLong(byteArray, 1481 + BYTE_ARRAY_OFFSET); 451 sum += UNSAFE.getLong(byteArray, 1518 + BYTE_ARRAY_OFFSET); 452 sum += UNSAFE.getLong(byteArray, 1555 + BYTE_ARRAY_OFFSET); 453 sum += UNSAFE.getLong(byteArray, 1592 + BYTE_ARRAY_OFFSET); 454 sum += UNSAFE.getLong(byteArray, 1629 + BYTE_ARRAY_OFFSET); 455 sum += UNSAFE.getLong(byteArray, 1666 + BYTE_ARRAY_OFFSET); 456 sum += UNSAFE.getLong(byteArray, 1703 + BYTE_ARRAY_OFFSET); 457 sum += UNSAFE.getLong(byteArray, 1740 + BYTE_ARRAY_OFFSET); 458 sum += UNSAFE.getLong(byteArray, 1777 + BYTE_ARRAY_OFFSET); 459 sum += UNSAFE.getLong(byteArray, 1814 + BYTE_ARRAY_OFFSET); 460 sum += UNSAFE.getLong(byteArray, 1851 + BYTE_ARRAY_OFFSET); 461 sum += UNSAFE.getLong(byteArray, 1888 + BYTE_ARRAY_OFFSET); 462 sum += UNSAFE.getLong(byteArray, 1925 + BYTE_ARRAY_OFFSET); 463 sum += UNSAFE.getLong(byteArray, 1962 + BYTE_ARRAY_OFFSET); 464 sum += UNSAFE.getLong(byteArray, 1999 + BYTE_ARRAY_OFFSET); 465 sum += UNSAFE.getLong(byteArray, 2036 + BYTE_ARRAY_OFFSET); 466 sum += UNSAFE.getLong(byteArray, 2073 + BYTE_ARRAY_OFFSET); 467 sum += UNSAFE.getLong(byteArray, 2110 + BYTE_ARRAY_OFFSET); 468 sum += UNSAFE.getLong(byteArray, 2147 + BYTE_ARRAY_OFFSET); 469 sum += UNSAFE.getLong(byteArray, 2184 + BYTE_ARRAY_OFFSET); 470 sum += UNSAFE.getLong(byteArray, 2221 + BYTE_ARRAY_OFFSET); 471 sum += UNSAFE.getLong(byteArray, 2258 + BYTE_ARRAY_OFFSET); 472 sum += UNSAFE.getLong(byteArray, 2295 + BYTE_ARRAY_OFFSET); 473 sum += UNSAFE.getLong(byteArray, 2332 + BYTE_ARRAY_OFFSET); 474 sum += UNSAFE.getLong(byteArray, 2369 + BYTE_ARRAY_OFFSET); 475 sum += UNSAFE.getLong(byteArray, 2406 + BYTE_ARRAY_OFFSET); 476 sum += UNSAFE.getLong(byteArray, 2443 + BYTE_ARRAY_OFFSET); 477 sum += UNSAFE.getLong(byteArray, 2480 + BYTE_ARRAY_OFFSET); 478 sum += UNSAFE.getLong(byteArray, 2517 + BYTE_ARRAY_OFFSET); 479 sum += UNSAFE.getLong(byteArray, 2554 + BYTE_ARRAY_OFFSET); 480 sum += UNSAFE.getLong(byteArray, 2591 + BYTE_ARRAY_OFFSET); 481 sum += UNSAFE.getLong(byteArray, 2628 + BYTE_ARRAY_OFFSET); 482 sum += UNSAFE.getLong(byteArray, 2665 + BYTE_ARRAY_OFFSET); 483 sum += UNSAFE.getLong(byteArray, 2702 + BYTE_ARRAY_OFFSET); 484 sum += UNSAFE.getLong(byteArray, 2739 + BYTE_ARRAY_OFFSET); 485 sum += UNSAFE.getLong(byteArray, 2776 + BYTE_ARRAY_OFFSET); 486 sum += UNSAFE.getLong(byteArray, 2813 + BYTE_ARRAY_OFFSET); 487 sum += UNSAFE.getLong(byteArray, 2850 + BYTE_ARRAY_OFFSET); 488 sum += UNSAFE.getLong(byteArray, 2887 + BYTE_ARRAY_OFFSET); 489 sum += UNSAFE.getLong(byteArray, 2924 + BYTE_ARRAY_OFFSET); 490 sum += UNSAFE.getLong(byteArray, 2961 + BYTE_ARRAY_OFFSET); 491 sum += UNSAFE.getLong(byteArray, 2998 + BYTE_ARRAY_OFFSET); 492 sum += UNSAFE.getLong(byteArray, 3035 + BYTE_ARRAY_OFFSET); 493 sum += UNSAFE.getLong(byteArray, 3072 + BYTE_ARRAY_OFFSET); 494 sum += UNSAFE.getLong(byteArray, 3109 + BYTE_ARRAY_OFFSET); 495 sum += UNSAFE.getLong(byteArray, 3146 + BYTE_ARRAY_OFFSET); 496 sum += UNSAFE.getLong(byteArray, 3183 + BYTE_ARRAY_OFFSET); 497 sum += UNSAFE.getLong(byteArray, 3220 + BYTE_ARRAY_OFFSET); 498 sum += UNSAFE.getLong(byteArray, 3257 + BYTE_ARRAY_OFFSET); 499 sum += UNSAFE.getLong(byteArray, 3294 + BYTE_ARRAY_OFFSET); 500 sum += UNSAFE.getLong(byteArray, 3331 + BYTE_ARRAY_OFFSET); 501 sum += UNSAFE.getLong(byteArray, 3368 + BYTE_ARRAY_OFFSET); 502 sum += UNSAFE.getLong(byteArray, 3405 + BYTE_ARRAY_OFFSET); 503 sum += UNSAFE.getLong(byteArray, 3442 + BYTE_ARRAY_OFFSET); 504 sum += UNSAFE.getLong(byteArray, 3479 + BYTE_ARRAY_OFFSET); 505 sum += UNSAFE.getLong(byteArray, 3516 + BYTE_ARRAY_OFFSET); 506 sum += UNSAFE.getLong(byteArray, 3553 + BYTE_ARRAY_OFFSET); 507 sum += UNSAFE.getLong(byteArray, 3590 + BYTE_ARRAY_OFFSET); 508 sum += UNSAFE.getLong(byteArray, 3627 + BYTE_ARRAY_OFFSET); 509 sum += UNSAFE.getLong(byteArray, 3664 + BYTE_ARRAY_OFFSET); 510 sum += UNSAFE.getLong(byteArray, 3701 + BYTE_ARRAY_OFFSET); 511 sum += UNSAFE.getLong(byteArray, 3738 + BYTE_ARRAY_OFFSET); 512 sum += UNSAFE.getLong(byteArray, 3775 + BYTE_ARRAY_OFFSET); 513 sum += UNSAFE.getLong(byteArray, 3812 + BYTE_ARRAY_OFFSET); 514 sum += UNSAFE.getLong(byteArray, 3849 + BYTE_ARRAY_OFFSET); 515 sum += UNSAFE.getLong(byteArray, 3886 + BYTE_ARRAY_OFFSET); 516 sum += UNSAFE.getLong(byteArray, 3923 + BYTE_ARRAY_OFFSET); 517 sum += UNSAFE.getLong(byteArray, 3960 + BYTE_ARRAY_OFFSET); 518 sum += UNSAFE.getLong(byteArray, 3997 + BYTE_ARRAY_OFFSET); 519 return sum; 520 } 521 522 @Test testFloats()523 static long testFloats() { 524 long sum = 0; 525 sum += UNSAFE.getFloat(byteArray, 1 + BYTE_ARRAY_OFFSET); 526 sum += UNSAFE.getFloat(byteArray, 38 + BYTE_ARRAY_OFFSET); 527 sum += UNSAFE.getFloat(byteArray, 75 + BYTE_ARRAY_OFFSET); 528 sum += UNSAFE.getFloat(byteArray, 112 + BYTE_ARRAY_OFFSET); 529 sum += UNSAFE.getFloat(byteArray, 149 + BYTE_ARRAY_OFFSET); 530 sum += UNSAFE.getFloat(byteArray, 186 + BYTE_ARRAY_OFFSET); 531 sum += UNSAFE.getFloat(byteArray, 223 + BYTE_ARRAY_OFFSET); 532 sum += UNSAFE.getFloat(byteArray, 260 + BYTE_ARRAY_OFFSET); 533 sum += UNSAFE.getFloat(byteArray, 297 + BYTE_ARRAY_OFFSET); 534 sum += UNSAFE.getFloat(byteArray, 334 + BYTE_ARRAY_OFFSET); 535 sum += UNSAFE.getFloat(byteArray, 371 + BYTE_ARRAY_OFFSET); 536 sum += UNSAFE.getFloat(byteArray, 408 + BYTE_ARRAY_OFFSET); 537 sum += UNSAFE.getFloat(byteArray, 445 + BYTE_ARRAY_OFFSET); 538 sum += UNSAFE.getFloat(byteArray, 482 + BYTE_ARRAY_OFFSET); 539 sum += UNSAFE.getFloat(byteArray, 519 + BYTE_ARRAY_OFFSET); 540 sum += UNSAFE.getFloat(byteArray, 556 + BYTE_ARRAY_OFFSET); 541 sum += UNSAFE.getFloat(byteArray, 593 + BYTE_ARRAY_OFFSET); 542 sum += UNSAFE.getFloat(byteArray, 630 + BYTE_ARRAY_OFFSET); 543 sum += UNSAFE.getFloat(byteArray, 667 + BYTE_ARRAY_OFFSET); 544 sum += UNSAFE.getFloat(byteArray, 704 + BYTE_ARRAY_OFFSET); 545 sum += UNSAFE.getFloat(byteArray, 741 + BYTE_ARRAY_OFFSET); 546 sum += UNSAFE.getFloat(byteArray, 778 + BYTE_ARRAY_OFFSET); 547 sum += UNSAFE.getFloat(byteArray, 815 + BYTE_ARRAY_OFFSET); 548 sum += UNSAFE.getFloat(byteArray, 852 + BYTE_ARRAY_OFFSET); 549 sum += UNSAFE.getFloat(byteArray, 889 + BYTE_ARRAY_OFFSET); 550 sum += UNSAFE.getFloat(byteArray, 926 + BYTE_ARRAY_OFFSET); 551 sum += UNSAFE.getFloat(byteArray, 963 + BYTE_ARRAY_OFFSET); 552 sum += UNSAFE.getFloat(byteArray, 1000 + BYTE_ARRAY_OFFSET); 553 sum += UNSAFE.getFloat(byteArray, 1037 + BYTE_ARRAY_OFFSET); 554 sum += UNSAFE.getFloat(byteArray, 1074 + BYTE_ARRAY_OFFSET); 555 sum += UNSAFE.getFloat(byteArray, 1111 + BYTE_ARRAY_OFFSET); 556 sum += UNSAFE.getFloat(byteArray, 1148 + BYTE_ARRAY_OFFSET); 557 sum += UNSAFE.getFloat(byteArray, 1185 + BYTE_ARRAY_OFFSET); 558 sum += UNSAFE.getFloat(byteArray, 1222 + BYTE_ARRAY_OFFSET); 559 sum += UNSAFE.getFloat(byteArray, 1259 + BYTE_ARRAY_OFFSET); 560 sum += UNSAFE.getFloat(byteArray, 1296 + BYTE_ARRAY_OFFSET); 561 sum += UNSAFE.getFloat(byteArray, 1333 + BYTE_ARRAY_OFFSET); 562 sum += UNSAFE.getFloat(byteArray, 1370 + BYTE_ARRAY_OFFSET); 563 sum += UNSAFE.getFloat(byteArray, 1407 + BYTE_ARRAY_OFFSET); 564 sum += UNSAFE.getFloat(byteArray, 1444 + BYTE_ARRAY_OFFSET); 565 sum += UNSAFE.getFloat(byteArray, 1481 + BYTE_ARRAY_OFFSET); 566 sum += UNSAFE.getFloat(byteArray, 1518 + BYTE_ARRAY_OFFSET); 567 sum += UNSAFE.getFloat(byteArray, 1555 + BYTE_ARRAY_OFFSET); 568 sum += UNSAFE.getFloat(byteArray, 1592 + BYTE_ARRAY_OFFSET); 569 sum += UNSAFE.getFloat(byteArray, 1629 + BYTE_ARRAY_OFFSET); 570 sum += UNSAFE.getFloat(byteArray, 1666 + BYTE_ARRAY_OFFSET); 571 sum += UNSAFE.getFloat(byteArray, 1703 + BYTE_ARRAY_OFFSET); 572 sum += UNSAFE.getFloat(byteArray, 1740 + BYTE_ARRAY_OFFSET); 573 sum += UNSAFE.getFloat(byteArray, 1777 + BYTE_ARRAY_OFFSET); 574 sum += UNSAFE.getFloat(byteArray, 1814 + BYTE_ARRAY_OFFSET); 575 sum += UNSAFE.getFloat(byteArray, 1851 + BYTE_ARRAY_OFFSET); 576 sum += UNSAFE.getFloat(byteArray, 1888 + BYTE_ARRAY_OFFSET); 577 sum += UNSAFE.getFloat(byteArray, 1925 + BYTE_ARRAY_OFFSET); 578 sum += UNSAFE.getFloat(byteArray, 1962 + BYTE_ARRAY_OFFSET); 579 sum += UNSAFE.getFloat(byteArray, 1999 + BYTE_ARRAY_OFFSET); 580 sum += UNSAFE.getFloat(byteArray, 2036 + BYTE_ARRAY_OFFSET); 581 sum += UNSAFE.getFloat(byteArray, 2073 + BYTE_ARRAY_OFFSET); 582 sum += UNSAFE.getFloat(byteArray, 2110 + BYTE_ARRAY_OFFSET); 583 sum += UNSAFE.getFloat(byteArray, 2147 + BYTE_ARRAY_OFFSET); 584 sum += UNSAFE.getFloat(byteArray, 2184 + BYTE_ARRAY_OFFSET); 585 sum += UNSAFE.getFloat(byteArray, 2221 + BYTE_ARRAY_OFFSET); 586 sum += UNSAFE.getFloat(byteArray, 2258 + BYTE_ARRAY_OFFSET); 587 sum += UNSAFE.getFloat(byteArray, 2295 + BYTE_ARRAY_OFFSET); 588 sum += UNSAFE.getFloat(byteArray, 2332 + BYTE_ARRAY_OFFSET); 589 sum += UNSAFE.getFloat(byteArray, 2369 + BYTE_ARRAY_OFFSET); 590 sum += UNSAFE.getFloat(byteArray, 2406 + BYTE_ARRAY_OFFSET); 591 sum += UNSAFE.getFloat(byteArray, 2443 + BYTE_ARRAY_OFFSET); 592 sum += UNSAFE.getFloat(byteArray, 2480 + BYTE_ARRAY_OFFSET); 593 sum += UNSAFE.getFloat(byteArray, 2517 + BYTE_ARRAY_OFFSET); 594 sum += UNSAFE.getFloat(byteArray, 2554 + BYTE_ARRAY_OFFSET); 595 sum += UNSAFE.getFloat(byteArray, 2591 + BYTE_ARRAY_OFFSET); 596 sum += UNSAFE.getFloat(byteArray, 2628 + BYTE_ARRAY_OFFSET); 597 sum += UNSAFE.getFloat(byteArray, 2665 + BYTE_ARRAY_OFFSET); 598 sum += UNSAFE.getFloat(byteArray, 2702 + BYTE_ARRAY_OFFSET); 599 sum += UNSAFE.getFloat(byteArray, 2739 + BYTE_ARRAY_OFFSET); 600 sum += UNSAFE.getFloat(byteArray, 2776 + BYTE_ARRAY_OFFSET); 601 sum += UNSAFE.getFloat(byteArray, 2813 + BYTE_ARRAY_OFFSET); 602 sum += UNSAFE.getFloat(byteArray, 2850 + BYTE_ARRAY_OFFSET); 603 sum += UNSAFE.getFloat(byteArray, 2887 + BYTE_ARRAY_OFFSET); 604 sum += UNSAFE.getFloat(byteArray, 2924 + BYTE_ARRAY_OFFSET); 605 sum += UNSAFE.getFloat(byteArray, 2961 + BYTE_ARRAY_OFFSET); 606 sum += UNSAFE.getFloat(byteArray, 2998 + BYTE_ARRAY_OFFSET); 607 sum += UNSAFE.getFloat(byteArray, 3035 + BYTE_ARRAY_OFFSET); 608 sum += UNSAFE.getFloat(byteArray, 3072 + BYTE_ARRAY_OFFSET); 609 sum += UNSAFE.getFloat(byteArray, 3109 + BYTE_ARRAY_OFFSET); 610 sum += UNSAFE.getFloat(byteArray, 3146 + BYTE_ARRAY_OFFSET); 611 sum += UNSAFE.getFloat(byteArray, 3183 + BYTE_ARRAY_OFFSET); 612 sum += UNSAFE.getFloat(byteArray, 3220 + BYTE_ARRAY_OFFSET); 613 sum += UNSAFE.getFloat(byteArray, 3257 + BYTE_ARRAY_OFFSET); 614 sum += UNSAFE.getFloat(byteArray, 3294 + BYTE_ARRAY_OFFSET); 615 sum += UNSAFE.getFloat(byteArray, 3331 + BYTE_ARRAY_OFFSET); 616 sum += UNSAFE.getFloat(byteArray, 3368 + BYTE_ARRAY_OFFSET); 617 sum += UNSAFE.getFloat(byteArray, 3405 + BYTE_ARRAY_OFFSET); 618 sum += UNSAFE.getFloat(byteArray, 3442 + BYTE_ARRAY_OFFSET); 619 sum += UNSAFE.getFloat(byteArray, 3479 + BYTE_ARRAY_OFFSET); 620 sum += UNSAFE.getFloat(byteArray, 3516 + BYTE_ARRAY_OFFSET); 621 sum += UNSAFE.getFloat(byteArray, 3553 + BYTE_ARRAY_OFFSET); 622 sum += UNSAFE.getFloat(byteArray, 3590 + BYTE_ARRAY_OFFSET); 623 sum += UNSAFE.getFloat(byteArray, 3627 + BYTE_ARRAY_OFFSET); 624 sum += UNSAFE.getFloat(byteArray, 3664 + BYTE_ARRAY_OFFSET); 625 sum += UNSAFE.getFloat(byteArray, 3701 + BYTE_ARRAY_OFFSET); 626 sum += UNSAFE.getFloat(byteArray, 3738 + BYTE_ARRAY_OFFSET); 627 sum += UNSAFE.getFloat(byteArray, 3775 + BYTE_ARRAY_OFFSET); 628 sum += UNSAFE.getFloat(byteArray, 3812 + BYTE_ARRAY_OFFSET); 629 sum += UNSAFE.getFloat(byteArray, 3849 + BYTE_ARRAY_OFFSET); 630 sum += UNSAFE.getFloat(byteArray, 3886 + BYTE_ARRAY_OFFSET); 631 sum += UNSAFE.getFloat(byteArray, 3923 + BYTE_ARRAY_OFFSET); 632 sum += UNSAFE.getFloat(byteArray, 3960 + BYTE_ARRAY_OFFSET); 633 sum += UNSAFE.getFloat(byteArray, 3997 + BYTE_ARRAY_OFFSET); 634 return sum; 635 } 636 637 @Test testDoubles()638 static long testDoubles() { 639 long sum = 0; 640 sum += UNSAFE.getDouble(byteArray, 1 + BYTE_ARRAY_OFFSET); 641 sum += UNSAFE.getDouble(byteArray, 38 + BYTE_ARRAY_OFFSET); 642 sum += UNSAFE.getDouble(byteArray, 75 + BYTE_ARRAY_OFFSET); 643 sum += UNSAFE.getDouble(byteArray, 112 + BYTE_ARRAY_OFFSET); 644 sum += UNSAFE.getDouble(byteArray, 149 + BYTE_ARRAY_OFFSET); 645 sum += UNSAFE.getDouble(byteArray, 186 + BYTE_ARRAY_OFFSET); 646 sum += UNSAFE.getDouble(byteArray, 223 + BYTE_ARRAY_OFFSET); 647 sum += UNSAFE.getDouble(byteArray, 260 + BYTE_ARRAY_OFFSET); 648 sum += UNSAFE.getDouble(byteArray, 297 + BYTE_ARRAY_OFFSET); 649 sum += UNSAFE.getDouble(byteArray, 334 + BYTE_ARRAY_OFFSET); 650 sum += UNSAFE.getDouble(byteArray, 371 + BYTE_ARRAY_OFFSET); 651 sum += UNSAFE.getDouble(byteArray, 408 + BYTE_ARRAY_OFFSET); 652 sum += UNSAFE.getDouble(byteArray, 445 + BYTE_ARRAY_OFFSET); 653 sum += UNSAFE.getDouble(byteArray, 482 + BYTE_ARRAY_OFFSET); 654 sum += UNSAFE.getDouble(byteArray, 519 + BYTE_ARRAY_OFFSET); 655 sum += UNSAFE.getDouble(byteArray, 556 + BYTE_ARRAY_OFFSET); 656 sum += UNSAFE.getDouble(byteArray, 593 + BYTE_ARRAY_OFFSET); 657 sum += UNSAFE.getDouble(byteArray, 630 + BYTE_ARRAY_OFFSET); 658 sum += UNSAFE.getDouble(byteArray, 667 + BYTE_ARRAY_OFFSET); 659 sum += UNSAFE.getDouble(byteArray, 704 + BYTE_ARRAY_OFFSET); 660 sum += UNSAFE.getDouble(byteArray, 741 + BYTE_ARRAY_OFFSET); 661 sum += UNSAFE.getDouble(byteArray, 778 + BYTE_ARRAY_OFFSET); 662 sum += UNSAFE.getDouble(byteArray, 815 + BYTE_ARRAY_OFFSET); 663 sum += UNSAFE.getDouble(byteArray, 852 + BYTE_ARRAY_OFFSET); 664 sum += UNSAFE.getDouble(byteArray, 889 + BYTE_ARRAY_OFFSET); 665 sum += UNSAFE.getDouble(byteArray, 926 + BYTE_ARRAY_OFFSET); 666 sum += UNSAFE.getDouble(byteArray, 963 + BYTE_ARRAY_OFFSET); 667 sum += UNSAFE.getDouble(byteArray, 1000 + BYTE_ARRAY_OFFSET); 668 sum += UNSAFE.getDouble(byteArray, 1037 + BYTE_ARRAY_OFFSET); 669 sum += UNSAFE.getDouble(byteArray, 1074 + BYTE_ARRAY_OFFSET); 670 sum += UNSAFE.getDouble(byteArray, 1111 + BYTE_ARRAY_OFFSET); 671 sum += UNSAFE.getDouble(byteArray, 1148 + BYTE_ARRAY_OFFSET); 672 sum += UNSAFE.getDouble(byteArray, 1185 + BYTE_ARRAY_OFFSET); 673 sum += UNSAFE.getDouble(byteArray, 1222 + BYTE_ARRAY_OFFSET); 674 sum += UNSAFE.getDouble(byteArray, 1259 + BYTE_ARRAY_OFFSET); 675 sum += UNSAFE.getDouble(byteArray, 1296 + BYTE_ARRAY_OFFSET); 676 sum += UNSAFE.getDouble(byteArray, 1333 + BYTE_ARRAY_OFFSET); 677 sum += UNSAFE.getDouble(byteArray, 1370 + BYTE_ARRAY_OFFSET); 678 sum += UNSAFE.getDouble(byteArray, 1407 + BYTE_ARRAY_OFFSET); 679 sum += UNSAFE.getDouble(byteArray, 1444 + BYTE_ARRAY_OFFSET); 680 sum += UNSAFE.getDouble(byteArray, 1481 + BYTE_ARRAY_OFFSET); 681 sum += UNSAFE.getDouble(byteArray, 1518 + BYTE_ARRAY_OFFSET); 682 sum += UNSAFE.getDouble(byteArray, 1555 + BYTE_ARRAY_OFFSET); 683 sum += UNSAFE.getDouble(byteArray, 1592 + BYTE_ARRAY_OFFSET); 684 sum += UNSAFE.getDouble(byteArray, 1629 + BYTE_ARRAY_OFFSET); 685 sum += UNSAFE.getDouble(byteArray, 1666 + BYTE_ARRAY_OFFSET); 686 sum += UNSAFE.getDouble(byteArray, 1703 + BYTE_ARRAY_OFFSET); 687 sum += UNSAFE.getDouble(byteArray, 1740 + BYTE_ARRAY_OFFSET); 688 sum += UNSAFE.getDouble(byteArray, 1777 + BYTE_ARRAY_OFFSET); 689 sum += UNSAFE.getDouble(byteArray, 1814 + BYTE_ARRAY_OFFSET); 690 sum += UNSAFE.getDouble(byteArray, 1851 + BYTE_ARRAY_OFFSET); 691 sum += UNSAFE.getDouble(byteArray, 1888 + BYTE_ARRAY_OFFSET); 692 sum += UNSAFE.getDouble(byteArray, 1925 + BYTE_ARRAY_OFFSET); 693 sum += UNSAFE.getDouble(byteArray, 1962 + BYTE_ARRAY_OFFSET); 694 sum += UNSAFE.getDouble(byteArray, 1999 + BYTE_ARRAY_OFFSET); 695 sum += UNSAFE.getDouble(byteArray, 2036 + BYTE_ARRAY_OFFSET); 696 sum += UNSAFE.getDouble(byteArray, 2073 + BYTE_ARRAY_OFFSET); 697 sum += UNSAFE.getDouble(byteArray, 2110 + BYTE_ARRAY_OFFSET); 698 sum += UNSAFE.getDouble(byteArray, 2147 + BYTE_ARRAY_OFFSET); 699 sum += UNSAFE.getDouble(byteArray, 2184 + BYTE_ARRAY_OFFSET); 700 sum += UNSAFE.getDouble(byteArray, 2221 + BYTE_ARRAY_OFFSET); 701 sum += UNSAFE.getDouble(byteArray, 2258 + BYTE_ARRAY_OFFSET); 702 sum += UNSAFE.getDouble(byteArray, 2295 + BYTE_ARRAY_OFFSET); 703 sum += UNSAFE.getDouble(byteArray, 2332 + BYTE_ARRAY_OFFSET); 704 sum += UNSAFE.getDouble(byteArray, 2369 + BYTE_ARRAY_OFFSET); 705 sum += UNSAFE.getDouble(byteArray, 2406 + BYTE_ARRAY_OFFSET); 706 sum += UNSAFE.getDouble(byteArray, 2443 + BYTE_ARRAY_OFFSET); 707 sum += UNSAFE.getDouble(byteArray, 2480 + BYTE_ARRAY_OFFSET); 708 sum += UNSAFE.getDouble(byteArray, 2517 + BYTE_ARRAY_OFFSET); 709 sum += UNSAFE.getDouble(byteArray, 2554 + BYTE_ARRAY_OFFSET); 710 sum += UNSAFE.getDouble(byteArray, 2591 + BYTE_ARRAY_OFFSET); 711 sum += UNSAFE.getDouble(byteArray, 2628 + BYTE_ARRAY_OFFSET); 712 sum += UNSAFE.getDouble(byteArray, 2665 + BYTE_ARRAY_OFFSET); 713 sum += UNSAFE.getDouble(byteArray, 2702 + BYTE_ARRAY_OFFSET); 714 sum += UNSAFE.getDouble(byteArray, 2739 + BYTE_ARRAY_OFFSET); 715 sum += UNSAFE.getDouble(byteArray, 2776 + BYTE_ARRAY_OFFSET); 716 sum += UNSAFE.getDouble(byteArray, 2813 + BYTE_ARRAY_OFFSET); 717 sum += UNSAFE.getDouble(byteArray, 2850 + BYTE_ARRAY_OFFSET); 718 sum += UNSAFE.getDouble(byteArray, 2887 + BYTE_ARRAY_OFFSET); 719 sum += UNSAFE.getDouble(byteArray, 2924 + BYTE_ARRAY_OFFSET); 720 sum += UNSAFE.getDouble(byteArray, 2961 + BYTE_ARRAY_OFFSET); 721 sum += UNSAFE.getDouble(byteArray, 2998 + BYTE_ARRAY_OFFSET); 722 sum += UNSAFE.getDouble(byteArray, 3035 + BYTE_ARRAY_OFFSET); 723 sum += UNSAFE.getDouble(byteArray, 3072 + BYTE_ARRAY_OFFSET); 724 sum += UNSAFE.getDouble(byteArray, 3109 + BYTE_ARRAY_OFFSET); 725 sum += UNSAFE.getDouble(byteArray, 3146 + BYTE_ARRAY_OFFSET); 726 sum += UNSAFE.getDouble(byteArray, 3183 + BYTE_ARRAY_OFFSET); 727 sum += UNSAFE.getDouble(byteArray, 3220 + BYTE_ARRAY_OFFSET); 728 sum += UNSAFE.getDouble(byteArray, 3257 + BYTE_ARRAY_OFFSET); 729 sum += UNSAFE.getDouble(byteArray, 3294 + BYTE_ARRAY_OFFSET); 730 sum += UNSAFE.getDouble(byteArray, 3331 + BYTE_ARRAY_OFFSET); 731 sum += UNSAFE.getDouble(byteArray, 3368 + BYTE_ARRAY_OFFSET); 732 sum += UNSAFE.getDouble(byteArray, 3405 + BYTE_ARRAY_OFFSET); 733 sum += UNSAFE.getDouble(byteArray, 3442 + BYTE_ARRAY_OFFSET); 734 sum += UNSAFE.getDouble(byteArray, 3479 + BYTE_ARRAY_OFFSET); 735 sum += UNSAFE.getDouble(byteArray, 3516 + BYTE_ARRAY_OFFSET); 736 sum += UNSAFE.getDouble(byteArray, 3553 + BYTE_ARRAY_OFFSET); 737 sum += UNSAFE.getDouble(byteArray, 3590 + BYTE_ARRAY_OFFSET); 738 sum += UNSAFE.getDouble(byteArray, 3627 + BYTE_ARRAY_OFFSET); 739 sum += UNSAFE.getDouble(byteArray, 3664 + BYTE_ARRAY_OFFSET); 740 sum += UNSAFE.getDouble(byteArray, 3701 + BYTE_ARRAY_OFFSET); 741 sum += UNSAFE.getDouble(byteArray, 3738 + BYTE_ARRAY_OFFSET); 742 sum += UNSAFE.getDouble(byteArray, 3775 + BYTE_ARRAY_OFFSET); 743 sum += UNSAFE.getDouble(byteArray, 3812 + BYTE_ARRAY_OFFSET); 744 sum += UNSAFE.getDouble(byteArray, 3849 + BYTE_ARRAY_OFFSET); 745 sum += UNSAFE.getDouble(byteArray, 3886 + BYTE_ARRAY_OFFSET); 746 sum += UNSAFE.getDouble(byteArray, 3923 + BYTE_ARRAY_OFFSET); 747 sum += UNSAFE.getDouble(byteArray, 3960 + BYTE_ARRAY_OFFSET); 748 sum += UNSAFE.getDouble(byteArray, 3997 + BYTE_ARRAY_OFFSET); 749 return sum; 750 } 751 752 753 static volatile long result; 754 main(String[] args)755 public static void main(String[] args) { 756 for (int i = 0; i < ITERS; i++) { 757 result += testBytes(); 758 result += testShorts(); 759 result += testInts(); 760 result += testLongs(); 761 result += testFloats(); 762 result += testDoubles(); 763 } 764 } 765 } 766 767 768