72 return UNSAFE.get$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
73 handle.fieldOffset);
74 }
75
76 @ForceInline
77 static $type$ getOpaque(FieldInstanceReadOnly handle, Object holder) {
78 return UNSAFE.get$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
79 handle.fieldOffset);
80 }
81
82 @ForceInline
83 static $type$ getAcquire(FieldInstanceReadOnly handle, Object holder) {
84 return UNSAFE.get$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
85 handle.fieldOffset);
86 }
87
88 static final VarForm FORM = new VarForm(FieldInstanceReadOnly.class, Object.class, $type$.class);
89 }
90
91 static final class FieldInstanceReadWrite extends FieldInstanceReadOnly {
92
93 FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
94 super(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadWrite.FORM);
95 }
96
97 @ForceInline
98 static void set(FieldInstanceReadWrite handle, Object holder, $type$ value) {
99 UNSAFE.put$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
100 handle.fieldOffset,
101 {#if[Object]?handle.fieldType.cast(value):value});
102 }
103
104 @ForceInline
105 static void setVolatile(FieldInstanceReadWrite handle, Object holder, $type$ value) {
106 UNSAFE.put$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
107 handle.fieldOffset,
108 {#if[Object]?handle.fieldType.cast(value):value});
109 }
110
111 @ForceInline
112 static void setOpaque(FieldInstanceReadWrite handle, Object holder, $type$ value) {
113 UNSAFE.put$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
114 handle.fieldOffset,
115 {#if[Object]?handle.fieldType.cast(value):value});
116 }
117
118 @ForceInline
119 static void setRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
120 UNSAFE.put$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
121 handle.fieldOffset,
122 {#if[Object]?handle.fieldType.cast(value):value});
123 }
124 #if[CAS]
125
126 @ForceInline
127 static boolean compareAndSet(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
128 return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
129 handle.fieldOffset,
130 {#if[Object]?handle.fieldType.cast(expected):expected},
131 {#if[Object]?handle.fieldType.cast(value):value});
132 }
133
134 @ForceInline
135 static $type$ compareAndExchange(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
136 return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
137 handle.fieldOffset,
138 {#if[Object]?handle.fieldType.cast(expected):expected},
139 {#if[Object]?handle.fieldType.cast(value):value});
140 }
141
142 @ForceInline
143 static $type$ compareAndExchangeAcquire(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
144 return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
145 handle.fieldOffset,
146 {#if[Object]?handle.fieldType.cast(expected):expected},
147 {#if[Object]?handle.fieldType.cast(value):value});
148 }
149
150 @ForceInline
151 static $type$ compareAndExchangeRelease(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
152 return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
153 handle.fieldOffset,
154 {#if[Object]?handle.fieldType.cast(expected):expected},
155 {#if[Object]?handle.fieldType.cast(value):value});
156 }
157
158 @ForceInline
159 static boolean weakCompareAndSetPlain(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
160 return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
161 handle.fieldOffset,
162 {#if[Object]?handle.fieldType.cast(expected):expected},
163 {#if[Object]?handle.fieldType.cast(value):value});
164 }
165
166 @ForceInline
167 static boolean weakCompareAndSet(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
168 return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
169 handle.fieldOffset,
170 {#if[Object]?handle.fieldType.cast(expected):expected},
171 {#if[Object]?handle.fieldType.cast(value):value});
172 }
173
174 @ForceInline
175 static boolean weakCompareAndSetAcquire(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
176 return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
177 handle.fieldOffset,
178 {#if[Object]?handle.fieldType.cast(expected):expected},
179 {#if[Object]?handle.fieldType.cast(value):value});
180 }
181
182 @ForceInline
183 static boolean weakCompareAndSetRelease(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
184 return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
185 handle.fieldOffset,
186 {#if[Object]?handle.fieldType.cast(expected):expected},
187 {#if[Object]?handle.fieldType.cast(value):value});
188 }
189
190 @ForceInline
191 static $type$ getAndSet(FieldInstanceReadWrite handle, Object holder, $type$ value) {
192 return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
193 handle.fieldOffset,
194 {#if[Object]?handle.fieldType.cast(value):value});
195 }
196
197 @ForceInline
198 static $type$ getAndSetAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
199 return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
200 handle.fieldOffset,
201 {#if[Object]?handle.fieldType.cast(value):value});
202 }
203
204 @ForceInline
205 static $type$ getAndSetRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
206 return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
207 handle.fieldOffset,
208 {#if[Object]?handle.fieldType.cast(value):value});
209 }
210 #end[CAS]
211 #if[AtomicAdd]
212
213 @ForceInline
214 static $type$ getAndAdd(FieldInstanceReadWrite handle, Object holder, $type$ value) {
215 return UNSAFE.getAndAdd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
216 handle.fieldOffset,
217 value);
218 }
219
220 @ForceInline
221 static $type$ getAndAddAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
222 return UNSAFE.getAndAdd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
223 handle.fieldOffset,
224 value);
225 }
226
227 @ForceInline
228 static $type$ getAndAddRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
339 return UNSAFE.get$Type$Volatile(handle.base,
340 handle.fieldOffset);
341 }
342
343 @ForceInline
344 static $type$ getOpaque(FieldStaticReadOnly handle) {
345 return UNSAFE.get$Type$Opaque(handle.base,
346 handle.fieldOffset);
347 }
348
349 @ForceInline
350 static $type$ getAcquire(FieldStaticReadOnly handle) {
351 return UNSAFE.get$Type$Acquire(handle.base,
352 handle.fieldOffset);
353 }
354
355 static final VarForm FORM = new VarForm(FieldStaticReadOnly.class, null, $type$.class);
356 }
357
358 static final class FieldStaticReadWrite extends FieldStaticReadOnly {
359
360 FieldStaticReadWrite(Object base, long fieldOffset{#if[Object]?, Class<?> fieldType}) {
361 super(base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadWrite.FORM);
362 }
363
364 @ForceInline
365 static void set(FieldStaticReadWrite handle, $type$ value) {
366 UNSAFE.put$Type$(handle.base,
367 handle.fieldOffset,
368 {#if[Object]?handle.fieldType.cast(value):value});
369 }
370
371 @ForceInline
372 static void setVolatile(FieldStaticReadWrite handle, $type$ value) {
373 UNSAFE.put$Type$Volatile(handle.base,
374 handle.fieldOffset,
375 {#if[Object]?handle.fieldType.cast(value):value});
376 }
377
378 @ForceInline
379 static void setOpaque(FieldStaticReadWrite handle, $type$ value) {
380 UNSAFE.put$Type$Opaque(handle.base,
381 handle.fieldOffset,
382 {#if[Object]?handle.fieldType.cast(value):value});
383 }
384
385 @ForceInline
386 static void setRelease(FieldStaticReadWrite handle, $type$ value) {
387 UNSAFE.put$Type$Release(handle.base,
388 handle.fieldOffset,
389 {#if[Object]?handle.fieldType.cast(value):value});
390 }
391 #if[CAS]
392
393 @ForceInline
394 static boolean compareAndSet(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
395 return UNSAFE.compareAndSet$Type$(handle.base,
396 handle.fieldOffset,
397 {#if[Object]?handle.fieldType.cast(expected):expected},
398 {#if[Object]?handle.fieldType.cast(value):value});
399 }
400
401
402 @ForceInline
403 static $type$ compareAndExchange(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
404 return UNSAFE.compareAndExchange$Type$(handle.base,
405 handle.fieldOffset,
406 {#if[Object]?handle.fieldType.cast(expected):expected},
407 {#if[Object]?handle.fieldType.cast(value):value});
408 }
409
410 @ForceInline
411 static $type$ compareAndExchangeAcquire(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
412 return UNSAFE.compareAndExchange$Type$Acquire(handle.base,
413 handle.fieldOffset,
414 {#if[Object]?handle.fieldType.cast(expected):expected},
415 {#if[Object]?handle.fieldType.cast(value):value});
416 }
417
418 @ForceInline
419 static $type$ compareAndExchangeRelease(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
420 return UNSAFE.compareAndExchange$Type$Release(handle.base,
421 handle.fieldOffset,
422 {#if[Object]?handle.fieldType.cast(expected):expected},
423 {#if[Object]?handle.fieldType.cast(value):value});
424 }
425
426 @ForceInline
427 static boolean weakCompareAndSetPlain(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
428 return UNSAFE.weakCompareAndSet$Type$Plain(handle.base,
429 handle.fieldOffset,
430 {#if[Object]?handle.fieldType.cast(expected):expected},
431 {#if[Object]?handle.fieldType.cast(value):value});
432 }
433
434 @ForceInline
435 static boolean weakCompareAndSet(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
436 return UNSAFE.weakCompareAndSet$Type$(handle.base,
437 handle.fieldOffset,
438 {#if[Object]?handle.fieldType.cast(expected):expected},
439 {#if[Object]?handle.fieldType.cast(value):value});
440 }
441
442 @ForceInline
443 static boolean weakCompareAndSetAcquire(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
444 return UNSAFE.weakCompareAndSet$Type$Acquire(handle.base,
445 handle.fieldOffset,
446 {#if[Object]?handle.fieldType.cast(expected):expected},
447 {#if[Object]?handle.fieldType.cast(value):value});
448 }
449
450 @ForceInline
451 static boolean weakCompareAndSetRelease(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
452 return UNSAFE.weakCompareAndSet$Type$Release(handle.base,
453 handle.fieldOffset,
454 {#if[Object]?handle.fieldType.cast(expected):expected},
455 {#if[Object]?handle.fieldType.cast(value):value});
456 }
457
458 @ForceInline
459 static $type$ getAndSet(FieldStaticReadWrite handle, $type$ value) {
460 return UNSAFE.getAndSet$Type$(handle.base,
461 handle.fieldOffset,
462 {#if[Object]?handle.fieldType.cast(value):value});
463 }
464
465 @ForceInline
466 static $type$ getAndSetAcquire(FieldStaticReadWrite handle, $type$ value) {
467 return UNSAFE.getAndSet$Type$Acquire(handle.base,
468 handle.fieldOffset,
469 {#if[Object]?handle.fieldType.cast(value):value});
470 }
471
472 @ForceInline
473 static $type$ getAndSetRelease(FieldStaticReadWrite handle, $type$ value) {
474 return UNSAFE.getAndSet$Type$Release(handle.base,
475 handle.fieldOffset,
476 {#if[Object]?handle.fieldType.cast(value):value});
477 }
478 #end[CAS]
479 #if[AtomicAdd]
480
481 @ForceInline
482 static $type$ getAndAdd(FieldStaticReadWrite handle, $type$ value) {
483 return UNSAFE.getAndAdd$Type$(handle.base,
484 handle.fieldOffset,
485 value);
486 }
487
488 @ForceInline
489 static $type$ getAndAddAcquire(FieldStaticReadWrite handle, $type$ value) {
490 return UNSAFE.getAndAdd$Type$Acquire(handle.base,
491 handle.fieldOffset,
492 value);
493 }
494
495 @ForceInline
496 static $type$ getAndAddRelease(FieldStaticReadWrite handle, $type$ value) {
|
72 return UNSAFE.get$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
73 handle.fieldOffset);
74 }
75
76 @ForceInline
77 static $type$ getOpaque(FieldInstanceReadOnly handle, Object holder) {
78 return UNSAFE.get$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
79 handle.fieldOffset);
80 }
81
82 @ForceInline
83 static $type$ getAcquire(FieldInstanceReadOnly handle, Object holder) {
84 return UNSAFE.get$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
85 handle.fieldOffset);
86 }
87
88 static final VarForm FORM = new VarForm(FieldInstanceReadOnly.class, Object.class, $type$.class);
89 }
90
91 static final class FieldInstanceReadWrite extends FieldInstanceReadOnly {
92 #if[Object]
93 final boolean needsNullCheck;
94 #end[Object]
95 FieldInstanceReadWrite(Class<?> receiverType, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullable}) {
96 super(receiverType, fieldOffset{#if[Object]?, fieldType}, FieldInstanceReadWrite.FORM);
97 #if[Object]
98 this.needsNullCheck = !nullable;
99 #end[Object]
100 }
101
102 #if[Object]
103 @ForceInline
104 static Object checkCast(FieldInstanceReadWrite handle, $type$ value) {
105 if (handle.needsNullCheck)
106 Objects.requireNonNull(value);
107 return handle.fieldType.cast(value);
108 }
109 #end[Object]
110
111 @ForceInline
112 static void set(FieldInstanceReadWrite handle, Object holder, $type$ value) {
113 UNSAFE.put$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
114 handle.fieldOffset,
115 {#if[Object]?checkCast(handle, value):value});
116 }
117
118 @ForceInline
119 static void setVolatile(FieldInstanceReadWrite handle, Object holder, $type$ value) {
120 UNSAFE.put$Type$Volatile(Objects.requireNonNull(handle.receiverType.cast(holder)),
121 handle.fieldOffset,
122 {#if[Object]?checkCast(handle, value):value});
123 }
124
125 @ForceInline
126 static void setOpaque(FieldInstanceReadWrite handle, Object holder, $type$ value) {
127 UNSAFE.put$Type$Opaque(Objects.requireNonNull(handle.receiverType.cast(holder)),
128 handle.fieldOffset,
129 {#if[Object]?checkCast(handle, value):value});
130 }
131
132 @ForceInline
133 static void setRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
134 UNSAFE.put$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
135 handle.fieldOffset,
136 {#if[Object]?checkCast(handle, value):value});
137 }
138 #if[CAS]
139
140 @ForceInline
141 static boolean compareAndSet(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
142 return UNSAFE.compareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
143 handle.fieldOffset,
144 {#if[Object]?handle.fieldType.cast(expected):expected},
145 {#if[Object]?checkCast(handle, value):value});
146 }
147
148 @ForceInline
149 static $type$ compareAndExchange(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
150 return UNSAFE.compareAndExchange$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
151 handle.fieldOffset,
152 {#if[Object]?handle.fieldType.cast(expected):expected},
153 {#if[Object]?checkCast(handle, value):value});
154 }
155
156 @ForceInline
157 static $type$ compareAndExchangeAcquire(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
158 return UNSAFE.compareAndExchange$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
159 handle.fieldOffset,
160 {#if[Object]?handle.fieldType.cast(expected):expected},
161 {#if[Object]?checkCast(handle, value):value});
162 }
163
164 @ForceInline
165 static $type$ compareAndExchangeRelease(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
166 return UNSAFE.compareAndExchange$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
167 handle.fieldOffset,
168 {#if[Object]?handle.fieldType.cast(expected):expected},
169 {#if[Object]?checkCast(handle, value):value});
170 }
171
172 @ForceInline
173 static boolean weakCompareAndSetPlain(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
174 return UNSAFE.weakCompareAndSet$Type$Plain(Objects.requireNonNull(handle.receiverType.cast(holder)),
175 handle.fieldOffset,
176 {#if[Object]?handle.fieldType.cast(expected):expected},
177 {#if[Object]?checkCast(handle, value):value});
178 }
179
180 @ForceInline
181 static boolean weakCompareAndSet(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
182 return UNSAFE.weakCompareAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
183 handle.fieldOffset,
184 {#if[Object]?handle.fieldType.cast(expected):expected},
185 {#if[Object]?checkCast(handle, value):value});
186 }
187
188 @ForceInline
189 static boolean weakCompareAndSetAcquire(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
190 return UNSAFE.weakCompareAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
191 handle.fieldOffset,
192 {#if[Object]?handle.fieldType.cast(expected):expected},
193 {#if[Object]?checkCast(handle, value):value});
194 }
195
196 @ForceInline
197 static boolean weakCompareAndSetRelease(FieldInstanceReadWrite handle, Object holder, $type$ expected, $type$ value) {
198 return UNSAFE.weakCompareAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
199 handle.fieldOffset,
200 {#if[Object]?handle.fieldType.cast(expected):expected},
201 {#if[Object]?checkCast(handle, value):value});
202 }
203
204 @ForceInline
205 static $type$ getAndSet(FieldInstanceReadWrite handle, Object holder, $type$ value) {
206 return UNSAFE.getAndSet$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
207 handle.fieldOffset,
208 {#if[Object]?checkCast(handle, value):value});
209 }
210
211 @ForceInline
212 static $type$ getAndSetAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
213 return UNSAFE.getAndSet$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
214 handle.fieldOffset,
215 {#if[Object]?checkCast(handle, value):value});
216 }
217
218 @ForceInline
219 static $type$ getAndSetRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
220 return UNSAFE.getAndSet$Type$Release(Objects.requireNonNull(handle.receiverType.cast(holder)),
221 handle.fieldOffset,
222 {#if[Object]?checkCast(handle, value):value});
223 }
224 #end[CAS]
225 #if[AtomicAdd]
226
227 @ForceInline
228 static $type$ getAndAdd(FieldInstanceReadWrite handle, Object holder, $type$ value) {
229 return UNSAFE.getAndAdd$Type$(Objects.requireNonNull(handle.receiverType.cast(holder)),
230 handle.fieldOffset,
231 value);
232 }
233
234 @ForceInline
235 static $type$ getAndAddAcquire(FieldInstanceReadWrite handle, Object holder, $type$ value) {
236 return UNSAFE.getAndAdd$Type$Acquire(Objects.requireNonNull(handle.receiverType.cast(holder)),
237 handle.fieldOffset,
238 value);
239 }
240
241 @ForceInline
242 static $type$ getAndAddRelease(FieldInstanceReadWrite handle, Object holder, $type$ value) {
353 return UNSAFE.get$Type$Volatile(handle.base,
354 handle.fieldOffset);
355 }
356
357 @ForceInline
358 static $type$ getOpaque(FieldStaticReadOnly handle) {
359 return UNSAFE.get$Type$Opaque(handle.base,
360 handle.fieldOffset);
361 }
362
363 @ForceInline
364 static $type$ getAcquire(FieldStaticReadOnly handle) {
365 return UNSAFE.get$Type$Acquire(handle.base,
366 handle.fieldOffset);
367 }
368
369 static final VarForm FORM = new VarForm(FieldStaticReadOnly.class, null, $type$.class);
370 }
371
372 static final class FieldStaticReadWrite extends FieldStaticReadOnly {
373 #if[Object]
374 final boolean needsNullCheck;
375 #end[Object]
376 FieldStaticReadWrite(Object base, long fieldOffset{#if[Object]?, Class<?> fieldType, boolean nullable}) {
377 super(base, fieldOffset{#if[Object]?, fieldType}, FieldStaticReadWrite.FORM);
378 #if[Object]
379 this.needsNullCheck = !nullable;
380 #end[Object]
381 }
382
383 #if[Object]
384 static Object checkCast(FieldStaticReadWrite handle, $type$ value) {
385 if (handle.needsNullCheck)
386 Objects.requireNonNull(value);
387 return handle.fieldType.cast(value);
388 }
389 #end[Object]
390
391 @ForceInline
392 static void set(FieldStaticReadWrite handle, $type$ value) {
393 UNSAFE.put$Type$(handle.base,
394 handle.fieldOffset,
395 {#if[Object]?checkCast(handle, value):value});
396 }
397
398 @ForceInline
399 static void setVolatile(FieldStaticReadWrite handle, $type$ value) {
400 UNSAFE.put$Type$Volatile(handle.base,
401 handle.fieldOffset,
402 {#if[Object]?checkCast(handle, value):value});
403 }
404
405 @ForceInline
406 static void setOpaque(FieldStaticReadWrite handle, $type$ value) {
407 UNSAFE.put$Type$Opaque(handle.base,
408 handle.fieldOffset,
409 {#if[Object]?checkCast(handle, value):value});
410 }
411
412 @ForceInline
413 static void setRelease(FieldStaticReadWrite handle, $type$ value) {
414 UNSAFE.put$Type$Release(handle.base,
415 handle.fieldOffset,
416 {#if[Object]?checkCast(handle, value):value});
417 }
418 #if[CAS]
419
420 @ForceInline
421 static boolean compareAndSet(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
422 return UNSAFE.compareAndSet$Type$(handle.base,
423 handle.fieldOffset,
424 {#if[Object]?handle.fieldType.cast(expected):expected},
425 {#if[Object]?checkCast(handle, value):value});
426 }
427
428
429 @ForceInline
430 static $type$ compareAndExchange(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
431 return UNSAFE.compareAndExchange$Type$(handle.base,
432 handle.fieldOffset,
433 {#if[Object]?handle.fieldType.cast(expected):expected},
434 {#if[Object]?checkCast(handle, value):value});
435 }
436
437 @ForceInline
438 static $type$ compareAndExchangeAcquire(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
439 return UNSAFE.compareAndExchange$Type$Acquire(handle.base,
440 handle.fieldOffset,
441 {#if[Object]?handle.fieldType.cast(expected):expected},
442 {#if[Object]?checkCast(handle, value):value});
443 }
444
445 @ForceInline
446 static $type$ compareAndExchangeRelease(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
447 return UNSAFE.compareAndExchange$Type$Release(handle.base,
448 handle.fieldOffset,
449 {#if[Object]?handle.fieldType.cast(expected):expected},
450 {#if[Object]?checkCast(handle, value):value});
451 }
452
453 @ForceInline
454 static boolean weakCompareAndSetPlain(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
455 return UNSAFE.weakCompareAndSet$Type$Plain(handle.base,
456 handle.fieldOffset,
457 {#if[Object]?handle.fieldType.cast(expected):expected},
458 {#if[Object]?checkCast(handle, value):value});
459 }
460
461 @ForceInline
462 static boolean weakCompareAndSet(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
463 return UNSAFE.weakCompareAndSet$Type$(handle.base,
464 handle.fieldOffset,
465 {#if[Object]?handle.fieldType.cast(expected):expected},
466 {#if[Object]?checkCast(handle, value):value});
467 }
468
469 @ForceInline
470 static boolean weakCompareAndSetAcquire(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
471 return UNSAFE.weakCompareAndSet$Type$Acquire(handle.base,
472 handle.fieldOffset,
473 {#if[Object]?handle.fieldType.cast(expected):expected},
474 {#if[Object]?checkCast(handle, value):value});
475 }
476
477 @ForceInline
478 static boolean weakCompareAndSetRelease(FieldStaticReadWrite handle, $type$ expected, $type$ value) {
479 return UNSAFE.weakCompareAndSet$Type$Release(handle.base,
480 handle.fieldOffset,
481 {#if[Object]?handle.fieldType.cast(expected):expected},
482 {#if[Object]?checkCast(handle, value):value});
483 }
484
485 @ForceInline
486 static $type$ getAndSet(FieldStaticReadWrite handle, $type$ value) {
487 return UNSAFE.getAndSet$Type$(handle.base,
488 handle.fieldOffset,
489 {#if[Object]?checkCast(handle, value):value});
490 }
491
492 @ForceInline
493 static $type$ getAndSetAcquire(FieldStaticReadWrite handle, $type$ value) {
494 return UNSAFE.getAndSet$Type$Acquire(handle.base,
495 handle.fieldOffset,
496 {#if[Object]?checkCast(handle, value):value});
497 }
498
499 @ForceInline
500 static $type$ getAndSetRelease(FieldStaticReadWrite handle, $type$ value) {
501 return UNSAFE.getAndSet$Type$Release(handle.base,
502 handle.fieldOffset,
503 {#if[Object]?checkCast(handle, value):value});
504 }
505 #end[CAS]
506 #if[AtomicAdd]
507
508 @ForceInline
509 static $type$ getAndAdd(FieldStaticReadWrite handle, $type$ value) {
510 return UNSAFE.getAndAdd$Type$(handle.base,
511 handle.fieldOffset,
512 value);
513 }
514
515 @ForceInline
516 static $type$ getAndAddAcquire(FieldStaticReadWrite handle, $type$ value) {
517 return UNSAFE.getAndAdd$Type$Acquire(handle.base,
518 handle.fieldOffset,
519 value);
520 }
521
522 @ForceInline
523 static $type$ getAndAddRelease(FieldStaticReadWrite handle, $type$ value) {
|