1 /*
2 * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package java.lang.invoke;
26
27 import jdk.internal.util.Preconditions;
28 import jdk.internal.vm.annotation.ForceInline;
29
30 import java.lang.invoke.VarHandle.VarHandleDesc;
31 import java.util.Objects;
32 import java.util.Optional;
33
34 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
35
36 #warn
37
38 final class VarHandle$Type$s {
39
40 static sealed class FieldInstanceReadOnly extends VarHandle {
41 final long fieldOffset;
42 final Class<?> receiverType;
43 #if[Object]
44 final Class<?> fieldType;
45 #end[Object]
46
47 FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
48 this(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadOnly.FORM, false);
49 }
50
51 protected FieldInstanceReadOnly(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType},
52 VarForm form, boolean exact) {
53 super(form, exact);
54 this.fieldOffset = fieldOffset;
55 this.receiverType = receiverType;
56 #if[Object]
57 this.fieldType = fieldType;
58 #end[Object]
59 }
60
61 @Override
62 public FieldInstanceReadOnly withInvokeExactBehavior() {
63 return hasInvokeExactBehavior()
64 ? this
65 : new FieldInstanceReadOnly(receiverType, fieldOffset{#if[Object]?, fieldType}, vform, true);
66 }
67
68 @Override
69 public FieldInstanceReadOnly withInvokeBehavior() {
70 return !hasInvokeExactBehavior()
71 ? this
72 : new FieldInstanceReadOnly(receiverType, fieldOffset{#if[Object]?, fieldType}, vform, false);
73 }
74
75 @Override
76 final MethodType accessModeTypeUncached(AccessType at) {
77 return at.accessModeType(receiverType, {#if[Object]?fieldType:$type$.class});
78 }
79
80 @Override
81 public Optional<VarHandleDesc> describeConstable() {
82 var receiverTypeRef = receiverType.describeConstable();
83 var fieldTypeRef = {#if[Object]?fieldType:$type$.class}.describeConstable();
84 if (!receiverTypeRef.isPresent() || !fieldTypeRef.isPresent())
85 return Optional.empty();
86
87 // Reflect on this VarHandle to extract the field name
88 String name = VarHandles.getFieldFromReceiverAndOffset(
89 receiverType, fieldOffset, {#if[Object]?fieldType:$type$.class}).getName();
90 return Optional.of(VarHandleDesc.ofField(receiverTypeRef.get(), name, fieldTypeRef.get()));
91 }
92
93 @ForceInline
94 static $type$ get(VarHandle ob, Object holder) {
95 FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
96 return UNSAFE.get$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
97 handle.fieldOffset{#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
302 @ForceInline
303 static $type$ getAndAddRelease(VarHandle ob, Object holder, $type$ value) {
304 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
305 return UNSAFE.getAndAdd$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
306 handle.fieldOffset,
307 value);
308 }
309
310 #end[AtomicAdd]
311 #if[Bitwise]
312
313 @ForceInline
314 static $type$ getAndBitwiseOr(VarHandle ob, Object holder, $type$ value) {
315 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
316 return UNSAFE.getAndBitwiseOr$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
317 handle.fieldOffset,
318 value);
319 }
320
321 @ForceInline
322 static $type$ getAndBitwiseOrRelease(VarHandle ob, Object holder, $type$ value) {
323 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
324 return UNSAFE.getAndBitwiseOr$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
325 handle.fieldOffset,
326 value);
327 }
328
329 @ForceInline
330 static $type$ getAndBitwiseOrAcquire(VarHandle ob, Object holder, $type$ value) {
331 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
332 return UNSAFE.getAndBitwiseOr$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
333 handle.fieldOffset,
334 value);
335 }
336
337 @ForceInline
338 static $type$ getAndBitwiseAnd(VarHandle ob, Object holder, $type$ value) {
339 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
340 return UNSAFE.getAndBitwiseAnd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
341 handle.fieldOffset,
342 value);
343 }
344
345 @ForceInline
346 static $type$ getAndBitwiseAndRelease(VarHandle ob, Object holder, $type$ value) {
347 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
348 return UNSAFE.getAndBitwiseAnd$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
349 handle.fieldOffset,
350 value);
351 }
352
353 @ForceInline
354 static $type$ getAndBitwiseAndAcquire(VarHandle ob, Object holder, $type$ value) {
355 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
356 return UNSAFE.getAndBitwiseAnd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
357 handle.fieldOffset,
358 value);
359 }
360
361 @ForceInline
362 static $type$ getAndBitwiseXor(VarHandle ob, Object holder, $type$ value) {
363 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
364 return UNSAFE.getAndBitwiseXor$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
365 handle.fieldOffset,
366 value);
367 }
368
369 @ForceInline
370 static $type$ getAndBitwiseXorRelease(VarHandle ob, Object holder, $type$ value) {
371 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
372 return UNSAFE.getAndBitwiseXor$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
373 handle.fieldOffset,
374 value);
375 }
376
377 @ForceInline
378 static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object holder, $type$ value) {
379 FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
380 return UNSAFE.getAndBitwiseXor$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
381 handle.fieldOffset,
382 value);
383 }
384 #end[Bitwise]
385
386 static final VarForm FORM = new VarForm(FieldInstanceReadWrite.class, Object.class, $type$.class);
387 }
388
389
390 static sealed class FieldStaticReadOnly extends VarHandle {
391 final Class<?> declaringClass;
392 final Object base;
393 final long fieldOffset;
394 #if[Object]
395 final Class<?> fieldType;
396 #end[Object]
397
398 FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
399 this(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadOnly.FORM, false);
400 }
401
402 protected FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType},
403 VarForm form, boolean exact) {
404 super(form, exact);
405 this.declaringClass = declaringClass;
406 this.base = base;
407 this.fieldOffset = fieldOffset;
408 #if[Object]
409 this.fieldType = fieldType;
410 #end[Object]
411 }
412
413 @Override
414 public FieldStaticReadOnly withInvokeExactBehavior() {
415 return hasInvokeExactBehavior()
416 ? this
417 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, vform, true);
418 }
419
420 @Override
421 public FieldStaticReadOnly withInvokeBehavior() {
422 return !hasInvokeExactBehavior()
423 ? this
424 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType}, vform, false);
425 }
426
427 @Override
428 public Optional<VarHandleDesc> describeConstable() {
429 var fieldTypeRef = {#if[Object]?fieldType:$type$.class}.describeConstable();
430 if (!fieldTypeRef.isPresent())
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
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.target();
652 return UNSAFE.getAndAdd$Type$Acquire(handle.base,
653 handle.fieldOffset,
654 value);
655 }
656
657 @ForceInline
658 static $type$ getAndAddRelease(VarHandle ob, $type$ value) {
659 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
660 return UNSAFE.getAndAdd$Type$Release(handle.base,
661 handle.fieldOffset,
662 value);
663 }
664 #end[AtomicAdd]
665 #if[Bitwise]
666
667 @ForceInline
668 static $type$ getAndBitwiseOr(VarHandle ob, $type$ value) {
669 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
670 return UNSAFE.getAndBitwiseOr$Type$(handle.base,
671 handle.fieldOffset,
672 value);
673 }
674
675 @ForceInline
676 static $type$ getAndBitwiseOrRelease(VarHandle ob, $type$ value) {
677 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
678 return UNSAFE.getAndBitwiseOr$Type$Release(handle.base,
679 handle.fieldOffset,
680 value);
681 }
682
683 @ForceInline
684 static $type$ getAndBitwiseOrAcquire(VarHandle ob, $type$ value) {
685 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
686 return UNSAFE.getAndBitwiseOr$Type$Acquire(handle.base,
687 handle.fieldOffset,
688 value);
689 }
690
691 @ForceInline
692 static $type$ getAndBitwiseAnd(VarHandle ob, $type$ value) {
693 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
694 return UNSAFE.getAndBitwiseAnd$Type$(handle.base,
695 handle.fieldOffset,
696 value);
697 }
698
699 @ForceInline
700 static $type$ getAndBitwiseAndRelease(VarHandle ob, $type$ value) {
701 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
702 return UNSAFE.getAndBitwiseAnd$Type$Release(handle.base,
703 handle.fieldOffset,
704 value);
705 }
706
707 @ForceInline
708 static $type$ getAndBitwiseAndAcquire(VarHandle ob, $type$ value) {
709 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
710 return UNSAFE.getAndBitwiseAnd$Type$Acquire(handle.base,
711 handle.fieldOffset,
712 value);
713 }
714
715 @ForceInline
716 static $type$ getAndBitwiseXor(VarHandle ob, $type$ value) {
717 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
718 return UNSAFE.getAndBitwiseXor$Type$(handle.base,
719 handle.fieldOffset,
720 value);
721 }
722
723 @ForceInline
724 static $type$ getAndBitwiseXorRelease(VarHandle ob, $type$ value) {
725 FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.target();
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.target();
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();
771 #end[Object]
772 }
773
774 @Override
775 public Array withInvokeExactBehavior() {
776 return hasInvokeExactBehavior()
777 ? this
778 : new Array(abase, ashift{#if[Object]?, arrayType}, true);
779 }
780
781 @Override
782 public Array withInvokeBehavior() {
783 return !hasInvokeExactBehavior()
784 ? this
785 : new Array(abase, ashift{#if[Object]?, arrayType}, false);
786 }
787
788 @Override
789 public Optional<VarHandleDesc> describeConstable() {
790 var arrayTypeRef = {#if[Object]?arrayType:$type$[].class}.describeConstable();
791 if (!arrayTypeRef.isPresent())
792 return Optional.empty();
793
794 return Optional.of(VarHandleDesc.ofArray(arrayTypeRef.get()));
795 }
796
797 @Override
798 final MethodType accessModeTypeUncached(AccessType at) {
799 return at.accessModeType({#if[Object]?arrayType:$type$[].class}, {#if[Object]?arrayType.getComponentType():$type$.class}, int.class);
800 }
801
802 #if[Object]
803 @ForceInline
804 static Object runtimeTypeCheck(Array handle, Object[] oarray, Object value) {
805 if (handle.arrayType == oarray.getClass()) {
806 // Fast path: static array type same as argument array type
807 return handle.componentType.cast(value);
808 } else {
809 // Slow path: check value against argument array component type
810 return reflectiveTypeCheck(oarray, value);
811 }
812 }
813
814 @ForceInline
815 static Object reflectiveTypeCheck(Object[] oarray, Object value) {
816 try {
817 return oarray.getClass().getComponentType().cast(value);
818 } catch (ClassCastException e) {
819 throw new ArrayStoreException();
820 }
821 }
822 #end[Object]
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,
1220 value);
1221 }
1222
1223 @ForceInline
1224 static $type$ getAndAddRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1225 Array handle = (Array)ob;
1226 $type$[] array = ($type$[]) oarray;
1227 return UNSAFE.getAndAdd$Type$Release(array,
1228 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1229 value);
1230 }
1231 #end[AtomicAdd]
1232 #if[Bitwise]
1233
1234 @ForceInline
1235 static $type$ getAndBitwiseOr(VarHandle ob, Object oarray, int index, $type$ value) {
1236 Array handle = (Array)ob;
1237 $type$[] array = ($type$[]) oarray;
1238 return UNSAFE.getAndBitwiseOr$Type$(array,
1239 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1240 value);
1241 }
1242
1243 @ForceInline
1244 static $type$ getAndBitwiseOrRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1245 Array handle = (Array)ob;
1246 $type$[] array = ($type$[]) oarray;
1247 return UNSAFE.getAndBitwiseOr$Type$Release(array,
1248 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1249 value);
1250 }
1251
1252 @ForceInline
1253 static $type$ getAndBitwiseOrAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1254 Array handle = (Array)ob;
1255 $type$[] array = ($type$[]) oarray;
1256 return UNSAFE.getAndBitwiseOr$Type$Acquire(array,
1257 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1258 value);
1259 }
1260
1261 @ForceInline
1262 static $type$ getAndBitwiseAnd(VarHandle ob, Object oarray, int index, $type$ value) {
1263 Array handle = (Array)ob;
1264 $type$[] array = ($type$[]) oarray;
1265 return UNSAFE.getAndBitwiseAnd$Type$(array,
1266 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1267 value);
1268 }
1269
1270 @ForceInline
1271 static $type$ getAndBitwiseAndRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1272 Array handle = (Array)ob;
1273 $type$[] array = ($type$[]) oarray;
1274 return UNSAFE.getAndBitwiseAnd$Type$Release(array,
1275 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1276 value);
1277 }
1278
1279 @ForceInline
1280 static $type$ getAndBitwiseAndAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1281 Array handle = (Array)ob;
1282 $type$[] array = ($type$[]) oarray;
1283 return UNSAFE.getAndBitwiseAnd$Type$Acquire(array,
1284 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1285 value);
1286 }
1287
1288 @ForceInline
1289 static $type$ getAndBitwiseXor(VarHandle ob, Object oarray, int index, $type$ value) {
1290 Array handle = (Array)ob;
1291 $type$[] array = ($type$[]) oarray;
1292 return UNSAFE.getAndBitwiseXor$Type$(array,
1293 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1294 value);
1295 }
1296
1297 @ForceInline
1298 static $type$ getAndBitwiseXorRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1299 Array handle = (Array)ob;
1300 $type$[] array = ($type$[]) oarray;
1301 return UNSAFE.getAndBitwiseXor$Type$Release(array,
1302 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1303 value);
1304 }
1305
1306 @ForceInline
1307 static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1308 Array handle = (Array)ob;
1309 $type$[] array = ($type$[]) oarray;
1310 return UNSAFE.getAndBitwiseXor$Type$Acquire(array,
1311 (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << handle.ashift) + handle.abase,
1312 value);
1313 }
1314 #end[Bitwise]
1315
1316 static final VarForm FORM = new VarForm(Array.class, {#if[Object]?Object[].class:$type$[].class}, {#if[Object]?Object.class:$type$.class}, int.class);
1317 }
1318 }