1 /*
   2  * Copyright (c) 2015, 2026, 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             this.fieldOffset = fieldOffset;
  62             this.receiverType = receiverType;
  63 #if[Object]
  64             this.fieldType = fieldType;
  65             this.nullRestricted = nullRestricted;
  66 #end[Object]
  67 #if[FlatValue]
  68             this.layout = layout;
  69 #end[FlatValue]
  70             super(form, exact);
  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             return value;
 111         }
 112 
 113 #if[NonPlainAccess]
 114         @ForceInline
 115         static $type$ getVolatile(VarHandle ob, Object holder) {
 116             FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
 117             $type$ value = UNSAFE.get$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
 118                                  handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
 119             return value;
 120         }
 121 
 122         @ForceInline
 123         static $type$ getOpaque(VarHandle ob, Object holder) {
 124             FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
 125             $type$ value = UNSAFE.get$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
 126                                  handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
 127             return value;
 128         }
 129 
 130         @ForceInline
 131         static $type$ getAcquire(VarHandle ob, Object holder) {
 132             FieldInstanceReadOnly handle = (FieldInstanceReadOnly)ob;
 133             $type$ value = UNSAFE.get$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 134                                  handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
 135             return value;
 136         }
 137 #end[NonPlainAccess]
 138 
 139         static final VarForm FORM = new VarForm(FieldInstanceReadOnly.class, Object.class, $type$.class);
 140     }
 141 
 142     static final class FieldInstanceReadWrite extends FieldInstanceReadOnly {
 143         FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout}) {
 144             this(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
 145         }
 146 
 147         private FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout},
 148                                        boolean exact) {
 149             super(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, FieldInstanceReadWrite.FORM, exact);
 150         }
 151 
 152         @Override
 153         public FieldInstanceReadWrite withInvokeExactBehavior() {
 154             return hasInvokeExactBehavior()
 155                 ? this
 156                 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, true);
 157         }
 158 
 159         @Override
 160         public FieldInstanceReadWrite withInvokeBehavior() {
 161             return !hasInvokeExactBehavior()
 162                 ? this
 163                 : new FieldInstanceReadWrite(receiverType, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
 164         }
 165 
 166 #if[Object]
 167         @ForceInline
 168         static Object checkCast(FieldInstanceReadWrite handle, $type$ value) {
 169             if (value == null && handle.nullRestricted)
 170                 throw new NullPointerException();
 171             return handle.fieldType.cast(value);
 172         }
 173 #end[Object]
 174 
 175         @ForceInline
 176         static void set(VarHandle ob, Object holder, $type$ value) {
 177             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 178             UNSAFE.put$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 179                              handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 180                              {#if[Object]?checkCast(handle, value):value});
 181         }
 182 
 183 #if[NonPlainAccess]
 184         @ForceInline
 185         static void setVolatile(VarHandle ob, Object holder, $type$ value) {
 186             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 187             UNSAFE.put$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
 188                                      handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 189                                      {#if[Object]?checkCast(handle, value):value});
 190         }
 191 
 192         @ForceInline
 193         static void setOpaque(VarHandle ob, Object holder, $type$ value) {
 194             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 195             UNSAFE.put$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
 196                                    handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 197                                    {#if[Object]?checkCast(handle, value):value});
 198         }
 199 
 200         @ForceInline
 201         static void setRelease(VarHandle ob, Object holder, $type$ value) {
 202             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 203             UNSAFE.put$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 204                                     handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 205                                     {#if[Object]?checkCast(handle, value):value});
 206         }
 207 #if[CAS]
 208 
 209         @ForceInline
 210         static boolean compareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 211             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 212             return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 213                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 214                                                {#if[Object]?checkCast(handle, expected):expected},
 215                                                {#if[Object]?checkCast(handle, value):value});
 216         }
 217 
 218         @ForceInline
 219         static $type$ compareAndExchange(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 220             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 221             return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 222                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 223                                                {#if[Object]?checkCast(handle, expected):expected},
 224                                                {#if[Object]?checkCast(handle, value):value});
 225         }
 226 
 227         @ForceInline
 228         static $type$ compareAndExchangeAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 229             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 230             return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 231                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 232                                                {#if[Object]?checkCast(handle, expected):expected},
 233                                                {#if[Object]?checkCast(handle, value):value});
 234         }
 235 
 236         @ForceInline
 237         static $type$ compareAndExchangeRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 238             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 239             return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 240                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 241                                                {#if[Object]?checkCast(handle, expected):expected},
 242                                                {#if[Object]?checkCast(handle, value):value});
 243         }
 244 
 245         @ForceInline
 246         static boolean weakCompareAndSetPlain(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 247             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 248             return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
 249                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 250                                                {#if[Object]?checkCast(handle, expected):expected},
 251                                                {#if[Object]?checkCast(handle, value):value});
 252         }
 253 
 254         @ForceInline
 255         static boolean weakCompareAndSet(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 256             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 257             return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 258                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 259                                                {#if[Object]?checkCast(handle, expected):expected},
 260                                                {#if[Object]?checkCast(handle, value):value});
 261         }
 262 
 263         @ForceInline
 264         static boolean weakCompareAndSetAcquire(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 265             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 266             return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 267                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 268                                                {#if[Object]?checkCast(handle, expected):expected},
 269                                                {#if[Object]?checkCast(handle, value):value});
 270         }
 271 
 272         @ForceInline
 273         static boolean weakCompareAndSetRelease(VarHandle ob, Object holder, $type$ expected, $type$ value) {
 274             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 275             return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 276                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 277                                                {#if[Object]?checkCast(handle, expected):expected},
 278                                                {#if[Object]?checkCast(handle, value):value});
 279         }
 280 
 281         @ForceInline
 282         static $type$ getAndSet(VarHandle ob, Object holder, $type$ value) {
 283             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 284             return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 285                                           handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 286                                           {#if[Object]?checkCast(handle, value):value});
 287         }
 288 
 289         @ForceInline
 290         static $type$ getAndSetAcquire(VarHandle ob, Object holder, $type$ value) {
 291             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 292             return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 293                                           handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 294                                           {#if[Object]?checkCast(handle, value):value});
 295         }
 296 
 297         @ForceInline
 298         static $type$ getAndSetRelease(VarHandle ob, Object holder, $type$ value) {
 299             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 300             return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 301                                           handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 302                                           {#if[Object]?checkCast(handle, value):value});
 303         }
 304 #end[CAS]
 305 #if[AtomicAdd]
 306 
 307         @ForceInline
 308         static $type$ getAndAdd(VarHandle ob, Object holder, $type$ value) {
 309             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 310             return UNSAFE.getAndAdd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 311                                        handle.fieldOffset,
 312                                        value);
 313         }
 314 
 315         @ForceInline
 316         static $type$ getAndAddAcquire(VarHandle ob, Object holder, $type$ value) {
 317             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 318             return UNSAFE.getAndAdd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 319                                        handle.fieldOffset,
 320                                        value);
 321         }
 322 
 323         @ForceInline
 324         static $type$ getAndAddRelease(VarHandle ob, Object holder, $type$ value) {
 325             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 326             return UNSAFE.getAndAdd$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 327                                        handle.fieldOffset,
 328                                        value);
 329         }
 330 
 331 #end[AtomicAdd]
 332 #if[Bitwise]
 333 
 334         @ForceInline
 335         static $type$ getAndBitwiseOr(VarHandle ob, Object holder, $type$ value) {
 336             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 337             return UNSAFE.getAndBitwiseOr$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 338                                        handle.fieldOffset,
 339                                        value);
 340         }
 341 
 342         @ForceInline
 343         static $type$ getAndBitwiseOrRelease(VarHandle ob, Object holder, $type$ value) {
 344             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 345             return UNSAFE.getAndBitwiseOr$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 346                                        handle.fieldOffset,
 347                                        value);
 348         }
 349 
 350         @ForceInline
 351         static $type$ getAndBitwiseOrAcquire(VarHandle ob, Object holder, $type$ value) {
 352             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 353             return UNSAFE.getAndBitwiseOr$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 354                                        handle.fieldOffset,
 355                                        value);
 356         }
 357 
 358         @ForceInline
 359         static $type$ getAndBitwiseAnd(VarHandle ob, Object holder, $type$ value) {
 360             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 361             return UNSAFE.getAndBitwiseAnd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 362                                        handle.fieldOffset,
 363                                        value);
 364         }
 365 
 366         @ForceInline
 367         static $type$ getAndBitwiseAndRelease(VarHandle ob, Object holder, $type$ value) {
 368             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 369             return UNSAFE.getAndBitwiseAnd$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 370                                        handle.fieldOffset,
 371                                        value);
 372         }
 373 
 374         @ForceInline
 375         static $type$ getAndBitwiseAndAcquire(VarHandle ob, Object holder, $type$ value) {
 376             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 377             return UNSAFE.getAndBitwiseAnd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 378                                        handle.fieldOffset,
 379                                        value);
 380         }
 381 
 382         @ForceInline
 383         static $type$ getAndBitwiseXor(VarHandle ob, Object holder, $type$ value) {
 384             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 385             return UNSAFE.getAndBitwiseXor$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
 386                                        handle.fieldOffset,
 387                                        value);
 388         }
 389 
 390         @ForceInline
 391         static $type$ getAndBitwiseXorRelease(VarHandle ob, Object holder, $type$ value) {
 392             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 393             return UNSAFE.getAndBitwiseXor$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
 394                                        handle.fieldOffset,
 395                                        value);
 396         }
 397 
 398         @ForceInline
 399         static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object holder, $type$ value) {
 400             FieldInstanceReadWrite handle = (FieldInstanceReadWrite)ob;
 401             return UNSAFE.getAndBitwiseXor$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
 402                                        handle.fieldOffset,
 403                                        value);
 404         }
 405 #end[Bitwise]
 406 #end[NonPlainAccess]
 407 
 408         static final VarForm FORM = new VarForm(FieldInstanceReadWrite.class, Object.class, $type$.class);
 409     }
 410 
 411 #if[Static]
 412     static sealed class FieldStaticReadOnly extends VarHandles.StaticFieldVarHandle {
 413 #if[Object]
 414         final Class<?> fieldType;
 415         final boolean nullRestricted;
 416 #end[Object]
 417 #if[FlatValue]
 418         final int layout;
 419 #end[FlatValue]
 420 
 421         FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout}) {
 422             this(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, FieldStaticReadOnly.FORM, false);
 423         }
 424 
 425         protected FieldStaticReadOnly(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout},
 426                                       VarForm form, boolean exact) {
 427 #if[Object]
 428             this.fieldType = fieldType;
 429             this.nullRestricted = nullRestricted;
 430 #end[Object]
 431 #if[FlatValue]
 432             this.layout = layout;
 433 #end[FlatValue]
 434             super(form, exact, declaringClass, base, fieldOffset);
 435         }
 436 
 437         @Override
 438         public FieldStaticReadOnly withInvokeExactBehavior() {
 439             return hasInvokeExactBehavior()
 440                 ? this
 441                 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, vform, true);
 442         }
 443 
 444         @Override
 445         public FieldStaticReadOnly withInvokeBehavior() {
 446             return !hasInvokeExactBehavior()
 447                 ? this
 448                 : new FieldStaticReadOnly(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, vform, false);
 449         }
 450 
 451         @Override
 452         public Optional<VarHandleDesc> describeConstable() {
 453             var fieldTypeRef = {#if[Object]?fieldType:$type$.class}.describeConstable();
 454             if (!fieldTypeRef.isPresent())
 455                 return Optional.empty();
 456 
 457             // Reflect on this VarHandle to extract the field name
 458             var staticField = VarHandles.getStaticFieldFromBaseAndOffset(
 459                 declaringClass, fieldOffset, {#if[Object]?fieldType:$type$.class});
 460             var declaringTypeRef = declaringClass.describeConstable();
 461             if (!declaringTypeRef.isPresent())
 462                 return Optional.empty();
 463             return Optional.of(VarHandleDesc.ofStaticField(declaringTypeRef.get(), staticField.getName(), fieldTypeRef.get()));
 464         }
 465 
 466         @Override
 467         final MethodType accessModeTypeUncached(AccessType at) {
 468             return at.accessModeType(null, {#if[Object]?fieldType:$type$.class});
 469         }
 470 
 471         @ForceInline
 472         static $type$ get(VarHandle ob) {
 473             FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.onStaticFieldAccess(true);
 474             $type$ value = UNSAFE.get$Type$(handle.base,
 475                                  handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
 476             return value;
 477         }
 478 
 479 #if[NonPlainAccess]
 480         @ForceInline
 481         static $type$ getVolatile(VarHandle ob) {
 482             FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.onStaticFieldAccess(true);
 483             $type$ value = UNSAFE.get$Type$Volatile(handle.base,
 484                                  handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
 485             return value;
 486         }
 487 
 488         @ForceInline
 489         static $type$ getOpaque(VarHandle ob) {
 490             FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.onStaticFieldAccess(true);
 491             $type$ value = UNSAFE.get$Type$Opaque(handle.base,
 492                                  handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
 493             return value;
 494         }
 495 
 496         @ForceInline
 497         static $type$ getAcquire(VarHandle ob) {
 498             FieldStaticReadOnly handle = (FieldStaticReadOnly) ob.onStaticFieldAccess(true);
 499             $type$ value = UNSAFE.get$Type$Acquire(handle.base,
 500                                  handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType});
 501             return value;
 502         }
 503 #end[NonPlainAccess]
 504 
 505         static final VarForm FORM = new VarForm(FieldStaticReadOnly.class, null, $type$.class);
 506     }
 507 
 508     static final class FieldStaticReadWrite extends FieldStaticReadOnly {
 509 
 510         FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout}) {
 511             this(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
 512         }
 513 
 514         private FieldStaticReadWrite(Class<?> declaringClass, Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullRestricted}{#if[FlatValue]?, int layout},
 515                                      boolean exact) {
 516             super(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, FieldStaticReadWrite.FORM, exact);
 517         }
 518 
 519         @Override
 520         public FieldStaticReadWrite withInvokeExactBehavior() {
 521             return hasInvokeExactBehavior()
 522                 ? this
 523                 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, true);
 524         }
 525 
 526         @Override
 527         public FieldStaticReadWrite withInvokeBehavior() {
 528             return !hasInvokeExactBehavior()
 529                 ? this
 530                 : new FieldStaticReadWrite(declaringClass, base, fieldOffset{#if[Object]?, fieldType, nullRestricted}{#if[FlatValue]?, layout}, false);
 531         }
 532 
 533 #if[Object]
 534         @ForceInline
 535         static Object checkCast(FieldStaticReadWrite handle, $type$ value) {
 536             return handle.fieldType.cast(value);
 537         }
 538 #end[Object]
 539 
 540         @ForceInline
 541         static void set(VarHandle ob, $type$ value) {
 542             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(false);
 543             UNSAFE.put$Type$(handle.base,
 544                              handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 545                              {#if[Object]?checkCast(handle, value):value});
 546         }
 547 
 548 #if[NonPlainAccess]
 549         @ForceInline
 550         static void setVolatile(VarHandle ob, $type$ value) {
 551             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(false);
 552             UNSAFE.put$Type$Volatile(handle.base,
 553                                      handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 554                                      {#if[Object]?checkCast(handle, value):value});
 555         }
 556 
 557         @ForceInline
 558         static void setOpaque(VarHandle ob, $type$ value) {
 559             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(false);
 560             UNSAFE.put$Type$Opaque(handle.base,
 561                                    handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 562                                    {#if[Object]?checkCast(handle, value):value});
 563         }
 564 
 565         @ForceInline
 566         static void setRelease(VarHandle ob, $type$ value) {
 567             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(false);
 568             UNSAFE.put$Type$Release(handle.base,
 569                                     handle.fieldOffset{#if[FlatValue]?, handle.layout, handle.fieldType},
 570                                     {#if[Object]?checkCast(handle, value):value});
 571         }
 572 #if[CAS]
 573 
 574         @ForceInline
 575         static boolean compareAndSet(VarHandle ob, $type$ expected, $type$ value) {
 576             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 577             return UNSAFE.compareAndSet$Type$(handle.base,
 578                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 579                                                {#if[Object]?checkCast(handle, expected):expected},
 580                                                {#if[Object]?checkCast(handle, value):value});
 581         }
 582 
 583 
 584         @ForceInline
 585         static $type$ compareAndExchange(VarHandle ob, $type$ expected, $type$ value) {
 586             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 587             return UNSAFE.compareAndExchange$Type$(handle.base,
 588                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 589                                                {#if[Object]?checkCast(handle, expected):expected},
 590                                                {#if[Object]?checkCast(handle, value):value});
 591         }
 592 
 593         @ForceInline
 594         static $type$ compareAndExchangeAcquire(VarHandle ob, $type$ expected, $type$ value) {
 595             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 596             return UNSAFE.compareAndExchange$Type$Acquire(handle.base,
 597                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 598                                                {#if[Object]?checkCast(handle, expected):expected},
 599                                                {#if[Object]?checkCast(handle, value):value});
 600         }
 601 
 602         @ForceInline
 603         static $type$ compareAndExchangeRelease(VarHandle ob, $type$ expected, $type$ value) {
 604             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 605             return UNSAFE.compareAndExchange$Type$Release(handle.base,
 606                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 607                                                {#if[Object]?checkCast(handle, expected):expected},
 608                                                {#if[Object]?checkCast(handle, value):value});
 609         }
 610 
 611         @ForceInline
 612         static boolean weakCompareAndSetPlain(VarHandle ob, $type$ expected, $type$ value) {
 613             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 614             return UNSAFE.weakCompareAndSet$Type$Plain(handle.base,
 615                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 616                                                {#if[Object]?checkCast(handle, expected):expected},
 617                                                {#if[Object]?checkCast(handle, value):value});
 618         }
 619 
 620         @ForceInline
 621         static boolean weakCompareAndSet(VarHandle ob, $type$ expected, $type$ value) {
 622             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 623             return UNSAFE.weakCompareAndSet$Type$(handle.base,
 624                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 625                                                {#if[Object]?checkCast(handle, expected):expected},
 626                                                {#if[Object]?checkCast(handle, value):value});
 627         }
 628 
 629         @ForceInline
 630         static boolean weakCompareAndSetAcquire(VarHandle ob, $type$ expected, $type$ value) {
 631             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 632             return UNSAFE.weakCompareAndSet$Type$Acquire(handle.base,
 633                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 634                                                {#if[Object]?checkCast(handle, expected):expected},
 635                                                {#if[Object]?checkCast(handle, value):value});
 636         }
 637 
 638         @ForceInline
 639         static boolean weakCompareAndSetRelease(VarHandle ob, $type$ expected, $type$ value) {
 640             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 641             return UNSAFE.weakCompareAndSet$Type$Release(handle.base,
 642                                                handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 643                                                {#if[Object]?checkCast(handle, expected):expected},
 644                                                {#if[Object]?checkCast(handle, value):value});
 645         }
 646 
 647         @ForceInline
 648         static $type$ getAndSet(VarHandle ob, $type$ value) {
 649             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 650             return UNSAFE.getAndSet$Type$(handle.base,
 651                                           handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 652                                           {#if[Object]?checkCast(handle, value):value});
 653         }
 654 
 655         @ForceInline
 656         static $type$ getAndSetAcquire(VarHandle ob, $type$ value) {
 657             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 658             return UNSAFE.getAndSet$Type$Acquire(handle.base,
 659                                           handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 660                                           {#if[Object]?checkCast(handle, value):value});
 661         }
 662 
 663         @ForceInline
 664         static $type$ getAndSetRelease(VarHandle ob, $type$ value) {
 665             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 666             return UNSAFE.getAndSet$Type$Release(handle.base,
 667                                           handle.fieldOffset{#if[FlatValue]?, handle.layout}{#if[Object]?, handle.fieldType},
 668                                           {#if[Object]?checkCast(handle, value):value});
 669         }
 670 #end[CAS]
 671 #if[AtomicAdd]
 672 
 673         @ForceInline
 674         static $type$ getAndAdd(VarHandle ob, $type$ value) {
 675             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 676             return UNSAFE.getAndAdd$Type$(handle.base,
 677                                        handle.fieldOffset,
 678                                        value);
 679         }
 680 
 681         @ForceInline
 682         static $type$ getAndAddAcquire(VarHandle ob, $type$ value) {
 683             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 684             return UNSAFE.getAndAdd$Type$Acquire(handle.base,
 685                                        handle.fieldOffset,
 686                                        value);
 687         }
 688 
 689         @ForceInline
 690         static $type$ getAndAddRelease(VarHandle ob, $type$ value) {
 691             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 692             return UNSAFE.getAndAdd$Type$Release(handle.base,
 693                                        handle.fieldOffset,
 694                                        value);
 695         }
 696 #end[AtomicAdd]
 697 #if[Bitwise]
 698 
 699         @ForceInline
 700         static $type$ getAndBitwiseOr(VarHandle ob, $type$ value) {
 701             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 702             return UNSAFE.getAndBitwiseOr$Type$(handle.base,
 703                                        handle.fieldOffset,
 704                                        value);
 705         }
 706 
 707         @ForceInline
 708         static $type$ getAndBitwiseOrRelease(VarHandle ob, $type$ value) {
 709             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 710             return UNSAFE.getAndBitwiseOr$Type$Release(handle.base,
 711                                        handle.fieldOffset,
 712                                        value);
 713         }
 714 
 715         @ForceInline
 716         static $type$ getAndBitwiseOrAcquire(VarHandle ob, $type$ value) {
 717             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 718             return UNSAFE.getAndBitwiseOr$Type$Acquire(handle.base,
 719                                        handle.fieldOffset,
 720                                        value);
 721         }
 722 
 723         @ForceInline
 724         static $type$ getAndBitwiseAnd(VarHandle ob, $type$ value) {
 725             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 726             return UNSAFE.getAndBitwiseAnd$Type$(handle.base,
 727                                        handle.fieldOffset,
 728                                        value);
 729         }
 730 
 731         @ForceInline
 732         static $type$ getAndBitwiseAndRelease(VarHandle ob, $type$ value) {
 733             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 734             return UNSAFE.getAndBitwiseAnd$Type$Release(handle.base,
 735                                        handle.fieldOffset,
 736                                        value);
 737         }
 738 
 739         @ForceInline
 740         static $type$ getAndBitwiseAndAcquire(VarHandle ob, $type$ value) {
 741             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 742             return UNSAFE.getAndBitwiseAnd$Type$Acquire(handle.base,
 743                                        handle.fieldOffset,
 744                                        value);
 745         }
 746 
 747         @ForceInline
 748         static $type$ getAndBitwiseXor(VarHandle ob, $type$ value) {
 749             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 750             return UNSAFE.getAndBitwiseXor$Type$(handle.base,
 751                                        handle.fieldOffset,
 752                                        value);
 753         }
 754 
 755         @ForceInline
 756         static $type$ getAndBitwiseXorRelease(VarHandle ob, $type$ value) {
 757             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 758             return UNSAFE.getAndBitwiseXor$Type$Release(handle.base,
 759                                        handle.fieldOffset,
 760                                        value);
 761         }
 762 
 763         @ForceInline
 764         static $type$ getAndBitwiseXorAcquire(VarHandle ob, $type$ value) {
 765             FieldStaticReadWrite handle = (FieldStaticReadWrite) ob.onStaticFieldAccess(true);
 766             return UNSAFE.getAndBitwiseXor$Type$Acquire(handle.base,
 767                                        handle.fieldOffset,
 768                                        value);
 769         }
 770 #end[Bitwise]
 771 #end[NonPlainAccess]
 772 
 773         static final VarForm FORM = new VarForm(FieldStaticReadWrite.class, null, $type$.class);
 774     }
 775 #end[Static]
 776 
 777 #if[Array]
 778     static final class Array extends VarHandle {
 779         static final long BASE = UNSAFE.arrayBaseOffset($type$[].class);
 780         static final int SHIFT = Integer.numberOfTrailingZeros(UNSAFE.arrayIndexScale($type$[].class));
 781 
 782         private Array(boolean exact) {
 783             super(Array.FORM, exact);
 784         }
 785 
 786         @Override
 787         public Array withInvokeExactBehavior() {
 788             return hasInvokeExactBehavior()
 789                 ? this
 790                 : EXACT_INSTANCE;
 791         }
 792 
 793         @Override
 794         public Array withInvokeBehavior() {
 795             return !hasInvokeExactBehavior()
 796                 ? this
 797                 : NON_EXACT_INSTANCE;
 798         }
 799 
 800         @Override
 801         public Optional<VarHandleDesc> describeConstable() {
 802             return Optional.of(VarHandleDesc.ofArray($type$[].class.describeConstable().orElseThrow()));
 803         }
 804 
 805         @Override
 806         final MethodType accessModeTypeUncached(AccessType at) {
 807             return at.accessModeType($type$[].class, $type$.class, int.class);
 808         }
 809 
 810         @ForceInline
 811         static $type$ get(VarHandle ob, Object oarray, int index) {
 812             $type$[] array = ($type$[]) oarray;
 813             return array[index];
 814         }
 815 
 816         @ForceInline
 817         static void set(VarHandle ob, Object oarray, int index, $type$ value) {
 818             $type$[] array = ($type$[]) oarray;
 819             array[index] = value;
 820         }
 821 
 822 #if[NonPlainAccess]
 823         @ForceInline
 824         static $type$ getVolatile(VarHandle ob, Object oarray, int index) {
 825             $type$[] array = ($type$[]) oarray;
 826             return UNSAFE.get$Type$Volatile(array,
 827                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE);
 828         }
 829 
 830         @ForceInline
 831         static void setVolatile(VarHandle ob, Object oarray, int index, $type$ value) {
 832             $type$[] array = ($type$[]) oarray;
 833             UNSAFE.put$Type$Volatile(array,
 834                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 835                     value);
 836         }
 837 
 838         @ForceInline
 839         static $type$ getOpaque(VarHandle ob, Object oarray, int index) {
 840             $type$[] array = ($type$[]) oarray;
 841             return UNSAFE.get$Type$Opaque(array,
 842                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE);
 843         }
 844 
 845         @ForceInline
 846         static void setOpaque(VarHandle ob, Object oarray, int index, $type$ value) {
 847             $type$[] array = ($type$[]) oarray;
 848             UNSAFE.put$Type$Opaque(array,
 849                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 850                     value);
 851         }
 852 
 853         @ForceInline
 854         static $type$ getAcquire(VarHandle ob, Object oarray, int index) {
 855             $type$[] array = ($type$[]) oarray;
 856             return UNSAFE.get$Type$Acquire(array,
 857                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE);
 858         }
 859 
 860         @ForceInline
 861         static void setRelease(VarHandle ob, Object oarray, int index, $type$ value) {
 862             $type$[] array = ($type$[]) oarray;
 863             UNSAFE.put$Type$Release(array,
 864                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 865                     value);
 866         }
 867 #if[CAS]
 868 
 869         @ForceInline
 870         static boolean compareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 871             $type$[] array = ($type$[]) oarray;
 872             return UNSAFE.compareAndSet$Type$(array,
 873                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 874                     expected,
 875                     value);
 876         }
 877 
 878         @ForceInline
 879         static $type$ compareAndExchange(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 880             $type$[] array = ($type$[]) oarray;
 881             return UNSAFE.compareAndExchange$Type$(array,
 882                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 883                     expected,
 884                     value);
 885         }
 886 
 887         @ForceInline
 888         static $type$ compareAndExchangeAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 889             $type$[] array = ($type$[]) oarray;
 890             return UNSAFE.compareAndExchange$Type$Acquire(array,
 891                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 892                     expected,
 893                     value);
 894         }
 895 
 896         @ForceInline
 897         static $type$ compareAndExchangeRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 898             $type$[] array = ($type$[]) oarray;
 899             return UNSAFE.compareAndExchange$Type$Release(array,
 900                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 901                     expected,
 902                     value);
 903         }
 904 
 905         @ForceInline
 906         static boolean weakCompareAndSetPlain(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 907             $type$[] array = ($type$[]) oarray;
 908             return UNSAFE.weakCompareAndSet$Type$Plain(array,
 909                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 910                     expected,
 911                     value);
 912         }
 913 
 914         @ForceInline
 915         static boolean weakCompareAndSet(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 916             $type$[] array = ($type$[]) oarray;
 917             return UNSAFE.weakCompareAndSet$Type$(array,
 918                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 919                     expected,
 920                     value);
 921         }
 922 
 923         @ForceInline
 924         static boolean weakCompareAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 925             $type$[] array = ($type$[]) oarray;
 926             return UNSAFE.weakCompareAndSet$Type$Acquire(array,
 927                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 928                     expected,
 929                     value);
 930         }
 931 
 932         @ForceInline
 933         static boolean weakCompareAndSetRelease(VarHandle ob, Object oarray, int index, $type$ expected, $type$ value) {
 934             $type$[] array = ($type$[]) oarray;
 935             return UNSAFE.weakCompareAndSet$Type$Release(array,
 936                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 937                     expected,
 938                     value);
 939         }
 940 
 941         @ForceInline
 942         static $type$ getAndSet(VarHandle ob, Object oarray, int index, $type$ value) {
 943             $type$[] array = ($type$[]) oarray;
 944             return UNSAFE.getAndSet$Type$(array,
 945                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 946                     value);
 947         }
 948 
 949         @ForceInline
 950         static $type$ getAndSetAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
 951             $type$[] array = ($type$[]) oarray;
 952             return UNSAFE.getAndSet$Type$Acquire(array,
 953                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 954                     value);
 955         }
 956 
 957         @ForceInline
 958         static $type$ getAndSetRelease(VarHandle ob, Object oarray, int index, $type$ value) {
 959             $type$[] array = ($type$[]) oarray;
 960             return UNSAFE.getAndSet$Type$Release(array,
 961                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 962                     value);
 963         }
 964 #end[CAS]
 965 #if[AtomicAdd]
 966 
 967         @ForceInline
 968         static $type$ getAndAdd(VarHandle ob, Object oarray, int index, $type$ value) {
 969             $type$[] array = ($type$[]) oarray;
 970             return UNSAFE.getAndAdd$Type$(array,
 971                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 972                     value);
 973         }
 974 
 975         @ForceInline
 976         static $type$ getAndAddAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
 977             $type$[] array = ($type$[]) oarray;
 978             return UNSAFE.getAndAdd$Type$Acquire(array,
 979                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 980                     value);
 981         }
 982 
 983         @ForceInline
 984         static $type$ getAndAddRelease(VarHandle ob, Object oarray, int index, $type$ value) {
 985             $type$[] array = ($type$[]) oarray;
 986             return UNSAFE.getAndAdd$Type$Release(array,
 987                     (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 988                     value);
 989         }
 990 #end[AtomicAdd]
 991 #if[Bitwise]
 992 
 993         @ForceInline
 994         static $type$ getAndBitwiseOr(VarHandle ob, Object oarray, int index, $type$ value) {
 995             $type$[] array = ($type$[]) oarray;
 996             return UNSAFE.getAndBitwiseOr$Type$(array,
 997                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
 998                                        value);
 999         }
1000 
1001         @ForceInline
1002         static $type$ getAndBitwiseOrRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1003             $type$[] array = ($type$[]) oarray;
1004             return UNSAFE.getAndBitwiseOr$Type$Release(array,
1005                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1006                                        value);
1007         }
1008 
1009         @ForceInline
1010         static $type$ getAndBitwiseOrAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1011             $type$[] array = ($type$[]) oarray;
1012             return UNSAFE.getAndBitwiseOr$Type$Acquire(array,
1013                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1014                                        value);
1015         }
1016 
1017         @ForceInline
1018         static $type$ getAndBitwiseAnd(VarHandle ob, Object oarray, int index, $type$ value) {
1019             $type$[] array = ($type$[]) oarray;
1020             return UNSAFE.getAndBitwiseAnd$Type$(array,
1021                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1022                                        value);
1023         }
1024 
1025         @ForceInline
1026         static $type$ getAndBitwiseAndRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1027             $type$[] array = ($type$[]) oarray;
1028             return UNSAFE.getAndBitwiseAnd$Type$Release(array,
1029                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1030                                        value);
1031         }
1032 
1033         @ForceInline
1034         static $type$ getAndBitwiseAndAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1035             $type$[] array = ($type$[]) oarray;
1036             return UNSAFE.getAndBitwiseAnd$Type$Acquire(array,
1037                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1038                                        value);
1039         }
1040 
1041         @ForceInline
1042         static $type$ getAndBitwiseXor(VarHandle ob, Object oarray, int index, $type$ value) {
1043             $type$[] array = ($type$[]) oarray;
1044             return UNSAFE.getAndBitwiseXor$Type$(array,
1045                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1046                                        value);
1047         }
1048 
1049         @ForceInline
1050         static $type$ getAndBitwiseXorRelease(VarHandle ob, Object oarray, int index, $type$ value) {
1051             $type$[] array = ($type$[]) oarray;
1052             return UNSAFE.getAndBitwiseXor$Type$Release(array,
1053                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1054                                        value);
1055         }
1056 
1057         @ForceInline
1058         static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object oarray, int index, $type$ value) {
1059             $type$[] array = ($type$[]) oarray;
1060             return UNSAFE.getAndBitwiseXor$Type$Acquire(array,
1061                                        (((long) Preconditions.checkIndex(index, array.length, Preconditions.AIOOBE_FORMATTER)) << SHIFT) + BASE,
1062                                        value);
1063         }
1064 #end[Bitwise]
1065 #end[NonPlainAccess]
1066 
1067         static final VarForm FORM = new VarForm(Array.class, $type$[].class, $type$.class, int.class);
1068         static final Array NON_EXACT_INSTANCE = new Array(false);
1069         static final Array EXACT_INSTANCE = new Array(true);
1070     }
1071 #end[Array]
1072 }