CoCalc -- ByteBufferViewVarHandle.java

GitHub Repository: PojavLauncherTeam/openj9
Path: blob/master/jcl/src/java.base/share/classes/java/lang/invoke/ByteBufferViewVarHandle.java
¹²⁵²¹ views
1
/*[INCLUDE-IF Sidecar19-SE & !OPENJDK_METHODHANDLES]*/
2
/*******************************************************************************
3
 * Copyright (c) 2016, 2020 IBM Corp. and others
4
 *
5
 * This program and the accompanying materials are made available under
6
 * the terms of the Eclipse Public License 2.0 which accompanies this
7
 * distribution and is available at https://www.eclipse.org/legal/epl-2.0/
8
 * or the Apache License, Version 2.0 which accompanies this distribution and
9
 * is available at https://www.apache.org/licenses/LICENSE-2.0.
10
 *
11
 * This Source Code may also be made available under the following
12
 * Secondary Licenses when the conditions for such availability set
13
 * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU
14
 * General Public License, version 2 with the GNU Classpath
15
 * Exception [1] and GNU General Public License, version 2 with the
16
 * OpenJDK Assembly Exception [2].
17
 *
18
 * [1] https://www.gnu.org/software/classpath/license.html
19
 * [2] http://openjdk.java.net/legal/assembly-exception.html
20
 *
21
 * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
22
 *******************************************************************************/
23
package java.lang.invoke;
24

25
import static java.lang.invoke.ByteBufferViewVarHandle.ByteBufferViewVarHandleOperations.*;
26
import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
27
import static java.lang.invoke.MethodType.methodType;
28

29
import com.ibm.oti.util.Msg;
30
import java.nio.ByteBuffer;
31
import java.nio.ByteOrder;
32
import java.nio.ReadOnlyBufferException;
33
import jdk.internal.misc.Unsafe;
34

35
final class ByteBufferViewVarHandle extends ViewVarHandle {
36
	private final static Class<?>[] COORDINATE_TYPES = new Class<?>[] {ByteBuffer.class, int.class};
37
	
38
	/**
39
	 * Populates the static MethodHandle[] corresponding to the provided type. 
40
	 * 
41
	 * @param type The type to create MethodHandles for.
42
	 * @param byteOrder The byteOrder of the ByteBuffer(s) that will be used.
43
	 * @return The populated MethodHandle[].
44
	 */
45
	static final MethodHandle[] populateMHs(Class<?> type, ByteOrder byteOrder) {
46
		Class<? extends ByteBufferViewVarHandleOperations> operationsClass = null;
47
		boolean convertEndian = (byteOrder != ByteOrder.nativeOrder());
48
		
49
		if (int.class == type) {
50
			operationsClass = convertEndian ? OpIntConvertEndian.class : OpInt.class;
51
		} else if (long.class == type) {
52
			operationsClass = convertEndian ? OpLongConvertEndian.class : OpLong.class;
53
		} else if (char.class == type) {
54
			operationsClass = convertEndian ? OpCharConvertEndian.class : OpChar.class;
55
		} else if (double.class == type) {
56
			operationsClass = convertEndian ? OpDoubleConvertEndian.class : OpDouble.class;
57
		} else if (float.class == type) {
58
			operationsClass = convertEndian ? OpFloatConvertEndian.class : OpFloat.class;
59
		} else if (short.class == type) {
60
			operationsClass = convertEndian ? OpShortConvertEndian.class : OpShort.class;
61
		} else {
62
			/*[MSG "K0624", "{0} is not a supported view type."]*/
63
			throw new UnsupportedOperationException(com.ibm.oti.util.Msg.getString("K0624", type)); //$NON-NLS-1$
64
		}
65
		
66
		MethodType getter = methodType(type, ByteBuffer.class, int.class, VarHandle.class);
67
		MethodType setter = methodType(void.class, ByteBuffer.class, int.class, type, VarHandle.class);
68
		MethodType compareAndSet = methodType(boolean.class, ByteBuffer.class, int.class, type, type, VarHandle.class);
69
		MethodType compareAndExchange = compareAndSet.changeReturnType(type);
70
		MethodType getAndSet = setter.changeReturnType(type);
71
		MethodType[] lookupTypes = populateMTs(getter, setter, compareAndSet, compareAndExchange, getAndSet);
72
		
73
		return populateMHs(operationsClass, lookupTypes, lookupTypes);
74
	}
75
	
76
	/**
77
	 * Constructs a VarHandle that can access elements of a byte array as wider types.
78
	 * 
79
	 * @param viewArrayType The component type used when viewing elements of the array. 
80
	 */
81
	ByteBufferViewVarHandle(Class<?> viewArrayType, ByteOrder byteOrder) {
82
		super(viewArrayType, COORDINATE_TYPES, populateMHs(viewArrayType, byteOrder), 0);
83
	}
84

85
	/**
86
	 * Type specific methods used by ByteBufferViewVarHandle methods.
87
	 */
88
	@SuppressWarnings("unused")
89
	static class ByteBufferViewVarHandleOperations extends ViewVarHandle.ViewVarHandleOperations {
90
		
91
		/**
92
		 * A ByteBuffer may be on-heap or off-heap. On-heap buffers are backed by a byte[], 
93
		 * and off-heap buffers have a base memory address. This class abstracts away the
94
		 * difference so that a buffer element can simply be referenced by base and offset.
95
		 */
96
		private static class BufferElement {
97
			private static final int INDEX_OFFSET = Unsafe.ARRAY_BYTE_BASE_OFFSET;
98
			private static final MethodHandle directBufferAddressMH;
99
			private static final MethodHandle onHeapBufferArrayMH;
100
			private static final MethodHandle bufferOffsetMH;
101
			
102
			final Object base;
103
			final long offset;
104
			
105
			static {
106
				MethodHandle addressMH = null;
107
				MethodHandle arrayMH = null;
108
				MethodHandle offsetMH = null;
109
				try {
110
					addressMH = IMPL_LOOKUP.findGetter(ByteBuffer.class, "address", long.class);
111
					arrayMH = IMPL_LOOKUP.findGetter(ByteBuffer.class, "hb", byte[].class);
112
					offsetMH = IMPL_LOOKUP.findGetter(ByteBuffer.class, "offset", int.class);
113
				} catch (Throwable t) {
114
					throw new InternalError("Could not create MethodHandles for ByteBuffer fields", t);
115
				}
116
				directBufferAddressMH = addressMH;
117
				onHeapBufferArrayMH = arrayMH;
118
				bufferOffsetMH = offsetMH;
119
			}
120
			
121
			BufferElement(ByteBuffer buffer, int viewTypeSize, int index) {
122
				if (buffer.isDirect()) {
123
					this.base = null;
124
					this.offset = computeAddress(buffer, index, viewTypeSize);
125
				} else {
126
					this.base = getArray(buffer);
127
					this.offset = computeOffset(buffer, index, viewTypeSize);
128
				}
129
			}
130
			
131
			private final byte[] getArray(ByteBuffer buffer) {
132
				try {
133
					return (byte[])onHeapBufferArrayMH.invokeExact(buffer);
134
				} catch (Throwable e) {
135
					throw new InternalError("Could not get ByteBuffer backing array", e);
136
				}
137
			}
138
			
139
			private static final long computeOffset(ByteBuffer buffer, int index, int viewTypeSize) {
140
				int arrayOffset = 0;
141
				try {
142
					arrayOffset = (int)bufferOffsetMH.invokeExact(buffer);
143
				} catch (Throwable e) {
144
					throw new InternalError("Could not get ByteBuffer offset", e);
145
				}
146
				return (long)INDEX_OFFSET + arrayOffset + index;
147
			}
148
			
149
			private static final long computeAddress(ByteBuffer buffer, int index, int viewTypeSize) {
150
				long base = 0;
151
				try {
152
					base = (long)directBufferAddressMH.invokeExact(buffer);
153
				} catch (Throwable e) {
154
					throw new InternalError("Could not get ByteBuffer address", e);
155
				}
156
				return (long)base + index;
157
			}
158
		}
159

160
		static BufferElement checkAndGetBufferElement(ByteBuffer receiver, int viewTypeSize, int index, boolean readOnlyOperation, boolean allowUnaligned) {
161
			receiver.getClass();
162
			boundsCheck(receiver.limit(), viewTypeSize, index);
163
			if ((!readOnlyOperation) && receiver.isReadOnly()) {
164
				throw new ReadOnlyBufferException();
165
			}
166
			BufferElement be = new BufferElement(receiver, viewTypeSize, index);
167
			alignmentCheck(be.offset, viewTypeSize, allowUnaligned);
168
			return be;
169
		}
170

171
		static final class OpChar extends ByteBufferViewVarHandleOperations {
172
			private static final int BYTES = Character.BYTES;
173
			
174
			private static final char get(ByteBuffer receiver, int index, VarHandle varHandle) {
175
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
176
				return _unsafe.getChar(be.base, be.offset);
177

178
			}
179

180
			private static final void set(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
181
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
182
				_unsafe.putChar(be.base, be.offset, value);
183
			}
184

185
			private static final char getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
186
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
187
				return _unsafe.getCharVolatile(be.base, be.offset);
188

189
			}
190

191
			private static final void setVolatile(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
192
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
193
				_unsafe.putCharVolatile(be.base, be.offset, value);
194
			}
195

196
			private static final char getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
197
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
198
				return _unsafe.getCharOpaque(be.base, be.offset);
199

200
			}
201

202
			private static final void setOpaque(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
203
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
204
				_unsafe.putCharOpaque(be.base, be.offset, value);
205
			}
206

207
			private static final char getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
208
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
209
				return _unsafe.getCharAcquire(be.base, be.offset);
210

211
			}
