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 */
25 package java.lang.invoke;
26
27 import jdk.internal.util.Preconditions;
28 import jdk.internal.vm.annotation.ForceInline;
29
30 import java.util.Objects;
31
32 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
33
34 #warn
35
36 final class VarHandle$Type$s {
37
38 static class FieldInstanceReadOnly extends VarHandle {
39 final long fieldOffset;
40 final Class<?> receiverType;
41 #if[Object]
42 final Class<?> fieldType;
43 #end[Object]
44
45 FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
46 this(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadOnly.FORM);
47 }
48
49 protected FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType},
50 VarForm form) {
51 super(form);
52 this.fieldOffset = fieldOffset;
53 this.receiverType = receiverType;
54 #if[Object]
55 this.fieldType = fieldType;
56 #end[Object]
57 }
58
59 @Override
60 final MethodType accessModeTypeUncached(AccessMode accessMode) {
61 return accessMode.at.accessModeType(receiverType, {#if[Object]?fieldType:$type$.class});
62 }
63
64 @ForceInline
65 static $type$ get(FieldInstanceReadOnly handle, Object holder) {
66 return UNSAFE.get$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
67 handle.fieldOffset);
68 }
69
70 @ForceInline
71 static $type$ getVolatile(FieldInstanceReadOnly handle, Object holder) {
72 return UNSAFE.get$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
73 handle.fieldOffset);
74 }
75
76 @ForceInline
77 static $type$ getOpaque(FieldInstanceReadOnly handle, Object holder) {
78 return UNSAFE.get$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
79 handle.fieldOffset);
80 }
81
82 @ForceInline
83 static $type$ getAcquire(FieldInstanceReadOnly handle, Object holder) {
84 return UNSAFE.get$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
85 handle.fieldOffset);
86 }
87
88 static final VarForm FORM = new VarForm(FieldInstanceReadOnly.class, Object.class, $type$.class);
89 }
90
91 static final class FieldInstanceReadWrite extends FieldInstanceReadOnly {
92
93 FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
94 super(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadWrite.FORM);
95 }
96
97 @ForceInline
98 static void set(FieldInstanceReadWrite handle, Object holder, $type$ value) {
99 UNSAFE.put$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
100 handle.fieldOffset,
101 {#if[Object]?handle.fieldType.cast(value):value});
102 }
103
104 @ForceInline
105 static void setVolatile(FieldInstanceReadWrite handle, Object holder, $type$ value) {
106 UNSAFE.put$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
107 handle.fieldOffset,
108 {#if[Object]?handle.fieldType.cast(value):value});
109 }
110
111 @ForceInline
112 static void setOpaque(FieldInstanceReadWrite handle, Object holder, $type$ value) {
113 UNSAFE.put$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
114 handle.fieldOffset,
115 {#if[Object]?handle.fieldType.cast(value):value});
116 }
117
118 @ForceInline
119 static void setRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
120 UNSAFE.put$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
121 handle.fieldOffset,
122 {#if[Object]?handle.fieldType.cast(value):value});
123 }
124 #if[CAS]
125
126 @ForceInline
127 static boolean compareAndSet(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
128 return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
129 handle.fieldOffset,
130 {#if[Object]?handle.fieldType.cast(expected):expected},
131 {#if[Object]?handle.fieldType.cast(value):value});
132 }
133
134 @ForceInline
135 static $type$ compareAndExchange(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
136 return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
137 handle.fieldOffset,
138 {#if[Object]?handle.fieldType.cast(expected):expected},
139 {#if[Object]?handle.fieldType.cast(value):value});
140 }
141
142 @ForceInline
143 static $type$ compareAndExchangeAcquire(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
144 return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
145 handle.fieldOffset,
146 {#if[Object]?handle.fieldType.cast(expected):expected},
147 {#if[Object]?handle.fieldType.cast(value):value});
148 }
149
150 @ForceInline
151 static $type$ compareAndExchangeRelease(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
152 return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
153 handle.fieldOffset,
154 {#if[Object]?handle.fieldType.cast(expected):expected},
155 {#if[Object]?handle.fieldType.cast(value):value});
156 }
157
158 @ForceInline
159 static boolean weakCompareAndSetPlain(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
160 return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
161 handle.fieldOffset,
162 {#if[Object]?handle.fieldType.cast(expected):expected},
163 {#if[Object]?handle.fieldType.cast(value):value});
164 }
165
166 @ForceInline
167 static boolean weakCompareAndSet(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
168 return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
169 handle.fieldOffset,
170 {#if[Object]?handle.fieldType.cast(expected):expected},
171 {#if[Object]?handle.fieldType.cast(value):value});
172 }
173
174 @ForceInline
175 static boolean weakCompareAndSetAcquire(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
176 return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
177 handle.fieldOffset,
178 {#if[Object]?handle.fieldType.cast(expected):expected},
179 {#if[Object]?handle.fieldType.cast(value):value});
180 }
181
182 @ForceInline
183 static boolean weakCompareAndSetRelease(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
184 return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
185 handle.fieldOffset,
186 {#if[Object]?handle.fieldType.cast(expected):expected},
187 {#if[Object]?handle.fieldType.cast(value):value});
188 }
189
190 @ForceInline
191 static $type$ getAndSet(FieldInstanceReadWrite handle, Object holder, $type$ value) {
192 return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
193 handle.fieldOffset,
194 {#if[Object]?handle.fieldType.cast(value):value});
195 }
196
197 @ForceInline
198 static $type$ getAndSetAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
199 return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
200 handle.fieldOffset,
201 {#if[Object]?handle.fieldType.cast(value):value});
202 }
203
204 @ForceInline
205 static $type$ getAndSetRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
206 return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
207 handle.fieldOffset,
208 {#if[Object]?handle.fieldType.cast(value):value});
209 }
210 #end[CAS]
211 #if[AtomicAdd]
212
213 @ForceInline
214 static $type$ getAndAdd(FieldInstanceReadWrite handle, Object holder, $type$ value) {
215 return UNSAFE.getAndAdd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
216 handle.fieldOffset,
217 value);
218 }
219
220 @ForceInline
221 static $type$ getAndAddAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
222 return UNSAFE.getAndAdd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
223 handle.fieldOffset,
224 value);
225 }
226
227 @ForceInline
228 static $type$ getAndAddRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
229 return UNSAFE.getAndAdd$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
230 handle.fieldOffset,
231 value);
232 }
233
234 #end[AtomicAdd]
235 #if[Bitwise]
236
237 @ForceInline
238 static $type$ getAndBitwiseOr(FieldInstanceReadWrite handle, Object holder, $type$ value) {
239 return UNSAFE.getAndBitwiseOr$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
240 handle.fieldOffset,
241 value);
242 }
243
244 @ForceInline
245 static $type$ getAndBitwiseOrRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
246 return UNSAFE.getAndBitwiseOr$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
247 handle.fieldOffset,
248 value);
249 }
250
251 @ForceInline
252 static $type$ getAndBitwiseOrAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
253 return UNSAFE.getAndBitwiseOr$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
254 handle.fieldOffset,
255 value);
256 }
257
258 @ForceInline
259 static $type$ getAndBitwiseAnd(FieldInstanceReadWrite handle, Object holder, $type$ value) {
260 return UNSAFE.getAndBitwiseAnd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
261 handle.fieldOffset,
262 value);
263 }
264
265 @ForceInline
266 static $type$ getAndBitwiseAndRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
267 return UNSAFE.getAndBitwiseAnd$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
268 handle.fieldOffset,
269 value);
270 }
271
272 @ForceInline
273 static $type$ getAndBitwiseAndAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
274 return UNSAFE.getAndBitwiseAnd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
275 handle.fieldOffset,
276 value);
277 }
278
279 @ForceInline
280 static $type$ getAndBitwiseXor(FieldInstanceReadWrite handle, Object holder, $type$ value) {
281 return UNSAFE.getAndBitwiseXor$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
282 handle.fieldOffset,
283 value);
284 }
285
286 @ForceInline
287 static $type$ getAndBitwiseXorRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
288 return UNSAFE.getAndBitwiseXor$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
289 handle.fieldOffset,
290 value);
291 }
292
293 @ForceInline
294 static $type$ getAndBitwiseXorAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
295 return UNSAFE.getAndBitwiseXor$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
296 handle.fieldOffset,
297 value);
298 }
299 #end[Bitwise]
300
301 static final VarForm FORM = new VarForm(FieldInstanceReadWrite.class, Object.class, $type$.class);
302 }
303
304
305 static class FieldStaticReadOnly extends VarHandle {
306 final Object base;
307 final long fieldOffset;
308 #if[Object]
309 final Class<?> fieldType;
310 #end[Object]
311
312 FieldStaticReadOnly(Object base, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
313 this(base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadOnly.FORM);
314 }
315
316 protected FieldStaticReadOnly(Object base, long fieldOffset{#if[Object]?, Class<?> fieldType},
317 VarForm form) {
318 super(form);
319 this.base = base;
320 this.fieldOffset = fieldOffset;
321 #if[Object]
322 this.fieldType = fieldType;
323 #end[Object]
324 }
325
326 @Override
327 final MethodType accessModeTypeUncached(AccessMode accessMode) {
328 return accessMode.at.accessModeType(null, {#if[Object]?fieldType:$type$.class});
329 }
330
331 @ForceInline
332 static $type$ get(FieldStaticReadOnly handle) {
333 return UNSAFE.get$Type$(handle.base,
334 handle.fieldOffset);
335 }
336
337 @ForceInline
338 static $type$ getVolatile(FieldStaticReadOnly handle) {
339 return UNSAFE.get$Type$Volatile(handle.base,
340 handle.fieldOffset);
341 }
342
343 @ForceInline
344 static $type$ getOpaque(FieldStaticReadOnly handle) {
345 return UNSAFE.get$Type$Opaque(handle.base,
346 handle.fieldOffset);
347 }
348
349 @ForceInline
350 static $type$ getAcquire(FieldStaticReadOnly handle) {
351 return UNSAFE.get$Type$Acquire(handle.base,
352 handle.fieldOffset);
353 }
354
355 static final VarForm FORM = new VarForm(FieldStaticReadOnly.class, null, $type$.class);
356 }
357
358 static final class FieldStaticReadWrite extends FieldStaticReadOnly {
359
360 FieldStaticReadWrite(Object base, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
361 super(base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadWrite.FORM);
362 }
363
364 @ForceInline
365 static void set(FieldStaticReadWrite handle, $type$ value) {
366 UNSAFE.put$Type$(handle.base,
367 handle.fieldOffset,
368 {#if[Object]?handle.fieldType.cast(value):value});
369 }
370
371 @ForceInline
372 static void setVolatile(FieldStaticReadWrite handle, $type$ value) {
373 UNSAFE.put$Type$Volatile(handle.base,
374 handle.fieldOffset,
375 {#if[Object]?handle.fieldType.cast(value):value});
376 }
377
378 @ForceInline
379 static void setOpaque(FieldStaticReadWrite handle, $type$ value) {
380 UNSAFE.put$Type$Opaque(handle.base,
381 handle.fieldOffset,
382 {#if[Object]?handle.fieldType.cast(value):value});
383 }
384
385 @ForceInline
386 static void setRelease(FieldStaticReadWrite handle, $type$ value) {
387 UNSAFE.put$Type$Release(handle.base,
388 handle.fieldOffset,
389 {#if[Object]?handle.fieldType.cast(value):value});
390 }
391 #if[CAS]
392
393 @ForceInline
394 static boolean compareAndSet(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
395 return UNSAFE.compareAndSet$Type$(handle.base,
396 handle.fieldOffset,
397 {#if[Object]?handle.fieldType.cast(expected):expected},
398 {#if[Object]?handle.fieldType.cast(value):value});
399 }
400
401
402 @ForceInline
403 static $type$ compareAndExchange(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
404 return UNSAFE.compareAndExchange$Type$(handle.base,
405 handle.fieldOffset,
406 {#if[Object]?handle.fieldType.cast(expected):expected},
407 {#if[Object]?handle.fieldType.cast(value):value});
408 }
409
410 @ForceInline
411 static $type$ compareAndExchangeAcquire(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
412 return UNSAFE.compareAndExchange$Type$Acquire(handle.base,
413 handle.fieldOffset,
414 {#if[Object]?handle.fieldType.cast(expected):expected},
415 {#if[Object]?handle.fieldType.cast(value):value});
416 }
417
418 @ForceInline
419 static $type$ compareAndExchangeRelease(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
420 return UNSAFE.compareAndExchange$Type$Release(handle.base,
421 handle.fieldOffset,
422 {#if[Object]?handle.fieldType.cast(expected):expected},
423 {#if[Object]?handle.fieldType.cast(value):value});
424 }
425
426 @ForceInline
427 static boolean weakCompareAndSetPlain(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
428 return UNSAFE.weakCompareAndSet$Type$Plain(handle.base,
429 handle.fieldOffset,
430 {#if[Object]?handle.fieldType.cast(expected):expected},
431 {#if[Object]?handle.fieldType.cast(value):value});
432 }
433
434 @ForceInline
435 static boolean weakCompareAndSet(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
436 return UNSAFE.weakCompareAndSet$Type$(handle.base,
437 handle.fieldOffset,
438 {#if[Object]?handle.fieldType.cast(expected):expected},
439 {#if[Object]?handle.fieldType.cast(value):value});
440 }
441
442 @ForceInline
443 static boolean weakCompareAndSetAcquire(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
444 return UNSAFE.weakCompareAndSet$Type$Acquire(handle.base,
445 handle.fieldOffset,
446 {#if[Object]?handle.fieldType.cast(expected):expected},
447 {#if[Object]?handle.fieldType.cast(value):value});
448 }
449
450 @ForceInline
451 static boolean weakCompareAndSetRelease(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
452 return UNSAFE.weakCompareAndSet$Type$Release(handle.base,
453 handle.fieldOffset,
454 {#if[Object]?handle.fieldType.cast(expected):expected},
455 {#if[Object]?handle.fieldType.cast(value):value});
456 }
457
458 @ForceInline
459 static $type$ getAndSet(FieldStaticReadWrite handle, $type$ value) {
460 return UNSAFE.getAndSet$Type$(handle.base,
461 handle.fieldOffset,
462 {#if[Object]?handle.fieldType.cast(value):value});
463 }
464
465 @ForceInline
466 static $type$ getAndSetAcquire(FieldStaticReadWrite handle, $type$ value) {
467 return UNSAFE.getAndSet$Type$Acquire(handle.base,
468 handle.fieldOffset,
469 {#if[Object]?handle.fieldType.cast(value):value});
470 }
471
472 @ForceInline
473 static $type$ getAndSetRelease(FieldStaticReadWrite handle, $type$ value) {
474 return UNSAFE.getAndSet$Type$Release(handle.base,
475 handle.fieldOffset,
476 {#if[Object]?handle.fieldType.cast(value):value});
477 }
478 #end[CAS]
479 #if[AtomicAdd]
480
481 @ForceInline
482 static $type$ getAndAdd(FieldStaticReadWrite handle, $type$ value) {
483 return UNSAFE.getAndAdd$Type$(handle.base,
484 handle.fieldOffset,
485 value);
486 }
487
488 @ForceInline
489 static $type$ getAndAddAcquire(FieldStaticReadWrite handle, $type$ value) {
490 return UNSAFE.getAndAdd$Type$Acquire(handle.base,
491 handle.fieldOffset,
492 value);
493 }
494
495 @ForceInline
496 static $type$ getAndAddRelease(FieldStaticReadWrite handle, $type$ value) {
497 return UNSAFE.getAndAdd$Type$Release(handle.base,
498 handle.fieldOffset,
499 value);
500 }
501 #end[AtomicAdd]
502 #if[Bitwise]
503
504 @ForceInline
505 static $type$ getAndBitwiseOr(FieldStaticReadWrite handle, $type$ value) {
506 return UNSAFE.getAndBitwiseOr$Type$(handle.base,
507 handle.fieldOffset,
508 value);
509 }
510
511 @ForceInline
512 static $type$ getAndBitwiseOrRelease(FieldStaticReadWrite handle, $type$ value) {
513 return UNSAFE.getAndBitwiseOr$Type$Release(handle.base,
514 handle.fieldOffset,
515 value);
516 }
517
518 @ForceInline
519 static $type$ getAndBitwiseOrAcquire(FieldStaticReadWrite handle, $type$ value) {
520 return UNSAFE.getAndBitwiseOr$Type$Acquire(handle.base,
521 handle.fieldOffset,
522 value);
523 }
524
525 @ForceInline
526 static $type$ getAndBitwiseAnd(FieldStaticReadWrite handle, $type$ value) {
527 return UNSAFE.getAndBitwiseAnd$Type$(handle.base,
528 handle.fieldOffset,
529 value);
530 }
531
532 @ForceInline
533 static $type$ getAndBitwiseAndRelease(FieldStaticReadWrite handle, $type$ value) {
534 return UNSAFE.getAndBitwiseAnd$Type$Release(handle.base,
535 handle.fieldOffset,
536 value);
537 }
538
539 @ForceInline
540 static $type$ getAndBitwiseAndAcquire(FieldStaticReadWrite handle, $type$ value) {
541 return UNSAFE.getAndBitwiseAnd$Type$Acquire(handle.base,
542 handle.fieldOffset,
543 value);
544 }
545
546 @ForceInline
547 static $type$ getAndBitwiseXor(FieldStaticReadWrite handle, $type$ value) {
548 return UNSAFE.getAndBitwiseXor$Type$(handle.base,
549 handle.fieldOffset,
550 value);
551 }
552
553 @ForceInline
554 static $type$ getAndBitwiseXorRelease(FieldStaticReadWrite handle, $type$ value) {
555 return UNSAFE.getAndBitwiseXor$Type$Release(handle.base,
556 handle.fieldOffset,
557 value);
558 }
559
560 @ForceInline
561 static $type$ getAndBitwiseXorAcquire(FieldStaticReadWrite handle, $type$ value) {
562 return UNSAFE.getAndBitwiseXor$Type$Acquire(handle.base,
563 handle.fieldOffset,
564 value);
565 }
566 #end[Bitwise]
567
568 static final VarForm FORM = new VarForm(FieldStaticReadWrite.class, null, $type$.class);
569 }
570
571 #if[Object]
572 static class ValueFieldInstanceReadOnly extends VarHandle {
573 final long fieldOffset;
574 final Class<?> receiverType;
575 final Class<?> fieldType;
576
577 ValueFieldInstanceReadOnly(Class<?> receiverType, long fieldOffset, Class<?> fieldType) {
578 this(receiverType, fieldOffset, fieldType, ValueFieldInstanceReadOnly.FORM);
579 }
580
581 protected ValueFieldInstanceReadOnly(Class<?> receiverType, long fieldOffset, Class<?> fieldType,
582 VarForm form) {
583 super(form);
584 this.fieldOffset = fieldOffset;
585 this.receiverType = receiverType;
586 this.fieldType = fieldType;
587 }
588
589 @Override
590 final MethodType accessModeTypeUncached(AccessMode accessMode) {
591 return accessMode.at.accessModeType(receiverType, fieldType);
592 }
593
594 @ForceInline
595 static Object get(ValueFieldInstanceReadOnly handle, Object holder) {
596 return UNSAFE.getValue(Objects.requireNonNull(handle.receiverType.cast(holder)),
597 handle.fieldOffset, handle.fieldType);
598 }
599
600 @ForceInline
601 static Object getVolatile(ValueFieldInstanceReadOnly handle, Object holder) {
602 return UNSAFE.getValueVolatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
603 handle.fieldOffset, handle.fieldType);
604 }
605
606 @ForceInline
607 static Object getOpaque(ValueFieldInstanceReadOnly handle, Object holder) {
608 return UNSAFE.getValueOpaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
609 handle.fieldOffset, handle.fieldType);
610 }
611
612 @ForceInline
613 static Object getAcquire(ValueFieldInstanceReadOnly handle, Object holder) {
614 return UNSAFE.getValueAcquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
615 handle.fieldOffset, handle.fieldType);
616 }
617
618 static final VarForm FORM = new VarForm(ValueFieldInstanceReadOnly.class, Object.class, Object.class);
619 }
620
621 static final class ValueFieldInstanceReadWrite extends ValueFieldInstanceReadOnly {
622
623 ValueFieldInstanceReadWrite(Class<?> receiverType, long fieldOffset, Class<?> fieldType) {
624 super(receiverType, fieldOffset, fieldType, ValueFieldInstanceReadWrite.FORM);
625 }
626
627 @ForceInline
628 static void set(ValueFieldInstanceReadWrite handle, Object holder, Object value) {
629 UNSAFE.putValue(Objects.requireNonNull(handle.receiverType.cast(holder)),
630 handle.fieldOffset, handle.fieldType,
631 handle.fieldType.cast(Objects.requireNonNull(value)));
632 }
633
634 @ForceInline
635 static void setVolatile(ValueFieldInstanceReadWrite handle, Object holder, Object value) {
636 UNSAFE.putValueVolatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
637 handle.fieldOffset, handle.fieldType,
638 handle.fieldType.cast(Objects.requireNonNull(value)));
639 }
640
641 @ForceInline
642 static void setOpaque(ValueFieldInstanceReadWrite handle, Object holder, Object value) {
643 UNSAFE.putValueOpaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
644 handle.fieldOffset, handle.fieldType,
645 handle.fieldType.cast(Objects.requireNonNull(value)));
646 }
647
648 @ForceInline
649 static void setRelease(ValueFieldInstanceReadWrite handle, Object holder, $type$ value) {
650 UNSAFE.putValueRelease(Objects.requireNonNull(handle.receiverType.cast(holder)),
651 handle.fieldOffset, handle.fieldType,
652 handle.fieldType.cast(Objects.requireNonNull(value)));
653 }
654 #if[CAS]
655
656 @ForceInline
657 static boolean compareAndSet(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
658 return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
659 handle.fieldOffset,
660 {#if[Object]?handle.fieldType.cast(expected):expected},
661 {#if[Object]?handle.fieldType.cast(value):value});
662 }
663
664 @ForceInline
665 static $type$ compareAndExchange(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
666 return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
667 handle.fieldOffset,
668 {#if[Object]?handle.fieldType.cast(expected):expected},
669 {#if[Object]?handle.fieldType.cast(value):value});
670 }
671
672 @ForceInline
673 static $type$ compareAndExchangeAcquire(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
674 return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
675 handle.fieldOffset,
676 {#if[Object]?handle.fieldType.cast(expected):expected},
677 {#if[Object]?handle.fieldType.cast(value):value});
678 }
679
680 @ForceInline
681 static $type$ compareAndExchangeRelease(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
682 return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
683 handle.fieldOffset,
684 {#if[Object]?handle.fieldType.cast(expected):expected},
685 {#if[Object]?handle.fieldType.cast(value):value});
686 }
687
688 @ForceInline
689 static boolean weakCompareAndSetPlain(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
690 return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
691 handle.fieldOffset,
692 {#if[Object]?handle.fieldType.cast(expected):expected},
693 {#if[Object]?handle.fieldType.cast(value):value});
694 }
695
696 @ForceInline
697 static boolean weakCompareAndSet(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
698 return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
699 handle.fieldOffset,
700 {#if[Object]?handle.fieldType.cast(expected):expected},
701 {#if[Object]?handle.fieldType.cast(value):value});
702 }
703
704 @ForceInline
705 static boolean weakCompareAndSetAcquire(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
706 return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
707 handle.fieldOffset,
708 {#if[Object]?handle.fieldType.cast(expected):expected},
709 {#if[Object]?handle.fieldType.cast(value):value});
710 }
711
712 @ForceInline
713 static boolean weakCompareAndSetRelease(ValueFieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
714 return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
715 handle.fieldOffset,
716 {#if[Object]?handle.fieldType.cast(expected):expected},
717 {#if[Object]?handle.fieldType.cast(value):value});
718 }
719
720 @ForceInline
721 static $type$ getAndSet(ValueFieldInstanceReadWrite handle, Object holder, $type$ value) {
722 return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
723 handle.fieldOffset,
724 {#if[Object]?handle.fieldType.cast(value):value});
725 }
726
727 @ForceInline
728 static $type$ getAndSetAcquire(ValueFieldInstanceReadWrite handle, Object holder, $type$ value) {
729 return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
730 handle.fieldOffset,
731 {#if[Object]?handle.fieldType.cast(value):value});
732 }
733
734 @ForceInline
735 static $type$ getAndSetRelease(ValueFieldInstanceReadWrite handle, Object holder, $type$ value) {
736 return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
737 handle.fieldOffset,
738 {#if[Object]?handle.fieldType.cast(value):value});
739 }
740 #end[CAS]
741 static final VarForm FORM = new VarForm(ValueFieldInstanceReadWrite.class, Object.class, Object.class);
742 }
743 #end[Object]
744
745 static final class Array extends VarHandle {
746 final int abase;
747 final int ashift;
748 #if[Object]
749 final Class<{#if[Object]??:$type$[]}> arrayType;
750 final Class<?> componentType;
751 #end[Object]
752
753 Array(int abase, int ashift{#if[Object]?, Class<?> arrayType}) {
754 super(Array.FORM);
755 this.abase = abase;
756 this.ashift = ashift;
757 #if[Object]
758 this.arrayType = {#if[Object]?arrayType:$type$[].class};
759 this.componentType = arrayType.getComponentType();
760 #end[Object]
761 }
762
763 @Override
764 final MethodType accessModeTypeUncached(AccessMode accessMode) {
765 return accessMode.at.accessModeType({#if[Object]?arrayType:$type$[].class}, {#if[Object]?arrayType.getComponentType():$type$.class}, int.class);
766 }
767
768 #if[Object]
769 @ForceInline
770 static Object runtimeTypeCheck(Array handle, Object[] oarray, Object value) {
771 if (handle.arrayType == oarray.getClass()) {
772 // Fast path: static array type same as argument array type
773 return handle.componentType.cast(value);
774 } else {
775 // Slow path: check value against argument array component type
776 return reflectiveTypeCheck(oarray, value);
777 }
778 }
779
780 @ForceInline
781 static Object reflectiveTypeCheck(Object[] oarray, Object value) {
782 try {
783 return oarray.getClass().getComponentType().cast(value);
784 } catch (ClassCastException e) {
785 throw new ArrayStoreException();
786 }
787 }
788 #end[Object]
789
790 @ForceInline
791 static $type$ get(Array handle, Object oarray, int index) {
792 #if[Object]
793 Object[] array = (Object[]) handle.arrayType.cast(oarray);
794 #else[Object]
795 $type$[] array = ($type$[]) oarray;
796 #end[Object]
797 return array[index];
798 }
799
800 @ForceInline
801 static void set(Array handle, Object oarray, int index, $type$ value) {
802 #if[Object]
803 Object[] array = (Object[]) handle.arrayType.cast(oarray);
804 #else[Object]
805 $type$[] array = ($type$[]) oarray;
806 #end[Object]
807 array[index] = {#if[Object]?handle.componentType.cast(value):value};
808 }
809
810 @ForceInline
811 static $type$ getVolatile(Array handle, Object oarray, int index) {
812 #if[Object]
813 Object[] array = (Object[]) handle.arrayType.cast(oarray);
814 #else[Object]
815 $type$[] array = ($type$[]) oarray;
816 #end[Object]
817 return UNSAFE.get$Type$Volatile(array,
818 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase);
819 }
820
821 @ForceInline
822 static void setVolatile(Array handle, Object oarray, int index, $type$ value) {
823 #if[Object]
824 Object[] array = (Object[]) handle.arrayType.cast(oarray);
825 #else[Object]
826 $type$[] array = ($type$[]) oarray;
827 #end[Object]
828 UNSAFE.put$Type$Volatile(array,
829 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
830 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
831 }
832
833 @ForceInline
834 static $type$ getOpaque(Array handle, Object oarray, int index) {
835 #if[Object]
836 Object[] array = (Object[]) handle.arrayType.cast(oarray);
837 #else[Object]
838 $type$[] array = ($type$[]) oarray;
839 #end[Object]
840 return UNSAFE.get$Type$Opaque(array,
841 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase);
842 }
843
844 @ForceInline
845 static void setOpaque(Array handle, Object oarray, int index, $type$ value) {
846 #if[Object]
847 Object[] array = (Object[]) handle.arrayType.cast(oarray);
848 #else[Object]
849 $type$[] array = ($type$[]) oarray;
850 #end[Object]
851 UNSAFE.put$Type$Opaque(array,
852 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
853 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
854 }
855
856 @ForceInline
857 static $type$ getAcquire(Array handle, Object oarray, int index) {
858 #if[Object]
859 Object[] array = (Object[]) handle.arrayType.cast(oarray);
860 #else[Object]
861 $type$[] array = ($type$[]) oarray;
862 #end[Object]
863 return UNSAFE.get$Type$Acquire(array,
864 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase);
865 }
866
867 @ForceInline
868 static void setRelease(Array handle, Object oarray, int index, $type$ value) {
869 #if[Object]
870 Object[] array = (Object[]) handle.arrayType.cast(oarray);
871 #else[Object]
872 $type$[] array = ($type$[]) oarray;
873 #end[Object]
874 UNSAFE.put$Type$Release(array,
875 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
876 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
877 }
878 #if[CAS]
879
880 @ForceInline
881 static boolean compareAndSet(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
882 #if[Object]
883 Object[] array = (Object[]) handle.arrayType.cast(oarray);
884 #else[Object]
885 $type$[] array = ($type$[]) oarray;
886 #end[Object]
887 return UNSAFE.compareAndSet$Type$(array,
888 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
889 {#if[Object]?handle.componentType.cast(expected):expected},
890 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
891 }
892
893 @ForceInline
894 static $type$ compareAndExchange(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
895 #if[Object]
896 Object[] array = (Object[]) handle.arrayType.cast(oarray);
897 #else[Object]
898 $type$[] array = ($type$[]) oarray;
899 #end[Object]
900 return UNSAFE.compareAndExchange$Type$(array,
901 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
902 {#if[Object]?handle.componentType.cast(expected):expected},
903 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
904 }
905
906 @ForceInline
907 static $type$ compareAndExchangeAcquire(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
908 #if[Object]
909 Object[] array = (Object[]) handle.arrayType.cast(oarray);
910 #else[Object]
911 $type$[] array = ($type$[]) oarray;
912 #end[Object]
913 return UNSAFE.compareAndExchange$Type$Acquire(array,
914 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
915 {#if[Object]?handle.componentType.cast(expected):expected},
916 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
917 }
918
919 @ForceInline
920 static $type$ compareAndExchangeRelease(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
921 #if[Object]
922 Object[] array = (Object[]) handle.arrayType.cast(oarray);
923 #else[Object]
924 $type$[] array = ($type$[]) oarray;
925 #end[Object]
926 return UNSAFE.compareAndExchange$Type$Release(array,
927 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
928 {#if[Object]?handle.componentType.cast(expected):expected},
929 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
930 }
931
932 @ForceInline
933 static boolean weakCompareAndSetPlain(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
934 #if[Object]
935 Object[] array = (Object[]) handle.arrayType.cast(oarray);
936 #else[Object]
937 $type$[] array = ($type$[]) oarray;
938 #end[Object]
939 return UNSAFE.weakCompareAndSet$Type$Plain(array,
940 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
941 {#if[Object]?handle.componentType.cast(expected):expected},
942 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
943 }
944
945 @ForceInline
946 static boolean weakCompareAndSet(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
947 #if[Object]
948 Object[] array = (Object[]) handle.arrayType.cast(oarray);
949 #else[Object]
950 $type$[] array = ($type$[]) oarray;
951 #end[Object]
952 return UNSAFE.weakCompareAndSet$Type$(array,
953 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
954 {#if[Object]?handle.componentType.cast(expected):expected},
955 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
956 }
957
958 @ForceInline
959 static boolean weakCompareAndSetAcquire(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
960 #if[Object]
961 Object[] array = (Object[]) handle.arrayType.cast(oarray);
962 #else[Object]
963 $type$[] array = ($type$[]) oarray;
964 #end[Object]
965 return UNSAFE.weakCompareAndSet$Type$Acquire(array,
966 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
967 {#if[Object]?handle.componentType.cast(expected):expected},
968 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
969 }
970
971 @ForceInline
972 static boolean weakCompareAndSetRelease(Array handle, Object oarray, int index, $type$ expected, $type$ value) {
973 #if[Object]
974 Object[] array = (Object[]) handle.arrayType.cast(oarray);
975 #else[Object]
976 $type$[] array = ($type$[]) oarray;
977 #end[Object]
978 return UNSAFE.weakCompareAndSet$Type$Release(array,
979 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
980 {#if[Object]?handle.componentType.cast(expected):expected},
981 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
982 }
983
984 @ForceInline
985 static $type$ getAndSet(Array handle, Object oarray, int index, $type$ value) {
986 #if[Object]
987 Object[] array = (Object[]) handle.arrayType.cast(oarray);
988 #else[Object]
989 $type$[] array = ($type$[]) oarray;
990 #end[Object]
991 return UNSAFE.getAndSet$Type$(array,
992 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
993 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
994 }
995
996 @ForceInline
997 static $type$ getAndSetAcquire(Array handle, Object oarray, int index, $type$ value) {
998 #if[Object]
999 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1000 #else[Object]
1001 $type$[] array = ($type$[]) oarray;
1002 #end[Object]
1003 return UNSAFE.getAndSet$Type$Acquire(array,
1004 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1005 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1006 }
1007
1008 @ForceInline
1009 static $type$ getAndSetRelease(Array handle, Object oarray, int index, $type$ value) {
1010 #if[Object]
1011 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1012 #else[Object]
1013 $type$[] array = ($type$[]) oarray;
1014 #end[Object]
1015 return UNSAFE.getAndSet$Type$Release(array,
1016 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1017 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1018 }
1019 #end[CAS]
1020 #if[AtomicAdd]
1021
1022 @ForceInline
1023 static $type$ getAndAdd(Array handle, Object oarray, int index, $type$ value) {
1024 $type$[] array = ($type$[]) oarray;
1025 return UNSAFE.getAndAdd$Type$(array,
1026 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1027 value);
1028 }
1029
1030 @ForceInline
1031 static $type$ getAndAddAcquire(Array handle, Object oarray, int index, $type$ value) {
1032 $type$[] array = ($type$[]) oarray;
1033 return UNSAFE.getAndAdd$Type$Acquire(array,
1034 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1035 value);
1036 }
1037
1038 @ForceInline
1039 static $type$ getAndAddRelease(Array handle, Object oarray, int index, $type$ value) {
1040 $type$[] array = ($type$[]) oarray;
1041 return UNSAFE.getAndAdd$Type$Release(array,
1042 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1043 value);
1044 }
1045 #end[AtomicAdd]
1046 #if[Bitwise]
1047
1048 @ForceInline
1049 static $type$ getAndBitwiseOr(Array handle, Object oarray, int index, $type$ value) {
1050 $type$[] array = ($type$[]) oarray;
1051 return UNSAFE.getAndBitwiseOr$Type$(array,
1052 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1053 value);
1054 }
1055
1056 @ForceInline
1057 static $type$ getAndBitwiseOrRelease(Array handle, Object oarray, int index, $type$ value) {
1058 $type$[] array = ($type$[]) oarray;
1059 return UNSAFE.getAndBitwiseOr$Type$Release(array,
1060 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1061 value);
1062 }
1063
1064 @ForceInline
1065 static $type$ getAndBitwiseOrAcquire(Array handle, Object oarray, int index, $type$ value) {
1066 $type$[] array = ($type$[]) oarray;
1067 return UNSAFE.getAndBitwiseOr$Type$Acquire(array,
1068 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1069 value);
1070 }
1071
1072 @ForceInline
1073 static $type$ getAndBitwiseAnd(Array handle, Object oarray, int index, $type$ value) {
1074 $type$[] array = ($type$[]) oarray;
1075 return UNSAFE.getAndBitwiseAnd$Type$(array,
1076 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1077 value);
1078 }
1079
1080 @ForceInline
1081 static $type$ getAndBitwiseAndRelease(Array handle, Object oarray, int index, $type$ value) {
1082 $type$[] array = ($type$[]) oarray;
1083 return UNSAFE.getAndBitwiseAnd$Type$Release(array,
1084 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1085 value);
1086 }
1087
1088 @ForceInline
1089 static $type$ getAndBitwiseAndAcquire(Array handle, Object oarray, int index, $type$ value) {
1090 $type$[] array = ($type$[]) oarray;
1091 return UNSAFE.getAndBitwiseAnd$Type$Acquire(array,
1092 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1093 value);
1094 }
1095
1096 @ForceInline
1097 static $type$ getAndBitwiseXor(Array handle, Object oarray, int index, $type$ value) {
1098 $type$[] array = ($type$[]) oarray;
1099 return UNSAFE.getAndBitwiseXor$Type$(array,
1100 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1101 value);
1102 }
1103
1104 @ForceInline
1105 static $type$ getAndBitwiseXorRelease(Array handle, Object oarray, int index, $type$ value) {
1106 $type$[] array = ($type$[]) oarray;
1107 return UNSAFE.getAndBitwiseXor$Type$Release(array,
1108 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1109 value);
1110 }
1111
1112 @ForceInline
1113 static $type$ getAndBitwiseXorAcquire(Array handle, Object oarray, int index, $type$ value) {
1114 $type$[] array = ($type$[]) oarray;
1115 return UNSAFE.getAndBitwiseXor$Type$Acquire(array,
1116 (((long) Preconditions.checkIndex(index, array.length, AIOOBE_SUPPLIER)) << handle.ashift) + handle.abase,
1117 value);
1118 }
1119 #end[Bitwise]
1120
1121 static final VarForm FORM = new VarForm(Array.class, {#if[Object]?Object[].class:$type$[].class}, {#if[Object]?Object.class:$type$.class}, int.class);
1122 }
1123 }