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