212

213
			private static final void setRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
214
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
215
				_unsafe.putCharRelease(be.base, be.offset, value);
216
			}
217

218
			private static final boolean compareAndSet(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
219
				throw operationNotSupported(varHandle);
220
			}
221

222
			private static final char compareAndExchange(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
223
				throw operationNotSupported(varHandle);
224
			}
225

226
			private static final char compareAndExchangeAcquire(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
227
				throw operationNotSupported(varHandle);
228
			}
229

230
			private static final char compareAndExchangeRelease(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
231
				throw operationNotSupported(varHandle);
232
			}
233

234
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
235
				throw operationNotSupported(varHandle);
236
			}
237

238
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
239
				throw operationNotSupported(varHandle);
240
			}
241

242
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
243
				throw operationNotSupported(varHandle);
244
			}
245

246
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
247
				throw operationNotSupported(varHandle);
248
			}
249

250
			private static final char getAndSet(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
251
				throw operationNotSupported(varHandle);
252
			}
253

254
			private static final char getAndSetAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
255
				throw operationNotSupported(varHandle);
256
			}
257

258
			private static final char getAndSetRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
259
				throw operationNotSupported(varHandle);
260
			}
261

262
			private static final char getAndAdd(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
263
				throw operationNotSupported(varHandle);
264
			}
265

266
			private static final char getAndAddAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
267
				throw operationNotSupported(varHandle);
268
			}
269

270
			private static final char getAndAddRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
271
				throw operationNotSupported(varHandle);
272
			}
273

274
			private static final char getAndBitwiseAnd(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
275
				throw operationNotSupported(varHandle);
276
			}
277

278
			private static final char getAndBitwiseAndAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
279
				throw operationNotSupported(varHandle);
280
			}
281

282
			private static final char getAndBitwiseAndRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
283
				throw operationNotSupported(varHandle);
284
			}
285

286
			private static final char getAndBitwiseOr(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
287
				throw operationNotSupported(varHandle);
288
			}
289

290
			private static final char getAndBitwiseOrAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
291
				throw operationNotSupported(varHandle);
292
			}
293

294
			private static final char getAndBitwiseOrRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
295
				throw operationNotSupported(varHandle);
296
			}
297

298
			private static final char getAndBitwiseXor(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
299
				throw operationNotSupported(varHandle);
300
			}
301

302
			private static final char getAndBitwiseXorAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
303
				throw operationNotSupported(varHandle);
304
			}
305

306
			private static final char getAndBitwiseXorRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
307
				throw operationNotSupported(varHandle);
308
			}
309
		}
310
		
311
		static final class OpDouble extends ByteBufferViewVarHandleOperations {
312
			private static final int BYTES = Double.BYTES;
313
			
314
			private static final double get(ByteBuffer receiver, int index, VarHandle varHandle) {
315
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
316
				return _unsafe.getDouble(be.base, be.offset);
317
			}
318

319
			private static final void set(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
320
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
321
				_unsafe.putDouble(be.base, be.offset, value);
322
			}
323

324
			private static final double getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
325
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
326
				return _unsafe.getDoubleVolatile(be.base, be.offset);
327
			}
328

329
			private static final void setVolatile(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
330
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
331
				_unsafe.putDoubleVolatile(be.base, be.offset, value);
332
			}
333

334
			private static final double getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
335
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
336
				return _unsafe.getDoubleOpaque(be.base, be.offset);
337
			}
338

339
			private static final void setOpaque(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
340
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
341
				_unsafe.putDoubleOpaque(be.base, be.offset, value);
342
			}
343

344
			private static final double getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
345
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
346
				return _unsafe.getDoubleAcquire(be.base, be.offset);
347
			}
348

349
			private static final void setRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
350
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
351
				_unsafe.putDoubleRelease(be.base, be.offset, value);
352
			}
353

354
			private static final boolean compareAndSet(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
355
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
356
/*[IF Sidecar19-SE-OpenJ9]*/				
357
				return _unsafe.compareAndSetDouble(be.base, be.offset, testValue, newValue);	
358
/*[ELSE]
359
				return _unsafe.compareAndSwapDouble(be.base, be.offset, testValue, newValue);
360
/*[ENDIF]*/				
361
			}
362

363
			private static final double compareAndExchange(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
364
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
365
/*[IF Sidecar19-SE-OpenJ9]*/				
366
				return _unsafe.compareAndExchangeDouble(be.base, be.offset, testValue, newValue);
367
/*[ELSE]
368
				return _unsafe.compareAndExchangeDoubleVolatile(be.base, be.offset, testValue, newValue);
369
/*[ENDIF]*/				
370
			}
371

372
			private static final double compareAndExchangeAcquire(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
373
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
374
				return _unsafe.compareAndExchangeDoubleAcquire(be.base, be.offset, testValue, newValue);
375
			}
376

377
			private static final double compareAndExchangeRelease(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
378
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
379
				return _unsafe.compareAndExchangeDoubleRelease(be.base, be.offset, testValue, newValue);
380
			}
381

382
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
383
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
384
/*[IF Sidecar19-SE-OpenJ9]*/				
385
				return _unsafe.weakCompareAndSetDoublePlain(be.base, be.offset, testValue, newValue);
386
/*[ELSE]
387
				return _unsafe.weakCompareAndSwapDouble(be.base, be.offset, testValue, newValue);
388
/*[ENDIF]*/				
389
			}
390

391
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
392
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
393
/*[IF Sidecar19-SE-OpenJ9]*/				
394
				return _unsafe.weakCompareAndSetDoubleAcquire(be.base, be.offset, testValue, newValue);
395
/*[ELSE]
396
				return _unsafe.weakCompareAndSwapDoubleAcquire(be.base, be.offset, testValue, newValue);
397
/*[ENDIF]*/				
398
			}
399

400
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
401
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
402
/*[IF Sidecar19-SE-OpenJ9]*/				
403
				return _unsafe.weakCompareAndSetDoubleRelease(be.base, be.offset, testValue, newValue);
404
/*[ELSE]
405
				return _unsafe.weakCompareAndSwapDoubleRelease(be.base, be.offset, testValue, newValue);
406
/*[ENDIF]*/				
407
			}
408

409
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
410
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
411
/*[IF Sidecar19-SE-OpenJ9]*/				
412
				return _unsafe.weakCompareAndSetDoublePlain(be.base, be.offset, testValue, newValue);
413
/*[ELSE]
414
				return _unsafe.weakCompareAndSwapDouble(be.base, be.offset, testValue, newValue);
415
/*[ENDIF]*/
416
			}
417

418
			private static final double getAndSet(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
419
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
420
				return _unsafe.getAndSetDouble(be.base, be.offset, value);
421
			}
422

423
			private static final double getAndSetAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
424
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
425
				return _unsafe.getAndSetDoubleAcquire(be.base, be.offset, value);
426
			}
427

428
			private static final double getAndSetRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
429
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
430
				return _unsafe.getAndSetDoubleRelease(be.base, be.offset, value);
431
			}
432

433
			private static final double getAndAdd(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
434
				throw operationNotSupported(varHandle);
435
			}
436

437
			private static final double getAndAddAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
438
				throw operationNotSupported(varHandle);
439
			}
440

441
			private static final double getAndAddRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
442
				throw operationNotSupported(varHandle);
443
			}
444

445
			private static final double getAndBitwiseAnd(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
446
				throw operationNotSupported(varHandle);
447
			}
448

449
			private static final double getAndBitwiseAndAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
450
				throw operationNotSupported(varHandle);
451
			}
452

453
			private static final double getAndBitwiseAndRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
454
				throw operationNotSupported(varHandle);
455
			}
456

457
			private static final double getAndBitwiseOr(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
458
				throw operationNotSupported(varHandle);
459
			}
460

461
			private static final double getAndBitwiseOrAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
462
				throw operationNotSupported(varHandle);
463
			}
464

465
			private static final double getAndBitwiseOrRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
466
				throw operationNotSupported(varHandle);
467
			}
468

469
			private static final double getAndBitwiseXor(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
470
				throw operationNotSupported(varHandle);
471
			}
472

473
			private static final double getAndBitwiseXorAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
474
				throw operationNotSupported(varHandle);
475
			}
476

477
			private static final double getAndBitwiseXorRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
478
				throw operationNotSupported(varHandle);
479
			}
480
		}
481
		
482
		static final class OpFloat extends ByteBufferViewVarHandleOperations {
483
			private static final int BYTES = Float.BYTES;
484
			
485
			private static final float get(ByteBuffer receiver, int index, VarHandle varHandle) {
486
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
487
				return _unsafe.getFloat(be.base, be.offset);
488
			}
489

490
			private static final void set(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
491
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
492
				_unsafe.putFloat(be.base, be.offset, value);
493
			}
494

495
			private static final float getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
496
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
497
				return _unsafe.getFloatVolatile(be.base, be.offset);
498
			}
499

500
			private static final void setVolatile(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
501
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
502
				_unsafe.putFloatVolatile(be.base, be.offset, value);
503
			}
504

505
			private static final float getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
506
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
507
				return _unsafe.getFloatOpaque(be.base, be.offset);
508
			}
509

510
			private static final void setOpaque(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
511
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
512
				_unsafe.putFloatOpaque(be.base, be.offset, value);
513
			}
514

515
			private static final float getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
