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