40 jbyte* cur_as_bytes = (jbyte*)(&cur);
41 jint new_val = cur;
42 jbyte* new_val_as_bytes = (jbyte*)(&new_val);
43 new_val_as_bytes[offset] = exchange_value;
44 while (cur_as_bytes[offset] == compare_value) {
45 jint res = cmpxchg(new_val, dest_int, cur);
46 if (res == cur) break;
47 cur = res;
48 new_val = cur;
49 new_val_as_bytes[offset] = exchange_value;
50 }
51 return cur_as_bytes[offset];
52 }
53
54 unsigned Atomic::xchg(unsigned int exchange_value, volatile unsigned int* dest) {
55 assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
56 return (unsigned int)Atomic::xchg((jint)exchange_value, (volatile jint*)dest);
57 }
58
59 unsigned Atomic::cmpxchg(unsigned int exchange_value,
60 volatile unsigned int* dest, unsigned int compare_value) {
61 assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
62 return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest,
63 (jint)compare_value);
64 }
65
66 jlong Atomic::add(jlong add_value, volatile jlong* dest) {
67 jlong old = load(dest);
68 jlong new_value = old + add_value;
69 while (old != cmpxchg(new_value, dest, old)) {
70 old = load(dest);
71 new_value = old + add_value;
72 }
73 return old;
74 }
75
76 void Atomic::inc(volatile short* dest) {
77 // Most platforms do not support atomic increment on a 2-byte value. However,
78 // if the value occupies the most significant 16 bits of an aligned 32-bit
79 // word, then we can do this with an atomic add of 0x10000 to the 32-bit word.
80 //
81 // The least significant parts of this 32-bit word will never be affected, even
82 // in case of overflow/underflow.
83 //
|
40 jbyte* cur_as_bytes = (jbyte*)(&cur);
41 jint new_val = cur;
42 jbyte* new_val_as_bytes = (jbyte*)(&new_val);
43 new_val_as_bytes[offset] = exchange_value;
44 while (cur_as_bytes[offset] == compare_value) {
45 jint res = cmpxchg(new_val, dest_int, cur);
46 if (res == cur) break;
47 cur = res;
48 new_val = cur;
49 new_val_as_bytes[offset] = exchange_value;
50 }
51 return cur_as_bytes[offset];
52 }
53
54 unsigned Atomic::xchg(unsigned int exchange_value, volatile unsigned int* dest) {
55 assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
56 return (unsigned int)Atomic::xchg((jint)exchange_value, (volatile jint*)dest);
57 }
58
59 unsigned Atomic::cmpxchg(unsigned int exchange_value,
60 volatile unsigned int* dest, unsigned int compare_value,
61 memory_order order) {
62 assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
63 return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest,
64 (jint)compare_value, order);
65 }
66
67 jlong Atomic::add(jlong add_value, volatile jlong* dest) {
68 jlong old = load(dest);
69 jlong new_value = old + add_value;
70 while (old != cmpxchg(new_value, dest, old)) {
71 old = load(dest);
72 new_value = old + add_value;
73 }
74 return old;
75 }
76
77 void Atomic::inc(volatile short* dest) {
78 // Most platforms do not support atomic increment on a 2-byte value. However,
79 // if the value occupies the most significant 16 bits of an aligned 32-bit
80 // word, then we can do this with an atomic add of 0x10000 to the 32-bit word.
81 //
82 // The least significant parts of this 32-bit word will never be affected, even
83 // in case of overflow/underflow.
84 //
|