516
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
517
				return _unsafe.getFloatAcquire(be.base, be.offset);
518
			}
519

520
			private static final void setRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
521
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
522
				_unsafe.putFloatRelease(be.base, be.offset, value);
523
			}
524

525
			private static final boolean compareAndSet(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
526
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
527
/*[IF Sidecar19-SE-OpenJ9]*/				
528
				return _unsafe.compareAndSetFloat(be.base, be.offset, testValue, newValue);
529
/*[ELSE]
530
				return _unsafe.compareAndSwapFloat(be.base, be.offset, testValue, newValue);
531
/*[ENDIF]*/				
532
			}
533

534
			private static final float compareAndExchange(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
535
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
536
/*[IF Sidecar19-SE-OpenJ9]*/				
537
				return _unsafe.compareAndExchangeFloat(be.base, be.offset, testValue, newValue);
538
/*[ELSE]
539
				return _unsafe.compareAndExchangeFloatVolatile(be.base, be.offset, testValue, newValue);
540
/*[ENDIF]*/				
541
			}
542

543
			private static final float compareAndExchangeAcquire(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
544
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
545
				return _unsafe.compareAndExchangeFloatAcquire(be.base, be.offset, testValue, newValue);
546
			}
547

548
			private static final float compareAndExchangeRelease(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
549
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
550
				return _unsafe.compareAndExchangeFloatRelease(be.base, be.offset, testValue, newValue);
551
			}
552

553
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
554
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
555
/*[IF Sidecar19-SE-OpenJ9]*/				
556
				return _unsafe.weakCompareAndSetFloatPlain(be.base, be.offset, testValue, newValue);
557
/*[ELSE]
558
				return _unsafe.weakCompareAndSwapFloat(be.base, be.offset, testValue, newValue);
559
/*[ENDIF]*/				
560
			}
561

562
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
563
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
564
/*[IF Sidecar19-SE-OpenJ9]*/				
565
				return _unsafe.weakCompareAndSetFloatAcquire(be.base, be.offset, testValue, newValue);
566
/*[ELSE]
567
				return _unsafe.weakCompareAndSwapFloatAcquire(be.base, be.offset, testValue, newValue);
568
/*[ENDIF]*/				
569
			}
570

571
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
572
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
573
/*[IF Sidecar19-SE-OpenJ9]*/				
574
				return _unsafe.weakCompareAndSetFloatRelease(be.base, be.offset, testValue, newValue);
575
/*[ELSE]
576
				return _unsafe.weakCompareAndSwapFloatRelease(be.base, be.offset, testValue, newValue);
577
/*[ENDIF]*/				
578
			}
579

580
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
581
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
582
/*[IF Sidecar19-SE-OpenJ9]*/				
583
				return _unsafe.weakCompareAndSetFloatPlain(be.base, be.offset, testValue, newValue);
584
/*[ELSE]
585
				return _unsafe.weakCompareAndSwapFloat(be.base, be.offset, testValue, newValue);
586
/*[ENDIF]*/				
587
			}
588

589
			private static final float getAndSet(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
590
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
591
				return _unsafe.getAndSetFloat(be.base, be.offset, value);
592
			}
593

594
			private static final float getAndSetAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
595
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
596
				return _unsafe.getAndSetFloatAcquire(be.base, be.offset, value);
597
			}
598

599
			private static final float getAndSetRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
600
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
601
				return _unsafe.getAndSetFloatRelease(be.base, be.offset, value);
602
			}
603

604
			private static final float getAndAdd(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
605
				throw operationNotSupported(varHandle);
606
			}
607

608
			private static final float getAndAddAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
609
				throw operationNotSupported(varHandle);
610
			}
611

612
			private static final float getAndAddRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
613
				throw operationNotSupported(varHandle);
614
			}
615

616
			private static final float getAndBitwiseAnd(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
617
				throw operationNotSupported(varHandle);
618
			}
619

620
			private static final float getAndBitwiseAndAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
621
				throw operationNotSupported(varHandle);
622
			}
623

624
			private static final float getAndBitwiseAndRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
625
				throw operationNotSupported(varHandle);
626
			}
627

628
			private static final float getAndBitwiseOr(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
629
				throw operationNotSupported(varHandle);
630
			}
631

632
			private static final float getAndBitwiseOrAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
633
				throw operationNotSupported(varHandle);
634
			}
635

636
			private static final float getAndBitwiseOrRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
637
				throw operationNotSupported(varHandle);
638
			}
639

640
			private static final float getAndBitwiseXor(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
641
				throw operationNotSupported(varHandle);
642
			}
643

644
			private static final float getAndBitwiseXorAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
645
				throw operationNotSupported(varHandle);
646
			}
647

648
			private static final float getAndBitwiseXorRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
649
				throw operationNotSupported(varHandle);
650
			}
651
		}
652
		
653
		static final class OpInt extends ByteBufferViewVarHandleOperations {
654
			private static final int BYTES = Integer.BYTES;
655
			
656
			private static final int get(ByteBuffer receiver, int index, VarHandle varHandle) {
657
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
658
				return _unsafe.getInt(be.base, be.offset);
659
			}
660

661
			private static final void set(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
662
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
663
				_unsafe.putInt(be.base, be.offset, value);
664
			}
665

666
			private static final int getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
667
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
668
				return _unsafe.getIntVolatile(be.base, be.offset);
669
			}
670

671
			private static final void setVolatile(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
672
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
673
				_unsafe.putIntVolatile(be.base, be.offset, value);
674
			}
675

676
			private static final int getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
677
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
678
				return _unsafe.getIntOpaque(be.base, be.offset);
679
			}
680

681
			private static final void setOpaque(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
682
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
683
				_unsafe.putIntOpaque(be.base, be.offset, value);
684
			}
685

686
			private static final int getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
687
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
688
				return _unsafe.getIntAcquire(be.base, be.offset);
689
			}
690

691
			private static final void setRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
692
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
693
				_unsafe.putIntRelease(be.base, be.offset, value);
694
			}
695

696
			private static final boolean compareAndSet(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
697
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
698
/*[IF Sidecar19-SE-OpenJ9]*/				
699
				return _unsafe.compareAndSetInt(be.base, be.offset, testValue, newValue);
700
/*[ELSE]
701
				return _unsafe.compareAndSwapInt(be.base, be.offset, testValue, newValue);
702
/*[ENDIF]*/				
703
			}
704

705
			private static final int compareAndExchange(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
706
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
707
/*[IF Sidecar19-SE-OpenJ9]*/				
708
				return _unsafe.compareAndExchangeInt(be.base, be.offset, testValue, newValue);
709
/*[ELSE]
710
				return _unsafe.compareAndExchangeIntVolatile(be.base, be.offset, testValue, newValue);
711
/*[ENDIF]*/				
712
			}
713

714
			private static final int compareAndExchangeAcquire(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
715
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
716
				return _unsafe.compareAndExchangeIntAcquire(be.base, be.offset, testValue, newValue);
717
			}
718

719
			private static final int compareAndExchangeRelease(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
720
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
721
				return _unsafe.compareAndExchangeIntRelease(be.base, be.offset, testValue, newValue);
722
			}
723

724
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
725
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
726
/*[IF Sidecar19-SE-OpenJ9]*/				
727
				return _unsafe.weakCompareAndSetIntPlain(be.base, be.offset, testValue, newValue);
728
/*[ELSE]
729
				return _unsafe.weakCompareAndSwapInt(be.base, be.offset, testValue, newValue);
730
/*[ENDIF]*/				
731
			}
732

733
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
734
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
735
/*[IF Sidecar19-SE-OpenJ9]*/				
736
				return _unsafe.weakCompareAndSetIntAcquire(be.base, be.offset, testValue, newValue);
737
/*[ELSE]
738
				return _unsafe.weakCompareAndSwapIntAcquire(be.base, be.offset, testValue, newValue);
739
/*[ENDIF]*/				
740
			}
741

742
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
743
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
744
/*[IF Sidecar19-SE-OpenJ9]*/				
745
				return _unsafe.weakCompareAndSetIntRelease(be.base, be.offset, testValue, newValue);
746
/*[ELSE]
747
				return _unsafe.weakCompareAndSwapIntRelease(be.base, be.offset, testValue, newValue);
748
/*[ENDIF]*/				
749
			}
750

751
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
752
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
753
/*[IF Sidecar19-SE-OpenJ9]*/				
754
				return _unsafe.weakCompareAndSetIntPlain(be.base, be.offset, testValue, newValue);
755
/*[ELSE]
756
				return _unsafe.weakCompareAndSwapInt(be.base, be.offset, testValue, newValue);
757
/*[ENDIF]*/				
758
			}
759

760
			private static final int getAndSet(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
761
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
762
				return _unsafe.getAndSetInt(be.base, be.offset, value);
763
			}
764

765
			private static final int getAndSetAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
766
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
767
				return _unsafe.getAndSetIntAcquire(be.base, be.offset, value);
768
			}
769

770
			private static final int getAndSetRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
771
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
772
				return _unsafe.getAndSetIntRelease(be.base, be.offset, value);
773
			}
774

775
			private static final int getAndAdd(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
776
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
777
				return _unsafe.getAndAddInt(be.base, be.offset, value);
778
			}
779

780
			private static final int getAndAddAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
781
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
782
				return _unsafe.getAndAddIntAcquire(be.base, be.offset, value);
783
			}
784

785
			private static final int getAndAddRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
786
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
787
				return _unsafe.getAndAddIntRelease(be.base, be.offset, value);
788
			}
789

