1 /*
2 * Copyright (c) 2015, 2023, 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.lang.invoke.VarHandle.VarHandleDesc;
31 import java.util.Objects;
32 import java.util.Optional;
33
34 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
35
36 #warn
37
38 final class VarHandle$Type$s {
39
40 static sealed class FieldInstanceReadOnly extends VarHandle {
41 final long fieldOffset;
42 final Class<?> receiverType;
43 #if[Object]
44 final Class<?> fieldType;
45 #end[Object]
46
47 FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
48 this(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadOnly.FORM, false);
49 }
50
51 protected FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType},
52 VarForm form, boolean exact) {
53 super(form, exact);
54 this.fieldOffset = fieldOffset;
55 this.receiverType = receiverType;
56 #if[Object]
57 this.fieldType = fieldType;
58 #end[Object]
59 }
60
61 @Override
62 public FieldInstanceReadOnly withInvokeExactBehavior() {
63 return hasInvokeExactBehavior()
64 ? this
65 : new FieldInstanceReadOnly(receiverType, fieldOffset{#if[Object]?, fieldType}, vform, true);
66 }
67
68 @Override
69 public FieldInstanceReadOnly withInvokeBehavior() {
70 return !hasInvokeExactBehavior()
71 ? this
72 : new FieldInstanceReadOnly(receiverType, fieldOffset{#if[Object]?, fieldType}, vform, false);
73 }
74
75 @Override
76 final MethodType accessModeTypeUncached(AccessType at) {
77 return at.accessModeType(receiverType, {#if[Object]?fieldType:$type$.class});
78 }
79
80 @Override
81 public Optional<VarHandleDesc> describeConstable() {
82 var receiverTypeRef = receiverType.describeConstable();
83 var fieldTypeRef = {#if[Object]?fieldType:$type$.class}.describeConstable();
84 if (!receiverTypeRef.isPresent() || !fieldTypeRef.isPresent())
85 return Optional.empty();
86
87 // Reflect on this VarHandle to extract the field name
88 String name = VarHandles.getFieldFromReceiverAndOffset(
89 receiverType, fieldOffset, {#if[Object]?fieldType:$type$.class}).getName();
90 return Optional.of(VarHandleDesc.ofField(receiverTypeRef.get(), name, fieldTypeRef.get()));
91 }
92
93 @ForceInline
94 static $type$ get(VarHandle ob, Object holder) {
95 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
96 return UNSAFE.get$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
97 handle.fieldOffset);
98 }
99
100 @ForceInline
101 static $type$ getVolatile(VarHandle ob, Object holder) {
102 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
103 return UNSAFE.get$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
104 handle.fieldOffset);
105 }
106
107 @ForceInline
108 static $type$ getOpaque(VarHandle ob, Object holder) {
109 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
110 return UNSAFE.get$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
111 handle.fieldOffset);
112 }
113
114 @ForceInline
115 static $type$ getAcquire(VarHandle ob, Object holder) {
116 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
117 return UNSAFE.get$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
118 handle.fieldOffset);
119 }
120
121 static final VarForm FORM = new VarForm(FieldInstanceReadOnly.class, Object.class, $type$.class);
122 }
123
124 static final class FieldInstanceReadWrite extends FieldInstanceReadOnly {
125
126 FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
127 this(receiverType, fieldOffset{#if[Object]?, fieldType}, false);
128 }
129
130 private FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType},
131 boolean exact) {
132 super(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadWrite.FORM, exact);
133 }
134
135 @Override
136 public FieldInstanceReadWrite withInvokeExactBehavior() {
137 return hasInvokeExactBehavior()
138 ? this
139 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType}, true);
140 }
141
142 @Override
143 public FieldInstanceReadWrite withInvokeBehavior() {
144 return !hasInvokeExactBehavior()
145 ? this
146 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType}, false);
147 }
148
149 @ForceInline
150 static void set(VarHandle ob, Object holder, $type$ value) {
151 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
152 UNSAFE.put$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
153 handle.fieldOffset,
154 {#if[Object]?handle.fieldType.cast(value):value});
155 }
156
157 @ForceInline
158 static void setVolatile(VarHandle ob, Object holder, $type$ value) {
159 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
160 UNSAFE.put$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
161 handle.fieldOffset,
162 {#if[Object]?handle.fieldType.cast(value):value});
163 }
164
165 @ForceInline
166 static void setOpaque(VarHandle ob, Object holder, $type$ value) {
167 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
168 UNSAFE.put$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
169 handle.fieldOffset,
170 {#if[Object]?handle.fieldType.cast(value):value});
171 }
172
173 @ForceInline
174 static void setRelease(VarHandle ob, Object holder, $type$ value) {
175 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
176 UNSAFE.put$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
177 handle.fieldOffset,
178 {#if[Object]?handle.fieldType.cast(value):value});
179 }
180 #if[CAS]
181
182 @ForceInline
183 static boolean compareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
184 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
185 return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
186 handle.fieldOffset,
187 {#if[Object]?handle.fieldType.cast(expected):expected},
188 {#if[Object]?handle.fieldType.cast(value):value});
189 }
190
191 @ForceInline
192 static $type$ compareAndExchange(VarHandle ob, Object holder, $type$ expected, $type$ value) {
193 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
194 return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
195 handle.fieldOffset,
196 {#if[Object]?handle.fieldType.cast(expected):expected},
197 {#if[Object]?handle.fieldType.cast(value):value});
198 }
199
200 @ForceInline
201 static $type$ compareAndExchangeAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
202 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
203 return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
204 handle.fieldOffset,
205 {#if[Object]?handle.fieldType.cast(expected):expected},
206 {#if[Object]?handle.fieldType.cast(value):value});
207 }
208
209 @ForceInline
210 static $type$ compareAndExchangeRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
211 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
212 return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
213 handle.fieldOffset,
214 {#if[Object]?handle.fieldType.cast(expected):expected},
215 {#if[Object]?handle.fieldType.cast(value):value});
216 }
217
218 @ForceInline
219 static boolean weakCompareAndSetPlain(VarHandle ob, Object holder, $type$ expected, $type$ value) {
220 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
221 return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
222 handle.fieldOffset,
223 {#if[Object]?handle.fieldType.cast(expected):expected},
224 {#if[Object]?handle.fieldType.cast(value):value});
225 }
226
227 @ForceInline
228 static boolean weakCompareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
229 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
230 return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
231 handle.fieldOffset,
232 {#if[Object]?handle.fieldType.cast(expected):expected},
233 {#if[Object]?handle.fieldType.cast(value):value});
234 }
235
236 @ForceInline
237 static boolean weakCompareAndSetAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
238 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
239 return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
240 handle.fieldOffset,
241 {#if[Object]?handle.fieldType.cast(expected):expected},
242 {#if[Object]?handle.fieldType.cast(value):value});
243 }
244
245 @ForceInline
246 static boolean weakCompareAndSetRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
247 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
248 return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
249 handle.fieldOffset,
250 {#if[Object]?handle.fieldType.cast(expected):expected},
251 {#if[Object]?handle.fieldType.cast(value):value});
252 }
253
254 @ForceInline
255 static $type$ getAndSet(VarHandle ob, Object holder, $type$ value) {
256 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
257 return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
258 handle.fieldOffset,
259 {#if[Object]?handle.fieldType.cast(value):value});
260 }
261
262 @ForceInline
263 static $type$ getAndSetAcquire(VarHandle ob, Object holder, $type$ value) {
264 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
265 return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
266 handle.fieldOffset,
267 {#if[Object]?handle.fieldType.cast(value):value});
268 }
269
270 @ForceInline
271 static $type$ getAndSetRelease(VarHandle ob, Object holder, $type$ value) {
272 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
273 return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
274 handle.fieldOffset,
275 {#if[Object]?handle.fieldType.cast(value):value});
276 }
277 #end[CAS]
278 #if[AtomicAdd]
279
280 @ForceInline
281 static $type$ getAndAdd(VarHandle ob, Object holder, $type$ value) {
282 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
283 return UNSAFE.getAndAdd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
284 handle.fieldOffset,
285 value);
286 }
287
288 @ForceInline
289 static $type$ getAndAddAcquire(VarHandle ob, Object holder, $type$ value) {
290 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
291 return UNSAFE.getAndAdd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
292 handle.fieldOffset,
293 value);
294 }
295
359 handle.fieldOffset,
360 value);
361 }
362
363 @ForceInline
364 static $type$ getAndBitwiseXorRelease(VarHandle ob, Object holder, $type$ value) {
365 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
366 return UNSAFE.getAndBitwiseXor$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
367 handle.fieldOffset,
368 value);
369 }
370
371 @ForceInline
372 static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object holder, $type$ value) {
373 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
374 return UNSAFE.getAndBitwiseXor$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
375 handle.fieldOffset,
376 value);
377 }
378 #end[Bitwise]
379
380 static final VarForm FORM = new VarForm(FieldInstanceReadWrite.class, Object.class, $type$.class);
381 }
382
383
384 static sealed class FieldStaticReadOnly extends VarHandle {
385 final Class<?> declaringClass;
386 final Object base;
387 final long fieldOffset;
388 #if[Object]
389 final Class<?> fieldType;
390 #end[Object]
391
392 FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
393 this(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadOnly.FORM, false);
394 }
395
396 protected FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType},
397 VarForm form, boolean exact) {
398 super(form, exact);
399 this.declaringClass = declaringClass;
400 this.base = base;
401 this.fieldOffset = fieldOffset;
402 #if[Object]
403 this.fieldType = fieldType;
404 #end[Object]
405 }
406
407 @Override
408 public FieldStaticReadOnly withInvokeExactBehavior() {
409 return hasInvokeExactBehavior()
410 ? this
411 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, vform, true);
412 }
413
414 @Override
415 public FieldStaticReadOnly withInvokeBehavior() {
416 return !hasInvokeExactBehavior()
417 ? this
418 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, vform, false);
419 }
420
421 @Override
422 public Optional<VarHandleDesc> describeConstable() {
423 var fieldTypeRef = {#if[Object]?fieldType:$type$.class}.describeConstable();
424 if (!fieldTypeRef.isPresent())
425 return Optional.empty();
426
427 // Reflect on this VarHandle to extract the field name
428 var staticField = VarHandles.getStaticFieldFromBaseAndOffset(
429 declaringClass, fieldOffset, {#if[Object]?fieldType:$type$.class});
430 var declaringTypeRef = declaringClass.describeConstable();
431 if (!declaringTypeRef.isPresent())
432 return Optional.empty();
433 return Optional.of(VarHandleDesc.ofStaticField(declaringTypeRef.get(), staticField.getName(), fieldTypeRef.get()));
434 }
435
436 @Override
437 final MethodType accessModeTypeUncached(AccessType at) {
438 return at.accessModeType(null, {#if[Object]?fieldType:$type$.class});
439 }
440
441 @ForceInline
442 static $type$ get(VarHandle ob) {
443 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
444 return UNSAFE.get$Type$(handle.base,
445 handle.fieldOffset);
446 }
447
448 @ForceInline
449 static $type$ getVolatile(VarHandle ob) {
450 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
451 return UNSAFE.get$Type$Volatile(handle.base,
452 handle.fieldOffset);
453 }
454
455 @ForceInline
456 static $type$ getOpaque(VarHandle ob) {
457 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
458 return UNSAFE.get$Type$Opaque(handle.base,
459 handle.fieldOffset);
460 }
461
462 @ForceInline
463 static $type$ getAcquire(VarHandle ob) {
464 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
465 return UNSAFE.get$Type$Acquire(handle.base,
466 handle.fieldOffset);
467 }
468
469 static final VarForm FORM = new VarForm(FieldStaticReadOnly.class, null, $type$.class);
470 }
471
472 static final class FieldStaticReadWrite extends FieldStaticReadOnly {
473
474 FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
475 this(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, false);
476 }
477
478 private FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType},
479 boolean exact) {
480 super(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadWrite.FORM, exact);
481 }
482
483 @Override
484 public FieldStaticReadWrite withInvokeExactBehavior() {
485 return hasInvokeExactBehavior()
486 ? this
487 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, true);
488 }
489
490 @Override
491 public FieldStaticReadWrite withInvokeBehavior() {
492 return !hasInvokeExactBehavior()
493 ? this
494 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, false);
495 }
496
497 @ForceInline
498 static void set(VarHandle ob, $type$ value) {
499 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
500 UNSAFE.put$Type$(handle.base,
501 handle.fieldOffset,
502 {#if[Object]?handle.fieldType.cast(value):value});
503 }
504
505 @ForceInline
506 static void setVolatile(VarHandle ob, $type$ value) {
507 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
508 UNSAFE.put$Type$Volatile(handle.base,
509 handle.fieldOffset,
510 {#if[Object]?handle.fieldType.cast(value):value});
511 }
512
513 @ForceInline
514 static void setOpaque(VarHandle ob, $type$ value) {
515 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
516 UNSAFE.put$Type$Opaque(handle.base,
517 handle.fieldOffset,
518 {#if[Object]?handle.fieldType.cast(value):value});
519 }
520
521 @ForceInline
522 static void setRelease(VarHandle ob, $type$ value) {
523 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
524 UNSAFE.put$Type$Release(handle.base,
525 handle.fieldOffset,
526 {#if[Object]?handle.fieldType.cast(value):value});
527 }
528 #if[CAS]
529
530 @ForceInline
531 static boolean compareAndSet(VarHandle ob, $type$ expected, $type$ value) {
532 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
533 return UNSAFE.compareAndSet$Type$(handle.base,
534 handle.fieldOffset,
535 {#if[Object]?handle.fieldType.cast(expected):expected},
536 {#if[Object]?handle.fieldType.cast(value):value});
537 }
538
539
540 @ForceInline
541 static $type$ compareAndExchange(VarHandle ob, $type$ expected, $type$ value) {
542 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
543 return UNSAFE.compareAndExchange$Type$(handle.base,
544 handle.fieldOffset,
545 {#if[Object]?handle.fieldType.cast(expected):expected},
546 {#if[Object]?handle.fieldType.cast(value):value});
547 }
548
549 @ForceInline
550 static $type$ compareAndExchangeAcquire(VarHandle ob, $type$ expected, $type$ value) {
551 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
552 return UNSAFE.compareAndExchange$Type$Acquire(handle.base,
553 handle.fieldOffset,
554 {#if[Object]?handle.fieldType.cast(expected):expected},
555 {#if[Object]?handle.fieldType.cast(value):value});
556 }
557
558 @ForceInline
559 static $type$ compareAndExchangeRelease(VarHandle ob, $type$ expected, $type$ value) {
560 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
561 return UNSAFE.compareAndExchange$Type$Release(handle.base,
562 handle.fieldOffset,
563 {#if[Object]?handle.fieldType.cast(expected):expected},
564 {#if[Object]?handle.fieldType.cast(value):value});
565 }
566
567 @ForceInline
568 static boolean weakCompareAndSetPlain(VarHandle ob, $type$ expected, $type$ value) {
569 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
570 return UNSAFE.weakCompareAndSet$Type$Plain(handle.base,
571 handle.fieldOffset,
572 {#if[Object]?handle.fieldType.cast(expected):expected},
573 {#if[Object]?handle.fieldType.cast(value):value});
574 }
575
576 @ForceInline
577 static boolean weakCompareAndSet(VarHandle ob, $type$ expected, $type$ value) {
578 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
579 return UNSAFE.weakCompareAndSet$Type$(handle.base,
580 handle.fieldOffset,
581 {#if[Object]?handle.fieldType.cast(expected):expected},
582 {#if[Object]?handle.fieldType.cast(value):value});
583 }
584
585 @ForceInline
586 static boolean weakCompareAndSetAcquire(VarHandle ob, $type$ expected, $type$ value) {
587 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
588 return UNSAFE.weakCompareAndSet$Type$Acquire(handle.base,
589 handle.fieldOffset,
590 {#if[Object]?handle.fieldType.cast(expected):expected},
591 {#if[Object]?handle.fieldType.cast(value):value});
592 }
593
594 @ForceInline
595 static boolean weakCompareAndSetRelease(VarHandle ob, $type$ expected, $type$ value) {
596 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
597 return UNSAFE.weakCompareAndSet$Type$Release(handle.base,
598 handle.fieldOffset,
599 {#if[Object]?handle.fieldType.cast(expected):expected},
600 {#if[Object]?handle.fieldType.cast(value):value});
601 }
602
603 @ForceInline
604 static $type$ getAndSet(VarHandle ob, $type$ value) {
605 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
606 return UNSAFE.getAndSet$Type$(handle.base,
607 handle.fieldOffset,
608 {#if[Object]?handle.fieldType.cast(value):value});
609 }
610
611 @ForceInline
612 static $type$ getAndSetAcquire(VarHandle ob, $type$ value) {
613 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
614 return UNSAFE.getAndSet$Type$Acquire(handle.base,
615 handle.fieldOffset,
616 {#if[Object]?handle.fieldType.cast(value):value});
617 }
618
619 @ForceInline
620 static $type$ getAndSetRelease(VarHandle ob, $type$ value) {
621 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
622 return UNSAFE.getAndSet$Type$Release(handle.base,
623 handle.fieldOffset,
624 {#if[Object]?handle.fieldType.cast(value):value});
625 }
626 #end[CAS]
627 #if[AtomicAdd]
628
629 @ForceInline
630 static $type$ getAndAdd(VarHandle ob, $type$ value) {
631 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
632 return UNSAFE.getAndAdd$Type$(handle.base,
633 handle.fieldOffset,
634 value);
635 }
636
637 @ForceInline
638 static $type$ getAndAddAcquire(VarHandle ob, $type$ value) {
639 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
640 return UNSAFE.getAndAdd$Type$Acquire(handle.base,
641 handle.fieldOffset,
642 value);
643 }
644
707 handle.fieldOffset,
708 value);
709 }
710
711 @ForceInline
712 static $type$ getAndBitwiseXorRelease(VarHandle ob, $type$ value) {
713 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
714 return UNSAFE.getAndBitwiseXor$Type$Release(handle.base,
715 handle.fieldOffset,
716 value);
717 }
718
719 @ForceInline
720 static $type$ getAndBitwiseXorAcquire(VarHandle ob, $type$ value) {
721 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
722 return UNSAFE.getAndBitwiseXor$Type$Acquire(handle.base,
723 handle.fieldOffset,
724 value);
725 }
726 #end[Bitwise]
727
728 static final VarForm FORM = new VarForm(FieldStaticReadWrite.class, null, $type$.class);
729 }
730
731
732 static final class Array extends VarHandle {
733 final int abase;
734 final int ashift;
735 #if[Object]
736 final Class<{#if[Object]??:$type$[]}> arrayType;
737 final Class<?> componentType;
738 #end[Object]
739
740 Array(int abase, int ashift{#if[Object]?, Class<?> arrayType}) {
741 this(abase, ashift{#if[Object]?, arrayType}, false);
742 }
743
744 private Array(int abase, int ashift{#if[Object]?, Class<?> arrayType}, boolean exact) {
745 super(Array.FORM, exact);
746 this.abase = abase;
747 this.ashift = ashift;
748 #if[Object]
749 this.arrayType = {#if[Object]?arrayType:$type$[].class};
750 this.componentType = arrayType.getComponentType();
751 #end[Object]
752 }
753
754 @Override
755 public Array withInvokeExactBehavior() {
756 return hasInvokeExactBehavior()
757 ? this
758 : new Array(abase, ashift{#if[Object]?, arrayType}, true);
759 }
760
761 @Override
762 public Array withInvokeBehavior() {
763 return !hasInvokeExactBehavior()
764 ? this
765 : new Array(abase, ashift{#if[Object]?, arrayType}, false);
766 }
767
768 @Override
769 public Optional<VarHandleDesc> describeConstable() {
770 var arrayTypeRef = {#if[Object]?arrayType:$type$[].class}.describeConstable();
771 if (!arrayTypeRef.isPresent())
772 return Optional.empty();
773
774 return Optional.of(VarHandleDesc.ofArray(arrayTypeRef.get()));
775 }
776
777 @Override
778 final MethodType accessModeTypeUncached(AccessType at) {
779 return at.accessModeType({#if[Object]?arrayType:$type$[].class}, {#if[Object]?arrayType.getComponentType():$type$.class}, int.class);
780 }
781
782 #if[Object]
783 @ForceInline
784 static Object runtimeTypeCheck(Array handle, Object[] oarray, Object value) {
785 if (handle.arrayType == oarray.getClass()) {
786 // Fast path: static array type same as argument array type
787 return handle.componentType.cast(value);
788 } else {
789 // Slow path: check value against argument array component type
790 return reflectiveTypeCheck(oarray, value);
791 }
792 }
793
794 @ForceInline
795 static Object reflectiveTypeCheck(Object[] oarray, Object value) {
796 try {
797 return oarray.getClass().getComponentType().cast(value);
798 } catch (ClassCastException e) {
799 throw new ArrayStoreException();
800 }
801 }
802 #end[Object]
803
804 @ForceInline
805 static $type$ get(VarHandle ob, Object oarray, int index) {
806 Array handle = (Array)ob;
807 #if[Object]
808 Object[] array = (Object[]) handle.arrayType.cast(oarray);
809 #else[Object]
810 $type$[] array = ($type$[]) oarray;
811 #end[Object]
812 return array[index];
813 }
814
815 @ForceInline
816 static void set(VarHandle ob, Object oarray, int index, $type$ value) {
817 Array handle = (Array)ob;
818 #if[Object]
819 Object[] array = (Object[]) handle.arrayType.cast(oarray);
820 #else[Object]
821 $type$[] array = ($type$[]) oarray;
822 #end[Object]
823 array[index] = {#if[Object]?handle.componentType.cast(value):value};
824 }
825
826 @ForceInline
827 static $type$ getVolatile(VarHandle ob, Object oarray, int index) {
828 Array handle = (Array)ob;
829 #if[Object]
830 Object[] array = (Object[]) handle.arrayType.cast(oarray);
831 #else[Object]
832 $type$[] array = ($type$[]) oarray;
833 #end[Object]
834 return UNSAFE.get$Type$Volatile(array,
835 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase);
836 }
837
838 @ForceInline
839 static void setVolatile(VarHandle ob, Object oarray, int index, $type$ value) {
840 Array handle = (Array)ob;
841 #if[Object]
842 Object[] array = (Object[]) handle.arrayType.cast(oarray);
843 #else[Object]
844 $type$[] array = ($type$[]) oarray;
845 #end[Object]
846 UNSAFE.put$Type$Volatile(array,
847 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
848 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
849 }
850
851 @ForceInline
852 static $type$ getOpaque(VarHandle ob, Object oarray, int index) {
853 Array handle = (Array)ob;
854 #if[Object]
855 Object[] array = (Object[]) handle.arrayType.cast(oarray);
856 #else[Object]
857 $type$[] array = ($type$[]) oarray;
858 #end[Object]
859 return UNSAFE.get$Type$Opaque(array,
860 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase);
861 }
862
863 @ForceInline
864 static void setOpaque(VarHandle ob, Object oarray, int index, $type$ value) {
865 Array handle = (Array)ob;
866 #if[Object]
867 Object[] array = (Object[]) handle.arrayType.cast(oarray);
868 #else[Object]
869 $type$[] array = ($type$[]) oarray;
870 #end[Object]
871 UNSAFE.put$Type$Opaque(array,
872 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
873 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
874 }
875
876 @ForceInline
877 static $type$ getAcquire(VarHandle ob, Object oarray, int index) {
878 Array handle = (Array)ob;
879 #if[Object]
880 Object[] array = (Object[]) handle.arrayType.cast(oarray);
881 #else[Object]
882 $type$[] array = ($type$[]) oarray;
883 #end[Object]
884 return UNSAFE.get$Type$Acquire(array,
885 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase);
886 }
887
888 @ForceInline
889 static void setRelease(VarHandle ob, Object oarray, int index, $type$ value) {
890 Array handle = (Array)ob;
891 #if[Object]
892 Object[] array = (Object[]) handle.arrayType.cast(oarray);
893 #else[Object]
894 $type$[] array = ($type$[]) oarray;
895 #end[Object]
896 UNSAFE.put$Type$Release(array,
897 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
898 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
899 }
900 #if[CAS]
901
902 @ForceInline
903 static boolean compareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
904 Array handle = (Array)ob;
905 #if[Object]
906 Object[] array = (Object[]) handle.arrayType.cast(oarray);
907 #else[Object]
908 $type$[] array = ($type$[]) oarray;
909 #end[Object]
910 return UNSAFE.compareAndSet$Type$(array,
911 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
912 {#if[Object]?handle.componentType.cast(expected):expected},
913 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
914 }
915
916 @ForceInline
917 static $type$ compareAndExchange(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
918 Array handle = (Array)ob;
919 #if[Object]
920 Object[] array = (Object[]) handle.arrayType.cast(oarray);
921 #else[Object]
922 $type$[] array = ($type$[]) oarray;
923 #end[Object]
924 return UNSAFE.compareAndExchange$Type$(array,
925 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
926 {#if[Object]?handle.componentType.cast(expected):expected},
927 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
928 }
929
930 @ForceInline
931 static $type$ compareAndExchangeAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
932 Array handle = (Array)ob;
933 #if[Object]
934 Object[] array = (Object[]) handle.arrayType.cast(oarray);
935 #else[Object]
936 $type$[] array = ($type$[]) oarray;
937 #end[Object]
938 return UNSAFE.compareAndExchange$Type$Acquire(array,
939 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
940 {#if[Object]?handle.componentType.cast(expected):expected},
941 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
942 }
943
944 @ForceInline
945 static $type$ compareAndExchangeRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
946 Array handle = (Array)ob;
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.compareAndExchange$Type$Release(array,
953 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << 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 weakCompareAndSetPlain(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
960 Array handle = (Array)ob;
961 #if[Object]
962 Object[] array = (Object[]) handle.arrayType.cast(oarray);
963 #else[Object]
964 $type$[] array = ($type$[]) oarray;
965 #end[Object]
966 return UNSAFE.weakCompareAndSet$Type$Plain(array,
967 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
968 {#if[Object]?handle.componentType.cast(expected):expected},
969 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
970 }
971
972 @ForceInline
973 static boolean weakCompareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
974 Array handle = (Array)ob;
975 #if[Object]
976 Object[] array = (Object[]) handle.arrayType.cast(oarray);
977 #else[Object]
978 $type$[] array = ($type$[]) oarray;
979 #end[Object]
980 return UNSAFE.weakCompareAndSet$Type$(array,
981 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
982 {#if[Object]?handle.componentType.cast(expected):expected},
983 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
984 }
985
986 @ForceInline
987 static boolean weakCompareAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
988 Array handle = (Array)ob;
989 #if[Object]
990 Object[] array = (Object[]) handle.arrayType.cast(oarray);
991 #else[Object]
992 $type$[] array = ($type$[]) oarray;
993 #end[Object]
994 return UNSAFE.weakCompareAndSet$Type$Acquire(array,
995 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
996 {#if[Object]?handle.componentType.cast(expected):expected},
997 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
998 }
999
1000 @ForceInline
1001 static boolean weakCompareAndSetRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1002 Array handle = (Array)ob;
1003 #if[Object]
1004 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1005 #else[Object]
1006 $type$[] array = ($type$[]) oarray;
1007 #end[Object]
1008 return UNSAFE.weakCompareAndSet$Type$Release(array,
1009 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1010 {#if[Object]?handle.componentType.cast(expected):expected},
1011 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1012 }
1013
1014 @ForceInline
1015 static $type$ getAndSet(VarHandle ob, Object oarray, int index, $type$ value) {
1016 Array handle = (Array)ob;
1017 #if[Object]
1018 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1019 #else[Object]
1020 $type$[] array = ($type$[]) oarray;
1021 #end[Object]
1022 return UNSAFE.getAndSet$Type$(array,
1023 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1024 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1025 }
1026
1027 @ForceInline
1028 static $type$ getAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1029 Array handle = (Array)ob;
1030 #if[Object]
1031 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1032 #else[Object]
1033 $type$[] array = ($type$[]) oarray;
1034 #end[Object]
1035 return UNSAFE.getAndSet$Type$Acquire(array,
1036 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1037 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1038 }
1039
1040 @ForceInline
1041 static $type$ getAndSetRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1042 Array handle = (Array)ob;
1043 #if[Object]
1044 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1045 #else[Object]
1046 $type$[] array = ($type$[]) oarray;
1047 #end[Object]
1048 return UNSAFE.getAndSet$Type$Release(array,
1049 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1050 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1051 }
1052 #end[CAS]
1053 #if[AtomicAdd]
1054
1055 @ForceInline
1056 static $type$ getAndAdd(VarHandle ob, Object oarray, int index, $type$ value) {
1057 Array handle = (Array)ob;
1058 $type$[] array = ($type$[]) oarray;
1059 return UNSAFE.getAndAdd$Type$(array,
1060 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1061 value);
1062 }
1063
1064 @ForceInline
1065 static $type$ getAndAddAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1066 Array handle = (Array)ob;
1067 $type$[] array = ($type$[]) oarray;
1068 return UNSAFE.getAndAdd$Type$Acquire(array,
1069 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1070 value);
1145 }
1146
1147 @ForceInline
1148 static $type$ getAndBitwiseXorRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1149 Array handle = (Array)ob;
1150 $type$[] array = ($type$[]) oarray;
1151 return UNSAFE.getAndBitwiseXor$Type$Release(array,
1152 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1153 value);
1154 }
1155
1156 @ForceInline
1157 static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1158 Array handle = (Array)ob;
1159 $type$[] array = ($type$[]) oarray;
1160 return UNSAFE.getAndBitwiseXor$Type$Acquire(array,
1161 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1162 value);
1163 }
1164 #end[Bitwise]
1165
1166 static final VarForm FORM = new VarForm(Array.class, {#if[Object]?Object[].class:$type$[].class}, {#if[Object]?Object.class:$type$.class}, int.class);
1167 }
1168 }
|
1 /*
2 * Copyright (c) 2015, 2025, 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 #if[Object]
28 import jdk.internal.value.ValueClass;
29 #end[Object]
30 import jdk.internal.util.Preconditions;
31 import jdk.internal.vm.annotation.ForceInline;
32
33 import java.lang.invoke.VarHandle.VarHandleDesc;
34 import java.lang.reflect.Field;
35 import java.util.Objects;
36 import java.util.Optional;
37
38 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
39
40 #warn
41
42 final class VarHandle$InputType$s {
43
44 static sealed class FieldInstanceReadOnly extends VarHandle {
45 final long fieldOffset;
46 final Class<?> receiverType;
47 #if[Object]
48 final Class<?> fieldType;
49 final boolean nullRestricted;
50 #end[Object]
51 #if[FlatValue]
52 final int layout; // Unsafe.fieldLayout
53 #end[FlatValue]
54
55 FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout}) {
56 this(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, FieldInstanceReadOnly.FORM, false);
57 }
58
59 protected FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout},
60 VarForm form, boolean exact) {
61 super(form, exact);
62 this.fieldOffset = fieldOffset;
63 this.receiverType = receiverType;
64 #if[Object]
65 this.fieldType = fieldType;
66 this.nullRestricted = nullRestricted;
67 #end[Object]
68 #if[FlatValue]
69 this.layout = layout;
70 #end[FlatValue]
71 }
72
73 @Override
74 public FieldInstanceReadOnly withInvokeExactBehavior() {
75 return hasInvokeExactBehavior()
76 ? this
77 : new FieldInstanceReadOnly(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, vform, true);
78 }
79
80 @Override
81 public FieldInstanceReadOnly withInvokeBehavior() {
82 return !hasInvokeExactBehavior()
83 ? this
84 : new FieldInstanceReadOnly(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, vform, false);
85 }
86
87 @Override
88 final MethodType accessModeTypeUncached(AccessType at) {
89 return at.accessModeType(receiverType, {#if[Object]?fieldType:$type$.class});
90 }
91
92 @Override
93 public Optional<VarHandleDesc> describeConstable() {
94 var receiverTypeRef = receiverType.describeConstable();
95 var fieldTypeRef = {#if[Object]?fieldType:$type$.class}.describeConstable();
96 if (!receiverTypeRef.isPresent() || !fieldTypeRef.isPresent())
97 return Optional.empty();
98
99 // Reflect on this VarHandle to extract the field name
100 String name = VarHandles.getFieldFromReceiverAndOffset(
101 receiverType, fieldOffset, {#if[Object]?fieldType:$type$.class}).getName();
102 return Optional.of(VarHandleDesc.ofField(receiverTypeRef.get(), name, fieldTypeRef.get()));
103 }
104
105 @ForceInline
106 static $type$ get(VarHandle ob, Object holder) {
107 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
108 $type$ value = UNSAFE.get$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
109 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
110 #if[Reference]
111 if (value == null && handle.nullRestricted) {
112 throw new NullPointerException("Uninitialized null-restricted field");
113 }
114 #end[Reference]
115 return value;
116 }
117
118 #if[NonPlainAccess]
119 @ForceInline
120 static $type$ getVolatile(VarHandle ob, Object holder) {
121 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
122 $type$ value = UNSAFE.get$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
123 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
124 #if[Reference]
125 if (value == null && handle.nullRestricted) {
126 throw new NullPointerException("Uninitialized null-restricted field");
127 }
128 #end[Reference]
129 return value;
130 }
131
132 @ForceInline
133 static $type$ getOpaque(VarHandle ob, Object holder) {
134 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
135 $type$ value = UNSAFE.get$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
136 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
137 #if[Reference]
138 if (value == null && handle.nullRestricted) {
139 throw new NullPointerException("Uninitialized null-restricted field");
140
141 }
142 #end[Reference]
143 return value;
144 }
145
146 @ForceInline
147 static $type$ getAcquire(VarHandle ob, Object holder) {
148 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
149 $type$ value = UNSAFE.get$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
150 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
151 #if[Reference]
152 if (value == null && handle.nullRestricted) {
153 throw new NullPointerException("Uninitialized null-restricted field");
154 }
155 #end[Reference]
156 return value;
157 }
158 #end[NonPlainAccess]
159
160 static final VarForm FORM = new VarForm(FieldInstanceReadOnly.class, Object.class, $type$.class);
161 }
162
163 static final class FieldInstanceReadWrite extends FieldInstanceReadOnly {
164 FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout}) {
165 this(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
166 }
167
168 private FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout},
169 boolean exact) {
170 super(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, FieldInstanceReadWrite.FORM, exact);
171 }
172
173 @Override
174 public FieldInstanceReadWrite withInvokeExactBehavior() {
175 return hasInvokeExactBehavior()
176 ? this
177 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, true);
178 }
179
180 @Override
181 public FieldInstanceReadWrite withInvokeBehavior() {
182 return !hasInvokeExactBehavior()
183 ? this
184 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
185 }
186
187 #if[Object]
188 @ForceInline
189 static Object checkCast(FieldInstanceReadWrite handle, $type$ value) {
190 #if[Reference]
191 if (value == null && handle.nullRestricted)
192 throw new NullPointerException("Uninitialized null-restricted field");
193 #end[Reference]
194 return handle.fieldType.cast(value);
195 }
196 #end[Object]
197
198 @ForceInline
199 static void set(VarHandle ob, Object holder, $type$ value) {
200 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
201 UNSAFE.put$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
202 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
203 {#if[Object]?checkCast(handle, value):value});
204 }
205
206 #if[NonPlainAccess]
207 @ForceInline
208 static void setVolatile(VarHandle ob, Object holder, $type$ value) {
209 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
210 UNSAFE.put$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
211 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
212 {#if[Object]?checkCast(handle, value):value});
213 }
214
215 @ForceInline
216 static void setOpaque(VarHandle ob, Object holder, $type$ value) {
217 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
218 UNSAFE.put$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
219 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
220 {#if[Object]?checkCast(handle, value):value});
221 }
222
223 @ForceInline
224 static void setRelease(VarHandle ob, Object holder, $type$ value) {
225 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
226 UNSAFE.put$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
227 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
228 {#if[Object]?checkCast(handle, value):value});
229 }
230 #if[CAS]
231
232 @ForceInline
233 static boolean compareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
234 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
235 return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
236 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
237 {#if[Object]?checkCast(handle, expected):expected},
238 {#if[Object]?checkCast(handle, value):value});
239 }
240
241 @ForceInline
242 static $type$ compareAndExchange(VarHandle ob, Object holder, $type$ expected, $type$ value) {
243 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
244 return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
245 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
246 {#if[Object]?checkCast(handle, expected):expected},
247 {#if[Object]?checkCast(handle, value):value});
248 }
249
250 @ForceInline
251 static $type$ compareAndExchangeAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
252 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
253 return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
254 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
255 {#if[Object]?checkCast(handle, expected):expected},
256 {#if[Object]?checkCast(handle, value):value});
257 }
258
259 @ForceInline
260 static $type$ compareAndExchangeRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
261 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
262 return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
263 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
264 {#if[Object]?checkCast(handle, expected):expected},
265 {#if[Object]?checkCast(handle, value):value});
266 }
267
268 @ForceInline
269 static boolean weakCompareAndSetPlain(VarHandle ob, Object holder, $type$ expected, $type$ value) {
270 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
271 return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
272 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
273 {#if[Object]?checkCast(handle, expected):expected},
274 {#if[Object]?checkCast(handle, value):value});
275 }
276
277 @ForceInline
278 static boolean weakCompareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
279 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
280 return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
281 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
282 {#if[Object]?checkCast(handle, expected):expected},
283 {#if[Object]?checkCast(handle, value):value});
284 }
285
286 @ForceInline
287 static boolean weakCompareAndSetAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
288 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
289 return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
290 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
291 {#if[Object]?checkCast(handle, expected):expected},
292 {#if[Object]?checkCast(handle, value):value});
293 }
294
295 @ForceInline
296 static boolean weakCompareAndSetRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
297 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
298 return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
299 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
300 {#if[Object]?checkCast(handle, expected):expected},
301 {#if[Object]?checkCast(handle, value):value});
302 }
303
304 @ForceInline
305 static $type$ getAndSet(VarHandle ob, Object holder, $type$ value) {
306 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
307 return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
308 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
309 {#if[Object]?checkCast(handle, value):value});
310 }
311
312 @ForceInline
313 static $type$ getAndSetAcquire(VarHandle ob, Object holder, $type$ value) {
314 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
315 return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
316 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
317 {#if[Object]?checkCast(handle, value):value});
318 }
319
320 @ForceInline
321 static $type$ getAndSetRelease(VarHandle ob, Object holder, $type$ value) {
322 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
323 return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
324 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
325 {#if[Object]?checkCast(handle, value):value});
326 }
327 #end[CAS]
328 #if[AtomicAdd]
329
330 @ForceInline
331 static $type$ getAndAdd(VarHandle ob, Object holder, $type$ value) {
332 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
333 return UNSAFE.getAndAdd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
334 handle.fieldOffset,
335 value);
336 }
337
338 @ForceInline
339 static $type$ getAndAddAcquire(VarHandle ob, Object holder, $type$ value) {
340 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
341 return UNSAFE.getAndAdd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
342 handle.fieldOffset,
343 value);
344 }
345
409 handle.fieldOffset,
410 value);
411 }
412
413 @ForceInline
414 static $type$ getAndBitwiseXorRelease(VarHandle ob, Object holder, $type$ value) {
415 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
416 return UNSAFE.getAndBitwiseXor$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
417 handle.fieldOffset,
418 value);
419 }
420
421 @ForceInline
422 static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object holder, $type$ value) {
423 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
424 return UNSAFE.getAndBitwiseXor$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
425 handle.fieldOffset,
426 value);
427 }
428 #end[Bitwise]
429 #end[NonPlainAccess]
430
431 static final VarForm FORM = new VarForm(FieldInstanceReadWrite.class, Object.class, $type$.class);
432 }
433
434 #if[Static]
435 static sealed class FieldStaticReadOnly extends VarHandle {
436 final Class<?> declaringClass;
437 final Object base;
438 final long fieldOffset;
439 #if[Object]
440 final Class<?> fieldType;
441 final boolean nullRestricted;
442 #end[Object]
443 #if[FlatValue]
444 final int layout;
445 #end[FlatValue]
446
447 FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout}) {
448 this(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, FieldStaticReadOnly.FORM, false);
449 }
450
451 protected FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout},
452 VarForm form, boolean exact) {
453 super(form, exact);
454 this.declaringClass = declaringClass;
455 this.base = base;
456 this.fieldOffset = fieldOffset;
457 #if[Object]
458 this.fieldType = fieldType;
459 this.nullRestricted = nullRestricted;
460 #end[Object]
461 #if[FlatValue]
462 this.layout = layout;
463 #end[FlatValue]
464 }
465
466 @Override
467 public FieldStaticReadOnly withInvokeExactBehavior() {
468 return hasInvokeExactBehavior()
469 ? this
470 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, vform, true);
471 }
472
473 @Override
474 public FieldStaticReadOnly withInvokeBehavior() {
475 return !hasInvokeExactBehavior()
476 ? this
477 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, vform, false);
478 }
479
480 @Override
481 public Optional<VarHandleDesc> describeConstable() {
482 var fieldTypeRef = {#if[Object]?fieldType:$type$.class}.describeConstable();
483 if (!fieldTypeRef.isPresent())
484 return Optional.empty();
485
486 // Reflect on this VarHandle to extract the field name
487 var staticField = VarHandles.getStaticFieldFromBaseAndOffset(
488 declaringClass, fieldOffset, {#if[Object]?fieldType:$type$.class});
489 var declaringTypeRef = declaringClass.describeConstable();
490 if (!declaringTypeRef.isPresent())
491 return Optional.empty();
492 return Optional.of(VarHandleDesc.ofStaticField(declaringTypeRef.get(), staticField.getName(), fieldTypeRef.get()));
493 }
494
495 @Override
496 final MethodType accessModeTypeUncached(AccessType at) {
497 return at.accessModeType(null, {#if[Object]?fieldType:$type$.class});
498 }
499
500 @ForceInline
501 static $type$ get(VarHandle ob) {
502 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
503 $type$ value = UNSAFE.get$Type$(handle.base,
504 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
505 #if[Reference]
506 if (value == null && handle.nullRestricted) {
507 throw new NullPointerException("Uninitialized null-restricted field");
508 }
509 #end[Reference]
510 return value;
511 }
512
513 #if[NonPlainAccess]
514 @ForceInline
515 static $type$ getVolatile(VarHandle ob) {
516 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
517 $type$ value = UNSAFE.get$Type$Volatile(handle.base,
518 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
519 #if[Reference]
520 if (value == null && handle.nullRestricted) {
521 throw new NullPointerException("Uninitialized null-restricted field");
522 }
523 #end[Reference]
524 return value;
525 }
526
527 @ForceInline
528 static $type$ getOpaque(VarHandle ob) {
529 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
530 $type$ value = UNSAFE.get$Type$Opaque(handle.base,
531 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
532 #if[Reference]
533 if (value == null && handle.nullRestricted) {
534 throw new NullPointerException("Uninitialized null-restricted field");
535 }
536 #end[Reference]
537 return value;
538 }
539
540 @ForceInline
541 static $type$ getAcquire(VarHandle ob) {
542 FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.target();
543 $type$ value = UNSAFE.get$Type$Acquire(handle.base,
544 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
545 #if[Reference]
546 if (value == null && handle.nullRestricted) {
547 throw new NullPointerException("Uninitialized null-restricted field");
548 }
549 #end[Reference]
550 return value;
551 }
552 #end[NonPlainAccess]
553
554 static final VarForm FORM = new VarForm(FieldStaticReadOnly.class, null, $type$.class);
555 }
556
557 static final class FieldStaticReadWrite extends FieldStaticReadOnly {
558
559 FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout}) {
560 this(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
561 }
562
563 private FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout},
564 boolean exact) {
565 super(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, FieldStaticReadWrite.FORM, exact);
566 }
567
568 @Override
569 public FieldStaticReadWrite withInvokeExactBehavior() {
570 return hasInvokeExactBehavior()
571 ? this
572 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, true);
573 }
574
575 @Override
576 public FieldStaticReadWrite withInvokeBehavior() {
577 return !hasInvokeExactBehavior()
578 ? this
579 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
580 }
581
582 #if[Object]
583 @ForceInline
584 static Object checkCast(FieldStaticReadWrite handle, $type$ value) {
585 return handle.fieldType.cast(value);
586 }
587 #end[Object]
588
589 @ForceInline
590 static void set(VarHandle ob, $type$ value) {
591 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
592 UNSAFE.put$Type$(handle.base,
593 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
594 {#if[Object]?checkCast(handle, value):value});
595 }
596
597 #if[NonPlainAccess]
598 @ForceInline
599 static void setVolatile(VarHandle ob, $type$ value) {
600 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
601 UNSAFE.put$Type$Volatile(handle.base,
602 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
603 {#if[Object]?checkCast(handle, value):value});
604 }
605
606 @ForceInline
607 static void setOpaque(VarHandle ob, $type$ value) {
608 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
609 UNSAFE.put$Type$Opaque(handle.base,
610 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
611 {#if[Object]?checkCast(handle, value):value});
612 }
613
614 @ForceInline
615 static void setRelease(VarHandle ob, $type$ value) {
616 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
617 UNSAFE.put$Type$Release(handle.base,
618 handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
619 {#if[Object]?checkCast(handle, value):value});
620 }
621 #if[CAS]
622
623 @ForceInline
624 static boolean compareAndSet(VarHandle ob, $type$ expected, $type$ value) {
625 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
626 return UNSAFE.compareAndSet$Type$(handle.base,
627 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
628 {#if[Object]?checkCast(handle, expected):expected},
629 {#if[Object]?checkCast(handle, value):value});
630 }
631
632
633 @ForceInline
634 static $type$ compareAndExchange(VarHandle ob, $type$ expected, $type$ value) {
635 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
636 return UNSAFE.compareAndExchange$Type$(handle.base,
637 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
638 {#if[Object]?checkCast(handle, expected):expected},
639 {#if[Object]?checkCast(handle, value):value});
640 }
641
642 @ForceInline
643 static $type$ compareAndExchangeAcquire(VarHandle ob, $type$ expected, $type$ value) {
644 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
645 return UNSAFE.compareAndExchange$Type$Acquire(handle.base,
646 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
647 {#if[Object]?checkCast(handle, expected):expected},
648 {#if[Object]?checkCast(handle, value):value});
649 }
650
651 @ForceInline
652 static $type$ compareAndExchangeRelease(VarHandle ob, $type$ expected, $type$ value) {
653 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
654 return UNSAFE.compareAndExchange$Type$Release(handle.base,
655 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
656 {#if[Object]?checkCast(handle, expected):expected},
657 {#if[Object]?checkCast(handle, value):value});
658 }
659
660 @ForceInline
661 static boolean weakCompareAndSetPlain(VarHandle ob, $type$ expected, $type$ value) {
662 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
663 return UNSAFE.weakCompareAndSet$Type$Plain(handle.base,
664 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
665 {#if[Object]?checkCast(handle, expected):expected},
666 {#if[Object]?checkCast(handle, value):value});
667 }
668
669 @ForceInline
670 static boolean weakCompareAndSet(VarHandle ob, $type$ expected, $type$ value) {
671 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
672 return UNSAFE.weakCompareAndSet$Type$(handle.base,
673 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
674 {#if[Object]?checkCast(handle, expected):expected},
675 {#if[Object]?checkCast(handle, value):value});
676 }
677
678 @ForceInline
679 static boolean weakCompareAndSetAcquire(VarHandle ob, $type$ expected, $type$ value) {
680 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
681 return UNSAFE.weakCompareAndSet$Type$Acquire(handle.base,
682 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
683 {#if[Object]?checkCast(handle, expected):expected},
684 {#if[Object]?checkCast(handle, value):value});
685 }
686
687 @ForceInline
688 static boolean weakCompareAndSetRelease(VarHandle ob, $type$ expected, $type$ value) {
689 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
690 return UNSAFE.weakCompareAndSet$Type$Release(handle.base,
691 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
692 {#if[Object]?checkCast(handle, expected):expected},
693 {#if[Object]?checkCast(handle, value):value});
694 }
695
696 @ForceInline
697 static $type$ getAndSet(VarHandle ob, $type$ value) {
698 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
699 return UNSAFE.getAndSet$Type$(handle.base,
700 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
701 {#if[Object]?checkCast(handle, value):value});
702 }
703
704 @ForceInline
705 static $type$ getAndSetAcquire(VarHandle ob, $type$ value) {
706 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
707 return UNSAFE.getAndSet$Type$Acquire(handle.base,
708 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
709 {#if[Object]?checkCast(handle, value):value});
710 }
711
712 @ForceInline
713 static $type$ getAndSetRelease(VarHandle ob, $type$ value) {
714 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
715 return UNSAFE.getAndSet$Type$Release(handle.base,
716 handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
717 {#if[Object]?checkCast(handle, value):value});
718 }
719 #end[CAS]
720 #if[AtomicAdd]
721
722 @ForceInline
723 static $type$ getAndAdd(VarHandle ob, $type$ value) {
724 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
725 return UNSAFE.getAndAdd$Type$(handle.base,
726 handle.fieldOffset,
727 value);
728 }
729
730 @ForceInline
731 static $type$ getAndAddAcquire(VarHandle ob, $type$ value) {
732 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
733 return UNSAFE.getAndAdd$Type$Acquire(handle.base,
734 handle.fieldOffset,
735 value);
736 }
737
800 handle.fieldOffset,
801 value);
802 }
803
804 @ForceInline
805 static $type$ getAndBitwiseXorRelease(VarHandle ob, $type$ value) {
806 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
807 return UNSAFE.getAndBitwiseXor$Type$Release(handle.base,
808 handle.fieldOffset,
809 value);
810 }
811
812 @ForceInline
813 static $type$ getAndBitwiseXorAcquire(VarHandle ob, $type$ value) {
814 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
815 return UNSAFE.getAndBitwiseXor$Type$Acquire(handle.base,
816 handle.fieldOffset,
817 value);
818 }
819 #end[Bitwise]
820 #end[NonPlainAccess]
821
822 static final VarForm FORM = new VarForm(FieldStaticReadWrite.class, null, $type$.class);
823 }
824 #end[Static]
825
826 #if[Array]
827 static final class Array extends VarHandle {
828 final int abase;
829 final int ashift;
830 #if[Object]
831 final Class<{#if[Object]??:$type$[]}> arrayType;
832 final Class<?> componentType;
833 #end[Object]
834 #if[FlatValue]
835 final int layout;
836 #end[FlatValue]
837
838 Array(int abase, int ashift{#if[Object]?, Class<?> arrayType}{#if[FlatValue]?, int layout}) {
839 this(abase, ashift{#if[Object]?, arrayType}{#if[FlatValue]?, layout}, false);
840 }
841
842 private Array(int abase, int ashift{#if[Object]?, Class<?> arrayType}{#if[FlatValue]?, int layout}, boolean exact) {
843 super(Array.FORM, exact);
844 this.abase = abase;
845 this.ashift = ashift;
846 #if[Object]
847 this.arrayType = {#if[Object]?arrayType:$type$[].class};
848 this.componentType = arrayType.getComponentType();
849 #end[Object]
850 #if[FlatValue]
851 this.layout = layout;
852 #end[FlatValue]
853 }
854
855 @Override
856 public Array withInvokeExactBehavior() {
857 return hasInvokeExactBehavior()
858 ? this
859 : new Array(abase, ashift{#if[Object]?, arrayType}{#if[FlatValue]?, layout}, true);
860 }
861
862 @Override
863 public Array withInvokeBehavior() {
864 return !hasInvokeExactBehavior()
865 ? this
866 : new Array(abase, ashift{#if[Object]?, arrayType}{#if[FlatValue]?, layout}, false);
867 }
868
869 @Override
870 public Optional<VarHandleDesc> describeConstable() {
871 var arrayTypeRef = {#if[Object]?arrayType:$type$[].class}.describeConstable();
872 if (!arrayTypeRef.isPresent())
873 return Optional.empty();
874
875 return Optional.of(VarHandleDesc.ofArray(arrayTypeRef.get()));
876 }
877
878 @Override
879 final MethodType accessModeTypeUncached(AccessType at) {
880 return at.accessModeType({#if[Object]?arrayType:$type$[].class}, {#if[Object]?componentType:$type$.class}, int.class);
881 }
882
883 #if[Object]
884 @ForceInline
885 static Object runtimeTypeCheck(Array handle, Object[] oarray, Object value) {
886 if (value == null && ValueClass.isNullRestrictedArray(oarray)) {
887 throw new NullPointerException("null not allowed for null-restricted array " + oarray.getClass().toGenericString());
888 }
889 if (handle.arrayType == oarray.getClass()) {
890 // Fast path: static array type same as argument array type
891 return handle.componentType.cast(value);
892 } else {
893 // Slow path: check value against argument array component type
894 return reflectiveTypeCheck(oarray, value);
895 }
896 }
897
898 @ForceInline
899 static Object reflectiveTypeCheck(Object[] oarray, Object value) {
900 try {
901 return oarray.getClass().getComponentType().cast(value);
902 } catch (ClassCastException e) {
903 throw new ArrayStoreException();
904 }
905 }
906 #end[Object]
907
908 @ForceInline
909 static $type$ get(VarHandle ob, Object oarray, int index) {
910 Array handle = (Array)ob;
911 #if[Object]
912 Object[] array = (Object[]) handle.arrayType.cast(oarray);
913 #else[Object]
914 $type$[] array = ($type$[]) oarray;
915 #end[Object]
916 return array[index];
917 }
918
919 @ForceInline
920 static void set(VarHandle ob, Object oarray, int index, $type$ value) {
921 Array handle = (Array)ob;
922 #if[Object]
923 Object[] array = (Object[]) handle.arrayType.cast(oarray);
924 #else[Object]
925 $type$[] array = ($type$[]) oarray;
926 #end[Object]
927 array[index] = {#if[Object]?runtimeTypeCheck(handle, array, value):value};
928 }
929
930 #if[NonPlainAccess]
931 @ForceInline
932 static $type$ getVolatile(VarHandle ob, Object oarray, int index) {
933 Array handle = (Array)ob;
934 #if[Object]
935 Object[] array = (Object[]) handle.arrayType.cast(oarray);
936 #else[Object]
937 $type$[] array = ($type$[]) oarray;
938 #end[Object]
939 #if[Reference]
940 Class<?> arrayType = oarray.getClass();
941 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
942 // delegate to flat access primitives
943 VarHandles.checkAtomicFlatArray(array);
944 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
945 int ascale = UNSAFE.arrayIndexScale(arrayType);
946 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
947 int layout = UNSAFE.arrayLayout(arrayType);
948 return UNSAFE.getFlatValueVolatile(array,
949 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType());
950 }
951 #end[Reference]
952 return UNSAFE.get$Type$Volatile(array,
953 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase);
954 }
955
956 @ForceInline
957 static void setVolatile(VarHandle ob, Object oarray, int index, $type$ value) {
958 Array handle = (Array)ob;
959 #if[Object]
960 Object[] array = (Object[]) handle.arrayType.cast(oarray);
961 #else[Object]
962 $type$[] array = ($type$[]) oarray;
963 #end[Object]
964 #if[Reference]
965 Class<?> arrayType = oarray.getClass();
966 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
967 // delegate to flat access primitives
968 VarHandles.checkAtomicFlatArray(array);
969 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
970 int ascale = UNSAFE.arrayIndexScale(arrayType);
971 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
972 int layout = UNSAFE.arrayLayout(arrayType);
973 UNSAFE.putFlatValueVolatile(array,
974 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
975 runtimeTypeCheck(handle, array, value));
976 return;
977 }
978 #end[Reference]
979 UNSAFE.put$Type$Volatile(array,
980 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
981 {#if[FlatValue]?handle.layout, handle.componentType, }{#if[Object]?runtimeTypeCheck(handle, array, value):value});
982 }
983
984 @ForceInline
985 static $type$ getOpaque(VarHandle ob, Object oarray, int index) {
986 Array handle = (Array)ob;
987 #if[Object]
988 Object[] array = (Object[]) handle.arrayType.cast(oarray);
989 #else[Object]
990 $type$[] array = ($type$[]) oarray;
991 #end[Object]
992 #if[Reference]
993 Class<?> arrayType = oarray.getClass();
994 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
995 // delegate to flat access primitives
996 VarHandles.checkAtomicFlatArray(array);
997 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
998 int ascale = UNSAFE.arrayIndexScale(arrayType);
999 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1000 int layout = UNSAFE.arrayLayout(arrayType);
1001 return UNSAFE.getFlatValueOpaque(array,
1002 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType());
1003 }
1004 #end[Reference]
1005 return UNSAFE.get$Type$Opaque(array,
1006 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[FlatValue]?, handle.layout, handle.componentType});
1007 }
1008
1009 @ForceInline
1010 static void setOpaque(VarHandle ob, Object oarray, int index, $type$ value) {
1011 Array handle = (Array)ob;
1012 #if[Object]
1013 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1014 #else[Object]
1015 $type$[] array = ($type$[]) oarray;
1016 #end[Object]
1017 #if[Reference]
1018 Class<?> arrayType = oarray.getClass();
1019 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1020 // delegate to flat access primitives
1021 VarHandles.checkAtomicFlatArray(array);
1022 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1023 int ascale = UNSAFE.arrayIndexScale(arrayType);
1024 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1025 int layout = UNSAFE.arrayLayout(arrayType);
1026 UNSAFE.putFlatValueOpaque(array,
1027 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1028 runtimeTypeCheck(handle, array, value));
1029 return;
1030 }
1031 #end[Reference]
1032 UNSAFE.put$Type$Opaque(array,
1033 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1034 {#if[FlatValue]?handle.layout, handle.componentType, }{#if[Object]?runtimeTypeCheck(handle, array, value):value});
1035 }
1036
1037 @ForceInline
1038 static $type$ getAcquire(VarHandle ob, Object oarray, int index) {
1039 Array handle = (Array)ob;
1040 #if[Object]
1041 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1042 #else[Object]
1043 $type$[] array = ($type$[]) oarray;
1044 #end[Object]
1045 #if[Reference]
1046 Class<?> arrayType = oarray.getClass();
1047 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1048 // delegate to flat access primitives
1049 VarHandles.checkAtomicFlatArray(array);
1050 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1051 int ascale = UNSAFE.arrayIndexScale(arrayType);
1052 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1053 int layout = UNSAFE.arrayLayout(arrayType);
1054 return UNSAFE.getFlatValueAcquire(array,
1055 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType());
1056 }
1057 #end[Reference]
1058 return UNSAFE.get$Type$Acquire(array,
1059 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[FlatValue]?, handle.layout, handle.componentType});
1060 }
1061
1062 @ForceInline
1063 static void setRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1064 Array handle = (Array)ob;
1065 #if[Object]
1066 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1067 #else[Object]
1068 $type$[] array = ($type$[]) oarray;
1069 #end[Object]
1070 #if[Reference]
1071 Class<?> arrayType = oarray.getClass();
1072 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1073 // delegate to flat access primitives
1074 VarHandles.checkAtomicFlatArray(array);
1075 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1076 int ascale = UNSAFE.arrayIndexScale(arrayType);
1077 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1078 int layout = UNSAFE.arrayLayout(arrayType);
1079 UNSAFE.putFlatValueRelease(array,
1080 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1081 runtimeTypeCheck(handle, array, value));
1082 return;
1083 }
1084 #end[Reference]
1085 UNSAFE.put$Type$Release(array,
1086 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1087 {#if[FlatValue]?handle.layout, handle.componentType, }{#if[Object]?runtimeTypeCheck(handle, array, value):value});
1088 }
1089 #if[CAS]
1090
1091 @ForceInline
1092 static boolean compareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1093 Array handle = (Array)ob;
1094 #if[Object]
1095 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1096 #else[Object]
1097 $type$[] array = ($type$[]) oarray;
1098 #end[Object]
1099 #if[Reference]
1100 Class<?> arrayType = oarray.getClass();
1101 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1102 // delegate to flat access primitives
1103 VarHandles.checkAtomicFlatArray(array);
1104 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1105 int ascale = UNSAFE.arrayIndexScale(arrayType);
1106 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1107 int layout = UNSAFE.arrayLayout(arrayType);
1108 return UNSAFE.compareAndSetFlatValue(array,
1109 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1110 arrayType.componentType().cast(expected),
1111 runtimeTypeCheck(handle, array, value));
1112 }
1113 #end[Reference]
1114 return UNSAFE.compareAndSet$Type$(array,
1115 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.componentType},
1116 {#if[Object]?handle.componentType.cast(expected):expected},
1117 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1118 }
1119
1120 @ForceInline
1121 static $type$ compareAndExchange(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1122 Array handle = (Array)ob;
1123 #if[Object]
1124 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1125 #else[Object]
1126 $type$[] array = ($type$[]) oarray;
1127 #end[Object]
1128 #if[Reference]
1129 Class<?> arrayType = oarray.getClass();
1130 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1131 // delegate to flat access primitives
1132 VarHandles.checkAtomicFlatArray(array);
1133 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1134 int ascale = UNSAFE.arrayIndexScale(arrayType);
1135 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1136 int layout = UNSAFE.arrayLayout(arrayType);
1137 return UNSAFE.compareAndExchangeFlatValue(array,
1138 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1139 arrayType.componentType().cast(expected),
1140 runtimeTypeCheck(handle, array, value));
1141 }
1142 #end[Reference]
1143 return UNSAFE.compareAndExchange$Type$(array,
1144 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.componentType},
1145 {#if[Object]?handle.componentType.cast(expected):expected},
1146 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1147 }
1148
1149 @ForceInline
1150 static $type$ compareAndExchangeAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1151 Array handle = (Array)ob;
1152 #if[Object]
1153 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1154 #else[Object]
1155 $type$[] array = ($type$[]) oarray;
1156 #end[Object]
1157 #if[Reference]
1158 Class<?> arrayType = oarray.getClass();
1159 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1160 // delegate to flat access primitives
1161 VarHandles.checkAtomicFlatArray(array);
1162 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1163 int ascale = UNSAFE.arrayIndexScale(arrayType);
1164 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1165 int layout = UNSAFE.arrayLayout(arrayType);
1166 return UNSAFE.compareAndExchangeFlatValueAcquire(array,
1167 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1168 arrayType.componentType().cast(expected),
1169 runtimeTypeCheck(handle, array, value));
1170 }
1171 #end[Reference]
1172 return UNSAFE.compareAndExchange$Type$Acquire(array,
1173 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.componentType},
1174 {#if[Object]?handle.componentType.cast(expected):expected},
1175 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1176 }
1177
1178 @ForceInline
1179 static $type$ compareAndExchangeRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1180 Array handle = (Array)ob;
1181 #if[Object]
1182 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1183 #else[Object]
1184 $type$[] array = ($type$[]) oarray;
1185 #end[Object]
1186 #if[Reference]
1187 Class<?> arrayType = oarray.getClass();
1188 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1189 // delegate to flat access primitives
1190 VarHandles.checkAtomicFlatArray(array);
1191 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1192 int ascale = UNSAFE.arrayIndexScale(arrayType);
1193 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1194 int layout = UNSAFE.arrayLayout(arrayType);
1195 return UNSAFE.compareAndExchangeFlatValueRelease(array,
1196 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1197 arrayType.componentType().cast(expected),
1198 runtimeTypeCheck(handle, array, value));
1199 }
1200 #end[Reference]
1201 return UNSAFE.compareAndExchange$Type$Release(array,
1202 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1203 {#if[Object]?handle.componentType.cast(expected):expected},
1204 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1205 }
1206
1207 @ForceInline
1208 static boolean weakCompareAndSetPlain(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1209 Array handle = (Array)ob;
1210 #if[Object]
1211 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1212 #else[Object]
1213 $type$[] array = ($type$[]) oarray;
1214 #end[Object]
1215 #if[Reference]
1216 Class<?> arrayType = oarray.getClass();
1217 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1218 // delegate to flat access primitives
1219 VarHandles.checkAtomicFlatArray(array);
1220 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1221 int ascale = UNSAFE.arrayIndexScale(arrayType);
1222 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1223 int layout = UNSAFE.arrayLayout(arrayType);
1224 return UNSAFE.weakCompareAndSetFlatValuePlain(array,
1225 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1226 arrayType.componentType().cast(expected),
1227 runtimeTypeCheck(handle, array, value));
1228 }
1229 #end[Reference]
1230 return UNSAFE.weakCompareAndSet$Type$Plain(array,
1231 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1232 {#if[Object]?handle.componentType.cast(expected):expected},
1233 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1234 }
1235
1236 @ForceInline
1237 static boolean weakCompareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1238 Array handle = (Array)ob;
1239 #if[Object]
1240 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1241 #else[Object]
1242 $type$[] array = ($type$[]) oarray;
1243 #end[Object]
1244 #if[Reference]
1245 Class<?> arrayType = oarray.getClass();
1246 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1247 // delegate to flat access primitives
1248 VarHandles.checkAtomicFlatArray(array);
1249 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1250 int ascale = UNSAFE.arrayIndexScale(arrayType);
1251 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1252 int layout = UNSAFE.arrayLayout(arrayType);
1253 return UNSAFE.weakCompareAndSetFlatValue(array,
1254 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1255 arrayType.componentType().cast(expected),
1256 runtimeTypeCheck(handle, array, value));
1257 }
1258 #end[Reference]
1259 return UNSAFE.weakCompareAndSet$Type$(array,
1260 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1261 {#if[Object]?handle.componentType.cast(expected):expected},
1262 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1263 }
1264
1265 @ForceInline
1266 static boolean weakCompareAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1267 Array handle = (Array)ob;
1268 #if[Object]
1269 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1270 #else[Object]
1271 $type$[] array = ($type$[]) oarray;
1272 #end[Object]
1273 #if[Reference]
1274 Class<?> arrayType = oarray.getClass();
1275 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1276 // delegate to flat access primitives
1277 VarHandles.checkAtomicFlatArray(array);
1278 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1279 int ascale = UNSAFE.arrayIndexScale(arrayType);
1280 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1281 int layout = UNSAFE.arrayLayout(arrayType);
1282 return UNSAFE.weakCompareAndSetFlatValueAcquire(array,
1283 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1284 arrayType.componentType().cast(expected),
1285 runtimeTypeCheck(handle, array, value));
1286 }
1287 #end[Reference]
1288 return UNSAFE.weakCompareAndSet$Type$Acquire(array,
1289 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1290 {#if[Object]?handle.componentType.cast(expected):expected},
1291 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1292 }
1293
1294 @ForceInline
1295 static boolean weakCompareAndSetRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1296 Array handle = (Array)ob;
1297 #if[Object]
1298 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1299 #else[Object]
1300 $type$[] array = ($type$[]) oarray;
1301 #end[Object]
1302 #if[Reference]
1303 Class<?> arrayType = oarray.getClass();
1304 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1305 // delegate to flat access primitives
1306 VarHandles.checkAtomicFlatArray(array);
1307 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1308 int ascale = UNSAFE.arrayIndexScale(arrayType);
1309 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1310 int layout = UNSAFE.arrayLayout(arrayType);
1311 return UNSAFE.weakCompareAndSetFlatValueRelease(array,
1312 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1313 arrayType.componentType().cast(expected),
1314 runtimeTypeCheck(handle, array, value));
1315 }
1316 #end[Reference]
1317 return UNSAFE.weakCompareAndSet$Type$Release(array,
1318 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1319 {#if[Object]?handle.componentType.cast(expected):expected},
1320 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1321 }
1322
1323 @ForceInline
1324 static $type$ getAndSet(VarHandle ob, Object oarray, int index, $type$ value) {
1325 Array handle = (Array)ob;
1326 #if[Object]
1327 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1328 #else[Object]
1329 $type$[] array = ($type$[]) oarray;
1330 #end[Object]
1331 #if[Reference]
1332 Class<?> arrayType = oarray.getClass();
1333 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1334 // delegate to flat access primitives
1335 VarHandles.checkAtomicFlatArray(array);
1336 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1337 int ascale = UNSAFE.arrayIndexScale(arrayType);
1338 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1339 int layout = UNSAFE.arrayLayout(arrayType);
1340 return UNSAFE.getAndSetFlatValue(array,
1341 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1342 runtimeTypeCheck(handle, array, value));
1343 }
1344 #end[Reference]
1345 return UNSAFE.getAndSet$Type$(array,
1346 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1347 {#if[Object]?handle.componentType, runtimeTypeCheck(handle, array, value):value});
1348 }
1349
1350 @ForceInline
1351 static $type$ getAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1352 Array handle = (Array)ob;
1353 #if[Object]
1354 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1355 #else[Object]
1356 $type$[] array = ($type$[]) oarray;
1357 #end[Object]
1358 #if[Reference]
1359 Class<?> arrayType = oarray.getClass();
1360 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1361 // delegate to flat access primitives
1362 VarHandles.checkAtomicFlatArray(array);
1363 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1364 int ascale = UNSAFE.arrayIndexScale(arrayType);
1365 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1366 int layout = UNSAFE.arrayLayout(arrayType);
1367 return UNSAFE.getAndSetFlatValueAcquire(array,
1368 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1369 runtimeTypeCheck(handle, array, value));
1370 }
1371 #end[Reference]
1372 return UNSAFE.getAndSet$Type$Acquire(array,
1373 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1374 {#if[Object]?handle.componentType, runtimeTypeCheck(handle, array, value):value});
1375 }
1376
1377 @ForceInline
1378 static $type$ getAndSetRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1379 Array handle = (Array)ob;
1380 #if[Object]
1381 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1382 #else[Object]
1383 $type$[] array = ($type$[]) oarray;
1384 #end[Object]
1385 #if[Reference]
1386 Class<?> arrayType = oarray.getClass();
1387 if (handle.arrayType != arrayType && ValueClass.isFlatArray(oarray)) {
1388 // delegate to flat access primitives
1389 VarHandles.checkAtomicFlatArray(array);
1390 int aoffset = (int) UNSAFE.arrayBaseOffset(arrayType);
1391 int ascale = UNSAFE.arrayIndexScale(arrayType);
1392 int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
1393 int layout = UNSAFE.arrayLayout(arrayType);
1394 return UNSAFE.getAndSetFlatValueRelease(array,
1395 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << ashift) + aoffset, layout, arrayType.componentType(),
1396 runtimeTypeCheck(handle, array, value));
1397 }
1398 #end[Reference]
1399 return UNSAFE.getAndSet$Type$Release(array,
1400 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1401 {#if[Object]?handle.componentType, runtimeTypeCheck(handle, array, value):value});
1402 }
1403 #end[CAS]
1404 #if[AtomicAdd]
1405
1406 @ForceInline
1407 static $type$ getAndAdd(VarHandle ob, Object oarray, int index, $type$ value) {
1408 Array handle = (Array)ob;
1409 $type$[] array = ($type$[]) oarray;
1410 return UNSAFE.getAndAdd$Type$(array,
1411 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1412 value);
1413 }
1414
1415 @ForceInline
1416 static $type$ getAndAddAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1417 Array handle = (Array)ob;
1418 $type$[] array = ($type$[]) oarray;
1419 return UNSAFE.getAndAdd$Type$Acquire(array,
1420 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1421 value);
1496 }
1497
1498 @ForceInline
1499 static $type$ getAndBitwiseXorRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1500 Array handle = (Array)ob;
1501 $type$[] array = ($type$[]) oarray;
1502 return UNSAFE.getAndBitwiseXor$Type$Release(array,
1503 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1504 value);
1505 }
1506
1507 @ForceInline
1508 static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1509 Array handle = (Array)ob;
1510 $type$[] array = ($type$[]) oarray;
1511 return UNSAFE.getAndBitwiseXor$Type$Acquire(array,
1512 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1513 value);
1514 }
1515 #end[Bitwise]
1516 #end[NonPlainAccess]
1517
1518 static final VarForm FORM = new VarForm(Array.class, {#if[Object]?Object[].class:$type$[].class}, {#if[Object]?Object.class:$type$.class}, int.class);
1519 }
1520 #end[Array]
1521 }
|