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