790
			private static final int getAndBitwiseAnd(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
791
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
792
				return _unsafe.getAndBitwiseAndInt(be.base, be.offset, value);
793
			}
794

795
			private static final int getAndBitwiseAndAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
796
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
797
				return _unsafe.getAndBitwiseAndIntAcquire(be.base, be.offset, value);
798
			}
799

800
			private static final int getAndBitwiseAndRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
801
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
802
				return _unsafe.getAndBitwiseAndIntRelease(be.base, be.offset, value);
803
			}
804

805
			private static final int getAndBitwiseOr(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
806
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
807
				return _unsafe.getAndBitwiseOrInt(be.base, be.offset, value);
808
			}
809

810
			private static final int getAndBitwiseOrAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
811
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
812
				return _unsafe.getAndBitwiseOrIntAcquire(be.base, be.offset, value);
813
			}
814

815
			private static final int getAndBitwiseOrRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
816
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
817
				return _unsafe.getAndBitwiseOrIntRelease(be.base, be.offset, value);
818
			}
819

820
			private static final int getAndBitwiseXor(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
821
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
822
				return _unsafe.getAndBitwiseXorInt(be.base, be.offset, value);
823
			}
824

825
			private static final int getAndBitwiseXorAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
826
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
827
				return _unsafe.getAndBitwiseXorIntAcquire(be.base, be.offset, value);
828
			}
829

830
			private static final int getAndBitwiseXorRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
831
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
832
				return _unsafe.getAndBitwiseXorIntRelease(be.base, be.offset, value);
833
			}
834
		}
835
		
836
		static final class OpLong extends ByteBufferViewVarHandleOperations {
837
			private static final int BYTES = Long.BYTES;
838
			
839
			private static final long get(ByteBuffer receiver, int index, VarHandle varHandle) {
840
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
841
				return _unsafe.getLong(be.base, be.offset);
842
			}
843

844
			private static final void set(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
845
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
846
				_unsafe.putLong(be.base, be.offset, value);
847
			}
848

849
			private static final long getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
850
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
851
				return _unsafe.getLongVolatile(be.base, be.offset);
852
			}
853

854
			private static final void setVolatile(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
855
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
856
				_unsafe.putLongVolatile(be.base, be.offset, value);
857
			}
858

859
			private static final long getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
860
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
861
				return _unsafe.getLongOpaque(be.base, be.offset);
862
			}
863

864
			private static final void setOpaque(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
865
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
866
				_unsafe.putLongOpaque(be.base, be.offset, value);
867
			}
868

869
			private static final long getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
870
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
871
				return _unsafe.getLongAcquire(be.base, be.offset);
872
			}
873

874
			private static final void setRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
875
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
876
				_unsafe.putLongRelease(be.base, be.offset, value);
877
			}
878

879
			private static final boolean compareAndSet(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
880
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
881
/*[IF Sidecar19-SE-OpenJ9]*/				
882
				return _unsafe.compareAndSetLong(be.base, be.offset, testValue, newValue);
883
/*[ELSE]
884
				return _unsafe.compareAndSwapLong(be.base, be.offset, testValue, newValue);
885
/*[ENDIF]*/				
886
			}
887

888
			private static final long compareAndExchange(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
889
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
890
/*[IF Sidecar19-SE-OpenJ9]*/				
891
				return _unsafe.compareAndExchangeLong(be.base, be.offset, testValue, newValue);
892
/*[ELSE]
893
				return _unsafe.compareAndExchangeLongVolatile(be.base, be.offset, testValue, newValue);
894
/*[ENDIF]*/				
895
			}
896

897
			private static final long compareAndExchangeAcquire(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
898
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
899
				return _unsafe.compareAndExchangeLongAcquire(be.base, be.offset, testValue, newValue);
900
			}
901

902
			private static final long compareAndExchangeRelease(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
903
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
904
				return _unsafe.compareAndExchangeLongRelease(be.base, be.offset, testValue, newValue);
905
			}
906

907
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
908
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
909
/*[IF Sidecar19-SE-OpenJ9]*/				
910
				return _unsafe.weakCompareAndSetLongPlain(be.base, be.offset, testValue, newValue);
911
/*[ELSE]
912
				return _unsafe.weakCompareAndSwapLong(be.base, be.offset, testValue, newValue);
913
/*[ENDIF]*/				
914
			}
915

916
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
917
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
918
/*[IF Sidecar19-SE-OpenJ9]*/				
919
				return _unsafe.weakCompareAndSetLongAcquire(be.base, be.offset, testValue, newValue);
920
/*[ELSE]
921
				return _unsafe.weakCompareAndSwapLongAcquire(be.base, be.offset, testValue, newValue);
922
/*[ENDIF]*/				
923
			}
924

925
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
926
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
927
/*[IF Sidecar19-SE-OpenJ9]*/				
928
				return _unsafe.weakCompareAndSetLongRelease(be.base, be.offset, testValue, newValue);
929
/*[ELSE]
930
				return _unsafe.weakCompareAndSwapLongRelease(be.base, be.offset, testValue, newValue);
931
/*[ENDIF]*/				
932
			}
933

934
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
935
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
936
/*[IF Sidecar19-SE-OpenJ9]*/				
937
				return _unsafe.weakCompareAndSetLongPlain(be.base, be.offset, testValue, newValue);
938
/*[ELSE]
939
				return _unsafe.weakCompareAndSwapLong(be.base, be.offset, testValue, newValue);
940
/*[ENDIF]*/				
941
			}
942

943
			private static final long getAndSet(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
944
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
945
				return _unsafe.getAndSetLong(be.base, be.offset, value);
946
			}
947

948
			private static final long getAndSetAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
949
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
950
				return _unsafe.getAndSetLongAcquire(be.base, be.offset, value);
951
			}
952

953
			private static final long getAndSetRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
954
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
955
				return _unsafe.getAndSetLongRelease(be.base, be.offset, value);
956
			}
957

958
			private static final long getAndAdd(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
959
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
960
				return _unsafe.getAndAddLong(be.base, be.offset, value);
961
			}
962

963
			private static final long getAndAddAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
964
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
965
				return _unsafe.getAndAddLongAcquire(be.base, be.offset, value);
966
			}
967

968
			private static final long getAndAddRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
969
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
970
				return _unsafe.getAndAddLongRelease(be.base, be.offset, value);
971
			}
972

973
			private static final long getAndBitwiseAnd(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
974
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
975
				return _unsafe.getAndBitwiseAndLong(be.base, be.offset, value);
976
			}
977

978
			private static final long getAndBitwiseAndAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
979
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
980
				return _unsafe.getAndBitwiseAndLongAcquire(be.base, be.offset, value);
981
			}
982

983
			private static final long getAndBitwiseAndRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
984
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
985
				return _unsafe.getAndBitwiseAndLongRelease(be.base, be.offset, value);
986
			}
987

988
			private static final long getAndBitwiseOr(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
989
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
990
				return _unsafe.getAndBitwiseOrLong(be.base, be.offset, value);
991
			}
992

993
			private static final long getAndBitwiseOrAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
994
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
995
				return _unsafe.getAndBitwiseOrLongAcquire(be.base, be.offset, value);
996
			}
997

998
			private static final long getAndBitwiseOrRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
999
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1000
				return _unsafe.getAndBitwiseOrLongRelease(be.base, be.offset, value);
1001
			}
1002

1003
			private static final long getAndBitwiseXor(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1004
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1005
				return _unsafe.getAndBitwiseXorLong(be.base, be.offset, value);
1006
			}
1007

1008
			private static final long getAndBitwiseXorAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1009
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1010
				return _unsafe.getAndBitwiseXorLongAcquire(be.base, be.offset, value);
1011
			}
1012

1013
			private static final long getAndBitwiseXorRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1014
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1015
				return _unsafe.getAndBitwiseXorLongRelease(be.base, be.offset, value);
1016
			}
1017
		}
1018
		
1019
		static final class OpShort extends ByteBufferViewVarHandleOperations {
1020
			private static final int BYTES = Short.BYTES;
1021
			
1022
			private static final short get(ByteBuffer receiver, int index, VarHandle varHandle) {
1023
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
1024
				return _unsafe.getShort(be.base, be.offset);
1025
			}
1026

1027
			private static final void set(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1028
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
1029
				_unsafe.putShort(be.base, be.offset, value);
1030
			}
1031

1032
			private static final short getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
1033
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1034
				return _unsafe.getShortVolatile(be.base, be.offset);
1035
			}
1036

1037
			private static final void setVolatile(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1038
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1039
				_unsafe.putShortVolatile(be.base, be.offset, value);
1040
			}
1041

1042
			private static final short getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
1043
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1044
				return _unsafe.getShortOpaque(be.base, be.offset);
1045
			}
1046

1047
			private static final void setOpaque(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1048
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1049
				_unsafe.putShortOpaque(be.base, be.offset, value);
1050
			}
1051

1052
			private static final short getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
1053
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1054
				return _unsafe.getShortAcquire(be.base, be.offset);
1055
			}
1056

1057
			private static final void setRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1058
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1059
				_unsafe.putShortRelease(be.base, be.offset, value);
1060
			}
1061

1062
			private static final boolean compareAndSet(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1063
				throw operationNotSupported(varHandle);
1064
			}
1065

1066
			private static final short compareAndExchange(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1067
				throw operationNotSupported(varHandle);
1068
			}
1069

1070
			private static final short compareAndExchangeAcquire(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1071
				throw operationNotSupported(varHandle);
1072
			}
1073

