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 }