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