1074
			private static final short compareAndExchangeRelease(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1075
				throw operationNotSupported(varHandle);
1076
			}
1077

1078
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1079
				throw operationNotSupported(varHandle);
1080
			}
1081

1082
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1083
				throw operationNotSupported(varHandle);
1084
			}
1085

1086
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1087
				throw operationNotSupported(varHandle);
1088
			}
1089

1090
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
1091
				throw operationNotSupported(varHandle);
1092
			}
1093

1094
			private static final short getAndSet(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1095
				throw operationNotSupported(varHandle);
1096
			}
1097

1098
			private static final short getAndSetAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1099
				throw operationNotSupported(varHandle);
1100
			}
1101

1102
			private static final short getAndSetRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1103
				throw operationNotSupported(varHandle);
1104
			}
1105

1106
			private static final short getAndAdd(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1107
				throw operationNotSupported(varHandle);
1108
			}
1109

1110
			private static final short getAndAddAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1111
				throw operationNotSupported(varHandle);
1112
			}
1113

1114
			private static final short getAndAddRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1115
				throw operationNotSupported(varHandle);
1116
			}
1117

1118
			private static final short getAndBitwiseAnd(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1119
				throw operationNotSupported(varHandle);
1120
			}
1121

1122
			private static final short getAndBitwiseAndAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1123
				throw operationNotSupported(varHandle);
1124
			}
1125

1126
			private static final short getAndBitwiseAndRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1127
				throw operationNotSupported(varHandle);
1128
			}
1129

1130
			private static final short getAndBitwiseOr(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1131
				throw operationNotSupported(varHandle);
1132
			}
1133

1134
			private static final short getAndBitwiseOrAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1135
				throw operationNotSupported(varHandle);
1136
			}
1137

1138
			private static final short getAndBitwiseOrRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1139
				throw operationNotSupported(varHandle);
1140
			}
1141

1142
			private static final short getAndBitwiseXor(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1143
				throw operationNotSupported(varHandle);
1144
			}
1145

1146
			private static final short getAndBitwiseXorAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1147
				throw operationNotSupported(varHandle);
1148
			}
1149

1150
			private static final short getAndBitwiseXorRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
1151
				throw operationNotSupported(varHandle);
1152
			}
1153
		}
1154
		
1155
		static final class OpCharConvertEndian extends ByteBufferViewVarHandleOperations {
1156
			private static final int BYTES = Character.BYTES;
1157
			
1158
			private static final char get(ByteBuffer receiver, int index, VarHandle varHandle) {
1159
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
1160
				char result = _unsafe.getChar(be.base, be.offset);
1161
				return convertEndian(result);
1162
			}
1163

1164
			private static final void set(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1165
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
1166
				_unsafe.putChar(be.base, be.offset, convertEndian(value));
1167
			}
1168

1169
			private static final char getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
1170
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1171
				char result = _unsafe.getCharVolatile(be.base, be.offset);
1172
				return convertEndian(result);
1173
			}
1174

1175
			private static final void setVolatile(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1176
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1177
				_unsafe.putCharVolatile(be.base, be.offset, convertEndian(value));
1178
			}
1179

1180
			private static final char getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
1181
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1182
				char result = _unsafe.getCharOpaque(be.base, be.offset);
1183
				return convertEndian(result);
1184
			}
1185

1186
			private static final void setOpaque(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1187
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1188
				_unsafe.putCharOpaque(be.base, be.offset, convertEndian(value));
1189
			}
1190

1191
			private static final char getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
1192
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1193
				char result = _unsafe.getCharAcquire(be.base, be.offset);
1194
				return convertEndian(result);
1195
			}
1196

1197
			private static final void setRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1198
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1199
				_unsafe.putCharRelease(be.base, be.offset, convertEndian(value));
1200
			}
1201

1202
			private static final boolean compareAndSet(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1203
				throw operationNotSupported(varHandle);
1204
			}
1205

1206
			private static final char compareAndExchange(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1207
				throw operationNotSupported(varHandle);
1208
			}
1209

1210
			private static final char compareAndExchangeAcquire(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1211
				throw operationNotSupported(varHandle);
1212
			}
1213

1214
			private static final char compareAndExchangeRelease(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1215
				throw operationNotSupported(varHandle);
1216
			}
1217

1218
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1219
				throw operationNotSupported(varHandle);
1220
			}
1221

1222
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1223
				throw operationNotSupported(varHandle);
1224
			}
1225

1226
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1227
				throw operationNotSupported(varHandle);
1228
			}
1229

1230
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, char testValue, char newValue, VarHandle varHandle) {
1231
				throw operationNotSupported(varHandle);
1232
			}
1233

1234
			private static final char getAndSet(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1235
				throw operationNotSupported(varHandle);
1236
			}
1237

1238
			private static final char getAndSetAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1239
				throw operationNotSupported(varHandle);
1240
			}
1241

1242
			private static final char getAndSetRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1243
				throw operationNotSupported(varHandle);
1244
			}
1245

1246
			private static final char getAndAdd(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1247
				throw operationNotSupported(varHandle);
1248
			}
1249

1250
			private static final char getAndAddAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1251
				throw operationNotSupported(varHandle);
1252
			}
1253

1254
			private static final char getAndAddRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1255
				throw operationNotSupported(varHandle);
1256
			}
1257

1258
			private static final char getAndBitwiseAnd(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1259
				throw operationNotSupported(varHandle);
1260
			}
1261

1262
			private static final char getAndBitwiseAndAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1263
				throw operationNotSupported(varHandle);
1264
			}
1265

1266
			private static final char getAndBitwiseAndRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1267
				throw operationNotSupported(varHandle);
1268
			}
1269

1270
			private static final char getAndBitwiseOr(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1271
				throw operationNotSupported(varHandle);
1272
			}
1273

1274
			private static final char getAndBitwiseOrAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1275
				throw operationNotSupported(varHandle);
1276
			}
1277

1278
			private static final char getAndBitwiseOrRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1279
				throw operationNotSupported(varHandle);
1280
			}
1281

1282
			private static final char getAndBitwiseXor(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1283
				throw operationNotSupported(varHandle);
1284
			}
1285

1286
			private static final char getAndBitwiseXorAcquire(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1287
				throw operationNotSupported(varHandle);
1288
			}
1289

1290
			private static final char getAndBitwiseXorRelease(ByteBuffer receiver, int index, char value, VarHandle varHandle) {
1291
				throw operationNotSupported(varHandle);
1292
			}
1293
		}
1294
		
1295
		static final class OpDoubleConvertEndian extends ByteBufferViewVarHandleOperations {
1296
			private static final int BYTES = Double.BYTES;
1297
			
1298
			private static final double get(ByteBuffer receiver, int index, VarHandle varHandle) {
1299
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
1300
				double result = _unsafe.getDouble(be.base, be.offset);
1301
				return convertEndian(result);
1302
			}
1303

1304
			private static final void set(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1305
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
1306
				_unsafe.putDouble(be.base, be.offset, convertEndian(value));
1307
			}
1308

1309
			private static final double getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
1310
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1311
				double result = _unsafe.getDoubleVolatile(be.base, be.offset);
1312
				return convertEndian(result);
1313
			}
1314

1315
			private static final void setVolatile(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1316
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1317
				_unsafe.putDoubleVolatile(be.base, be.offset, convertEndian(value));
1318
			}
1319

1320
			private static final double getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
1321
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1322
				double result = _unsafe.getDoubleOpaque(be.base, be.offset);
1323
				return convertEndian(result);
1324
			}
1325

1326
			private static final void setOpaque(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1327
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1328
				_unsafe.putDoubleOpaque(be.base, be.offset, convertEndian(value));
1329
			}
1330

1331
			private static final double getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
1332
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1333
				double result = _unsafe.getDoubleAcquire(be.base, be.offset);
1334
				return convertEndian(result);
1335
			}
1336

1337
			private static final void setRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1338
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1339
				_unsafe.putDoubleRelease(be.base, be.offset, convertEndian(value));
1340
			}
1341

1342
			private static final boolean compareAndSet(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1343
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1344
/*[IF Sidecar19-SE-OpenJ9]*/				
1345
				return _unsafe.compareAndSetDouble(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1346
/*[ELSE]
1347
				return _unsafe.compareAndSwapDouble(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1348
/*[ENDIF]*/				
1349
			}
1350

1351
			private static final double compareAndExchange(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1352
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1353
/*[IF Sidecar19-SE-OpenJ9]*/				
1354
				double result = _unsafe.compareAndExchangeDouble(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1355
/*[ELSE]
1356
				double result = _unsafe.compareAndExchangeDoubleVolatile(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1357
/*[ENDIF]*/				
1358
				return convertEndian(result);
1359
			}
1360

1361
			private static final double compareAndExchangeAcquire(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1362
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1363
				double result = _unsafe.compareAndExchangeDoubleAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1364
				return convertEndian(result);
1365
			}
1366

1367
			private static final double compareAndExchangeRelease(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1368
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1369
				double result = _unsafe.compareAndExchangeDoubleRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1370
				return convertEndian(result);
1371
			}
1372

1373
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1374
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1375
/*[IF Sidecar19-SE-OpenJ9]*/				
1376
				return _unsafe.weakCompareAndSetDoublePlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1377
/*[ELSE]
1378
				return _unsafe.weakCompareAndSwapDouble(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1379
/*[ENDIF]*/				
1380
			}
1381

1382
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1383
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1384
/*[IF Sidecar19-SE-OpenJ9]*/				
1385
				return _unsafe.weakCompareAndSetDoubleAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1386
/*[ELSE]
1387
				return _unsafe.weakCompareAndSwapDoubleAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1388
/*[ENDIF]*/				
1389
			}
