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
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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();
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,
|
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{#if[Value]?, handle.fieldType});
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{#if[Value]?, handle.fieldType});
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{#if[Value]?, handle.fieldType});
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{#if[Value]?, handle.fieldType});
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 FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
126 this(receiverType, fieldOffset{#if[Object]?, fieldType}, false);
127 }
128
129 private FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType},
130 boolean exact) {
131 super(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadWrite.FORM, exact);
132 }
133
134 @Override
135 public FieldInstanceReadWrite withInvokeExactBehavior() {
136 return hasInvokeExactBehavior()
137 ? this
138 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType}, true);
139 }
140
141 @Override
142 public FieldInstanceReadWrite withInvokeBehavior() {
143 return !hasInvokeExactBehavior()
144 ? this
145 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType}, false);
146 }
147
148 #if[Object]
149 @ForceInline
150 static Object checkCast(FieldInstanceReadWrite handle, $type$ value) {
151 return handle.fieldType.cast(value);
152 }
153 #end[Object]
154
155 @ForceInline
156 static void set(VarHandle ob, Object holder, $type$ value) {
157 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
158 UNSAFE.put$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
159 handle.fieldOffset{#if[Value]?, handle.fieldType},
160 {#if[Object]?checkCast(handle, value):value});
161 }
162
163 @ForceInline
164 static void setVolatile(VarHandle ob, Object holder, $type$ value) {
165 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
166 UNSAFE.put$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
167 handle.fieldOffset{#if[Value]?, handle.fieldType},
168 {#if[Object]?checkCast(handle, value):value});
169 }
170
171 @ForceInline
172 static void setOpaque(VarHandle ob, Object holder, $type$ value) {
173 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
174 UNSAFE.put$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
175 handle.fieldOffset{#if[Value]?, handle.fieldType},
176 {#if[Object]?checkCast(handle, value):value});
177 }
178
179 @ForceInline
180 static void setRelease(VarHandle ob, Object holder, $type$ value) {
181 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
182 UNSAFE.put$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
183 handle.fieldOffset{#if[Value]?, handle.fieldType},
184 {#if[Object]?checkCast(handle, value):value});
185 }
186 #if[CAS]
187
188 @ForceInline
189 static boolean compareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
190 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
191 return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
192 handle.fieldOffset{#if[Object]?, handle.fieldType},
193 {#if[Object]?checkCast(handle, expected):expected},
194 {#if[Object]?checkCast(handle, value):value});
195 }
196
197 @ForceInline
198 static $type$ compareAndExchange(VarHandle ob, Object holder, $type$ expected, $type$ value) {
199 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
200 return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
201 handle.fieldOffset{#if[Object]?, handle.fieldType},
202 {#if[Object]?checkCast(handle, expected):expected},
203 {#if[Object]?checkCast(handle, value):value});
204 }
205
206 @ForceInline
207 static $type$ compareAndExchangeAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
208 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
209 return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
210 handle.fieldOffset{#if[Object]?, handle.fieldType},
211 {#if[Object]?checkCast(handle, expected):expected},
212 {#if[Object]?checkCast(handle, value):value});
213 }
214
215 @ForceInline
216 static $type$ compareAndExchangeRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
217 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
218 return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
219 handle.fieldOffset{#if[Object]?, handle.fieldType},
220 {#if[Object]?checkCast(handle, expected):expected},
221 {#if[Object]?checkCast(handle, value):value});
222 }
223
224 @ForceInline
225 static boolean weakCompareAndSetPlain(VarHandle ob, Object holder, $type$ expected, $type$ value) {
226 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
227 return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
228 handle.fieldOffset{#if[Object]?, handle.fieldType},
229 {#if[Object]?checkCast(handle, expected):expected},
230 {#if[Object]?checkCast(handle, value):value});
231 }
232
233 @ForceInline
234 static boolean weakCompareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
235 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
236 return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
237 handle.fieldOffset{#if[Object]?, handle.fieldType},
238 {#if[Object]?checkCast(handle, expected):expected},
239 {#if[Object]?checkCast(handle, value):value});
240 }
241
242 @ForceInline
243 static boolean weakCompareAndSetAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
244 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
245 return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
246 handle.fieldOffset{#if[Object]?, handle.fieldType},
247 {#if[Object]?checkCast(handle, expected):expected},
248 {#if[Object]?checkCast(handle, value):value});
249 }
250
251 @ForceInline
252 static boolean weakCompareAndSetRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
253 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
254 return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
255 handle.fieldOffset{#if[Object]?, handle.fieldType},
256 {#if[Object]?checkCast(handle, expected):expected},
257 {#if[Object]?checkCast(handle, value):value});
258 }
259
260 @ForceInline
261 static $type$ getAndSet(VarHandle ob, Object holder, $type$ value) {
262 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
263 return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
264 handle.fieldOffset{#if[Value]?, handle.fieldType},
265 {#if[Object]?checkCast(handle, value):value});
266 }
267
268 @ForceInline
269 static $type$ getAndSetAcquire(VarHandle ob, Object holder, $type$ value) {
270 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
271 return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
272 handle.fieldOffset{#if[Value]?, handle.fieldType},
273 {#if[Object]?checkCast(handle, value):value});
274 }
275
276 @ForceInline
277 static $type$ getAndSetRelease(VarHandle ob, Object holder, $type$ value) {
278 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
279 return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
280 handle.fieldOffset{#if[Value]?, handle.fieldType},
281 {#if[Object]?checkCast(handle, value):value});
282 }
283 #end[CAS]
284 #if[AtomicAdd]
285
286 @ForceInline
287 static $type$ getAndAdd(VarHandle ob, Object holder, $type$ value) {
288 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
289 return UNSAFE.getAndAdd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
290 handle.fieldOffset,
291 value);
292 }
293
294 @ForceInline
295 static $type$ getAndAddAcquire(VarHandle ob, Object holder, $type$ value) {
296 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
297 return UNSAFE.getAndAdd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
298 handle.fieldOffset,
299 value);
300 }
301
431 return Optional.empty();
432
433 // Reflect on this VarHandle to extract the field name
434 var staticField = VarHandles.getStaticFieldFromBaseAndOffset(
435 declaringClass, fieldOffset, {#if[Object]?fieldType:$type$.class});
436 var declaringTypeRef = declaringClass.describeConstable();
437 if (!declaringTypeRef.isPresent())
438 return Optional.empty();
439 return Optional.of(VarHandleDesc.ofStaticField(declaringTypeRef.get(), staticField.getName(), fieldTypeRef.get()));
440 }
441
442 @Override
443 final MethodType accessModeTypeUncached(AccessType at) {
444 return at.accessModeType(null, {#if[Object]?fieldType:$type$.class});
445 }
446
447 @ForceInline
448 static $type$ get(VarHandle ob) {
449 FieldStaticReadOnly handle = (FieldStaticReadOnly)ob;
450 return UNSAFE.get$Type$(handle.base,
451 handle.fieldOffset{#if[Value]?, handle.fieldType});
452 }
453
454 @ForceInline
455 static $type$ getVolatile(VarHandle ob) {
456 FieldStaticReadOnly handle = (FieldStaticReadOnly)ob;
457 return UNSAFE.get$Type$Volatile(handle.base,
458 handle.fieldOffset{#if[Value]?, handle.fieldType});
459 }
460
461 @ForceInline
462 static $type$ getOpaque(VarHandle ob) {
463 FieldStaticReadOnly handle = (FieldStaticReadOnly)ob;
464 return UNSAFE.get$Type$Opaque(handle.base,
465 handle.fieldOffset{#if[Value]?, handle.fieldType});
466 }
467
468 @ForceInline
469 static $type$ getAcquire(VarHandle ob) {
470 FieldStaticReadOnly handle = (FieldStaticReadOnly)ob;
471 return UNSAFE.get$Type$Acquire(handle.base,
472 handle.fieldOffset{#if[Value]?, handle.fieldType});
473 }
474
475 static final VarForm FORM = new VarForm(FieldStaticReadOnly.class, null, $type$.class);
476 }
477
478 static final class FieldStaticReadWrite extends FieldStaticReadOnly {
479
480 FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
481 this(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, false);
482 }
483
484 private FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType},
485 boolean exact) {
486 super(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadWrite.FORM, exact);
487 }
488
489 @Override
490 public FieldStaticReadWrite withInvokeExactBehavior() {
491 return hasInvokeExactBehavior()
492 ? this
493 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, true);
494 }
495
496 @Override
497 public FieldStaticReadWrite withInvokeBehavior() {
498 return !hasInvokeExactBehavior()
499 ? this
500 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, false);
501 }
502
503 #if[Object]
504 static Object checkCast(FieldStaticReadWrite handle, $type$ value) {
505 return handle.fieldType.cast(value);
506 }
507 #end[Object]
508
509 @ForceInline
510 static void set(VarHandle ob, $type$ value) {
511 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
512 UNSAFE.put$Type$(handle.base,
513 handle.fieldOffset{#if[Value]?, handle.fieldType},
514 {#if[Object]?checkCast(handle, value):value});
515 }
516
517 @ForceInline
518 static void setVolatile(VarHandle ob, $type$ value) {
519 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
520 UNSAFE.put$Type$Volatile(handle.base,
521 handle.fieldOffset{#if[Value]?, handle.fieldType},
522 {#if[Object]?checkCast(handle, value):value});
523 }
524
525 @ForceInline
526 static void setOpaque(VarHandle ob, $type$ value) {
527 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
528 UNSAFE.put$Type$Opaque(handle.base,
529 handle.fieldOffset{#if[Value]?, handle.fieldType},
530 {#if[Object]?checkCast(handle, value):value});
531 }
532
533 @ForceInline
534 static void setRelease(VarHandle ob, $type$ value) {
535 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
536 UNSAFE.put$Type$Release(handle.base,
537 handle.fieldOffset{#if[Value]?, handle.fieldType},
538 {#if[Object]?checkCast(handle, value):value});
539 }
540 #if[CAS]
541
542 @ForceInline
543 static boolean compareAndSet(VarHandle ob, $type$ expected, $type$ value) {
544 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
545 return UNSAFE.compareAndSet$Type$(handle.base,
546 handle.fieldOffset{#if[Object]?, handle.fieldType},
547 {#if[Object]?checkCast(handle, expected):expected},
548 {#if[Object]?checkCast(handle, value):value});
549 }
550
551
552 @ForceInline
553 static $type$ compareAndExchange(VarHandle ob, $type$ expected, $type$ value) {
554 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
555 return UNSAFE.compareAndExchange$Type$(handle.base,
556 handle.fieldOffset{#if[Object]?, handle.fieldType},
557 {#if[Object]?checkCast(handle, expected):expected},
558 {#if[Object]?checkCast(handle, value):value});
559 }
560
561 @ForceInline
562 static $type$ compareAndExchangeAcquire(VarHandle ob, $type$ expected, $type$ value) {
563 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
564 return UNSAFE.compareAndExchange$Type$Acquire(handle.base,
565 handle.fieldOffset{#if[Object]?, handle.fieldType},
566 {#if[Object]?checkCast(handle, expected):expected},
567 {#if[Object]?checkCast(handle, value):value});
568 }
569
570 @ForceInline
571 static $type$ compareAndExchangeRelease(VarHandle ob, $type$ expected, $type$ value) {
572 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
573 return UNSAFE.compareAndExchange$Type$Release(handle.base,
574 handle.fieldOffset{#if[Object]?, handle.fieldType},
575 {#if[Object]?checkCast(handle, expected):expected},
576 {#if[Object]?checkCast(handle, value):value});
577 }
578
579 @ForceInline
580 static boolean weakCompareAndSetPlain(VarHandle ob, $type$ expected, $type$ value) {
581 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
582 return UNSAFE.weakCompareAndSet$Type$Plain(handle.base,
583 handle.fieldOffset{#if[Object]?, handle.fieldType},
584 {#if[Object]?checkCast(handle, expected):expected},
585 {#if[Object]?checkCast(handle, value):value});
586 }
587
588 @ForceInline
589 static boolean weakCompareAndSet(VarHandle ob, $type$ expected, $type$ value) {
590 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
591 return UNSAFE.weakCompareAndSet$Type$(handle.base,
592 handle.fieldOffset{#if[Object]?, handle.fieldType},
593 {#if[Object]?checkCast(handle, expected):expected},
594 {#if[Object]?checkCast(handle, value):value});
595 }
596
597 @ForceInline
598 static boolean weakCompareAndSetAcquire(VarHandle ob, $type$ expected, $type$ value) {
599 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
600 return UNSAFE.weakCompareAndSet$Type$Acquire(handle.base,
601 handle.fieldOffset{#if[Object]?, handle.fieldType},
602 {#if[Object]?checkCast(handle, expected):expected},
603 {#if[Object]?checkCast(handle, value):value});
604 }
605
606 @ForceInline
607 static boolean weakCompareAndSetRelease(VarHandle ob, $type$ expected, $type$ value) {
608 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
609 return UNSAFE.weakCompareAndSet$Type$Release(handle.base,
610 handle.fieldOffset{#if[Object]?, handle.fieldType},
611 {#if[Object]?checkCast(handle, expected):expected},
612 {#if[Object]?checkCast(handle, value):value});
613 }
614
615 @ForceInline
616 static $type$ getAndSet(VarHandle ob, $type$ value) {
617 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
618 return UNSAFE.getAndSet$Type$(handle.base,
619 handle.fieldOffset{#if[Value]?, handle.fieldType},
620 {#if[Object]?checkCast(handle, value):value});
621 }
622
623 @ForceInline
624 static $type$ getAndSetAcquire(VarHandle ob, $type$ value) {
625 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
626 return UNSAFE.getAndSet$Type$Acquire(handle.base,
627 handle.fieldOffset{#if[Value]?, handle.fieldType},
628 {#if[Object]?checkCast(handle, value):value});
629 }
630
631 @ForceInline
632 static $type$ getAndSetRelease(VarHandle ob, $type$ value) {
633 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
634 return UNSAFE.getAndSet$Type$Release(handle.base,
635 handle.fieldOffset{#if[Value]?, handle.fieldType},
636 {#if[Object]?checkCast(handle, value):value});
637 }
638 #end[CAS]
639 #if[AtomicAdd]
640
641 @ForceInline
642 static $type$ getAndAdd(VarHandle ob, $type$ value) {
643 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
644 return UNSAFE.getAndAdd$Type$(handle.base,
645 handle.fieldOffset,
646 value);
647 }
648
649 @ForceInline
650 static $type$ getAndAddAcquire(VarHandle ob, $type$ value) {
651 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
652 return UNSAFE.getAndAdd$Type$Acquire(handle.base,
653 handle.fieldOffset,
654 value);
655 }
656
723 @ForceInline
724 static $type$ getAndBitwiseXorRelease(VarHandle ob, $type$ value) {
725 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
726 return UNSAFE.getAndBitwiseXor$Type$Release(handle.base,
727 handle.fieldOffset,
728 value);
729 }
730
731 @ForceInline
732 static $type$ getAndBitwiseXorAcquire(VarHandle ob, $type$ value) {
733 FieldStaticReadWrite handle = (FieldStaticReadWrite)ob;
734 return UNSAFE.getAndBitwiseXor$Type$Acquire(handle.base,
735 handle.fieldOffset,
736 value);
737 }
738 #end[Bitwise]
739
740 static final VarForm FORM = new VarForm(FieldStaticReadWrite.class, null, $type$.class);
741 }
742
743 #if[Reference]
744 static VarHandle makeVarHandleValuesArray(Class<?> arrayClass) {
745 Class<?> componentType = arrayClass.getComponentType();
746 assert UNSAFE.isFlattenedArray(arrayClass);
747 // should cache these VarHandle for performance
748 return VarHandles.makeArrayElementHandle(arrayClass);
749 }
750 #end[Reference]
751
752 static final class Array extends VarHandle {
753 final int abase;
754 final int ashift;
755 #if[Object]
756 final Class<{#if[Object]??:$type$[]}> arrayType;
757 final Class<?> componentType;
758 #end[Object]
759
760 Array(int abase, int ashift{#if[Object]?, Class<?> arrayType}) {
761 this(abase, ashift{#if[Object]?, arrayType}, false);
762 }
763
764 private Array(int abase, int ashift{#if[Object]?, Class<?> arrayType}, boolean exact) {
765 super(Array.FORM, exact);
766 this.abase = abase;
767 this.ashift = ashift;
768 #if[Object]
769 this.arrayType = {#if[Object]?arrayType:$type$[].class};
770 this.componentType = arrayType.getComponentType();
823
824 @ForceInline
825 static $type$ get(VarHandle ob, Object oarray, int index) {
826 Array handle = (Array)ob;
827 #if[Object]
828 Object[] array = (Object[]) handle.arrayType.cast(oarray);
829 #else[Object]
830 $type$[] array = ($type$[]) oarray;
831 #end[Object]
832 return array[index];
833 }
834
835 @ForceInline
836 static void set(VarHandle ob, Object oarray, int index, $type$ value) {
837 Array handle = (Array)ob;
838 #if[Object]
839 Object[] array = (Object[]) handle.arrayType.cast(oarray);
840 #else[Object]
841 $type$[] array = ($type$[]) oarray;
842 #end[Object]
843 #if[Reference]
844 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
845 // for flattened array, delegate to VarHandle of the inline type array
846 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
847 vh.set(oarray, index, reflectiveTypeCheck(array, value));
848 return;
849 }
850 #end[Reference]
851 array[index] = {#if[Object]?runtimeTypeCheck(handle, array, value):value};
852 }
853
854 @ForceInline
855 static $type$ getVolatile(VarHandle ob, Object oarray, int index) {
856 Array handle = (Array)ob;
857 #if[Object]
858 Object[] array = (Object[]) handle.arrayType.cast(oarray);
859 #else[Object]
860 $type$[] array = ($type$[]) oarray;
861 #end[Object]
862 #if[Reference]
863 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
864 // for flattened array, delegate to VarHandle of the inline type array
865 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
866 return vh.getVolatile(oarray, index);
867 }
868 #end[Reference]
869 return UNSAFE.get$Type$Volatile(array,
870 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType});
871 }
872
873 @ForceInline
874 static void setVolatile(VarHandle ob, Object oarray, int index, $type$ value) {
875 Array handle = (Array)ob;
876 #if[Object]
877 Object[] array = (Object[]) handle.arrayType.cast(oarray);
878 #else[Object]
879 $type$[] array = ($type$[]) oarray;
880 #end[Object]
881 #if[Reference]
882 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
883 // for flattened array, delegate to VarHandle of the inline type array
884 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
885 vh.setVolatile(oarray, index, reflectiveTypeCheck(array, value));
886 return;
887 }
888 #end[Reference]
889 UNSAFE.put$Type$Volatile(array,
890 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType},
891 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
892 }
893
894 @ForceInline
895 static $type$ getOpaque(VarHandle ob, Object oarray, int index) {
896 Array handle = (Array)ob;
897 #if[Object]
898 Object[] array = (Object[]) handle.arrayType.cast(oarray);
899 #else[Object]
900 $type$[] array = ($type$[]) oarray;
901 #end[Object]
902 #if[Reference]
903 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
904 // for flattened array, delegate to VarHandle of the inline type array
905 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
906 return vh.getOpaque(oarray, index);
907 }
908 #end[Reference]
909 return UNSAFE.get$Type$Opaque(array,
910 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType});
911 }
912
913 @ForceInline
914 static void setOpaque(VarHandle ob, Object oarray, int index, $type$ value) {
915 Array handle = (Array)ob;
916 #if[Object]
917 Object[] array = (Object[]) handle.arrayType.cast(oarray);
918 #else[Object]
919 $type$[] array = ($type$[]) oarray;
920 #end[Object]
921 #if[Reference]
922 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
923 // for flattened array, delegate to VarHandle of the inline type array
924 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
925 vh.setOpaque(oarray, index, reflectiveTypeCheck(array, value));
926 return;
927 }
928 #end[Reference]
929 UNSAFE.put$Type$Opaque(array,
930 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType},
931 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
932 }
933
934 @ForceInline
935 static $type$ getAcquire(VarHandle ob, Object oarray, int index) {
936 Array handle = (Array)ob;
937 #if[Object]
938 Object[] array = (Object[]) handle.arrayType.cast(oarray);
939 #else[Object]
940 $type$[] array = ($type$[]) oarray;
941 #end[Object]
942 #if[Reference]
943 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
944 // for flattened array, delegate to VarHandle of the inline type array
945 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
946 return vh.getAcquire(oarray, index);
947 }
948 #end[Reference]
949 return UNSAFE.get$Type$Acquire(array,
950 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType});
951 }
952
953 @ForceInline
954 static void setRelease(VarHandle ob, Object oarray, int index, $type$ value) {
955 Array handle = (Array)ob;
956 #if[Object]
957 Object[] array = (Object[]) handle.arrayType.cast(oarray);
958 #else[Object]
959 $type$[] array = ($type$[]) oarray;
960 #end[Object]
961 #if[Reference]
962 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
963 // for flattened array, delegate to VarHandle of the inline type array
964 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
965 vh.setRelease(oarray, index, reflectiveTypeCheck(array, value));
966 return;
967 }
968 #end[Reference]
969 UNSAFE.put$Type$Release(array,
970 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType},
971 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
972 }
973 #if[CAS]
974
975 @ForceInline
976 static boolean compareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
977 Array handle = (Array)ob;
978 #if[Object]
979 Object[] array = (Object[]) handle.arrayType.cast(oarray);
980 #else[Object]
981 $type$[] array = ($type$[]) oarray;
982 #end[Object]
983 #if[Reference]
984 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
985 // for flattened array, delegate to VarHandle of the inline type array
986 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
987 return vh.compareAndSet(oarray, index, expected, reflectiveTypeCheck(array, value));
988 }
989 #end[Reference]
990 return UNSAFE.compareAndSet$Type$(array,
991 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
992 {#if[Object]?handle.componentType.cast(expected):expected},
993 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
994 }
995
996 @ForceInline
997 static $type$ compareAndExchange(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
998 Array handle = (Array)ob;
999 #if[Object]
1000 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1001 #else[Object]
1002 $type$[] array = ($type$[]) oarray;
1003 #end[Object]
1004 #if[Reference]
1005 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1006 // for flattened array, delegate to VarHandle of the inline type array
1007 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1008 return vh.compareAndExchange(oarray, index, expected, reflectiveTypeCheck(array, value));
1009 }
1010 #end[Reference]
1011 return UNSAFE.compareAndExchange$Type$(array,
1012 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1013 {#if[Object]?handle.componentType.cast(expected):expected},
1014 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1015 }
1016
1017 @ForceInline
1018 static $type$ compareAndExchangeAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1019 Array handle = (Array)ob;
1020 #if[Object]
1021 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1022 #else[Object]
1023 $type$[] array = ($type$[]) oarray;
1024 #end[Object]
1025 #if[Reference]
1026 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1027 // for flattened array, delegate to VarHandle of the inline type array
1028 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1029 return vh.compareAndExchangeAcquire(oarray, index, expected, reflectiveTypeCheck(array, value));
1030 }
1031 #end[Reference]
1032 return UNSAFE.compareAndExchange$Type$Acquire(array,
1033 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1034 {#if[Object]?handle.componentType.cast(expected):expected},
1035 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1036 }
1037
1038 @ForceInline
1039 static $type$ compareAndExchangeRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1040 Array handle = (Array)ob;
1041 #if[Object]
1042 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1043 #else[Object]
1044 $type$[] array = ($type$[]) oarray;
1045 #end[Object]
1046 #if[Reference]
1047 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1048 // for flattened array, delegate to VarHandle of the inline type array
1049 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1050 return vh.compareAndExchangeRelease(oarray, index, expected, reflectiveTypeCheck(array, value));
1051 }
1052 #end[Reference]
1053 return UNSAFE.compareAndExchange$Type$Release(array,
1054 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1055 {#if[Object]?handle.componentType.cast(expected):expected},
1056 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1057 }
1058
1059 @ForceInline
1060 static boolean weakCompareAndSetPlain(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1061 Array handle = (Array)ob;
1062 #if[Object]
1063 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1064 #else[Object]
1065 $type$[] array = ($type$[]) oarray;
1066 #end[Object]
1067 #if[Reference]
1068 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1069 // for flattened array, delegate to VarHandle of the inline type array
1070 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1071 return vh.weakCompareAndSetPlain(oarray, index, expected, reflectiveTypeCheck(array, value));
1072 }
1073 #end[Reference]
1074 return UNSAFE.weakCompareAndSet$Type$Plain(array,
1075 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1076 {#if[Object]?handle.componentType.cast(expected):expected},
1077 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1078 }
1079
1080 @ForceInline
1081 static boolean weakCompareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1082 Array handle = (Array)ob;
1083 #if[Object]
1084 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1085 #else[Object]
1086 $type$[] array = ($type$[]) oarray;
1087 #end[Object]
1088 #if[Reference]
1089 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1090 // for flattened array, delegate to VarHandle of the inline type array
1091 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1092 return vh.weakCompareAndSet(oarray, index, expected, reflectiveTypeCheck(array, value));
1093 }
1094 #end[Reference]
1095 return UNSAFE.weakCompareAndSet$Type$(array,
1096 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1097 {#if[Object]?handle.componentType.cast(expected):expected},
1098 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1099 }
1100
1101 @ForceInline
1102 static boolean weakCompareAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1103 Array handle = (Array)ob;
1104 #if[Object]
1105 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1106 #else[Object]
1107 $type$[] array = ($type$[]) oarray;
1108 #end[Object]
1109 #if[Reference]
1110 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1111 // for flattened array, delegate to VarHandle of the inline type array
1112 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1113 return vh.weakCompareAndSetAcquire(oarray, index, expected, reflectiveTypeCheck(array, value));
1114 }
1115 #end[Reference]
1116 return UNSAFE.weakCompareAndSet$Type$Acquire(array,
1117 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1118 {#if[Object]?handle.componentType.cast(expected):expected},
1119 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1120 }
1121
1122 @ForceInline
1123 static boolean weakCompareAndSetRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
1124 Array handle = (Array)ob;
1125 #if[Object]
1126 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1127 #else[Object]
1128 $type$[] array = ($type$[]) oarray;
1129 #end[Object]
1130 #if[Reference]
1131 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1132 // for flattened array, delegate to VarHandle of the inline type array
1133 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1134 return vh.weakCompareAndSetRelease(oarray, index, expected, reflectiveTypeCheck(array, value));
1135 }
1136 #end[Reference]
1137 return UNSAFE.weakCompareAndSet$Type$Release(array,
1138 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Object]?, handle.componentType},
1139 {#if[Object]?handle.componentType.cast(expected):expected},
1140 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1141 }
1142
1143 @ForceInline
1144 static $type$ getAndSet(VarHandle ob, Object oarray, int index, $type$ value) {
1145 Array handle = (Array)ob;
1146 #if[Object]
1147 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1148 #else[Object]
1149 $type$[] array = ($type$[]) oarray;
1150 #end[Object]
1151 #if[Reference]
1152 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1153 // for flattened array, delegate to VarHandle of the inline type array
1154 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1155 return vh.getAndSet(oarray, index, reflectiveTypeCheck(array, value));
1156 }
1157 #end[Reference]
1158 return UNSAFE.getAndSet$Type$(array,
1159 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType},
1160 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1161 }
1162
1163 @ForceInline
1164 static $type$ getAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1165 Array handle = (Array)ob;
1166 #if[Object]
1167 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1168 #else[Object]
1169 $type$[] array = ($type$[]) oarray;
1170 #end[Object]
1171 #if[Reference]
1172 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1173 // for flattened array, delegate to VarHandle of the inline type array
1174 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1175 return vh.getAndSetAcquire(oarray, index, reflectiveTypeCheck(array, value));
1176 }
1177 #end[Reference]
1178 return UNSAFE.getAndSet$Type$Acquire(array,
1179 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType},
1180 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1181 }
1182
1183 @ForceInline
1184 static $type$ getAndSetRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1185 Array handle = (Array)ob;
1186 #if[Object]
1187 Object[] array = (Object[]) handle.arrayType.cast(oarray);
1188 #else[Object]
1189 $type$[] array = ($type$[]) oarray;
1190 #end[Object]
1191 #if[Reference]
1192 if (UNSAFE.isFlattenedArray(oarray.getClass())) {
1193 // for flattened array, delegate to VarHandle of the inline type array
1194 VarHandle vh = makeVarHandleValuesArray(oarray.getClass());
1195 return vh.getAndSetRelease(oarray, index, reflectiveTypeCheck(array, value));
1196 }
1197 #end[Reference]
1198 return UNSAFE.getAndSet$Type$Release(array,
1199 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase{#if[Value]?, handle.componentType},
1200 {#if[Object]?runtimeTypeCheck(handle, array, value):value});
1201 }
1202 #end[CAS]
1203 #if[AtomicAdd]
1204
1205 @ForceInline
1206 static $type$ getAndAdd(VarHandle ob, Object oarray, int index, $type$ value) {
1207 Array handle = (Array)ob;
1208 $type$[] array = ($type$[]) oarray;
1209 return UNSAFE.getAndAdd$Type$(array,
1210 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1211 value);
1212 }
1213
1214 @ForceInline
1215 static $type$ getAndAddAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1216 Array handle = (Array)ob;
1217 $type$[] array = ($type$[]) oarray;
1218 return UNSAFE.getAndAdd$Type$Acquire(array,
1219 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
|