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