1390

1391
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1392
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1393
/*[IF Sidecar19-SE-OpenJ9]*/				
1394
				return _unsafe.weakCompareAndSetDoubleRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1395
/*[ELSE]
1396
				return _unsafe.weakCompareAndSwapDoubleRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1397
/*[ENDIF]*/				
1398
			}
1399

1400
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, double testValue, double newValue, VarHandle varHandle) {
1401
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1402
/*[IF Sidecar19-SE-OpenJ9]*/				
1403
				return _unsafe.weakCompareAndSetDoublePlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1404
/*[ELSE]
1405
				return _unsafe.weakCompareAndSwapDouble(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1406
/*[ENDIF]*/
1407
			}
1408

1409
			private static final double getAndSet(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1410
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1411
				double result = _unsafe.getAndSetDouble(be.base, be.offset, convertEndian(value));
1412
				return convertEndian(result);
1413
			}
1414

1415
			private static final double getAndSetAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1416
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1417
				double result = _unsafe.getAndSetDoubleAcquire(be.base, be.offset, convertEndian(value));
1418
				return convertEndian(result);
1419
			}
1420

1421
			private static final double getAndSetRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1422
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1423
				double result = _unsafe.getAndSetDoubleRelease(be.base, be.offset, convertEndian(value));
1424
				return convertEndian(result);
1425
			}
1426

1427
			private static final double getAndAdd(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1428
				throw operationNotSupported(varHandle);
1429
			}
1430

1431
			private static final double getAndAddAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1432
				throw operationNotSupported(varHandle);
1433
			}
1434

1435
			private static final double getAndAddRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1436
				throw operationNotSupported(varHandle);
1437
			}
1438

1439
			private static final double getAndBitwiseAnd(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1440
				throw operationNotSupported(varHandle);
1441
			}
1442

1443
			private static final double getAndBitwiseAndAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1444
				throw operationNotSupported(varHandle);
1445
			}
1446

1447
			private static final double getAndBitwiseAndRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1448
				throw operationNotSupported(varHandle);
1449
			}
1450

1451
			private static final double getAndBitwiseOr(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1452
				throw operationNotSupported(varHandle);
1453
			}
1454

1455
			private static final double getAndBitwiseOrAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1456
				throw operationNotSupported(varHandle);
1457
			}
1458

1459
			private static final double getAndBitwiseOrRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1460
				throw operationNotSupported(varHandle);
1461
			}
1462

1463
			private static final double getAndBitwiseXor(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1464
				throw operationNotSupported(varHandle);
1465
			}
1466

1467
			private static final double getAndBitwiseXorAcquire(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1468
				throw operationNotSupported(varHandle);
1469
			}
1470

1471
			private static final double getAndBitwiseXorRelease(ByteBuffer receiver, int index, double value, VarHandle varHandle) {
1472
				throw operationNotSupported(varHandle);
1473
			}
1474
		}
1475
		
1476
		static final class OpFloatConvertEndian extends ByteBufferViewVarHandleOperations {
1477
			private static final int BYTES = Float.BYTES;
1478
			
1479
			private static final float get(ByteBuffer receiver, int index, VarHandle varHandle) {
1480
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
1481
				float result = _unsafe.getFloat(be.base, be.offset);
1482
				return convertEndian(result);
1483
			}
1484

1485
			private static final void set(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1486
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
1487
				_unsafe.putFloat(be.base, be.offset, convertEndian(value));
1488
			}
1489

1490
			private static final float getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
1491
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1492
				float result = _unsafe.getFloatVolatile(be.base, be.offset);
1493
				return convertEndian(result);
1494
			}
1495

1496
			private static final void setVolatile(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1497
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1498
				_unsafe.putFloatVolatile(be.base, be.offset, convertEndian(value));
1499
			}
1500

1501
			private static final float getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
1502
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1503
				float result = _unsafe.getFloatOpaque(be.base, be.offset);
1504
				return convertEndian(result);
1505
			}
1506

1507
			private static final void setOpaque(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1508
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1509
				_unsafe.putFloatOpaque(be.base, be.offset, convertEndian(value));
1510
			}
1511

1512
			private static final float getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
1513
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1514
				float result = _unsafe.getFloatAcquire(be.base, be.offset);
1515
				return convertEndian(result);
1516
			}
1517

1518
			private static final void setRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1519
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1520
				_unsafe.putFloatRelease(be.base, be.offset, convertEndian(value));
1521
			}
1522

1523
			private static final boolean compareAndSet(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1524
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1525
/*[IF Sidecar19-SE-OpenJ9]*/				
1526
				return _unsafe.compareAndSetFloat(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1527
/*[ELSE]
1528
				return _unsafe.compareAndSwapFloat(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1529
/*[ENDIF]*/				
1530
			}
1531

1532
			private static final float compareAndExchange(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1533
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1534
/*[IF Sidecar19-SE-OpenJ9]*/
1535
				float result = _unsafe.compareAndExchangeFloat(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1536
/*[ELSE]
1537
				float result = _unsafe.compareAndExchangeFloatVolatile(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1538
/*[ENDIF]*/				
1539
				return convertEndian(result);
1540
			}
1541

1542
			private static final float compareAndExchangeAcquire(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1543
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1544
				float result = _unsafe.compareAndExchangeFloatAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1545
				return convertEndian(result);
1546
			}
1547

1548
			private static final float compareAndExchangeRelease(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1549
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1550
				float result = _unsafe.compareAndExchangeFloatRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1551
				return convertEndian(result);
1552
			}
1553

1554
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1555
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1556
/*[IF Sidecar19-SE-OpenJ9]*/				
1557
				return _unsafe.weakCompareAndSetFloatPlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1558
/*[ELSE]
1559
				return _unsafe.weakCompareAndSwapFloat(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1560
/*[ENDIF]*/				
1561
			}
1562

1563
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1564
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1565
/*[IF Sidecar19-SE-OpenJ9]*/				
1566
				return _unsafe.weakCompareAndSetFloatAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1567
/*[ELSE]
1568
				return _unsafe.weakCompareAndSwapFloatAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1569
/*[ENDIF]*/				
1570
			}
1571

1572
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1573
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1574
/*[IF Sidecar19-SE-OpenJ9]*/				
1575
				return _unsafe.weakCompareAndSetFloatRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1576
/*[ELSE]
1577
				return _unsafe.weakCompareAndSwapFloatRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1578
/*[ENDIF]*/				
1579
			}
1580

1581
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, float testValue, float newValue, VarHandle varHandle) {
1582
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1583
/*[IF Sidecar19-SE-OpenJ9]*/
1584
				return _unsafe.weakCompareAndSetFloatPlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1585
/*[ELSE]
1586
				return _unsafe.weakCompareAndSwapFloat(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1587
/*[ENDIF]*/				
1588
			}
1589

1590
			private static final float getAndSet(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1591
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1592
				float result = _unsafe.getAndSetFloat(be.base, be.offset, convertEndian(value));
1593
				return convertEndian(result);
1594
			}
1595

1596
			private static final float getAndSetAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1597
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1598
				float result = _unsafe.getAndSetFloatAcquire(be.base, be.offset, convertEndian(value));
1599
				return convertEndian(result);
1600
			}
1601

1602
			private static final float getAndSetRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1603
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1604
				float result = _unsafe.getAndSetFloatRelease(be.base, be.offset, convertEndian(value));
1605
				return convertEndian(result);
1606
			}
1607

1608
			private static final float getAndAdd(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1609
				throw operationNotSupported(varHandle);
1610
			}
1611

1612
			private static final float getAndAddAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1613
				throw operationNotSupported(varHandle);
1614
			}
1615

1616
			private static final float getAndAddRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1617
				throw operationNotSupported(varHandle);
1618
			}
1619

1620
			private static final float getAndBitwiseAnd(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1621
				throw operationNotSupported(varHandle);
1622
			}
1623

1624
			private static final float getAndBitwiseAndAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1625
				throw operationNotSupported(varHandle);
1626
			}
1627

1628
			private static final float getAndBitwiseAndRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1629
				throw operationNotSupported(varHandle);
1630
			}
1631

1632
			private static final float getAndBitwiseOr(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1633
				throw operationNotSupported(varHandle);
1634
			}
1635

1636
			private static final float getAndBitwiseOrAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1637
				throw operationNotSupported(varHandle);
1638
			}
1639

1640
			private static final float getAndBitwiseOrRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1641
				throw operationNotSupported(varHandle);
1642
			}
1643

1644
			private static final float getAndBitwiseXor(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1645
				throw operationNotSupported(varHandle);
1646
			}
1647

1648
			private static final float getAndBitwiseXorAcquire(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1649
				throw operationNotSupported(varHandle);
1650
			}
1651

1652
			private static final float getAndBitwiseXorRelease(ByteBuffer receiver, int index, float value, VarHandle varHandle) {
1653
				throw operationNotSupported(varHandle);
1654
			}
1655
		}
1656
		
1657
		static final class OpIntConvertEndian extends ByteBufferViewVarHandleOperations {
1658
			private static final int BYTES = Integer.BYTES;
1659
			
1660
			private static final int get(ByteBuffer receiver, int index, VarHandle varHandle) {
1661
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
1662
				int result = _unsafe.getInt(be.base, be.offset);
1663
				return convertEndian(result);
1664
			}
1665

1666
			private static final void set(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1667
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
1668
				_unsafe.putInt(be.base, be.offset, convertEndian(value));
1669
			}
1670

1671
			private static final int getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
1672
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1673
				int result = _unsafe.getIntVolatile(be.base, be.offset);
1674
				return convertEndian(result);
1675
			}
