1 /*
2 * Copyright (c) 2015, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package java.lang.invoke;
26
27 import jdk.internal.access.JavaNioAccess;
28 import jdk.internal.access.SharedSecrets;
29 import jdk.internal.misc.Unsafe;
30 import jdk.internal.util.Preconditions;
31 import jdk.internal.vm.annotation.ForceInline;
32
33 import java.nio.ByteBuffer;
34 import java.nio.ReadOnlyBufferException;
35 import java.util.Objects;
36
37 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
38
39 #warn
40
41 final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase {
42
43 static JavaNioAccess nioAccess = SharedSecrets.getJavaNioAccess();
44
45 static final int ALIGN = $BoxType$.BYTES - 1;
46
47 #if[floatingPoint]
48 @ForceInline
49 static $rawType$ convEndian(boolean big, $type$ v) {
50 $rawType$ rv = $Type$.$type$ToRaw$RawType$Bits(v);
51 return big == BE ? rv : $RawBoxType$.reverseBytes(rv);
52 }
53
54 @ForceInline
55 static $type$ convEndian(boolean big, $rawType$ rv) {
56 rv = big == BE ? rv : $RawBoxType$.reverseBytes(rv);
57 return $Type$.$rawType$BitsTo$Type$(rv);
58 }
59 #else[floatingPoint]
60 @ForceInline
61 static $type$ convEndian(boolean big, $type$ n) {
62 return big == BE ? n : $BoxType$.reverseBytes(n);
63 }
64 #end[floatingPoint]
65
66
67 private static abstract class ByteArrayViewVarHandle extends VarHandle {
68 final boolean be;
69
70 ByteArrayViewVarHandle(VarForm form, boolean be) {
71 super(form);
72 this.be = be;
73 }
74 }
75
76 static final class ArrayHandle extends ByteArrayViewVarHandle {
77
78 ArrayHandle(boolean be) {
79 super(ArrayHandle.FORM, be);
80 }
81
82 @Override
83 final MethodType accessModeTypeUncached(AccessMode accessMode) {
84 return accessMode.at.accessModeType(byte[].class, $type$.class, int.class);
85 }
86
87 @ForceInline
88 static int index(byte[] ba, int index) {
89 return Preconditions.checkIndex(index, ba.length - ALIGN, null);
90 }
91
92 @ForceInline
93 static long address(byte[] ba, int index) {
94 long address = ((long) index) + Unsafe.ARRAY_BYTE_BASE_OFFSET;
95 if ((address & ALIGN) != 0)
96 throw newIllegalStateExceptionForMisalignedAccess(index);
97 return address;
98 }
99
100 @ForceInline
101 static $type$ get(ArrayHandle handle, Object oba, int index) {
102 byte[] ba = (byte[]) oba;
103 #if[floatingPoint]
104 $rawType$ rawValue = UNSAFE.get$RawType$Unaligned(
105 ba,
106 ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
107 handle.be);
108 return $Type$.$rawType$BitsTo$Type$(rawValue);
109 #else[floatingPoint]
110 return UNSAFE.get$Type$Unaligned(
111 ba,
112 ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
113 handle.be);
114 #end[floatingPoint]
115 }
116
117 @ForceInline
118 static void set(ArrayHandle handle, Object oba, int index, $type$ value) {
119 byte[] ba = (byte[]) oba;
120 #if[floatingPoint]
121 UNSAFE.put$RawType$Unaligned(
122 ba,
123 ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
124 $Type$.$type$ToRaw$RawType$Bits(value),
125 handle.be);
126 #else[floatingPoint]
127 UNSAFE.put$RawType$Unaligned(
128 ba,
129 ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
130 value,
131 handle.be);
132 #end[floatingPoint]
133 }
134
135 @ForceInline
136 static $type$ getVolatile(ArrayHandle handle, Object oba, int index) {
137 byte[] ba = (byte[]) oba;
138 return convEndian(handle.be,
139 UNSAFE.get$RawType$Volatile(
140 ba,
141 address(ba, index(ba, index))));
142 }
143
144 @ForceInline
145 static void setVolatile(ArrayHandle handle, Object oba, int index, $type$ value) {
146 byte[] ba = (byte[]) oba;
147 UNSAFE.put$RawType$Volatile(
148 ba,
149 address(ba, index(ba, index)),
150 convEndian(handle.be, value));
151 }
152
153 @ForceInline
154 static $type$ getAcquire(ArrayHandle handle, Object oba, int index) {
155 byte[] ba = (byte[]) oba;
156 return convEndian(handle.be,
157 UNSAFE.get$RawType$Acquire(
158 ba,
159 address(ba, index(ba, index))));
160 }
161
162 @ForceInline
163 static void setRelease(ArrayHandle handle, Object oba, int index, $type$ value) {
164 byte[] ba = (byte[]) oba;
165 UNSAFE.put$RawType$Release(
166 ba,
167 address(ba, index(ba, index)),
168 convEndian(handle.be, value));
169 }
170
171 @ForceInline
172 static $type$ getOpaque(ArrayHandle handle, Object oba, int index) {
173 byte[] ba = (byte[]) oba;
174 return convEndian(handle.be,
175 UNSAFE.get$RawType$Opaque(
176 ba,
177 address(ba, index(ba, index))));
178 }
179
180 @ForceInline
181 static void setOpaque(ArrayHandle handle, Object oba, int index, $type$ value) {
182 byte[] ba = (byte[]) oba;
183 UNSAFE.put$RawType$Opaque(
184 ba,
185 address(ba, index(ba, index)),
186 convEndian(handle.be, value));
187 }
188 #if[CAS]
189
190 @ForceInline
191 static boolean compareAndSet(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
192 byte[] ba = (byte[]) oba;
193 #if[Object]
194 return UNSAFE.compareAndSetReference(
195 ba,
196 address(ba, index(ba, index)),
197 convEndian(handle.be, expected), convEndian(handle.be, value));
198 #else[Object]
199 return UNSAFE.compareAndSet$RawType$(
200 ba,
201 address(ba, index(ba, index)),
202 convEndian(handle.be, expected), convEndian(handle.be, value));
203 #end[Object]
204 }
205
206 @ForceInline
207 static $type$ compareAndExchange(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
208 byte[] ba = (byte[]) oba;
209 return convEndian(handle.be,
210 UNSAFE.compareAndExchange$RawType$(
211 ba,
212 address(ba, index(ba, index)),
213 convEndian(handle.be, expected), convEndian(handle.be, value)));
214 }
215
216 @ForceInline
217 static $type$ compareAndExchangeAcquire(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
218 byte[] ba = (byte[]) oba;
219 return convEndian(handle.be,
220 UNSAFE.compareAndExchange$RawType$Acquire(
221 ba,
222 address(ba, index(ba, index)),
223 convEndian(handle.be, expected), convEndian(handle.be, value)));
224 }
225
226 @ForceInline
227 static $type$ compareAndExchangeRelease(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
228 byte[] ba = (byte[]) oba;
229 return convEndian(handle.be,
230 UNSAFE.compareAndExchange$RawType$Release(
231 ba,
232 address(ba, index(ba, index)),
233 convEndian(handle.be, expected), convEndian(handle.be, value)));
234 }
235
236 @ForceInline
237 static boolean weakCompareAndSetPlain(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
238 byte[] ba = (byte[]) oba;
239 return UNSAFE.weakCompareAndSet$RawType$Plain(
240 ba,
241 address(ba, index(ba, index)),
242 convEndian(handle.be, expected), convEndian(handle.be, value));
243 }
244
245 @ForceInline
246 static boolean weakCompareAndSet(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
247 byte[] ba = (byte[]) oba;
248 return UNSAFE.weakCompareAndSet$RawType$(
249 ba,
250 address(ba, index(ba, index)),
251 convEndian(handle.be, expected), convEndian(handle.be, value));
252 }
253
254 @ForceInline
255 static boolean weakCompareAndSetAcquire(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
256 byte[] ba = (byte[]) oba;
257 return UNSAFE.weakCompareAndSet$RawType$Acquire(
258 ba,
259 address(ba, index(ba, index)),
260 convEndian(handle.be, expected), convEndian(handle.be, value));
261 }
262
263 @ForceInline
264 static boolean weakCompareAndSetRelease(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
265 byte[] ba = (byte[]) oba;
266 return UNSAFE.weakCompareAndSet$RawType$Release(
267 ba,
268 address(ba, index(ba, index)),
269 convEndian(handle.be, expected), convEndian(handle.be, value));
270 }
271
272 @ForceInline
273 static $type$ getAndSet(ArrayHandle handle, Object oba, int index, $type$ value) {
274 byte[] ba = (byte[]) oba;
275 #if[Object]
276 return convEndian(handle.be,
277 UNSAFE.getAndSetReference(
278 ba,
279 address(ba, index(ba, index)),
280 convEndian(handle.be, value)));
281 #else[Object]
282 return convEndian(handle.be,
283 UNSAFE.getAndSet$RawType$(
284 ba,
285 address(ba, index(ba, index)),
286 convEndian(handle.be, value)));
287 #end[Object]
288 }
289
290 @ForceInline
291 static $type$ getAndSetAcquire(ArrayHandle handle, Object oba, int index, $type$ value) {
292 byte[] ba = (byte[]) oba;
293 return convEndian(handle.be,
294 UNSAFE.getAndSet$RawType$Acquire(
295 ba,
296 address(ba, index(ba, index)),
297 convEndian(handle.be, value)));
298 }
299
300 @ForceInline
301 static $type$ getAndSetRelease(ArrayHandle handle, Object oba, int index, $type$ value) {
302 byte[] ba = (byte[]) oba;
303 return convEndian(handle.be,
304 UNSAFE.getAndSet$RawType$Release(
305 ba,
306 address(ba, index(ba, index)),
307 convEndian(handle.be, value)));
308 }
309 #end[CAS]
310 #if[AtomicAdd]
311
312 @ForceInline
313 static $type$ getAndAdd(ArrayHandle handle, Object oba, int index, $type$ delta) {
314 byte[] ba = (byte[]) oba;
315 if (handle.be == BE) {
316 return UNSAFE.getAndAdd$RawType$(
317 ba,
318 address(ba, index(ba, index)),
319 delta);
320 } else {
321 return getAndAddConvEndianWithCAS(ba, index, delta);
322 }
323 }
324
325 @ForceInline
326 static $type$ getAndAddAcquire(ArrayHandle handle, Object oba, int index, $type$ delta) {
327 byte[] ba = (byte[]) oba;
328 if (handle.be == BE) {
329 return UNSAFE.getAndAdd$RawType$Acquire(
330 ba,
331 address(ba, index(ba, index)),
332 delta);
333 } else {
334 return getAndAddConvEndianWithCAS(ba, index, delta);
335 }
336 }
337
338 @ForceInline
339 static $type$ getAndAddRelease(ArrayHandle handle, Object oba, int index, $type$ delta) {
340 byte[] ba = (byte[]) oba;
341 if (handle.be == BE) {
342 return UNSAFE.getAndAdd$RawType$Release(
343 ba,
344 address(ba, index(ba, index)),
345 delta);
346 } else {
347 return getAndAddConvEndianWithCAS(ba, index, delta);
348 }
349 }
350
351 @ForceInline
352 static $type$ getAndAddConvEndianWithCAS(byte[] ba, int index, $type$ delta) {
353 $type$ nativeExpectedValue, expectedValue;
354 long offset = address(ba, index(ba, index));
355 do {
356 nativeExpectedValue = UNSAFE.get$RawType$Volatile(ba, offset);
357 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
358 } while (!UNSAFE.weakCompareAndSet$RawType$(ba, offset,
359 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue + delta)));
360 return expectedValue;
361 }
362 #end[AtomicAdd]
363 #if[Bitwise]
364
365 @ForceInline
366 static $type$ getAndBitwiseOr(ArrayHandle handle, Object oba, int index, $type$ value) {
367 byte[] ba = (byte[]) oba;
368 if (handle.be == BE) {
369 return UNSAFE.getAndBitwiseOr$RawType$(
370 ba,
371 address(ba, index(ba, index)),
372 value);
373 } else {
374 return getAndBitwiseOrConvEndianWithCAS(ba, index, value);
375 }
376 }
377
378 @ForceInline
379 static $type$ getAndBitwiseOrRelease(ArrayHandle handle, Object oba, int index, $type$ value) {
380 byte[] ba = (byte[]) oba;
381 if (handle.be == BE) {
382 return UNSAFE.getAndBitwiseOr$RawType$Release(
383 ba,
384 address(ba, index(ba, index)),
385 value);
386 } else {
387 return getAndBitwiseOrConvEndianWithCAS(ba, index, value);
388 }
389 }
390
391 @ForceInline
392 static $type$ getAndBitwiseOrAcquire(ArrayHandle handle, Object oba, int index, $type$ value) {
393 byte[] ba = (byte[]) oba;
394 if (handle.be == BE) {
395 return UNSAFE.getAndBitwiseOr$RawType$Acquire(
396 ba,
397 address(ba, index(ba, index)),
398 value);
399 } else {
400 return getAndBitwiseOrConvEndianWithCAS(ba, index, value);
401 }
402 }
403
404 @ForceInline
405 static $type$ getAndBitwiseOrConvEndianWithCAS(byte[] ba, int index, $type$ value) {
406 $type$ nativeExpectedValue, expectedValue;
407 long offset = address(ba, index(ba, index));
408 do {
409 nativeExpectedValue = UNSAFE.get$RawType$Volatile(ba, offset);
410 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
411 } while (!UNSAFE.weakCompareAndSet$RawType$(ba, offset,
412 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue | value)));
413 return expectedValue;
414 }
415
416 @ForceInline
417 static $type$ getAndBitwiseAnd(ArrayHandle handle, Object oba, int index, $type$ value) {
418 byte[] ba = (byte[]) oba;
419 if (handle.be == BE) {
420 return UNSAFE.getAndBitwiseAnd$RawType$(
421 ba,
422 address(ba, index(ba, index)),
423 value);
424 } else {
425 return getAndBitwiseAndConvEndianWithCAS(ba, index, value);
426 }
427 }
428
429 @ForceInline
430 static $type$ getAndBitwiseAndRelease(ArrayHandle handle, Object oba, int index, $type$ value) {
431 byte[] ba = (byte[]) oba;
432 if (handle.be == BE) {
433 return UNSAFE.getAndBitwiseAnd$RawType$Release(
434 ba,
435 address(ba, index(ba, index)),
436 value);
437 } else {
438 return getAndBitwiseAndConvEndianWithCAS(ba, index, value);
439 }
440 }
441
442 @ForceInline
443 static $type$ getAndBitwiseAndAcquire(ArrayHandle handle, Object oba, int index, $type$ value) {
444 byte[] ba = (byte[]) oba;
445 if (handle.be == BE) {
446 return UNSAFE.getAndBitwiseAnd$RawType$Acquire(
447 ba,
448 address(ba, index(ba, index)),
449 value);
450 } else {
451 return getAndBitwiseAndConvEndianWithCAS(ba, index, value);
452 }
453 }
454
455 @ForceInline
456 static $type$ getAndBitwiseAndConvEndianWithCAS(byte[] ba, int index, $type$ value) {
457 $type$ nativeExpectedValue, expectedValue;
458 long offset = address(ba, index(ba, index));
459 do {
460 nativeExpectedValue = UNSAFE.get$RawType$Volatile(ba, offset);
461 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
462 } while (!UNSAFE.weakCompareAndSet$RawType$(ba, offset,
463 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue & value)));
464 return expectedValue;
465 }
466
467 @ForceInline
468 static $type$ getAndBitwiseXor(ArrayHandle handle, Object oba, int index, $type$ value) {
469 byte[] ba = (byte[]) oba;
470 if (handle.be == BE) {
471 return UNSAFE.getAndBitwiseXor$RawType$(
472 ba,
473 address(ba, index(ba, index)),
474 value);
475 } else {
476 return getAndBitwiseXorConvEndianWithCAS(ba, index, value);
477 }
478 }
479
480 @ForceInline
481 static $type$ getAndBitwiseXorRelease(ArrayHandle handle, Object oba, int index, $type$ value) {
482 byte[] ba = (byte[]) oba;
483 if (handle.be == BE) {
484 return UNSAFE.getAndBitwiseXor$RawType$Release(
485 ba,
486 address(ba, index(ba, index)),
487 value);
488 } else {
489 return getAndBitwiseXorConvEndianWithCAS(ba, index, value);
490 }
491 }
492
493 @ForceInline
494 static $type$ getAndBitwiseXorAcquire(ArrayHandle handle, Object oba, int index, $type$ value) {
495 byte[] ba = (byte[]) oba;
496 if (handle.be == BE) {
497 return UNSAFE.getAndBitwiseXor$RawType$Acquire(
498 ba,
499 address(ba, index(ba, index)),
500 value);
501 } else {
502 return getAndBitwiseXorConvEndianWithCAS(ba, index, value);
503 }
504 }
505
506 @ForceInline
507 static $type$ getAndBitwiseXorConvEndianWithCAS(byte[] ba, int index, $type$ value) {
508 $type$ nativeExpectedValue, expectedValue;
509 long offset = address(ba, index(ba, index));
510 do {
511 nativeExpectedValue = UNSAFE.get$RawType$Volatile(ba, offset);
512 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
513 } while (!UNSAFE.weakCompareAndSet$RawType$(ba, offset,
514 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue ^ value)));
515 return expectedValue;
516 }
517 #end[Bitwise]
518
519 static final VarForm FORM = new VarForm(ArrayHandle.class, byte[].class, $type$.class, int.class);
520 }
521
522
523 static final class ByteBufferHandle extends ByteArrayViewVarHandle {
524
525 ByteBufferHandle(boolean be) {
526 super(ByteBufferHandle.FORM, be);
527 }
528
529 @Override
530 final MethodType accessModeTypeUncached(AccessMode accessMode) {
531 return accessMode.at.accessModeType(ByteBuffer.class, $type$.class, int.class);
532 }
533
534 @ForceInline
535 static int index(ByteBuffer bb, int index) {
536 nioAccess.checkSegment(bb);
537 return Preconditions.checkIndex(index, UNSAFE.getInt(bb, BUFFER_LIMIT) - ALIGN, null);
538 }
539
540 @ForceInline
541 static int indexRO(ByteBuffer bb, int index) {
542 if (UNSAFE.getBoolean(bb, BYTE_BUFFER_IS_READ_ONLY))
543 throw new ReadOnlyBufferException();
544 return index(bb, index);
545 }
546
547 @ForceInline
548 static long address(ByteBuffer bb, int index) {
549 long address = ((long) index) + UNSAFE.getLong(bb, BUFFER_ADDRESS);
550 if ((address & ALIGN) != 0)
551 throw newIllegalStateExceptionForMisalignedAccess(index);
552 return address;
553 }
554
555 @ForceInline
556 static $type$ get(ByteBufferHandle handle, Object obb, int index) {
557 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
558 #if[floatingPoint]
559 $rawType$ rawValue = UNSAFE.get$RawType$Unaligned(
560 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
561 ((long) index(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
562 handle.be);
563 return $Type$.$rawType$BitsTo$Type$(rawValue);
564 #else[floatingPoint]
565 return UNSAFE.get$Type$Unaligned(
566 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
567 ((long) index(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
568 handle.be);
569 #end[floatingPoint]
570 }
571
572 @ForceInline
573 static void set(ByteBufferHandle handle, Object obb, int index, $type$ value) {
574 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
575 #if[floatingPoint]
576 UNSAFE.put$RawType$Unaligned(
577 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
578 ((long) indexRO(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
579 $Type$.$type$ToRaw$RawType$Bits(value),
580 handle.be);
581 #else[floatingPoint]
582 UNSAFE.put$Type$Unaligned(
583 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
584 ((long) indexRO(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
585 value,
586 handle.be);
587 #end[floatingPoint]
588 }
589
590 @ForceInline
591 static $type$ getVolatile(ByteBufferHandle handle, Object obb, int index) {
592 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
593 return convEndian(handle.be,
594 UNSAFE.get$RawType$Volatile(
595 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
596 address(bb, index(bb, index))));
597 }
598
599 @ForceInline
600 static void setVolatile(ByteBufferHandle handle, Object obb, int index, $type$ value) {
601 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
602 UNSAFE.put$RawType$Volatile(
603 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
604 address(bb, indexRO(bb, index)),
605 convEndian(handle.be, value));
606 }
607
608 @ForceInline
609 static $type$ getAcquire(ByteBufferHandle handle, Object obb, int index) {
610 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
611 return convEndian(handle.be,
612 UNSAFE.get$RawType$Acquire(
613 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
614 address(bb, index(bb, index))));
615 }
616
617 @ForceInline
618 static void setRelease(ByteBufferHandle handle, Object obb, int index, $type$ value) {
619 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
620 UNSAFE.put$RawType$Release(
621 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
622 address(bb, indexRO(bb, index)),
623 convEndian(handle.be, value));
624 }
625
626 @ForceInline
627 static $type$ getOpaque(ByteBufferHandle handle, Object obb, int index) {
628 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
629 return convEndian(handle.be,
630 UNSAFE.get$RawType$Opaque(
631 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
632 address(bb, index(bb, index))));
633 }
634
635 @ForceInline
636 static void setOpaque(ByteBufferHandle handle, Object obb, int index, $type$ value) {
637 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
638 UNSAFE.put$RawType$Opaque(
639 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
640 address(bb, indexRO(bb, index)),
641 convEndian(handle.be, value));
642 }
643 #if[CAS]
644
645 @ForceInline
646 static boolean compareAndSet(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
647 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
648 #if[Object]
649 return UNSAFE.compareAndSetReference(
650 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
651 address(bb, indexRO(bb, index)),
652 convEndian(handle.be, expected), convEndian(handle.be, value));
653 #else[Object]
654 return UNSAFE.compareAndSet$RawType$(
655 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
656 address(bb, indexRO(bb, index)),
657 convEndian(handle.be, expected), convEndian(handle.be, value));
658 #end[Object]
659 }
660
661 @ForceInline
662 static $type$ compareAndExchange(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
663 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
664 return convEndian(handle.be,
665 UNSAFE.compareAndExchange$RawType$(
666 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
667 address(bb, indexRO(bb, index)),
668 convEndian(handle.be, expected), convEndian(handle.be, value)));
669 }
670
671 @ForceInline
672 static $type$ compareAndExchangeAcquire(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
673 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
674 return convEndian(handle.be,
675 UNSAFE.compareAndExchange$RawType$Acquire(
676 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
677 address(bb, indexRO(bb, index)),
678 convEndian(handle.be, expected), convEndian(handle.be, value)));
679 }
680
681 @ForceInline
682 static $type$ compareAndExchangeRelease(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
683 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
684 return convEndian(handle.be,
685 UNSAFE.compareAndExchange$RawType$Release(
686 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
687 address(bb, indexRO(bb, index)),
688 convEndian(handle.be, expected), convEndian(handle.be, value)));
689 }
690
691 @ForceInline
692 static boolean weakCompareAndSetPlain(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
693 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
694 return UNSAFE.weakCompareAndSet$RawType$Plain(
695 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
696 address(bb, indexRO(bb, index)),
697 convEndian(handle.be, expected), convEndian(handle.be, value));
698 }
699
700 @ForceInline
701 static boolean weakCompareAndSet(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
702 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
703 return UNSAFE.weakCompareAndSet$RawType$(
704 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
705 address(bb, indexRO(bb, index)),
706 convEndian(handle.be, expected), convEndian(handle.be, value));
707 }
708
709 @ForceInline
710 static boolean weakCompareAndSetAcquire(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
711 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
712 return UNSAFE.weakCompareAndSet$RawType$Acquire(
713 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
714 address(bb, indexRO(bb, index)),
715 convEndian(handle.be, expected), convEndian(handle.be, value));
716 }
717
718 @ForceInline
719 static boolean weakCompareAndSetRelease(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
720 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
721 return UNSAFE.weakCompareAndSet$RawType$Release(
722 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
723 address(bb, indexRO(bb, index)),
724 convEndian(handle.be, expected), convEndian(handle.be, value));
725 }
726
727 @ForceInline
728 static $type$ getAndSet(ByteBufferHandle handle, Object obb, int index, $type$ value) {
729 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
730 #if[Object]
731 return convEndian(handle.be,
732 UNSAFE.getAndSetReference(
733 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
734 address(bb, indexRO(bb, index)),
735 convEndian(handle.be, value)));
736 #else[Object]
737 return convEndian(handle.be,
738 UNSAFE.getAndSet$RawType$(
739 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
740 address(bb, indexRO(bb, index)),
741 convEndian(handle.be, value)));
742 #end[Object]
743 }
744
745 @ForceInline
746 static $type$ getAndSetAcquire(ByteBufferHandle handle, Object obb, int index, $type$ value) {
747 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
748 return convEndian(handle.be,
749 UNSAFE.getAndSet$RawType$Acquire(
750 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
751 address(bb, indexRO(bb, index)),
752 convEndian(handle.be, value)));
753 }
754
755 @ForceInline
756 static $type$ getAndSetRelease(ByteBufferHandle handle, Object obb, int index, $type$ value) {
757 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
758 return convEndian(handle.be,
759 UNSAFE.getAndSet$RawType$Release(
760 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
761 address(bb, indexRO(bb, index)),
762 convEndian(handle.be, value)));
763 }
764 #end[CAS]
765 #if[AtomicAdd]
766
767 @ForceInline
768 static $type$ getAndAdd(ByteBufferHandle handle, Object obb, int index, $type$ delta) {
769 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
770 if (handle.be == BE) {
771 return UNSAFE.getAndAdd$RawType$(
772 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
773 address(bb, indexRO(bb, index)),
774 delta);
775 } else {
776 return getAndAddConvEndianWithCAS(bb, index, delta);
777 }
778 }
779
780 @ForceInline
781 static $type$ getAndAddAcquire(ByteBufferHandle handle, Object obb, int index, $type$ delta) {
782 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
783 if (handle.be == BE) {
784 return UNSAFE.getAndAdd$RawType$Acquire(
785 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
786 address(bb, indexRO(bb, index)),
787 delta);
788 } else {
789 return getAndAddConvEndianWithCAS(bb, index, delta);
790 }
791 }
792
793 @ForceInline
794 static $type$ getAndAddRelease(ByteBufferHandle handle, Object obb, int index, $type$ delta) {
795 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
796 if (handle.be == BE) {
797 return UNSAFE.getAndAdd$RawType$Release(
798 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
799 address(bb, indexRO(bb, index)),
800 delta);
801 } else {
802 return getAndAddConvEndianWithCAS(bb, index, delta);
803 }
804 }
805
806 @ForceInline
807 static $type$ getAndAddConvEndianWithCAS(ByteBuffer bb, int index, $type$ delta) {
808 $type$ nativeExpectedValue, expectedValue;
809 Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB);
810 long offset = address(bb, indexRO(bb, index));
811 do {
812 nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset);
813 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
814 } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset,
815 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue + delta)));
816 return expectedValue;
817 }
818 #end[AtomicAdd]
819 #if[Bitwise]
820
821 @ForceInline
822 static $type$ getAndBitwiseOr(ByteBufferHandle handle, Object obb, int index, $type$ value) {
823 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
824 if (handle.be == BE) {
825 return UNSAFE.getAndBitwiseOr$RawType$(
826 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
827 address(bb, indexRO(bb, index)),
828 value);
829 } else {
830 return getAndBitwiseOrConvEndianWithCAS(bb, index, value);
831 }
832 }
833
834 @ForceInline
835 static $type$ getAndBitwiseOrRelease(ByteBufferHandle handle, Object obb, int index, $type$ value) {
836 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
837 if (handle.be == BE) {
838 return UNSAFE.getAndBitwiseOr$RawType$Release(
839 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
840 address(bb, indexRO(bb, index)),
841 value);
842 } else {
843 return getAndBitwiseOrConvEndianWithCAS(bb, index, value);
844 }
845 }
846
847 @ForceInline
848 static $type$ getAndBitwiseOrAcquire(ByteBufferHandle handle, Object obb, int index, $type$ value) {
849 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
850 if (handle.be == BE) {
851 return UNSAFE.getAndBitwiseOr$RawType$Acquire(
852 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
853 address(bb, indexRO(bb, index)),
854 value);
855 } else {
856 return getAndBitwiseOrConvEndianWithCAS(bb, index, value);
857 }
858 }
859
860 @ForceInline
861 static $type$ getAndBitwiseOrConvEndianWithCAS(ByteBuffer bb, int index, $type$ value) {
862 $type$ nativeExpectedValue, expectedValue;
863 Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB);
864 long offset = address(bb, indexRO(bb, index));
865 do {
866 nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset);
867 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
868 } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset,
869 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue | value)));
870 return expectedValue;
871 }
872
873 @ForceInline
874 static $type$ getAndBitwiseAnd(ByteBufferHandle handle, Object obb, int index, $type$ value) {
875 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
876 if (handle.be == BE) {
877 return UNSAFE.getAndBitwiseAnd$RawType$(
878 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
879 address(bb, indexRO(bb, index)),
880 value);
881 } else {
882 return getAndBitwiseAndConvEndianWithCAS(bb, index, value);
883 }
884 }
885
886 @ForceInline
887 static $type$ getAndBitwiseAndRelease(ByteBufferHandle handle, Object obb, int index, $type$ value) {
888 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
889 if (handle.be == BE) {
890 return UNSAFE.getAndBitwiseAnd$RawType$Release(
891 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
892 address(bb, indexRO(bb, index)),
893 value);
894 } else {
895 return getAndBitwiseAndConvEndianWithCAS(bb, index, value);
896 }
897 }
898
899 @ForceInline
900 static $type$ getAndBitwiseAndAcquire(ByteBufferHandle handle, Object obb, int index, $type$ value) {
901 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
902 if (handle.be == BE) {
903 return UNSAFE.getAndBitwiseAnd$RawType$Acquire(
904 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
905 address(bb, indexRO(bb, index)),
906 value);
907 } else {
908 return getAndBitwiseAndConvEndianWithCAS(bb, index, value);
909 }
910 }
911
912 @ForceInline
913 static $type$ getAndBitwiseAndConvEndianWithCAS(ByteBuffer bb, int index, $type$ value) {
914 $type$ nativeExpectedValue, expectedValue;
915 Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB);
916 long offset = address(bb, indexRO(bb, index));
917 do {
918 nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset);
919 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
920 } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset,
921 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue & value)));
922 return expectedValue;
923 }
924
925
926 @ForceInline
927 static $type$ getAndBitwiseXor(ByteBufferHandle handle, Object obb, int index, $type$ value) {
928 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
929 if (handle.be == BE) {
930 return UNSAFE.getAndBitwiseXor$RawType$(
931 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
932 address(bb, indexRO(bb, index)),
933 value);
934 } else {
935 return getAndBitwiseXorConvEndianWithCAS(bb, index, value);
936 }
937 }
938
939 @ForceInline
940 static $type$ getAndBitwiseXorRelease(ByteBufferHandle handle, Object obb, int index, $type$ value) {
941 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
942 if (handle.be == BE) {
943 return UNSAFE.getAndBitwiseXor$RawType$Release(
944 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
945 address(bb, indexRO(bb, index)),
946 value);
947 } else {
948 return getAndBitwiseXorConvEndianWithCAS(bb, index, value);
949 }
950 }
951
952 @ForceInline
953 static $type$ getAndBitwiseXorAcquire(ByteBufferHandle handle, Object obb, int index, $type$ value) {
954 ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb);
955 if (handle.be == BE) {
956 return UNSAFE.getAndBitwiseXor$RawType$Acquire(
957 UNSAFE.getReference(bb, BYTE_BUFFER_HB),
958 address(bb, indexRO(bb, index)),
959 value);
960 } else {
961 return getAndBitwiseXorConvEndianWithCAS(bb, index, value);
962 }
963 }
964
965 @ForceInline
966 static $type$ getAndBitwiseXorConvEndianWithCAS(ByteBuffer bb, int index, $type$ value) {
967 $type$ nativeExpectedValue, expectedValue;
968 Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB);
969 long offset = address(bb, indexRO(bb, index));
970 do {
971 nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset);
972 expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue);
973 } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset,
974 nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue ^ value)));
975 return expectedValue;
976 }
977 #end[Bitwise]
978
979 static final VarForm FORM = new VarForm(ByteBufferHandle.class, ByteBuffer.class, $type$.class, int.class);
980 }
981 }