orderAccess_windows_x86.inline.hpp revision 844:bd02caa94611 
1/*
2 * Copyright 2003-2009 Sun Microsystems, Inc.  All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25#pragma warning(disable: 4035) // Disables warnings reporting missing return statement
26
27// Implementation of class OrderAccess.
28
29inline void OrderAccess::loadload()   { acquire(); }
30inline void OrderAccess::storestore() { release(); }
31inline void OrderAccess::loadstore()  { acquire(); }
32inline void OrderAccess::storeload()  { fence(); }
33
34inline void OrderAccess::acquire() {
35#ifndef AMD64
36  __asm {
37    mov eax, dword ptr [esp];
38  }
39#endif // !AMD64
40}
41
42inline void OrderAccess::release() {
43  // A volatile store has release semantics.
44  dummy = 0;
45}
46
47inline void OrderAccess::fence() {
48#ifdef AMD64
49  StubRoutines_fence();
50#else
51  if (os::is_MP()) {
52    __asm {
53      lock add dword ptr [esp], 0;
54    }
55  }
56#endif // AMD64
57}
58
59inline jbyte    OrderAccess::load_acquire(volatile jbyte*   p) { return *p; }
60inline jshort   OrderAccess::load_acquire(volatile jshort*  p) { return *p; }
61inline jint     OrderAccess::load_acquire(volatile jint*    p) { return *p; }
62inline jlong    OrderAccess::load_acquire(volatile jlong*   p) { return *p; }
63inline jubyte   OrderAccess::load_acquire(volatile jubyte*  p) { return *p; }
64inline jushort  OrderAccess::load_acquire(volatile jushort* p) { return *p; }
65inline juint    OrderAccess::load_acquire(volatile juint*   p) { return *p; }
66inline julong   OrderAccess::load_acquire(volatile julong*  p) { return *p; }
67inline jfloat   OrderAccess::load_acquire(volatile jfloat*  p) { return *p; }
68inline jdouble  OrderAccess::load_acquire(volatile jdouble* p) { return *p; }
69
70inline intptr_t OrderAccess::load_ptr_acquire(volatile intptr_t*   p) { return *p; }
71inline void*    OrderAccess::load_ptr_acquire(volatile void*       p) { return *(void* volatile *)p; }
72inline void*    OrderAccess::load_ptr_acquire(const volatile void* p) { return *(void* const volatile *)p; }
73
74inline void     OrderAccess::release_store(volatile jbyte*   p, jbyte   v) { *p = v; }
75inline void     OrderAccess::release_store(volatile jshort*  p, jshort  v) { *p = v; }
76inline void     OrderAccess::release_store(volatile jint*    p, jint    v) { *p = v; }
77inline void     OrderAccess::release_store(volatile jlong*   p, jlong   v) { *p = v; }
78inline void     OrderAccess::release_store(volatile jubyte*  p, jubyte  v) { *p = v; }
79inline void     OrderAccess::release_store(volatile jushort* p, jushort v) { *p = v; }
80inline void     OrderAccess::release_store(volatile juint*   p, juint   v) { *p = v; }
81inline void     OrderAccess::release_store(volatile julong*  p, julong  v) { *p = v; }
82inline void     OrderAccess::release_store(volatile jfloat*  p, jfloat  v) { *p = v; }
83inline void     OrderAccess::release_store(volatile jdouble* p, jdouble v) { *p = v; }
84
85inline void     OrderAccess::release_store_ptr(volatile intptr_t* p, intptr_t v) { *p = v; }
86inline void     OrderAccess::release_store_ptr(volatile void*     p, void*    v) { *(void* volatile *)p = v; }
87
88inline void     OrderAccess::store_fence(jbyte*  p, jbyte  v) {
89#ifdef AMD64
90  *p = v; fence();
91#else
92  __asm {
93    mov edx, p;
94    mov al, v;
95    xchg al, byte ptr [edx];
96  }
97#endif // AMD64
98}
99
100inline void     OrderAccess::store_fence(jshort* p, jshort v) {
101#ifdef AMD64
102  *p = v; fence();
103#else
104  __asm {
105    mov edx, p;
106    mov ax, v;
107    xchg ax, word ptr [edx];
108  }
109#endif // AMD64
110}
111
112inline void     OrderAccess::store_fence(jint*   p, jint   v) {
113#ifdef AMD64
114  *p = v; fence();
115#else
116  __asm {
117    mov edx, p;
118    mov eax, v;
119    xchg eax, dword ptr [edx];
120  }
121#endif // AMD64
122}
123
124inline void     OrderAccess::store_fence(jlong*   p, jlong   v) { *p = v; fence(); }
125inline void     OrderAccess::store_fence(jubyte*  p, jubyte  v) { store_fence((jbyte*)p,  (jbyte)v);  }
126inline void     OrderAccess::store_fence(jushort* p, jushort v) { store_fence((jshort*)p, (jshort)v); }
127inline void     OrderAccess::store_fence(juint*   p, juint   v) { store_fence((jint*)p,   (jint)v);   }
128inline void     OrderAccess::store_fence(julong*  p, julong  v) { store_fence((jlong*)p,  (jlong)v);  }
129inline void     OrderAccess::store_fence(jfloat*  p, jfloat  v) { *p = v; fence(); }
130inline void     OrderAccess::store_fence(jdouble* p, jdouble v) { *p = v; fence(); }
131
132inline void     OrderAccess::store_ptr_fence(intptr_t* p, intptr_t v) {
133#ifdef AMD64
134  *p = v; fence();
135#else
136  store_fence((jint*)p, (jint)v);
137#endif // AMD64
138}
139
140inline void     OrderAccess::store_ptr_fence(void**    p, void*    v) {
141#ifdef AMD64
142  *p = v; fence();
143#else
144  store_fence((jint*)p, (jint)v);
145#endif // AMD64
146}
147
148// Must duplicate definitions instead of calling store_fence because we don't want to cast away volatile.
149inline void     OrderAccess::release_store_fence(volatile jbyte*  p, jbyte  v) {
150#ifdef AMD64
151  *p = v; fence();
152#else
153  __asm {
154    mov edx, p;
155    mov al, v;
156    xchg al, byte ptr [edx];
157  }
158#endif // AMD64
159}
160
161inline void     OrderAccess::release_store_fence(volatile jshort* p, jshort v) {
162#ifdef AMD64
163  *p = v; fence();
164#else
165  __asm {
166    mov edx, p;
167    mov ax, v;
168    xchg ax, word ptr [edx];
169  }
170#endif // AMD64
171}
172
173inline void     OrderAccess::release_store_fence(volatile jint*   p, jint   v) {
174#ifdef AMD64
175  *p = v; fence();
176#else
177  __asm {
178    mov edx, p;
179    mov eax, v;
180    xchg eax, dword ptr [edx];
181  }
182#endif // AMD64
183}
184
185inline void     OrderAccess::release_store_fence(volatile jlong*   p, jlong   v) { *p = v; fence(); }
186
187inline void     OrderAccess::release_store_fence(volatile jubyte*  p, jubyte  v) { release_store_fence((volatile jbyte*)p,  (jbyte)v);  }
188inline void     OrderAccess::release_store_fence(volatile jushort* p, jushort v) { release_store_fence((volatile jshort*)p, (jshort)v); }
189inline void     OrderAccess::release_store_fence(volatile juint*   p, juint   v) { release_store_fence((volatile jint*)p,   (jint)v);   }
190inline void     OrderAccess::release_store_fence(volatile julong*  p, julong  v) { release_store_fence((volatile jlong*)p,  (jlong)v);  }
191inline void     OrderAccess::release_store_fence(volatile jfloat*  p, jfloat  v) { *p = v; fence(); }
192inline void     OrderAccess::release_store_fence(volatile jdouble* p, jdouble v) { *p = v; fence(); }
193
194inline void     OrderAccess::release_store_ptr_fence(volatile intptr_t* p, intptr_t v) {
195#ifdef AMD64
196  *p = v; fence();
197#else
198  release_store_fence((volatile jint*)p, (jint)v);
199#endif // AMD64
200}
201
202inline void     OrderAccess::release_store_ptr_fence(volatile void*     p, void*    v) {
203#ifdef AMD64
204  *(void* volatile *)p = v; fence();
205#else
206  release_store_fence((volatile jint*)p, (jint)v);
207#endif // AMD64
208}
209
210#pragma warning(default: 4035) // Enables warnings reporting missing return statement
211