1676

1677
			private static final void setVolatile(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1678
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1679
				_unsafe.putIntVolatile(be.base, be.offset, convertEndian(value));
1680
			}
1681

1682
			private static final int getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
1683
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1684
				int result = _unsafe.getIntOpaque(be.base, be.offset);
1685
				return convertEndian(result);
1686
			}
1687

1688
			private static final void setOpaque(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1689
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1690
				_unsafe.putIntOpaque(be.base, be.offset, convertEndian(value));
1691
			}
1692

1693
			private static final int getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
1694
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1695
				int result = _unsafe.getIntAcquire(be.base, be.offset);
1696
				return convertEndian(result);
1697
			}
1698

1699
			private static final void setRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1700
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1701
				_unsafe.putIntRelease(be.base, be.offset, convertEndian(value));
1702
			}
1703

1704
			private static final boolean compareAndSet(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1705
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1706
/*[IF Sidecar19-SE-OpenJ9]*/				
1707
				return _unsafe.compareAndSetInt(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1708
/*[ELSE]
1709
				return _unsafe.compareAndSwapInt(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1710
/*[ENDIF]*/				
1711
			}
1712

1713
			private static final int compareAndExchange(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1714
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1715
/*[IF Sidecar19-SE-OpenJ9]*/
1716
				int result = _unsafe.compareAndExchangeInt(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1717
/*[ELSE]
1718
				int result = _unsafe.compareAndExchangeIntVolatile(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1719
/*[ENDIF]*/				
1720
				return convertEndian(result);
1721
			}
1722

1723
			private static final int compareAndExchangeAcquire(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1724
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1725
				int result = _unsafe.compareAndExchangeIntAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1726
				return convertEndian(result);
1727
			}
1728

1729
			private static final int compareAndExchangeRelease(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1730
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1731
				int result = _unsafe.compareAndExchangeIntRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1732
				return convertEndian(result);
1733
			}
1734

1735
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1736
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1737
/*[IF Sidecar19-SE-OpenJ9]*/
1738
				return _unsafe.weakCompareAndSetIntPlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1739
/*[ELSE]
1740
				return _unsafe.weakCompareAndSwapInt(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1741
/*[ENDIF]*/				
1742
			}
1743

1744
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1745
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1746
/*[IF Sidecar19-SE-OpenJ9]*/				
1747
				return _unsafe.weakCompareAndSetIntAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1748
/*[ELSE]
1749
				return _unsafe.weakCompareAndSwapIntAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1750
/*[ENDIF]*/				
1751
			}
1752

1753
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1754
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1755
/*[IF Sidecar19-SE-OpenJ9]*/				
1756
				return _unsafe.weakCompareAndSetIntRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1757
/*[ELSE]
1758
				return _unsafe.weakCompareAndSwapIntRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1759
/*[ENDIF]*/				
1760
			}
1761

1762
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, int testValue, int newValue, VarHandle varHandle) {
1763
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1764
/*[IF Sidecar19-SE-OpenJ9]*/
1765
				return _unsafe.weakCompareAndSetIntPlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1766
/*[ELSE]
1767
				return _unsafe.weakCompareAndSwapInt(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1768
/*[ENDIF]*/				
1769
			}
1770

1771
			private static final int getAndSet(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1772
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1773
				int result = _unsafe.getAndSetInt(be.base, be.offset, convertEndian(value));
1774
				return convertEndian(result);
1775
			}
1776

1777
			private static final int getAndSetAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1778
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1779
				int result = _unsafe.getAndSetIntAcquire(be.base, be.offset, convertEndian(value));
1780
				return convertEndian(result);
1781
			}
1782

1783
			private static final int getAndSetRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1784
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1785
				int result = _unsafe.getAndSetIntRelease(be.base, be.offset, convertEndian(value));
1786
				return convertEndian(result);
1787
			}
1788

1789
			private static final int getAndAdd(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1790
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1791
				int result = _unsafe.getAndAddInt(be.base, be.offset, convertEndian(value));
1792
				return convertEndian(result);
1793
			}
1794

1795
			private static final int getAndAddAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1796
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1797
				int result = _unsafe.getAndAddIntAcquire(be.base, be.offset, convertEndian(value));
1798
				return convertEndian(result);
1799
			}
1800

1801
			private static final int getAndAddRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1802
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1803
				int result = _unsafe.getAndAddIntRelease(be.base, be.offset, convertEndian(value));
1804
				return convertEndian(result);
1805
			}
1806

1807
			private static final int getAndBitwiseAnd(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1808
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1809
				int result = _unsafe.getAndBitwiseAndInt(be.base, be.offset, convertEndian(value));
1810
				return convertEndian(result);
1811
			}
1812

1813
			private static final int getAndBitwiseAndAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1814
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1815
				int result = _unsafe.getAndBitwiseAndIntAcquire(be.base, be.offset, convertEndian(value));
1816
				return convertEndian(result);
1817
			}
1818

1819
			private static final int getAndBitwiseAndRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1820
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1821
				int result = _unsafe.getAndBitwiseAndIntRelease(be.base, be.offset, convertEndian(value));
1822
				return convertEndian(result);
1823
			}
1824

1825
			private static final int getAndBitwiseOr(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1826
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1827
				int result = _unsafe.getAndBitwiseOrInt(be.base, be.offset, convertEndian(value));
1828
				return convertEndian(result);
1829
			}
1830

1831
			private static final int getAndBitwiseOrAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1832
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1833
				int result = _unsafe.getAndBitwiseOrIntAcquire(be.base, be.offset, convertEndian(value));
1834
				return convertEndian(result);
1835
			}
1836

1837
			private static final int getAndBitwiseOrRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1838
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1839
				int result = _unsafe.getAndBitwiseOrIntRelease(be.base, be.offset, convertEndian(value));
1840
				return convertEndian(result);
1841
			}
1842

1843
			private static final int getAndBitwiseXor(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1844
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1845
				int result = _unsafe.getAndBitwiseXorInt(be.base, be.offset, convertEndian(value));
1846
				return convertEndian(result);
1847
			}
1848

1849
			private static final int getAndBitwiseXorAcquire(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1850
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1851
				int result = _unsafe.getAndBitwiseXorIntAcquire(be.base, be.offset, convertEndian(value));
1852
				return convertEndian(result);
1853
			}
1854

1855
			private static final int getAndBitwiseXorRelease(ByteBuffer receiver, int index, int value, VarHandle varHandle) {
1856
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1857
				int result = _unsafe.getAndBitwiseXorIntRelease(be.base, be.offset, convertEndian(value));
1858
				return convertEndian(result);
1859
			}
1860
		}
1861
		
1862
		static final class OpLongConvertEndian extends ByteBufferViewVarHandleOperations {
1863
			private static final int BYTES = Long.BYTES;
1864
			
1865
			private static final long get(ByteBuffer receiver, int index, VarHandle varHandle) {
1866
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
1867
				long result = _unsafe.getLong(be.base, be.offset);
1868
				return convertEndian(result);
1869
			}
1870

1871
			private static final void set(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1872
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
1873
				_unsafe.putLong(be.base, be.offset, convertEndian(value));
1874
			}
1875

1876
			private static final long getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
1877
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1878
				long result = _unsafe.getLongVolatile(be.base, be.offset);
1879
				return convertEndian(result);
1880
			}
1881

1882
			private static final void setVolatile(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1883
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1884
				_unsafe.putLongVolatile(be.base, be.offset, convertEndian(value));
1885
			}
1886

1887
			private static final long getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
1888
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1889
				long result = _unsafe.getLongOpaque(be.base, be.offset);
1890
				return convertEndian(result);
1891
			}
1892

1893
			private static final void setOpaque(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1894
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1895
				_unsafe.putLongOpaque(be.base, be.offset, convertEndian(value));
1896
			}
1897

1898
			private static final long getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
1899
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
1900
				long result = _unsafe.getLongAcquire(be.base, be.offset);
1901
				return convertEndian(result);
1902
			}
1903

1904
			private static final void setRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1905
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1906
				_unsafe.putLongRelease(be.base, be.offset, convertEndian(value));
1907
			}
1908

1909
			private static final boolean compareAndSet(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1910
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1911
/*[IF Sidecar19-SE-OpenJ9]*/				
1912
				return _unsafe.compareAndSetLong(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1913
/*[ELSE]
1914
				return _unsafe.compareAndSwapLong(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1915
/*[ENDIF]*/				
1916
			}
1917

1918
			private static final long compareAndExchange(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1919
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1920
/*[IF Sidecar19-SE-OpenJ9]*/
1921
				long result = _unsafe.compareAndExchangeLong(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1922
/*[ELSE]
1923
				long result = _unsafe.compareAndExchangeLongVolatile(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1924
/*[ENDIF]*/				
1925
				return convertEndian(result);
1926
			}
1927

1928
			private static final long compareAndExchangeAcquire(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1929
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1930
				long result = _unsafe.compareAndExchangeLongAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1931
				return convertEndian(result);
1932
			}
1933

1934
			private static final long compareAndExchangeRelease(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1935
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1936
				long result = _unsafe.compareAndExchangeLongRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1937
				return convertEndian(result);
1938
			}
1939

1940
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1941
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1942
/*[IF Sidecar19-SE-OpenJ9]*/
1943
				return _unsafe.weakCompareAndSetLongPlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1944
/*[ELSE]
1945
				return _unsafe.weakCompareAndSwapLong(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1946
/*[ENDIF]*/				
1947
			}
1948

1949
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1950
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1951
/*[IF Sidecar19-SE-OpenJ9]*/				
1952
				return _unsafe.weakCompareAndSetLongAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1953
/*[ELSE]
1954
				return _unsafe.weakCompareAndSwapLongAcquire(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1955
/*[ENDIF]*/				
1956
			}
