1 /*
2 * Copyright (c) 2014, 2018, 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
26 package java.lang.invoke;
27
28 import jdk.internal.HotSpotIntrinsicCandidate;
29 import jdk.internal.util.Preconditions;
30 import jdk.internal.vm.annotation.ForceInline;
31 import jdk.internal.vm.annotation.Stable;
32
33 import java.util.HashMap;
34 import java.util.List;
35 import java.util.Map;
36 import java.util.function.BiFunction;
37 import java.util.function.Function;
38
39 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
40 import static java.lang.invoke.MethodHandleStatics.newInternalError;
41
42 /**
43 * A VarHandle is a dynamically strongly typed reference to a variable, or to a
44 * parametrically-defined family of variables, including static fields,
45 * non-static fields, array elements, or components of an off-heap data
46 * structure. Access to such variables is supported under various
47 * <em>access modes</em>, including plain read/write access, volatile
48 * read/write access, and compare-and-set.
49 *
50 * <p>VarHandles are immutable and have no visible state. VarHandles cannot be
51 * subclassed by the user.
52 *
53 * <p>A VarHandle has:
54 * <ul>
55 * <li>a {@link #varType variable type} T, the type of every variable referenced
56 * by this VarHandle; and
57 * <li>a list of {@link #coordinateTypes coordinate types}
58 * {@code CT1, CT2, ..., CTn}, the types of <em>coordinate expressions</em> that
59 * jointly locate a variable referenced by this VarHandle.
60 * </ul>
61 * Variable and coordinate types may be primitive or reference, and are
62 * represented by {@code Class} objects. The list of coordinate types may be
63 * empty.
64 *
65 * <p>Factory methods that produce or {@link java.lang.invoke.MethodHandles.Lookup
66 * lookup} VarHandle instances document the supported variable type and the list
67 * of coordinate types.
68 *
69 * <p>Each access mode is associated with one <em>access mode method</em>, a
70 * <a href="MethodHandle.html#sigpoly">signature polymorphic</a> method named
71 * for the access mode. When an access mode method is invoked on a VarHandle
72 * instance, the initial arguments to the invocation are coordinate expressions
73 * that indicate in precisely which object the variable is to be accessed.
74 * Trailing arguments to the invocation represent values of importance to the
75 * access mode. For example, the various compare-and-set or compare-and-exchange
76 * access modes require two trailing arguments for the variable's expected value
77 * and new value.
78 *
79 * <p>The arity and types of arguments to the invocation of an access mode
80 * method are not checked statically. Instead, each access mode method
81 * specifies an {@link #accessModeType(AccessMode) access mode type},
82 * represented as an instance of {@link MethodType}, that serves as a kind of
83 * method signature against which the arguments are checked dynamically. An
84 * access mode type gives formal parameter types in terms of the coordinate
85 * types of a VarHandle instance and the types for values of importance to the
86 * access mode. An access mode type also gives a return type, often in terms of
87 * the variable type of a VarHandle instance. When an access mode method is
88 * invoked on a VarHandle instance, the symbolic type descriptor at the
89 * call site, the run time types of arguments to the invocation, and the run
90 * time type of the return value, must <a href="#invoke">match</a> the types
91 * given in the access mode type. A runtime exception will be thrown if the
92 * match fails.
93 *
94 * For example, the access mode method {@link #compareAndSet} specifies that if
95 * its receiver is a VarHandle instance with coordinate types
96 * {@code CT1, ..., CTn} and variable type {@code T}, then its access mode type
97 * is {@code (CT1 c1, ..., CTn cn, T expectedValue, T newValue)boolean}.
98 * Suppose that a VarHandle instance can access array elements, and that its
99 * coordinate types are {@code String[]} and {@code int} while its variable type
100 * is {@code String}. The access mode type for {@code compareAndSet} on this
101 * VarHandle instance would be
102 * {@code (String[] c1, int c2, String expectedValue, String newValue)boolean}.
103 * Such a VarHandle instance may be produced by the
104 * {@link MethodHandles#arrayElementVarHandle(Class) array factory method} and
105 * access array elements as follows:
106 * <pre> {@code
107 * String[] sa = ...
108 * VarHandle avh = MethodHandles.arrayElementVarHandle(String[].class);
109 * boolean r = avh.compareAndSet(sa, 10, "expected", "new");
110 * }</pre>
111 *
112 * <p>Access modes control atomicity and consistency properties.
113 * <em>Plain</em> read ({@code get}) and write ({@code set})
114 * accesses are guaranteed to be bitwise atomic only for references
115 * and for primitive values of at most 32 bits, and impose no observable
116 * ordering constraints with respect to threads other than the
117 * executing thread. <em>Opaque</em> operations are bitwise atomic and
118 * coherently ordered with respect to accesses to the same variable.
119 * In addition to obeying Opaque properties, <em>Acquire</em> mode
120 * reads and their subsequent accesses are ordered after matching
121 * <em>Release</em> mode writes and their previous accesses. In
122 * addition to obeying Acquire and Release properties, all
123 * <em>Volatile</em> operations are totally ordered with respect to
124 * each other.
125 *
126 * <p>Access modes are grouped into the following categories:
127 * <ul>
128 * <li>read access modes that get the value of a variable under specified
129 * memory ordering effects.
130 * The set of corresponding access mode methods belonging to this group
131 * consists of the methods
132 * {@link #get get},
133 * {@link #getVolatile getVolatile},
134 * {@link #getAcquire getAcquire},
135 * {@link #getOpaque getOpaque}.
136 * <li>write access modes that set the value of a variable under specified
137 * memory ordering effects.
138 * The set of corresponding access mode methods belonging to this group
139 * consists of the methods
140 * {@link #set set},
141 * {@link #setVolatile setVolatile},
142 * {@link #setRelease setRelease},
143 * {@link #setOpaque setOpaque}.
144 * <li>atomic update access modes that, for example, atomically compare and set
145 * the value of a variable under specified memory ordering effects.
146 * The set of corresponding access mode methods belonging to this group
147 * consists of the methods
148 * {@link #compareAndSet compareAndSet},
149 * {@link #weakCompareAndSetPlain weakCompareAndSetPlain},
150 * {@link #weakCompareAndSet weakCompareAndSet},
151 * {@link #weakCompareAndSetAcquire weakCompareAndSetAcquire},
152 * {@link #weakCompareAndSetRelease weakCompareAndSetRelease},
153 * {@link #compareAndExchangeAcquire compareAndExchangeAcquire},
154 * {@link #compareAndExchange compareAndExchange},
155 * {@link #compareAndExchangeRelease compareAndExchangeRelease},
156 * {@link #getAndSet getAndSet},
157 * {@link #getAndSetAcquire getAndSetAcquire},
158 * {@link #getAndSetRelease getAndSetRelease}.
159 * <li>numeric atomic update access modes that, for example, atomically get and
160 * set with addition the value of a variable under specified memory ordering
161 * effects.
162 * The set of corresponding access mode methods belonging to this group
163 * consists of the methods
164 * {@link #getAndAdd getAndAdd},
165 * {@link #getAndAddAcquire getAndAddAcquire},
166 * {@link #getAndAddRelease getAndAddRelease},
167 * <li>bitwise atomic update access modes that, for example, atomically get and
168 * bitwise OR the value of a variable under specified memory ordering
169 * effects.
170 * The set of corresponding access mode methods belonging to this group
171 * consists of the methods
172 * {@link #getAndBitwiseOr getAndBitwiseOr},
173 * {@link #getAndBitwiseOrAcquire getAndBitwiseOrAcquire},
174 * {@link #getAndBitwiseOrRelease getAndBitwiseOrRelease},
175 * {@link #getAndBitwiseAnd getAndBitwiseAnd},
176 * {@link #getAndBitwiseAndAcquire getAndBitwiseAndAcquire},
177 * {@link #getAndBitwiseAndRelease getAndBitwiseAndRelease},
178 * {@link #getAndBitwiseXor getAndBitwiseXor},
179 * {@link #getAndBitwiseXorAcquire getAndBitwiseXorAcquire},
180 * {@link #getAndBitwiseXorRelease getAndBitwiseXorRelease}.
181 * </ul>
182 *
183 * <p>Factory methods that produce or {@link java.lang.invoke.MethodHandles.Lookup
184 * lookup} VarHandle instances document the set of access modes that are
185 * supported, which may also include documenting restrictions based on the
186 * variable type and whether a variable is read-only. If an access mode is not
187 * supported then the corresponding access mode method will on invocation throw
188 * an {@code UnsupportedOperationException}. Factory methods should document
189 * any additional undeclared exceptions that may be thrown by access mode
190 * methods.
191 * The {@link #get get} access mode is supported for all
192 * VarHandle instances and the corresponding method never throws
193 * {@code UnsupportedOperationException}.
194 * If a VarHandle references a read-only variable (for example a {@code final}
195 * field) then write, atomic update, numeric atomic update, and bitwise atomic
196 * update access modes are not supported and corresponding methods throw
197 * {@code UnsupportedOperationException}.
198 * Read/write access modes (if supported), with the exception of
199 * {@code get} and {@code set}, provide atomic access for
200 * reference types and all primitive types.
201 * Unless stated otherwise in the documentation of a factory method, the access
202 * modes {@code get} and {@code set} (if supported) provide atomic access for
203 * reference types and all primitives types, with the exception of {@code long}
204 * and {@code double} on 32-bit platforms.
205 *
206 * <p>Access modes will override any memory ordering effects specified at
207 * the declaration site of a variable. For example, a VarHandle accessing
208 * a field using the {@code get} access mode will access the field as
209 * specified <em>by its access mode</em> even if that field is declared
210 * {@code volatile}. When mixed access is performed extreme care should be
211 * taken since the Java Memory Model may permit surprising results.
212 *
213 * <p>In addition to supporting access to variables under various access modes,
214 * a set of static methods, referred to as memory fence methods, is also
215 * provided for fine-grained control of memory ordering.
216 *
217 * The Java Language Specification permits other threads to observe operations
218 * as if they were executed in orders different than are apparent in program
219 * source code, subject to constraints arising, for example, from the use of
220 * locks, {@code volatile} fields or VarHandles. The static methods,
221 * {@link #fullFence fullFence}, {@link #acquireFence acquireFence},
222 * {@link #releaseFence releaseFence}, {@link #loadLoadFence loadLoadFence} and
223 * {@link #storeStoreFence storeStoreFence}, can also be used to impose
224 * constraints. Their specifications, as is the case for certain access modes,
225 * are phrased in terms of the lack of "reorderings" -- observable ordering
226 * effects that might otherwise occur if the fence was not present. More
227 * precise phrasing of the specification of access mode methods and memory fence
228 * methods may accompany future updates of the Java Language Specification.
229 *
230 * <h1>Compiling invocation of access mode methods</h1>
231 * A Java method call expression naming an access mode method can invoke a
232 * VarHandle from Java source code. From the viewpoint of source code, these
233 * methods can take any arguments and their polymorphic result (if expressed)
234 * can be cast to any return type. Formally this is accomplished by giving the
235 * access mode methods variable arity {@code Object} arguments and
236 * {@code Object} return types (if the return type is polymorphic), but they
237 * have an additional quality called <em>signature polymorphism</em> which
238 * connects this freedom of invocation directly to the JVM execution stack.
239 * <p>
240 * As is usual with virtual methods, source-level calls to access mode methods
241 * compile to an {@code invokevirtual} instruction. More unusually, the
242 * compiler must record the actual argument types, and may not perform method
243 * invocation conversions on the arguments. Instead, it must generate
244 * instructions to push them on the stack according to their own unconverted
245 * types. The VarHandle object itself will be pushed on the stack before the
246 * arguments. The compiler then generates an {@code invokevirtual} instruction
247 * that invokes the access mode method with a symbolic type descriptor which
248 * describes the argument and return types.
249 * <p>
250 * To issue a complete symbolic type descriptor, the compiler must also
251 * determine the return type (if polymorphic). This is based on a cast on the
252 * method invocation expression, if there is one, or else {@code Object} if the
253 * invocation is an expression, or else {@code void} if the invocation is a
254 * statement. The cast may be to a primitive type (but not {@code void}).
255 * <p>
256 * As a corner case, an uncasted {@code null} argument is given a symbolic type
257 * descriptor of {@code java.lang.Void}. The ambiguity with the type
258 * {@code Void} is harmless, since there are no references of type {@code Void}
259 * except the null reference.
260 *
261 *
262 * <h1><a id="invoke">Performing invocation of access mode methods</a></h1>
263 * The first time an {@code invokevirtual} instruction is executed it is linked
264 * by symbolically resolving the names in the instruction and verifying that
265 * the method call is statically legal. This also holds for calls to access mode
266 * methods. In this case, the symbolic type descriptor emitted by the compiler
267 * is checked for correct syntax, and names it contains are resolved. Thus, an
268 * {@code invokevirtual} instruction which invokes an access mode method will
269 * always link, as long as the symbolic type descriptor is syntactically
270 * well-formed and the types exist.
271 * <p>
272 * When the {@code invokevirtual} is executed after linking, the receiving
273 * VarHandle's access mode type is first checked by the JVM to ensure that it
274 * matches the symbolic type descriptor. If the type
275 * match fails, it means that the access mode method which the caller is
276 * invoking is not present on the individual VarHandle being invoked.
277 *
278 * <p>
279 * Invocation of an access mode method behaves as if an invocation of
280 * {@link MethodHandle#invoke}, where the receiving method handle accepts the
281 * VarHandle instance as the leading argument. More specifically, the
282 * following, where {@code {access-mode}} corresponds to the access mode method
283 * name:
284 * <pre> {@code
285 * VarHandle vh = ..
286 * R r = (R) vh.{access-mode}(p1, p2, ..., pN);
287 * }</pre>
288 * behaves as if:
289 * <pre> {@code
290 * VarHandle vh = ..
291 * VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
292 * MethodHandle mh = MethodHandles.varHandleExactInvoker(
293 * am,
294 * vh.accessModeType(am));
295 *
296 * R r = (R) mh.invoke(vh, p1, p2, ..., pN)
297 * }</pre>
298 * (modulo access mode methods do not declare throwing of {@code Throwable}).
299 * This is equivalent to:
300 * <pre> {@code
301 * MethodHandle mh = MethodHandles.lookup().findVirtual(
302 * VarHandle.class,
303 * "{access-mode}",
304 * MethodType.methodType(R, p1, p2, ..., pN));
305 *
306 * R r = (R) mh.invokeExact(vh, p1, p2, ..., pN)
307 * }</pre>
308 * where the desired method type is the symbolic type descriptor and a
309 * {@link MethodHandle#invokeExact} is performed, since before invocation of the
310 * target, the handle will apply reference casts as necessary and box, unbox, or
311 * widen primitive values, as if by {@link MethodHandle#asType asType} (see also
312 * {@link MethodHandles#varHandleInvoker}).
313 *
314 * More concisely, such behaviour is equivalent to:
315 * <pre> {@code
316 * VarHandle vh = ..
317 * VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
318 * MethodHandle mh = vh.toMethodHandle(am);
319 *
320 * R r = (R) mh.invoke(p1, p2, ..., pN)
321 * }</pre>
322 * Where, in this case, the method handle is bound to the VarHandle instance.
323 *
324 *
325 * <h1>Invocation checking</h1>
326 * In typical programs, VarHandle access mode type matching will usually
327 * succeed. But if a match fails, the JVM will throw a
328 * {@link WrongMethodTypeException}.
329 * <p>
330 * Thus, an access mode type mismatch which might show up as a linkage error
331 * in a statically typed program can show up as a dynamic
332 * {@code WrongMethodTypeException} in a program which uses VarHandles.
333 * <p>
334 * Because access mode types contain "live" {@code Class} objects, method type
335 * matching takes into account both type names and class loaders.
336 * Thus, even if a VarHandle {@code VH} is created in one class loader
337 * {@code L1} and used in another {@code L2}, VarHandle access mode method
338 * calls are type-safe, because the caller's symbolic type descriptor, as
339 * resolved in {@code L2}, is matched against the original callee method's
340 * symbolic type descriptor, as resolved in {@code L1}. The resolution in
341 * {@code L1} happens when {@code VH} is created and its access mode types are
342 * assigned, while the resolution in {@code L2} happens when the
343 * {@code invokevirtual} instruction is linked.
344 * <p>
345 * Apart from type descriptor checks, a VarHandles's capability to
346 * access it's variables is unrestricted.
347 * If a VarHandle is formed on a non-public variable by a class that has access
348 * to that variable, the resulting VarHandle can be used in any place by any
349 * caller who receives a reference to it.
350 * <p>
351 * Unlike with the Core Reflection API, where access is checked every time a
352 * reflective method is invoked, VarHandle access checking is performed
353 * <a href="MethodHandles.Lookup.html#access">when the VarHandle is
354 * created</a>.
355 * Thus, VarHandles to non-public variables, or to variables in non-public
356 * classes, should generally be kept secret. They should not be passed to
357 * untrusted code unless their use from the untrusted code would be harmless.
358 *
359 *
360 * <h1>VarHandle creation</h1>
361 * Java code can create a VarHandle that directly accesses any field that is
362 * accessible to that code. This is done via a reflective, capability-based
363 * API called {@link java.lang.invoke.MethodHandles.Lookup
364 * MethodHandles.Lookup}.
365 * For example, a VarHandle for a non-static field can be obtained
366 * from {@link java.lang.invoke.MethodHandles.Lookup#findVarHandle
367 * Lookup.findVarHandle}.
368 * There is also a conversion method from Core Reflection API objects,
369 * {@link java.lang.invoke.MethodHandles.Lookup#unreflectVarHandle
370 * Lookup.unreflectVarHandle}.
371 * <p>
372 * Access to protected field members is restricted to receivers only of the
373 * accessing class, or one of its subclasses, and the accessing class must in
374 * turn be a subclass (or package sibling) of the protected member's defining
375 * class. If a VarHandle refers to a protected non-static field of a declaring
376 * class outside the current package, the receiver argument will be narrowed to
377 * the type of the accessing class.
378 *
379 * <h1>Interoperation between VarHandles and the Core Reflection API</h1>
380 * Using factory methods in the {@link java.lang.invoke.MethodHandles.Lookup
381 * Lookup} API, any field represented by a Core Reflection API object
382 * can be converted to a behaviorally equivalent VarHandle.
383 * For example, a reflective {@link java.lang.reflect.Field Field} can
384 * be converted to a VarHandle using
385 * {@link java.lang.invoke.MethodHandles.Lookup#unreflectVarHandle
386 * Lookup.unreflectVarHandle}.
387 * The resulting VarHandles generally provide more direct and efficient
388 * access to the underlying fields.
389 * <p>
390 * As a special case, when the Core Reflection API is used to view the
391 * signature polymorphic access mode methods in this class, they appear as
392 * ordinary non-polymorphic methods. Their reflective appearance, as viewed by
393 * {@link java.lang.Class#getDeclaredMethod Class.getDeclaredMethod},
394 * is unaffected by their special status in this API.
395 * For example, {@link java.lang.reflect.Method#getModifiers
396 * Method.getModifiers}
397 * will report exactly those modifier bits required for any similarly
398 * declared method, including in this case {@code native} and {@code varargs}
399 * bits.
400 * <p>
401 * As with any reflected method, these methods (when reflected) may be invoked
402 * directly via {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke},
403 * via JNI, or indirectly via
404 * {@link java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect}.
405 * However, such reflective calls do not result in access mode method
406 * invocations. Such a call, if passed the required argument (a single one, of
407 * type {@code Object[]}), will ignore the argument and will throw an
408 * {@code UnsupportedOperationException}.
409 * <p>
410 * Since {@code invokevirtual} instructions can natively invoke VarHandle
411 * access mode methods under any symbolic type descriptor, this reflective view
412 * conflicts with the normal presentation of these methods via bytecodes.
413 * Thus, these native methods, when reflectively viewed by
414 * {@code Class.getDeclaredMethod}, may be regarded as placeholders only.
415 * <p>
416 * In order to obtain an invoker method for a particular access mode type,
417 * use {@link java.lang.invoke.MethodHandles#varHandleExactInvoker} or
418 * {@link java.lang.invoke.MethodHandles#varHandleInvoker}. The
419 * {@link java.lang.invoke.MethodHandles.Lookup#findVirtual Lookup.findVirtual}
420 * API is also able to return a method handle to call an access mode method for
421 * any specified access mode type and is equivalent in behaviour to
422 * {@link java.lang.invoke.MethodHandles#varHandleInvoker}.
423 *
424 * <h1>Interoperation between VarHandles and Java generics</h1>
425 * A VarHandle can be obtained for a variable, such as a field, which is
426 * declared with Java generic types. As with the Core Reflection API, the
427 * VarHandle's variable type will be constructed from the erasure of the
428 * source-level type. When a VarHandle access mode method is invoked, the
429 * types
430 * of its arguments or the return value cast type may be generic types or type
431 * instances. If this occurs, the compiler will replace those types by their
432 * erasures when it constructs the symbolic type descriptor for the
433 * {@code invokevirtual} instruction.
434 *
435 * @see MethodHandle
436 * @see MethodHandles
437 * @see MethodType
438 * @since 9
439 */
440 public abstract class VarHandle {
441 final VarForm vform;
442
443 VarHandle(VarForm vform) {
444 this.vform = vform;
445 }
446
447 RuntimeException unsupported() {
448 return new UnsupportedOperationException();
449 }
450
451 // Plain accessors
452
453 /**
454 * Returns the value of a variable, with memory semantics of reading as
455 * if the variable was declared non-{@code volatile}. Commonly referred to
456 * as plain read access.
457 *
458 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
459 *
460 * <p>The symbolic type descriptor at the call site of {@code get}
461 * must match the access mode type that is the result of calling
462 * {@code accessModeType(VarHandle.AccessMode.GET)} on this VarHandle.
463 *
464 * <p>This access mode is supported by all VarHandle instances and never
465 * throws {@code UnsupportedOperationException}.
466 *
467 * @param args the signature-polymorphic parameter list of the form
468 * {@code (CT1 ct1, ..., CTn)}
469 * , statically represented using varargs.
470 * @return the signature-polymorphic result that is the value of the
471 * variable
472 * , statically represented using {@code Object}.
473 * @throws WrongMethodTypeException if the access mode type does not
474 * match the caller's symbolic type descriptor.
475 * @throws ClassCastException if the access mode type matches the caller's
476 * symbolic type descriptor, but a reference cast fails.
477 */
478 public final native
479 @MethodHandle.PolymorphicSignature
480 @HotSpotIntrinsicCandidate
481 Object get(Object... args);
482
483 /**
484 * Sets the value of a variable to the {@code newValue}, with memory
485 * semantics of setting as if the variable was declared non-{@code volatile}
486 * and non-{@code final}. Commonly referred to as plain write access.
487 *
488 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}
489 *
490 * <p>The symbolic type descriptor at the call site of {@code set}
491 * must match the access mode type that is the result of calling
492 * {@code accessModeType(VarHandle.AccessMode.SET)} on this VarHandle.
493 *
494 * @param args the signature-polymorphic parameter list of the form
495 * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
496 * , statically represented using varargs.
497 * @throws UnsupportedOperationException if the access mode is unsupported
498 * for this VarHandle.
499 * @throws WrongMethodTypeException if the access mode type does not
500 * match the caller's symbolic type descriptor.
501 * @throws ClassCastException if the access mode type matches the caller's
502 * symbolic type descriptor, but a reference cast fails.
503 */
504 public final native
505 @MethodHandle.PolymorphicSignature
506 @HotSpotIntrinsicCandidate
507 void set(Object... args);
508
509
510 // Volatile accessors
511
512 /**
513 * Returns the value of a variable, with memory semantics of reading as if
514 * the variable was declared {@code volatile}.
515 *
516 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
517 *
518 * <p>The symbolic type descriptor at the call site of {@code getVolatile}
519 * must match the access mode type that is the result of calling
520 * {@code accessModeType(VarHandle.AccessMode.GET_VOLATILE)} on this
521 * VarHandle.
522 *
523 * @param args the signature-polymorphic parameter list of the form
524 * {@code (CT1 ct1, ..., CTn ctn)}
525 * , statically represented using varargs.
526 * @return the signature-polymorphic result that is the value of the
527 * variable
528 * , statically represented using {@code Object}.
529 * @throws UnsupportedOperationException if the access mode is unsupported
530 * for this VarHandle.
531 * @throws WrongMethodTypeException if the access mode type does not
532 * match the caller's symbolic type descriptor.
533 * @throws ClassCastException if the access mode type matches the caller's
534 * symbolic type descriptor, but a reference cast fails.
535 */
536 public final native
537 @MethodHandle.PolymorphicSignature
538 @HotSpotIntrinsicCandidate
539 Object getVolatile(Object... args);
540
541 /**
542 * Sets the value of a variable to the {@code newValue}, with memory
543 * semantics of setting as if the variable was declared {@code volatile}.
544 *
545 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
546 *
547 * <p>The symbolic type descriptor at the call site of {@code setVolatile}
548 * must match the access mode type that is the result of calling
549 * {@code accessModeType(VarHandle.AccessMode.SET_VOLATILE)} on this
550 * VarHandle.
551 *
552 * @apiNote
553 * Ignoring the many semantic differences from C and C++, this method has
554 * memory ordering effects compatible with {@code memory_order_seq_cst}.
555 *
556 * @param args the signature-polymorphic parameter list of the form
557 * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
558 * , statically represented using varargs.
559 * @throws UnsupportedOperationException if the access mode is unsupported
560 * for this VarHandle.
561 * @throws WrongMethodTypeException if the access mode type does not
562 * match the caller's symbolic type descriptor.
563 * @throws ClassCastException if the access mode type matches the caller's
564 * symbolic type descriptor, but a reference cast fails.
565 */
566 public final native
567 @MethodHandle.PolymorphicSignature
568 @HotSpotIntrinsicCandidate
569 void setVolatile(Object... args);
570
571
572 /**
573 * Returns the value of a variable, accessed in program order, but with no
574 * assurance of memory ordering effects with respect to other threads.
575 *
576 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
577 *
578 * <p>The symbolic type descriptor at the call site of {@code getOpaque}
579 * must match the access mode type that is the result of calling
580 * {@code accessModeType(VarHandle.AccessMode.GET_OPAQUE)} on this
581 * VarHandle.
582 *
583 * @param args the signature-polymorphic parameter list of the form
584 * {@code (CT1 ct1, ..., CTn ctn)}
585 * , statically represented using varargs.
586 * @return the signature-polymorphic result that is the value of the
587 * variable
588 * , statically represented using {@code Object}.
589 * @throws UnsupportedOperationException if the access mode is unsupported
590 * for this VarHandle.
591 * @throws WrongMethodTypeException if the access mode type does not
592 * match the caller's symbolic type descriptor.
593 * @throws ClassCastException if the access mode type matches the caller's
594 * symbolic type descriptor, but a reference cast fails.
595 */
596 public final native
597 @MethodHandle.PolymorphicSignature
598 @HotSpotIntrinsicCandidate
599 Object getOpaque(Object... args);
600
601 /**
602 * Sets the value of a variable to the {@code newValue}, in program order,
603 * but with no assurance of memory ordering effects with respect to other
604 * threads.
605 *
606 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
607 *
608 * <p>The symbolic type descriptor at the call site of {@code setOpaque}
609 * must match the access mode type that is the result of calling
610 * {@code accessModeType(VarHandle.AccessMode.SET_OPAQUE)} on this
611 * VarHandle.
612 *
613 * @param args the signature-polymorphic parameter list of the form
614 * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
615 * , statically represented using varargs.
616 * @throws UnsupportedOperationException if the access mode is unsupported
617 * for this VarHandle.
618 * @throws WrongMethodTypeException if the access mode type does not
619 * match the caller's symbolic type descriptor.
620 * @throws ClassCastException if the access mode type matches the caller's
621 * symbolic type descriptor, but a reference cast fails.
622 */
623 public final native
624 @MethodHandle.PolymorphicSignature
625 @HotSpotIntrinsicCandidate
626 void setOpaque(Object... args);
627
628
629 // Lazy accessors
630
631 /**
632 * Returns the value of a variable, and ensures that subsequent loads and
633 * stores are not reordered before this access.
634 *
635 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
636 *
637 * <p>The symbolic type descriptor at the call site of {@code getAcquire}
638 * must match the access mode type that is the result of calling
639 * {@code accessModeType(VarHandle.AccessMode.GET_ACQUIRE)} on this
640 * VarHandle.
641 *
642 * @apiNote
643 * Ignoring the many semantic differences from C and C++, this method has
644 * memory ordering effects compatible with {@code memory_order_acquire}
645 * ordering.
646 *
647 * @param args the signature-polymorphic parameter list of the form
648 * {@code (CT1 ct1, ..., CTn ctn)}
649 * , statically represented using varargs.
650 * @return the signature-polymorphic result that is the value of the
651 * variable
652 * , statically represented using {@code Object}.
653 * @throws UnsupportedOperationException if the access mode is unsupported
654 * for this VarHandle.
655 * @throws WrongMethodTypeException if the access mode type does not
656 * match the caller's symbolic type descriptor.
657 * @throws ClassCastException if the access mode type matches the caller's
658 * symbolic type descriptor, but a reference cast fails.
659 */
660 public final native
661 @MethodHandle.PolymorphicSignature
662 @HotSpotIntrinsicCandidate
663 Object getAcquire(Object... args);
664
665 /**
666 * Sets the value of a variable to the {@code newValue}, and ensures that
667 * prior loads and stores are not reordered after this access.
668 *
669 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
670 *
671 * <p>The symbolic type descriptor at the call site of {@code setRelease}
672 * must match the access mode type that is the result of calling
673 * {@code accessModeType(VarHandle.AccessMode.SET_RELEASE)} on this
674 * VarHandle.
675 *
676 * @apiNote
677 * Ignoring the many semantic differences from C and C++, this method has
678 * memory ordering effects compatible with {@code memory_order_release}
679 * ordering.
680 *
681 * @param args the signature-polymorphic parameter list of the form
682 * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
683 * , statically represented using varargs.
684 * @throws UnsupportedOperationException if the access mode is unsupported
685 * for this VarHandle.
686 * @throws WrongMethodTypeException if the access mode type does not
687 * match the caller's symbolic type descriptor.
688 * @throws ClassCastException if the access mode type matches the caller's
689 * symbolic type descriptor, but a reference cast fails.
690 */
691 public final native
692 @MethodHandle.PolymorphicSignature
693 @HotSpotIntrinsicCandidate
694 void setRelease(Object... args);
695
696
697 // Compare and set accessors
698
699 /**
700 * Atomically sets the value of a variable to the {@code newValue} with the
701 * memory semantics of {@link #setVolatile} if the variable's current value,
702 * referred to as the <em>witness value</em>, {@code ==} the
703 * {@code expectedValue}, as accessed with the memory semantics of
704 * {@link #getVolatile}.
705 *
706 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
707 *
708 * <p>The symbolic type descriptor at the call site of {@code
709 * compareAndSet} must match the access mode type that is the result of
710 * calling {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_SET)} on
711 * this VarHandle.
712 *
713 * @param args the signature-polymorphic parameter list of the form
714 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
715 * , statically represented using varargs.
716 * @return {@code true} if successful, otherwise {@code false} if the
717 * witness value was not the same as the {@code expectedValue}.
718 * @throws UnsupportedOperationException if the access mode is unsupported
719 * for this VarHandle.
720 * @throws WrongMethodTypeException if the access mode type does not
721 * match the caller's symbolic type descriptor.
722 * @throws ClassCastException if the access mode type matches the caller's
723 * symbolic type descriptor, but a reference cast fails.
724 * @see #setVolatile(Object...)
725 * @see #getVolatile(Object...)
726 */
727 public final native
728 @MethodHandle.PolymorphicSignature
729 @HotSpotIntrinsicCandidate
730 boolean compareAndSet(Object... args);
731
732 /**
733 * Atomically sets the value of a variable to the {@code newValue} with the
734 * memory semantics of {@link #setVolatile} if the variable's current value,
735 * referred to as the <em>witness value</em>, {@code ==} the
736 * {@code expectedValue}, as accessed with the memory semantics of
737 * {@link #getVolatile}.
738 *
739 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
740 *
741 * <p>The symbolic type descriptor at the call site of {@code
742 * compareAndExchange}
743 * must match the access mode type that is the result of calling
744 * {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE)}
745 * on this VarHandle.
746 *
747 * @param args the signature-polymorphic parameter list of the form
748 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
749 * , statically represented using varargs.
750 * @return the signature-polymorphic result that is the witness value, which
751 * will be the same as the {@code expectedValue} if successful
752 * , statically represented using {@code Object}.
753 * @throws UnsupportedOperationException if the access mode is unsupported
754 * for this VarHandle.
755 * @throws WrongMethodTypeException if the access mode type is not
756 * compatible with the caller's symbolic type descriptor.
757 * @throws ClassCastException if the access mode type is compatible with the
758 * caller's symbolic type descriptor, but a reference cast fails.
759 * @see #setVolatile(Object...)
760 * @see #getVolatile(Object...)
761 */
762 public final native
763 @MethodHandle.PolymorphicSignature
764 @HotSpotIntrinsicCandidate
765 Object compareAndExchange(Object... args);
766
767 /**
768 * Atomically sets the value of a variable to the {@code newValue} with the
769 * memory semantics of {@link #set} if the variable's current value,
770 * referred to as the <em>witness value</em>, {@code ==} the
771 * {@code expectedValue}, as accessed with the memory semantics of
772 * {@link #getAcquire}.
773 *
774 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
775 *
776 * <p>The symbolic type descriptor at the call site of {@code
777 * compareAndExchangeAcquire}
778 * must match the access mode type that is the result of calling
779 * {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE)} on
780 * this VarHandle.
781 *
782 * @param args the signature-polymorphic parameter list of the form
783 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
784 * , statically represented using varargs.
785 * @return the signature-polymorphic result that is the witness value, which
786 * will be the same as the {@code expectedValue} if successful
787 * , statically represented using {@code Object}.
788 * @throws UnsupportedOperationException if the access mode is unsupported
789 * for this VarHandle.
790 * @throws WrongMethodTypeException if the access mode type does not
791 * match the caller's symbolic type descriptor.
792 * @throws ClassCastException if the access mode type matches the caller's
793 * symbolic type descriptor, but a reference cast fails.
794 * @see #set(Object...)
795 * @see #getAcquire(Object...)
796 */
797 public final native
798 @MethodHandle.PolymorphicSignature
799 @HotSpotIntrinsicCandidate
800 Object compareAndExchangeAcquire(Object... args);
801
802 /**
803 * Atomically sets the value of a variable to the {@code newValue} with the
804 * memory semantics of {@link #setRelease} if the variable's current value,
805 * referred to as the <em>witness value</em>, {@code ==} the
806 * {@code expectedValue}, as accessed with the memory semantics of
807 * {@link #get}.
808 *
809 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
810 *
811 * <p>The symbolic type descriptor at the call site of {@code
812 * compareAndExchangeRelease}
813 * must match the access mode type that is the result of calling
814 * {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE)}
815 * on this VarHandle.
816 *
817 * @param args the signature-polymorphic parameter list of the form
818 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
819 * , statically represented using varargs.
820 * @return the signature-polymorphic result that is the witness value, which
821 * will be the same as the {@code expectedValue} if successful
822 * , statically represented using {@code Object}.
823 * @throws UnsupportedOperationException if the access mode is unsupported
824 * for this VarHandle.
825 * @throws WrongMethodTypeException if the access mode type does not
826 * match the caller's symbolic type descriptor.
827 * @throws ClassCastException if the access mode type matches the caller's
828 * symbolic type descriptor, but a reference cast fails.
829 * @see #setRelease(Object...)
830 * @see #get(Object...)
831 */
832 public final native
833 @MethodHandle.PolymorphicSignature
834 @HotSpotIntrinsicCandidate
835 Object compareAndExchangeRelease(Object... args);
836
837 // Weak (spurious failures allowed)
838
839 /**
840 * Possibly atomically sets the value of a variable to the {@code newValue}
841 * with the semantics of {@link #set} if the variable's current value,
842 * referred to as the <em>witness value</em>, {@code ==} the
843 * {@code expectedValue}, as accessed with the memory semantics of
844 * {@link #get}.
845 *
846 * <p>This operation may fail spuriously (typically, due to memory
847 * contention) even if the witness value does match the expected value.
848 *
849 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
850 *
851 * <p>The symbolic type descriptor at the call site of {@code
852 * weakCompareAndSetPlain} must match the access mode type that is the result of
853 * calling {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN)}
854 * on this VarHandle.
855 *
856 * @param args the signature-polymorphic parameter list of the form
857 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
858 * , statically represented using varargs.
859 * @return {@code true} if successful, otherwise {@code false} if the
860 * witness value was not the same as the {@code expectedValue} or if this
861 * operation spuriously failed.
862 * @throws UnsupportedOperationException if the access mode is unsupported
863 * for this VarHandle.
864 * @throws WrongMethodTypeException if the access mode type does not
865 * match the caller's symbolic type descriptor.
866 * @throws ClassCastException if the access mode type matches the caller's
867 * symbolic type descriptor, but a reference cast fails.
868 * @see #set(Object...)
869 * @see #get(Object...)
870 */
871 public final native
872 @MethodHandle.PolymorphicSignature
873 @HotSpotIntrinsicCandidate
874 boolean weakCompareAndSetPlain(Object... args);
875
876 /**
877 * Possibly atomically sets the value of a variable to the {@code newValue}
878 * with the memory semantics of {@link #setVolatile} if the variable's
879 * current value, referred to as the <em>witness value</em>, {@code ==} the
880 * {@code expectedValue}, as accessed with the memory semantics of
881 * {@link #getVolatile}.
882 *
883 * <p>This operation may fail spuriously (typically, due to memory
884 * contention) even if the witness value does match the expected value.
885 *
886 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
887 *
888 * <p>The symbolic type descriptor at the call site of {@code
889 * weakCompareAndSet} must match the access mode type that is the
890 * result of calling {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET)}
891 * on this VarHandle.
892 *
893 * @param args the signature-polymorphic parameter list of the form
894 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
895 * , statically represented using varargs.
896 * @return {@code true} if successful, otherwise {@code false} if the
897 * witness value was not the same as the {@code expectedValue} or if this
898 * operation spuriously failed.
899 * @throws UnsupportedOperationException if the access mode is unsupported
900 * for this VarHandle.
901 * @throws WrongMethodTypeException if the access mode type does not
902 * match the caller's symbolic type descriptor.
903 * @throws ClassCastException if the access mode type matches the caller's
904 * symbolic type descriptor, but a reference cast fails.
905 * @see #setVolatile(Object...)
906 * @see #getVolatile(Object...)
907 */
908 public final native
909 @MethodHandle.PolymorphicSignature
910 @HotSpotIntrinsicCandidate
911 boolean weakCompareAndSet(Object... args);
912
913 /**
914 * Possibly atomically sets the value of a variable to the {@code newValue}
915 * with the semantics of {@link #set} if the variable's current value,
916 * referred to as the <em>witness value</em>, {@code ==} the
917 * {@code expectedValue}, as accessed with the memory semantics of
918 * {@link #getAcquire}.
919 *
920 * <p>This operation may fail spuriously (typically, due to memory
921 * contention) even if the witness value does match the expected value.
922 *
923 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
924 *
925 * <p>The symbolic type descriptor at the call site of {@code
926 * weakCompareAndSetAcquire}
927 * must match the access mode type that is the result of calling
928 * {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE)}
929 * on this VarHandle.
930 *
931 * @param args the signature-polymorphic parameter list of the form
932 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
933 * , statically represented using varargs.
934 * @return {@code true} if successful, otherwise {@code false} if the
935 * witness value was not the same as the {@code expectedValue} or if this
936 * operation spuriously failed.
937 * @throws UnsupportedOperationException if the access mode is unsupported
938 * for this VarHandle.
939 * @throws WrongMethodTypeException if the access mode type does not
940 * match the caller's symbolic type descriptor.
941 * @throws ClassCastException if the access mode type matches the caller's
942 * symbolic type descriptor, but a reference cast fails.
943 * @see #set(Object...)
944 * @see #getAcquire(Object...)
945 */
946 public final native
947 @MethodHandle.PolymorphicSignature
948 @HotSpotIntrinsicCandidate
949 boolean weakCompareAndSetAcquire(Object... args);
950
951 /**
952 * Possibly atomically sets the value of a variable to the {@code newValue}
953 * with the semantics of {@link #setRelease} if the variable's current
954 * value, referred to as the <em>witness value</em>, {@code ==} the
955 * {@code expectedValue}, as accessed with the memory semantics of
956 * {@link #get}.
957 *
958 * <p>This operation may fail spuriously (typically, due to memory
959 * contention) even if the witness value does match the expected value.
960 *
961 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
962 *
963 * <p>The symbolic type descriptor at the call site of {@code
964 * weakCompareAndSetRelease}
965 * must match the access mode type that is the result of calling
966 * {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE)}
967 * on this VarHandle.
968 *
969 * @param args the signature-polymorphic parameter list of the form
970 * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
971 * , statically represented using varargs.
972 * @return {@code true} if successful, otherwise {@code false} if the
973 * witness value was not the same as the {@code expectedValue} or if this
974 * operation spuriously failed.
975 * @throws UnsupportedOperationException if the access mode is unsupported
976 * for this VarHandle.
977 * @throws WrongMethodTypeException if the access mode type does not
978 * match the caller's symbolic type descriptor.
979 * @throws ClassCastException if the access mode type matches the caller's
980 * symbolic type descriptor, but a reference cast fails.
981 * @see #setRelease(Object...)
982 * @see #get(Object...)
983 */
984 public final native
985 @MethodHandle.PolymorphicSignature
986 @HotSpotIntrinsicCandidate
987 boolean weakCompareAndSetRelease(Object... args);
988
989 /**
990 * Atomically sets the value of a variable to the {@code newValue} with the
991 * memory semantics of {@link #setVolatile} and returns the variable's
992 * previous value, as accessed with the memory semantics of
993 * {@link #getVolatile}.
994 *
995 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
996 *
997 * <p>The symbolic type descriptor at the call site of {@code getAndSet}
998 * must match the access mode type that is the result of calling
999 * {@code accessModeType(VarHandle.AccessMode.GET_AND_SET)} on this
1000 * VarHandle.
1001 *
1002 * @param args the signature-polymorphic parameter list of the form
1003 * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
1004 * , statically represented using varargs.
1005 * @return the signature-polymorphic result that is the previous value of
1006 * the variable
1007 * , statically represented using {@code Object}.
1008 * @throws UnsupportedOperationException if the access mode is unsupported
1009 * for this VarHandle.
1010 * @throws WrongMethodTypeException if the access mode type does not
1011 * match the caller's symbolic type descriptor.
1012 * @throws ClassCastException if the access mode type matches the caller's
1013 * symbolic type descriptor, but a reference cast fails.
1014 * @see #setVolatile(Object...)
1015 * @see #getVolatile(Object...)
1016 */
1017 public final native
1018 @MethodHandle.PolymorphicSignature
1019 @HotSpotIntrinsicCandidate
1020 Object getAndSet(Object... args);
1021
1022 /**
1023 * Atomically sets the value of a variable to the {@code newValue} with the
1024 * memory semantics of {@link #set} and returns the variable's
1025 * previous value, as accessed with the memory semantics of
1026 * {@link #getAcquire}.
1027 *
1028 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
1029 *
1030 * <p>The symbolic type descriptor at the call site of {@code getAndSetAcquire}
1031 * must match the access mode type that is the result of calling
1032 * {@code accessModeType(VarHandle.AccessMode.GET_AND_SET_ACQUIRE)} on this
1033 * VarHandle.
1034 *
1035 * @param args the signature-polymorphic parameter list of the form
1036 * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
1037 * , statically represented using varargs.
1038 * @return the signature-polymorphic result that is the previous value of
1039 * the variable
1040 * , statically represented using {@code Object}.
1041 * @throws UnsupportedOperationException if the access mode is unsupported
1042 * for this VarHandle.
1043 * @throws WrongMethodTypeException if the access mode type does not
1044 * match the caller's symbolic type descriptor.
1045 * @throws ClassCastException if the access mode type matches the caller's
1046 * symbolic type descriptor, but a reference cast fails.
1047 * @see #setVolatile(Object...)
1048 * @see #getVolatile(Object...)
1049 */
1050 public final native
1051 @MethodHandle.PolymorphicSignature
1052 @HotSpotIntrinsicCandidate
1053 Object getAndSetAcquire(Object... args);
1054
1055 /**
1056 * Atomically sets the value of a variable to the {@code newValue} with the
1057 * memory semantics of {@link #setRelease} and returns the variable's
1058 * previous value, as accessed with the memory semantics of
1059 * {@link #get}.
1060 *
1061 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
1062 *
1063 * <p>The symbolic type descriptor at the call site of {@code getAndSetRelease}
1064 * must match the access mode type that is the result of calling
1065 * {@code accessModeType(VarHandle.AccessMode.GET_AND_SET_RELEASE)} on this
1066 * VarHandle.
1067 *
1068 * @param args the signature-polymorphic parameter list of the form
1069 * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
1070 * , statically represented using varargs.
1071 * @return the signature-polymorphic result that is the previous value of
1072 * the variable
1073 * , statically represented using {@code Object}.
1074 * @throws UnsupportedOperationException if the access mode is unsupported
1075 * for this VarHandle.
1076 * @throws WrongMethodTypeException if the access mode type does not
1077 * match the caller's symbolic type descriptor.
1078 * @throws ClassCastException if the access mode type matches the caller's
1079 * symbolic type descriptor, but a reference cast fails.
1080 * @see #setVolatile(Object...)
1081 * @see #getVolatile(Object...)
1082 */
1083 public final native
1084 @MethodHandle.PolymorphicSignature
1085 @HotSpotIntrinsicCandidate
1086 Object getAndSetRelease(Object... args);
1087
1088 // Primitive adders
1089 // Throw UnsupportedOperationException for refs
1090
1091 /**
1092 * Atomically adds the {@code value} to the current value of a variable with
1093 * the memory semantics of {@link #setVolatile}, and returns the variable's
1094 * previous value, as accessed with the memory semantics of
1095 * {@link #getVolatile}.
1096 *
1097 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
1098 *
1099 * <p>The symbolic type descriptor at the call site of {@code getAndAdd}
1100 * must match the access mode type that is the result of calling
1101 * {@code accessModeType(VarHandle.AccessMode.GET_AND_ADD)} on this
1102 * VarHandle.
1103 *
1104 * @param args the signature-polymorphic parameter list of the form
1105 * {@code (CT1 ct1, ..., CTn ctn, T value)}
1106 * , statically represented using varargs.
1107 * @return the signature-polymorphic result that is the previous value of
1108 * the variable
1109 * , statically represented using {@code Object}.
1110 * @throws UnsupportedOperationException if the access mode is unsupported
1111 * for this VarHandle.
1112 * @throws WrongMethodTypeException if the access mode type does not
1113 * match the caller's symbolic type descriptor.
1114 * @throws ClassCastException if the access mode type matches the caller's
1115 * symbolic type descriptor, but a reference cast fails.
1116 * @see #setVolatile(Object...)
1117 * @see #getVolatile(Object...)
1118 */
1119 public final native
1120 @MethodHandle.PolymorphicSignature
1121 @HotSpotIntrinsicCandidate
1122 Object getAndAdd(Object... args);
1123
1124 /**
1125 * Atomically adds the {@code value} to the current value of a variable with
1126 * the memory semantics of {@link #set}, and returns the variable's
1127 * previous value, as accessed with the memory semantics of
1128 * {@link #getAcquire}.
1129 *
1130 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
1131 *
1132 * <p>The symbolic type descriptor at the call site of {@code getAndAddAcquire}
1133 * must match the access mode type that is the result of calling
1134 * {@code accessModeType(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE)} on this
1135 * VarHandle.
1136 *
1137 * @param args the signature-polymorphic parameter list of the form
1138 * {@code (CT1 ct1, ..., CTn ctn, T value)}
1139 * , statically represented using varargs.
1140 * @return the signature-polymorphic result that is the previous value of
1141 * the variable
1142 * , statically represented using {@code Object}.
1143 * @throws UnsupportedOperationException if the access mode is unsupported
1144 * for this VarHandle.
1145 * @throws WrongMethodTypeException if the access mode type does not
1146 * match the caller's symbolic type descriptor.
1147 * @throws ClassCastException if the access mode type matches the caller's
1148 * symbolic type descriptor, but a reference cast fails.
1149 * @see #setVolatile(Object...)
1150 * @see #getVolatile(Object...)
1151 */
1152 public final native
1153 @MethodHandle.PolymorphicSignature
1154 @HotSpotIntrinsicCandidate
1155 Object getAndAddAcquire(Object... args);
1156
1157 /**
1158 * Atomically adds the {@code value} to the current value of a variable with
1159 * the memory semantics of {@link #setRelease}, and returns the variable's
1160 * previous value, as accessed with the memory semantics of
1161 * {@link #get}.
1162 *
1163 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
1164 *
1165 * <p>The symbolic type descriptor at the call site of {@code getAndAddRelease}
1166 * must match the access mode type that is the result of calling
1167 * {@code accessModeType(VarHandle.AccessMode.GET_AND_ADD_RELEASE)} on this
1168 * VarHandle.
1169 *
1170 * @param args the signature-polymorphic parameter list of the form
1171 * {@code (CT1 ct1, ..., CTn ctn, T value)}
1172 * , statically represented using varargs.
1173 * @return the signature-polymorphic result that is the previous value of
1174 * the variable
1175 * , statically represented using {@code Object}.
1176 * @throws UnsupportedOperationException if the access mode is unsupported
1177 * for this VarHandle.
1178 * @throws WrongMethodTypeException if the access mode type does not
1179 * match the caller's symbolic type descriptor.
1180 * @throws ClassCastException if the access mode type matches the caller's
1181 * symbolic type descriptor, but a reference cast fails.
1182 * @see #setVolatile(Object...)
1183 * @see #getVolatile(Object...)
1184 */
1185 public final native
1186 @MethodHandle.PolymorphicSignature
1187 @HotSpotIntrinsicCandidate
1188 Object getAndAddRelease(Object... args);
1189
1190
1191 // Bitwise operations
1192 // Throw UnsupportedOperationException for refs
1193
1194 /**
1195 * Atomically sets the value of a variable to the result of
1196 * bitwise OR between the variable's current value and the {@code mask}
1197 * with the memory semantics of {@link #setVolatile} and returns the
1198 * variable's previous value, as accessed with the memory semantics of
1199 * {@link #getVolatile}.
1200 *
1201 * <p>If the variable type is the non-integral {@code boolean} type then a
1202 * logical OR is performed instead of a bitwise OR.
1203 *
1204 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1205 *
1206 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseOr}
1207 * must match the access mode type that is the result of calling
1208 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR)} on this
1209 * VarHandle.
1210 *
1211 * @param args the signature-polymorphic parameter list of the form
1212 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1213 * , statically represented using varargs.
1214 * @return the signature-polymorphic result that is the previous value of
1215 * the variable
1216 * , statically represented using {@code Object}.
1217 * @throws UnsupportedOperationException if the access mode is unsupported
1218 * for this VarHandle.
1219 * @throws WrongMethodTypeException if the access mode type does not
1220 * match the caller's symbolic type descriptor.
1221 * @throws ClassCastException if the access mode type matches the caller's
1222 * symbolic type descriptor, but a reference cast fails.
1223 * @see #setVolatile(Object...)
1224 * @see #getVolatile(Object...)
1225 */
1226 public final native
1227 @MethodHandle.PolymorphicSignature
1228 @HotSpotIntrinsicCandidate
1229 Object getAndBitwiseOr(Object... args);
1230
1231 /**
1232 * Atomically sets the value of a variable to the result of
1233 * bitwise OR between the variable's current value and the {@code mask}
1234 * with the memory semantics of {@link #set} and returns the
1235 * variable's previous value, as accessed with the memory semantics of
1236 * {@link #getAcquire}.
1237 *
1238 * <p>If the variable type is the non-integral {@code boolean} type then a
1239 * logical OR is performed instead of a bitwise OR.
1240 *
1241 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1242 *
1243 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseOrAcquire}
1244 * must match the access mode type that is the result of calling
1245 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE)} on this
1246 * VarHandle.
1247 *
1248 * @param args the signature-polymorphic parameter list of the form
1249 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1250 * , statically represented using varargs.
1251 * @return the signature-polymorphic result that is the previous value of
1252 * the variable
1253 * , statically represented using {@code Object}.
1254 * @throws UnsupportedOperationException if the access mode is unsupported
1255 * for this VarHandle.
1256 * @throws WrongMethodTypeException if the access mode type does not
1257 * match the caller's symbolic type descriptor.
1258 * @throws ClassCastException if the access mode type matches the caller's
1259 * symbolic type descriptor, but a reference cast fails.
1260 * @see #set(Object...)
1261 * @see #getAcquire(Object...)
1262 */
1263 public final native
1264 @MethodHandle.PolymorphicSignature
1265 @HotSpotIntrinsicCandidate
1266 Object getAndBitwiseOrAcquire(Object... args);
1267
1268 /**
1269 * Atomically sets the value of a variable to the result of
1270 * bitwise OR between the variable's current value and the {@code mask}
1271 * with the memory semantics of {@link #setRelease} and returns the
1272 * variable's previous value, as accessed with the memory semantics of
1273 * {@link #get}.
1274 *
1275 * <p>If the variable type is the non-integral {@code boolean} type then a
1276 * logical OR is performed instead of a bitwise OR.
1277 *
1278 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1279 *
1280 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseOrRelease}
1281 * must match the access mode type that is the result of calling
1282 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE)} on this
1283 * VarHandle.
1284 *
1285 * @param args the signature-polymorphic parameter list of the form
1286 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1287 * , statically represented using varargs.
1288 * @return the signature-polymorphic result that is the previous value of
1289 * the variable
1290 * , statically represented using {@code Object}.
1291 * @throws UnsupportedOperationException if the access mode is unsupported
1292 * for this VarHandle.
1293 * @throws WrongMethodTypeException if the access mode type does not
1294 * match the caller's symbolic type descriptor.
1295 * @throws ClassCastException if the access mode type matches the caller's
1296 * symbolic type descriptor, but a reference cast fails.
1297 * @see #setRelease(Object...)
1298 * @see #get(Object...)
1299 */
1300 public final native
1301 @MethodHandle.PolymorphicSignature
1302 @HotSpotIntrinsicCandidate
1303 Object getAndBitwiseOrRelease(Object... args);
1304
1305 /**
1306 * Atomically sets the value of a variable to the result of
1307 * bitwise AND between the variable's current value and the {@code mask}
1308 * with the memory semantics of {@link #setVolatile} and returns the
1309 * variable's previous value, as accessed with the memory semantics of
1310 * {@link #getVolatile}.
1311 *
1312 * <p>If the variable type is the non-integral {@code boolean} type then a
1313 * logical AND is performed instead of a bitwise AND.
1314 *
1315 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1316 *
1317 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseAnd}
1318 * must match the access mode type that is the result of calling
1319 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND)} on this
1320 * VarHandle.
1321 *
1322 * @param args the signature-polymorphic parameter list of the form
1323 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1324 * , statically represented using varargs.
1325 * @return the signature-polymorphic result that is the previous value of
1326 * the variable
1327 * , statically represented using {@code Object}.
1328 * @throws UnsupportedOperationException if the access mode is unsupported
1329 * for this VarHandle.
1330 * @throws WrongMethodTypeException if the access mode type does not
1331 * match the caller's symbolic type descriptor.
1332 * @throws ClassCastException if the access mode type matches the caller's
1333 * symbolic type descriptor, but a reference cast fails.
1334 * @see #setVolatile(Object...)
1335 * @see #getVolatile(Object...)
1336 */
1337 public final native
1338 @MethodHandle.PolymorphicSignature
1339 @HotSpotIntrinsicCandidate
1340 Object getAndBitwiseAnd(Object... args);
1341
1342 /**
1343 * Atomically sets the value of a variable to the result of
1344 * bitwise AND between the variable's current value and the {@code mask}
1345 * with the memory semantics of {@link #set} and returns the
1346 * variable's previous value, as accessed with the memory semantics of
1347 * {@link #getAcquire}.
1348 *
1349 * <p>If the variable type is the non-integral {@code boolean} type then a
1350 * logical AND is performed instead of a bitwise AND.
1351 *
1352 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1353 *
1354 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseAndAcquire}
1355 * must match the access mode type that is the result of calling
1356 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE)} on this
1357 * VarHandle.
1358 *
1359 * @param args the signature-polymorphic parameter list of the form
1360 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1361 * , statically represented using varargs.
1362 * @return the signature-polymorphic result that is the previous value of
1363 * the variable
1364 * , statically represented using {@code Object}.
1365 * @throws UnsupportedOperationException if the access mode is unsupported
1366 * for this VarHandle.
1367 * @throws WrongMethodTypeException if the access mode type does not
1368 * match the caller's symbolic type descriptor.
1369 * @throws ClassCastException if the access mode type matches the caller's
1370 * symbolic type descriptor, but a reference cast fails.
1371 * @see #set(Object...)
1372 * @see #getAcquire(Object...)
1373 */
1374 public final native
1375 @MethodHandle.PolymorphicSignature
1376 @HotSpotIntrinsicCandidate
1377 Object getAndBitwiseAndAcquire(Object... args);
1378
1379 /**
1380 * Atomically sets the value of a variable to the result of
1381 * bitwise AND between the variable's current value and the {@code mask}
1382 * with the memory semantics of {@link #setRelease} and returns the
1383 * variable's previous value, as accessed with the memory semantics of
1384 * {@link #get}.
1385 *
1386 * <p>If the variable type is the non-integral {@code boolean} type then a
1387 * logical AND is performed instead of a bitwise AND.
1388 *
1389 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1390 *
1391 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseAndRelease}
1392 * must match the access mode type that is the result of calling
1393 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE)} on this
1394 * VarHandle.
1395 *
1396 * @param args the signature-polymorphic parameter list of the form
1397 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1398 * , statically represented using varargs.
1399 * @return the signature-polymorphic result that is the previous value of
1400 * the variable
1401 * , statically represented using {@code Object}.
1402 * @throws UnsupportedOperationException if the access mode is unsupported
1403 * for this VarHandle.
1404 * @throws WrongMethodTypeException if the access mode type does not
1405 * match the caller's symbolic type descriptor.
1406 * @throws ClassCastException if the access mode type matches the caller's
1407 * symbolic type descriptor, but a reference cast fails.
1408 * @see #setRelease(Object...)
1409 * @see #get(Object...)
1410 */
1411 public final native
1412 @MethodHandle.PolymorphicSignature
1413 @HotSpotIntrinsicCandidate
1414 Object getAndBitwiseAndRelease(Object... args);
1415
1416 /**
1417 * Atomically sets the value of a variable to the result of
1418 * bitwise XOR between the variable's current value and the {@code mask}
1419 * with the memory semantics of {@link #setVolatile} and returns the
1420 * variable's previous value, as accessed with the memory semantics of
1421 * {@link #getVolatile}.
1422 *
1423 * <p>If the variable type is the non-integral {@code boolean} type then a
1424 * logical XOR is performed instead of a bitwise XOR.
1425 *
1426 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1427 *
1428 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseXor}
1429 * must match the access mode type that is the result of calling
1430 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR)} on this
1431 * VarHandle.
1432 *
1433 * @param args the signature-polymorphic parameter list of the form
1434 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1435 * , statically represented using varargs.
1436 * @return the signature-polymorphic result that is the previous value of
1437 * the variable
1438 * , statically represented using {@code Object}.
1439 * @throws UnsupportedOperationException if the access mode is unsupported
1440 * for this VarHandle.
1441 * @throws WrongMethodTypeException if the access mode type does not
1442 * match the caller's symbolic type descriptor.
1443 * @throws ClassCastException if the access mode type matches the caller's
1444 * symbolic type descriptor, but a reference cast fails.
1445 * @see #setVolatile(Object...)
1446 * @see #getVolatile(Object...)
1447 */
1448 public final native
1449 @MethodHandle.PolymorphicSignature
1450 @HotSpotIntrinsicCandidate
1451 Object getAndBitwiseXor(Object... args);
1452
1453 /**
1454 * Atomically sets the value of a variable to the result of
1455 * bitwise XOR between the variable's current value and the {@code mask}
1456 * with the memory semantics of {@link #set} and returns the
1457 * variable's previous value, as accessed with the memory semantics of
1458 * {@link #getAcquire}.
1459 *
1460 * <p>If the variable type is the non-integral {@code boolean} type then a
1461 * logical XOR is performed instead of a bitwise XOR.
1462 *
1463 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1464 *
1465 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseXorAcquire}
1466 * must match the access mode type that is the result of calling
1467 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE)} on this
1468 * VarHandle.
1469 *
1470 * @param args the signature-polymorphic parameter list of the form
1471 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1472 * , statically represented using varargs.
1473 * @return the signature-polymorphic result that is the previous value of
1474 * the variable
1475 * , statically represented using {@code Object}.
1476 * @throws UnsupportedOperationException if the access mode is unsupported
1477 * for this VarHandle.
1478 * @throws WrongMethodTypeException if the access mode type does not
1479 * match the caller's symbolic type descriptor.
1480 * @throws ClassCastException if the access mode type matches the caller's
1481 * symbolic type descriptor, but a reference cast fails.
1482 * @see #set(Object...)
1483 * @see #getAcquire(Object...)
1484 */
1485 public final native
1486 @MethodHandle.PolymorphicSignature
1487 @HotSpotIntrinsicCandidate
1488 Object getAndBitwiseXorAcquire(Object... args);
1489
1490 /**
1491 * Atomically sets the value of a variable to the result of
1492 * bitwise XOR between the variable's current value and the {@code mask}
1493 * with the memory semantics of {@link #setRelease} and returns the
1494 * variable's previous value, as accessed with the memory semantics of
1495 * {@link #get}.
1496 *
1497 * <p>If the variable type is the non-integral {@code boolean} type then a
1498 * logical XOR is performed instead of a bitwise XOR.
1499 *
1500 * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
1501 *
1502 * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseXorRelease}
1503 * must match the access mode type that is the result of calling
1504 * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)} on this
1505 * VarHandle.
1506 *
1507 * @param args the signature-polymorphic parameter list of the form
1508 * {@code (CT1 ct1, ..., CTn ctn, T mask)}
1509 * , statically represented using varargs.
1510 * @return the signature-polymorphic result that is the previous value of
1511 * the variable
1512 * , statically represented using {@code Object}.
1513 * @throws UnsupportedOperationException if the access mode is unsupported
1514 * for this VarHandle.
1515 * @throws WrongMethodTypeException if the access mode type does not
1516 * match the caller's symbolic type descriptor.
1517 * @throws ClassCastException if the access mode type matches the caller's
1518 * symbolic type descriptor, but a reference cast fails.
1519 * @see #setRelease(Object...)
1520 * @see #get(Object...)
1521 */
1522 public final native
1523 @MethodHandle.PolymorphicSignature
1524 @HotSpotIntrinsicCandidate
1525 Object getAndBitwiseXorRelease(Object... args);
1526
1527
1528 enum AccessType {
1529 GET(Object.class),
1530 SET(void.class),
1531 COMPARE_AND_SET(boolean.class),
1532 COMPARE_AND_EXCHANGE(Object.class),
1533 GET_AND_UPDATE(Object.class);
1534
1535 final Class<?> returnType;
1536 final boolean isMonomorphicInReturnType;
1537
1538 AccessType(Class<?> returnType) {
1539 this.returnType = returnType;
1540 isMonomorphicInReturnType = returnType != Object.class;
1541 }
1542
1543 MethodType accessModeType(Class<?> receiver, Class<?> value,
1544 Class<?>... intermediate) {
1545 Class<?>[] ps;
1546 int i;
1547 switch (this) {
1548 case GET:
1549 ps = allocateParameters(0, receiver, intermediate);
1550 fillParameters(ps, receiver, intermediate);
1551 return MethodType.methodType(value, ps);
1552 case SET:
1553 ps = allocateParameters(1, receiver, intermediate);
1554 i = fillParameters(ps, receiver, intermediate);
1555 ps[i] = value;
1556 return MethodType.methodType(void.class, ps);
1557 case COMPARE_AND_SET:
1558 ps = allocateParameters(2, receiver, intermediate);
1559 i = fillParameters(ps, receiver, intermediate);
1560 ps[i++] = value;
1561 ps[i] = value;
1562 return MethodType.methodType(boolean.class, ps);
1563 case COMPARE_AND_EXCHANGE:
1564 ps = allocateParameters(2, receiver, intermediate);
1565 i = fillParameters(ps, receiver, intermediate);
1566 ps[i++] = value;
1567 ps[i] = value;
1568 return MethodType.methodType(value, ps);
1569 case GET_AND_UPDATE:
1570 ps = allocateParameters(1, receiver, intermediate);
1571 i = fillParameters(ps, receiver, intermediate);
1572 ps[i] = value;
1573 return MethodType.methodType(value, ps);
1574 default:
1575 throw new InternalError("Unknown AccessType");
1576 }
1577 }
1578
1579 private static Class<?>[] allocateParameters(int values,
1580 Class<?> receiver, Class<?>... intermediate) {
1581 int size = ((receiver != null) ? 1 : 0) + intermediate.length + values;
1582 return new Class<?>[size];
1583 }
1584
1585 private static int fillParameters(Class<?>[] ps,
1586 Class<?> receiver, Class<?>... intermediate) {
1587 int i = 0;
1588 if (receiver != null)
1589 ps[i++] = receiver;
1590 for (int j = 0; j < intermediate.length; j++)
1591 ps[i++] = intermediate[j];
1592 return i;
1593 }
1594 }
1595
1596 /**
1597 * The set of access modes that specify how a variable, referenced by a
1598 * VarHandle, is accessed.
1599 */
1600 public enum AccessMode {
1601 /**
1602 * The access mode whose access is specified by the corresponding
1603 * method
1604 * {@link VarHandle#get VarHandle.get}
1605 */
1606 GET("get", AccessType.GET),
1607 /**
1608 * The access mode whose access is specified by the corresponding
1609 * method
1610 * {@link VarHandle#set VarHandle.set}
1611 */
1612 SET("set", AccessType.SET),
1613 /**
1614 * The access mode whose access is specified by the corresponding
1615 * method
1616 * {@link VarHandle#getVolatile VarHandle.getVolatile}
1617 */
1618 GET_VOLATILE("getVolatile", AccessType.GET),
1619 /**
1620 * The access mode whose access is specified by the corresponding
1621 * method
1622 * {@link VarHandle#setVolatile VarHandle.setVolatile}
1623 */
1624 SET_VOLATILE("setVolatile", AccessType.SET),
1625 /**
1626 * The access mode whose access is specified by the corresponding
1627 * method
1628 * {@link VarHandle#getAcquire VarHandle.getAcquire}
1629 */
1630 GET_ACQUIRE("getAcquire", AccessType.GET),
1631 /**
1632 * The access mode whose access is specified by the corresponding
1633 * method
1634 * {@link VarHandle#setRelease VarHandle.setRelease}
1635 */
1636 SET_RELEASE("setRelease", AccessType.SET),
1637 /**
1638 * The access mode whose access is specified by the corresponding
1639 * method
1640 * {@link VarHandle#getOpaque VarHandle.getOpaque}
1641 */
1642 GET_OPAQUE("getOpaque", AccessType.GET),
1643 /**
1644 * The access mode whose access is specified by the corresponding
1645 * method
1646 * {@link VarHandle#setOpaque VarHandle.setOpaque}
1647 */
1648 SET_OPAQUE("setOpaque", AccessType.SET),
1649 /**
1650 * The access mode whose access is specified by the corresponding
1651 * method
1652 * {@link VarHandle#compareAndSet VarHandle.compareAndSet}
1653 */
1654 COMPARE_AND_SET("compareAndSet", AccessType.COMPARE_AND_SET),
1655 /**
1656 * The access mode whose access is specified by the corresponding
1657 * method
1658 * {@link VarHandle#compareAndExchange VarHandle.compareAndExchange}
1659 */
1660 COMPARE_AND_EXCHANGE("compareAndExchange", AccessType.COMPARE_AND_EXCHANGE),
1661 /**
1662 * The access mode whose access is specified by the corresponding
1663 * method
1664 * {@link VarHandle#compareAndExchangeAcquire VarHandle.compareAndExchangeAcquire}
1665 */
1666 COMPARE_AND_EXCHANGE_ACQUIRE("compareAndExchangeAcquire", AccessType.COMPARE_AND_EXCHANGE),
1667 /**
1668 * The access mode whose access is specified by the corresponding
1669 * method
1670 * {@link VarHandle#compareAndExchangeRelease VarHandle.compareAndExchangeRelease}
1671 */
1672 COMPARE_AND_EXCHANGE_RELEASE("compareAndExchangeRelease", AccessType.COMPARE_AND_EXCHANGE),
1673 /**
1674 * The access mode whose access is specified by the corresponding
1675 * method
1676 * {@link VarHandle#weakCompareAndSetPlain VarHandle.weakCompareAndSetPlain}
1677 */
1678 WEAK_COMPARE_AND_SET_PLAIN("weakCompareAndSetPlain", AccessType.COMPARE_AND_SET),
1679 /**
1680 * The access mode whose access is specified by the corresponding
1681 * method
1682 * {@link VarHandle#weakCompareAndSet VarHandle.weakCompareAndSet}
1683 */
1684 WEAK_COMPARE_AND_SET("weakCompareAndSet", AccessType.COMPARE_AND_SET),
1685 /**
1686 * The access mode whose access is specified by the corresponding
1687 * method
1688 * {@link VarHandle#weakCompareAndSetAcquire VarHandle.weakCompareAndSetAcquire}
1689 */
1690 WEAK_COMPARE_AND_SET_ACQUIRE("weakCompareAndSetAcquire", AccessType.COMPARE_AND_SET),
1691 /**
1692 * The access mode whose access is specified by the corresponding
1693 * method
1694 * {@link VarHandle#weakCompareAndSetRelease VarHandle.weakCompareAndSetRelease}
1695 */
1696 WEAK_COMPARE_AND_SET_RELEASE("weakCompareAndSetRelease", AccessType.COMPARE_AND_SET),
1697 /**
1698 * The access mode whose access is specified by the corresponding
1699 * method
1700 * {@link VarHandle#getAndSet VarHandle.getAndSet}
1701 */
1702 GET_AND_SET("getAndSet", AccessType.GET_AND_UPDATE),
1703 /**
1704 * The access mode whose access is specified by the corresponding
1705 * method
1706 * {@link VarHandle#getAndSetAcquire VarHandle.getAndSetAcquire}
1707 */
1708 GET_AND_SET_ACQUIRE("getAndSetAcquire", AccessType.GET_AND_UPDATE),
1709 /**
1710 * The access mode whose access is specified by the corresponding
1711 * method
1712 * {@link VarHandle#getAndSetRelease VarHandle.getAndSetRelease}
1713 */
1714 GET_AND_SET_RELEASE("getAndSetRelease", AccessType.GET_AND_UPDATE),
1715 /**
1716 * The access mode whose access is specified by the corresponding
1717 * method
1718 * {@link VarHandle#getAndAdd VarHandle.getAndAdd}
1719 */
1720 GET_AND_ADD("getAndAdd", AccessType.GET_AND_UPDATE),
1721 /**
1722 * The access mode whose access is specified by the corresponding
1723 * method
1724 * {@link VarHandle#getAndAddAcquire VarHandle.getAndAddAcquire}
1725 */
1726 GET_AND_ADD_ACQUIRE("getAndAddAcquire", AccessType.GET_AND_UPDATE),
1727 /**
1728 * The access mode whose access is specified by the corresponding
1729 * method
1730 * {@link VarHandle#getAndAddRelease VarHandle.getAndAddRelease}
1731 */
1732 GET_AND_ADD_RELEASE("getAndAddRelease", AccessType.GET_AND_UPDATE),
1733 /**
1734 * The access mode whose access is specified by the corresponding
1735 * method
1736 * {@link VarHandle#getAndBitwiseOr VarHandle.getAndBitwiseOr}
1737 */
1738 GET_AND_BITWISE_OR("getAndBitwiseOr", AccessType.GET_AND_UPDATE),
1739 /**
1740 * The access mode whose access is specified by the corresponding
1741 * method
1742 * {@link VarHandle#getAndBitwiseOrRelease VarHandle.getAndBitwiseOrRelease}
1743 */
1744 GET_AND_BITWISE_OR_RELEASE("getAndBitwiseOrRelease", AccessType.GET_AND_UPDATE),
1745 /**
1746 * The access mode whose access is specified by the corresponding
1747 * method
1748 * {@link VarHandle#getAndBitwiseOrAcquire VarHandle.getAndBitwiseOrAcquire}
1749 */
1750 GET_AND_BITWISE_OR_ACQUIRE("getAndBitwiseOrAcquire", AccessType.GET_AND_UPDATE),
1751 /**
1752 * The access mode whose access is specified by the corresponding
1753 * method
1754 * {@link VarHandle#getAndBitwiseAnd VarHandle.getAndBitwiseAnd}
1755 */
1756 GET_AND_BITWISE_AND("getAndBitwiseAnd", AccessType.GET_AND_UPDATE),
1757 /**
1758 * The access mode whose access is specified by the corresponding
1759 * method
1760 * {@link VarHandle#getAndBitwiseAndRelease VarHandle.getAndBitwiseAndRelease}
1761 */
1762 GET_AND_BITWISE_AND_RELEASE("getAndBitwiseAndRelease", AccessType.GET_AND_UPDATE),
1763 /**
1764 * The access mode whose access is specified by the corresponding
1765 * method
1766 * {@link VarHandle#getAndBitwiseAndAcquire VarHandle.getAndBitwiseAndAcquire}
1767 */
1768 GET_AND_BITWISE_AND_ACQUIRE("getAndBitwiseAndAcquire", AccessType.GET_AND_UPDATE),
1769 /**
1770 * The access mode whose access is specified by the corresponding
1771 * method
1772 * {@link VarHandle#getAndBitwiseXor VarHandle.getAndBitwiseXor}
1773 */
1774 GET_AND_BITWISE_XOR("getAndBitwiseXor", AccessType.GET_AND_UPDATE),
1775 /**
1776 * The access mode whose access is specified by the corresponding
1777 * method
1778 * {@link VarHandle#getAndBitwiseXorRelease VarHandle.getAndBitwiseXorRelease}
1779 */
1780 GET_AND_BITWISE_XOR_RELEASE("getAndBitwiseXorRelease", AccessType.GET_AND_UPDATE),
1781 /**
1782 * The access mode whose access is specified by the corresponding
1783 * method
1784 * {@link VarHandle#getAndBitwiseXorAcquire VarHandle.getAndBitwiseXorAcquire}
1785 */
1786 GET_AND_BITWISE_XOR_ACQUIRE("getAndBitwiseXorAcquire", AccessType.GET_AND_UPDATE),
1787 ;
1788
1789 static final Map<String, AccessMode> methodNameToAccessMode;
1790 static {
1791 AccessMode[] values = AccessMode.values();
1792 // Initial capacity of # values divided by the load factor is sufficient
1793 // to avoid resizes for the smallest table size (64)
1794 int initialCapacity = (int)(values.length / 0.75f) + 1;
1795 methodNameToAccessMode = new HashMap<>(initialCapacity);
1796 for (AccessMode am : values) {
1797 methodNameToAccessMode.put(am.methodName, am);
1798 }
1799 }
1800
1801 final String methodName;
1802 final AccessType at;
1803
1804 AccessMode(final String methodName, AccessType at) {
1805 this.methodName = methodName;
1806 this.at = at;
1807 }
1808
1809 /**
1810 * Returns the {@code VarHandle} signature-polymorphic method name
1811 * associated with this {@code AccessMode} value.
1812 *
1813 * @return the signature-polymorphic method name
1814 * @see #valueFromMethodName
1815 */
1816 public String methodName() {
1817 return methodName;
1818 }
1819
1820 /**
1821 * Returns the {@code AccessMode} value associated with the specified
1822 * {@code VarHandle} signature-polymorphic method name.
1823 *
1824 * @param methodName the signature-polymorphic method name
1825 * @return the {@code AccessMode} value
1826 * @throws IllegalArgumentException if there is no {@code AccessMode}
1827 * value associated with method name (indicating the method
1828 * name does not correspond to a {@code VarHandle}
1829 * signature-polymorphic method name).
1830 * @see #methodName()
1831 */
1832 public static AccessMode valueFromMethodName(String methodName) {
1833 AccessMode am = methodNameToAccessMode.get(methodName);
1834 if (am != null) return am;
1835 throw new IllegalArgumentException("No AccessMode value for method name " + methodName);
1836 }
1837
1838 @ForceInline
1839 static MemberName getMemberName(int ordinal, VarForm vform) {
1840 return vform.memberName_table[ordinal];
1841 }
1842 }
1843
1844 static final class AccessDescriptor {
1845 final MethodType symbolicMethodTypeErased;
1846 final MethodType symbolicMethodTypeInvoker;
1847 final Class<?> returnType;
1848 final int type;
1849 final int mode;
1850
1851 public AccessDescriptor(MethodType symbolicMethodType, int type, int mode) {
1852 this.symbolicMethodTypeErased = symbolicMethodType.erase();
1853 this.symbolicMethodTypeInvoker = symbolicMethodType.insertParameterTypes(0, VarHandle.class);
1854 this.returnType = symbolicMethodType.returnType();
1855 this.type = type;
1856 this.mode = mode;
1857 }
1858 }
1859
1860 /**
1861 * Returns the variable type of variables referenced by this VarHandle.
1862 *
1863 * @return the variable type of variables referenced by this VarHandle
1864 */
1865 public final Class<?> varType() {
1866 MethodType typeSet = accessModeType(AccessMode.SET);
1867 return typeSet.parameterType(typeSet.parameterCount() - 1);
1868 }
1869
1870 /**
1871 * Returns the coordinate types for this VarHandle.
1872 *
1873 * @return the coordinate types for this VarHandle. The returned
1874 * list is unmodifiable
1875 */
1876 public final List<Class<?>> coordinateTypes() {
1877 MethodType typeGet = accessModeType(AccessMode.GET);
1878 return typeGet.parameterList();
1879 }
1880
1881 /**
1882 * Obtains the access mode type for this VarHandle and a given access mode.
1883 *
1884 * <p>The access mode type's parameter types will consist of a prefix that
1885 * is the coordinate types of this VarHandle followed by further
1886 * types as defined by the access mode method.
1887 * The access mode type's return type is defined by the return type of the
1888 * access mode method.
1889 *
1890 * @param accessMode the access mode, corresponding to the
1891 * signature-polymorphic method of the same name
1892 * @return the access mode type for the given access mode
1893 */
1894 public final MethodType accessModeType(AccessMode accessMode) {
1895 TypesAndInvokers tis = getTypesAndInvokers();
1896 MethodType mt = tis.methodType_table[accessMode.at.ordinal()];
1897 if (mt == null) {
1898 mt = tis.methodType_table[accessMode.at.ordinal()] =
1899 accessModeTypeUncached(accessMode);
1900 }
1901 return mt;
1902 }
1903 abstract MethodType accessModeTypeUncached(AccessMode accessMode);
1904
1905 /**
1906 * Returns {@code true} if the given access mode is supported, otherwise
1907 * {@code false}.
1908 *
1909 * <p>The return of a {@code false} value for a given access mode indicates
1910 * that an {@code UnsupportedOperationException} is thrown on invocation
1911 * of the corresponding access mode method.
1912 *
1913 * @param accessMode the access mode, corresponding to the
1914 * signature-polymorphic method of the same name
1915 * @return {@code true} if the given access mode is supported, otherwise
1916 * {@code false}.
1917 */
1918 public final boolean isAccessModeSupported(AccessMode accessMode) {
1919 return AccessMode.getMemberName(accessMode.ordinal(), vform) != null;
1920 }
1921
1922 /**
1923 * Obtains a method handle bound to this VarHandle and the given access
1924 * mode.
1925 *
1926 * @apiNote This method, for a VarHandle {@code vh} and access mode
1927 * {@code {access-mode}}, returns a method handle that is equivalent to
1928 * method handle {@code bmh} in the following code (though it may be more
1929 * efficient):
1930 * <pre>{@code
1931 * MethodHandle mh = MethodHandles.varHandleExactInvoker(
1932 * vh.accessModeType(VarHandle.AccessMode.{access-mode}));
1933 *
1934 * MethodHandle bmh = mh.bindTo(vh);
1935 * }</pre>
1936 *
1937 * @param accessMode the access mode, corresponding to the
1938 * signature-polymorphic method of the same name
1939 * @return a method handle bound to this VarHandle and the given access mode
1940 */
1941 public final MethodHandle toMethodHandle(AccessMode accessMode) {
1942 MemberName mn = AccessMode.getMemberName(accessMode.ordinal(), vform);
1943 if (mn != null) {
1944 MethodHandle mh = getMethodHandle(accessMode.ordinal());
1945 return mh.bindTo(this);
1946 }
1947 else {
1948 // Ensure an UnsupportedOperationException is thrown
1949 return MethodHandles.varHandleInvoker(accessMode, accessModeType(accessMode)).
1950 bindTo(this);
1951 }
1952 }
1953
1954 @Stable
1955 TypesAndInvokers typesAndInvokers;
1956
1957 static class TypesAndInvokers {
1958 final @Stable
1959 MethodType[] methodType_table =
1960 new MethodType[VarHandle.AccessType.values().length];
1961
1962 final @Stable
1963 MethodHandle[] methodHandle_table =
1964 new MethodHandle[AccessMode.values().length];
1965 }
1966
1967 @ForceInline
1968 private final TypesAndInvokers getTypesAndInvokers() {
1969 TypesAndInvokers tis = typesAndInvokers;
1970 if (tis == null) {
1971 tis = typesAndInvokers = new TypesAndInvokers();
1972 }
1973 return tis;
1974 }
1975
1976 @ForceInline
1977 final MethodHandle getMethodHandle(int mode) {
1978 TypesAndInvokers tis = getTypesAndInvokers();
1979 MethodHandle mh = tis.methodHandle_table[mode];
1980 if (mh == null) {
1981 mh = tis.methodHandle_table[mode] = getMethodHandleUncached(mode);
1982 }
1983 return mh;
1984 }
1985 private final MethodHandle getMethodHandleUncached(int mode) {
1986 MethodType mt = accessModeType(AccessMode.values()[mode]).
1987 insertParameterTypes(0, VarHandle.class);
1988 MemberName mn = vform.getMemberName(mode);
1989 DirectMethodHandle dmh = DirectMethodHandle.make(mn);
1990 // Such a method handle must not be publically exposed directly
1991 // otherwise it can be cracked, it must be transformed or rebound
1992 // before exposure
1993 MethodHandle mh = dmh.copyWith(mt, dmh.form);
1994 assert mh.type().erase() == mn.getMethodType().erase();
1995 return mh;
1996 }
1997
1998
1999 /*non-public*/
2000 final void updateVarForm(VarForm newVForm) {
2001 if (vform == newVForm) return;
2002 UNSAFE.putObject(this, VFORM_OFFSET, newVForm);
2003 UNSAFE.fullFence();
2004 }
2005
2006 static final BiFunction<String, List<Integer>, ArrayIndexOutOfBoundsException>
2007 AIOOBE_SUPPLIER = Preconditions.outOfBoundsExceptionFormatter(
2008 new Function<String, ArrayIndexOutOfBoundsException>() {
2009 @Override
2010 public ArrayIndexOutOfBoundsException apply(String s) {
2011 return new ArrayIndexOutOfBoundsException(s);
2012 }
2013 });
2014
2015 private static final long VFORM_OFFSET;
2016
2017 static {
2018 VFORM_OFFSET = UNSAFE.objectFieldOffset(VarHandle.class, "vform");
2019
2020 // The VarHandleGuards must be initialized to ensure correct
2021 // compilation of the guard methods
2022 UNSAFE.ensureClassInitialized(VarHandleGuards.class);
2023 }
2024
2025
2026 // Fence methods
2027
2028 /**
2029 * Ensures that loads and stores before the fence will not be reordered
2030 * with
2031 * loads and stores after the fence.
2032 *
2033 * @apiNote Ignoring the many semantic differences from C and C++, this
2034 * method has memory ordering effects compatible with
2035 * {@code atomic_thread_fence(memory_order_seq_cst)}
2036 */
2037 @ForceInline
2038 public static void fullFence() {
2039 UNSAFE.fullFence();
2040 }
2041
2042 /**
2043 * Ensures that loads before the fence will not be reordered with loads and
2044 * stores after the fence.
2045 *
2046 * @apiNote Ignoring the many semantic differences from C and C++, this
2047 * method has memory ordering effects compatible with
2048 * {@code atomic_thread_fence(memory_order_acquire)}
2049 */
2050 @ForceInline
2051 public static void acquireFence() {
2052 UNSAFE.loadFence();
2053 }
2054
2055 /**
2056 * Ensures that loads and stores before the fence will not be
2057 * reordered with stores after the fence.
2058 *
2059 * @apiNote Ignoring the many semantic differences from C and C++, this
2060 * method has memory ordering effects compatible with
2061 * {@code atomic_thread_fence(memory_order_release)}
2062 */
2063 @ForceInline
2064 public static void releaseFence() {
2065 UNSAFE.storeFence();
2066 }
2067
2068 /**
2069 * Ensures that loads before the fence will not be reordered with
2070 * loads after the fence.
2071 */
2072 @ForceInline
2073 public static void loadLoadFence() {
2074 UNSAFE.loadLoadFence();
2075 }
2076
2077 /**
2078 * Ensures that stores before the fence will not be reordered with
2079 * stores after the fence.
2080 */
2081 @ForceInline
2082 public static void storeStoreFence() {
2083 UNSAFE.storeStoreFence();
2084 }
2085 }