1957

1958
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1959
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1960
/*[IF Sidecar19-SE-OpenJ9]*/				
1961
				return _unsafe.weakCompareAndSetLongRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1962
/*[ELSE]
1963
				return _unsafe.weakCompareAndSwapLongRelease(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1964
/*[ENDIF]*/				
1965
			}
1966

1967
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, long testValue, long newValue, VarHandle varHandle) {
1968
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1969
/*[IF Sidecar19-SE-OpenJ9]*/
1970
				return _unsafe.weakCompareAndSetLongPlain(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1971
/*[ELSE]
1972
				return _unsafe.weakCompareAndSwapLong(be.base, be.offset, convertEndian(testValue), convertEndian(newValue));
1973
/*[ENDIF]*/				
1974
			}
1975

1976
			private static final long getAndSet(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1977
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1978
				long result = _unsafe.getAndSetLong(be.base, be.offset, convertEndian(value));
1979
				return convertEndian(result);
1980
			}
1981

1982
			private static final long getAndSetAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1983
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1984
				long result = _unsafe.getAndSetLongAcquire(be.base, be.offset, convertEndian(value));
1985
				return convertEndian(result);
1986
			}
1987

1988
			private static final long getAndSetRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1989
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1990
				long result = _unsafe.getAndSetLongRelease(be.base, be.offset, convertEndian(value));
1991
				return convertEndian(result);
1992
			}
1993

1994
			private static final long getAndAdd(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
1995
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
1996
				long result = _unsafe.getAndAddLong(be.base, be.offset, convertEndian(value));
1997
				return convertEndian(result);
1998
			}
1999

2000
			private static final long getAndAddAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2001
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2002
				long result = _unsafe.getAndAddLongAcquire(be.base, be.offset, convertEndian(value));
2003
				return convertEndian(result);
2004
			}
2005

2006
			private static final long getAndAddRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2007
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2008
				long result = _unsafe.getAndAddLongRelease(be.base, be.offset, convertEndian(value));
2009
				return convertEndian(result);
2010
			}
2011

2012
			private static final long getAndBitwiseAnd(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2013
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2014
				long result = _unsafe.getAndBitwiseAndLong(be.base, be.offset, convertEndian(value));
2015
				return convertEndian(result);
2016
			}
2017

2018
			private static final long getAndBitwiseAndAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2019
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2020
				long result = _unsafe.getAndBitwiseAndLongAcquire(be.base, be.offset, convertEndian(value));
2021
				return convertEndian(result);
2022
			}
2023

2024
			private static final long getAndBitwiseAndRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2025
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2026
				long result = _unsafe.getAndBitwiseAndLongRelease(be.base, be.offset, convertEndian(value));
2027
				return convertEndian(result);
2028
			}
2029

2030
			private static final long getAndBitwiseOr(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2031
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2032
				long result = _unsafe.getAndBitwiseOrLong(be.base, be.offset, convertEndian(value));
2033
				return convertEndian(result);
2034
			}
2035

2036
			private static final long getAndBitwiseOrAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2037
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2038
				long result = _unsafe.getAndBitwiseOrLongAcquire(be.base, be.offset, convertEndian(value));
2039
				return convertEndian(result);
2040
			}
2041

2042
			private static final long getAndBitwiseOrRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2043
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2044
				long result = _unsafe.getAndBitwiseOrLongRelease(be.base, be.offset, convertEndian(value));
2045
				return convertEndian(result);
2046
			}
2047

2048
			private static final long getAndBitwiseXor(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2049
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2050
				long result = _unsafe.getAndBitwiseXorLong(be.base, be.offset, convertEndian(value));
2051
				return convertEndian(result);
2052
			}
2053

2054
			private static final long getAndBitwiseXorAcquire(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2055
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2056
				long result = _unsafe.getAndBitwiseXorLongAcquire(be.base, be.offset, convertEndian(value));
2057
				return convertEndian(result);
2058
			}
2059

2060
			private static final long getAndBitwiseXorRelease(ByteBuffer receiver, int index, long value, VarHandle varHandle) {
2061
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2062
				long result = _unsafe.getAndBitwiseXorLongRelease(be.base, be.offset, convertEndian(value));
2063
				return convertEndian(result);
2064
			}
2065
		}
2066
		
2067
		static final class OpShortConvertEndian extends ByteBufferViewVarHandleOperations {
2068
			private static final int BYTES = Short.BYTES;
2069
			
2070
			private static final short get(ByteBuffer receiver, int index, VarHandle varHandle) {
2071
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, true);
2072
				short result = _unsafe.getShort(be.base, be.offset);
2073
				return convertEndian(result);
2074
			}
2075

2076
			private static final void set(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2077
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, true);
2078
				_unsafe.putShort(be.base, be.offset, convertEndian(value));
2079
			}
2080

2081
			private static final short getVolatile(ByteBuffer receiver, int index, VarHandle varHandle) {
2082
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
2083
				short result = _unsafe.getShortVolatile(be.base, be.offset);
2084
				return convertEndian(result);
2085
			}
2086

2087
			private static final void setVolatile(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2088
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2089
				_unsafe.putShortVolatile(be.base, be.offset, convertEndian(value));
2090
			}
2091

2092
			private static final short getOpaque(ByteBuffer receiver, int index, VarHandle varHandle) {
2093
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
2094
				short result = _unsafe.getShortOpaque(be.base, be.offset);
2095
				return convertEndian(result);
2096
			}
2097

2098
			private static final void setOpaque(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2099
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2100
				_unsafe.putShortOpaque(be.base, be.offset, convertEndian(value));
2101
			}
2102

2103
			private static final short getAcquire(ByteBuffer receiver, int index, VarHandle varHandle) {
2104
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, true, false);
2105
				short result = _unsafe.getShortAcquire(be.base, be.offset);
2106
				return convertEndian(result);
2107
			}
2108

2109
			private static final void setRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2110
				BufferElement be = checkAndGetBufferElement(receiver, BYTES, index, false, false);
2111
				_unsafe.putShortRelease(be.base, be.offset, convertEndian(value));
2112
			}
2113

2114
			private static final boolean compareAndSet(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2115
				throw operationNotSupported(varHandle);
2116
			}
2117

2118
			private static final short compareAndExchange(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2119
				throw operationNotSupported(varHandle);
2120
			}
2121

2122
			private static final short compareAndExchangeAcquire(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2123
				throw operationNotSupported(varHandle);
2124
			}
2125

2126
			private static final short compareAndExchangeRelease(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2127
				throw operationNotSupported(varHandle);
2128
			}
2129

2130
			private static final boolean weakCompareAndSet(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2131
				throw operationNotSupported(varHandle);
2132
			}
2133

2134
			private static final boolean weakCompareAndSetAcquire(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2135
				throw operationNotSupported(varHandle);
2136
			}
2137

2138
			private static final boolean weakCompareAndSetRelease(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2139
				throw operationNotSupported(varHandle);
2140
			}
2141

2142
			private static final boolean weakCompareAndSetPlain(ByteBuffer receiver, int index, short testValue, short newValue, VarHandle varHandle) {
2143
				throw operationNotSupported(varHandle);
2144
			}
2145

2146
			private static final short getAndSet(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2147
				throw operationNotSupported(varHandle);
2148
			}
2149

2150
			private static final short getAndSetAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2151
				throw operationNotSupported(varHandle);
2152
			}
2153

2154
			private static final short getAndSetRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2155
				throw operationNotSupported(varHandle);
2156
			}
2157

2158
			private static final short getAndAdd(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2159
				throw operationNotSupported(varHandle);
2160
			}
2161

2162
			private static final short getAndAddAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2163
				throw operationNotSupported(varHandle);
2164
			}
2165

2166
			private static final short getAndAddRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2167
				throw operationNotSupported(varHandle);
2168
			}
2169

2170
			private static final short getAndBitwiseAnd(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2171
				throw operationNotSupported(varHandle);
2172
			}
2173

2174
			private static final short getAndBitwiseAndAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2175
				throw operationNotSupported(varHandle);
2176
			}
2177

2178
			private static final short getAndBitwiseAndRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2179
				throw operationNotSupported(varHandle);
2180
			}
2181

2182
			private static final short getAndBitwiseOr(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2183
				throw operationNotSupported(varHandle);
2184
			}
2185

2186
			private static final short getAndBitwiseOrAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2187
				throw operationNotSupported(varHandle);
2188
			}
2189

2190
			private static final short getAndBitwiseOrRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2191
				throw operationNotSupported(varHandle);
2192
			}
2193

2194
			private static final short getAndBitwiseXor(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2195
				throw operationNotSupported(varHandle);
2196
			}
2197

2198
			private static final short getAndBitwiseXorAcquire(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2199
				throw operationNotSupported(varHandle);
2200
			}
2201

2202
			private static final short getAndBitwiseXorRelease(ByteBuffer receiver, int index, short value, VarHandle varHandle) {
2203
				throw operationNotSupported(varHandle);
2204
			}
2205
		}
2206
	}
2207
}
2208

2209
Product

Resources

Company
