/[qemu]/qemu/cpu-all.h
ViewVC logotype

Diff of /qemu/cpu-all.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.11 by bellard, Sun Oct 5 14:28:56 2003 UTC revision 1.12 by bellard, Mon Oct 27 21:22:22 2003 UTC
# Line 20  Line 20 
20  #ifndef CPU_ALL_H  #ifndef CPU_ALL_H
21  #define CPU_ALL_H  #define CPU_ALL_H
22    
23  /* all CPU memory access use these macros */  /* CPU memory access without any memory or io remapping */
24  static inline int ldub(void *ptr)  
25    static inline int ldub_raw(void *ptr)
26  {  {
27      return *(uint8_t *)ptr;      return *(uint8_t *)ptr;
28  }  }
29    
30  static inline int ldsb(void *ptr)  static inline int ldsb_raw(void *ptr)
31  {  {
32      return *(int8_t *)ptr;      return *(int8_t *)ptr;
33  }  }
34    
35  static inline void stb(void *ptr, int v)  static inline void stb_raw(void *ptr, int v)
36  {  {
37      *(uint8_t *)ptr = v;      *(uint8_t *)ptr = v;
38  }  }
# Line 42  static inline void stb(void *ptr, int v) Line 43  static inline void stb(void *ptr, int v)
43  #if defined(WORDS_BIGENDIAN) || defined(__arm__)  #if defined(WORDS_BIGENDIAN) || defined(__arm__)
44    
45  /* conservative code for little endian unaligned accesses */  /* conservative code for little endian unaligned accesses */
46  static inline int lduw(void *ptr)  static inline int lduw_raw(void *ptr)
47  {  {
48  #ifdef __powerpc__  #ifdef __powerpc__
49      int val;      int val;
# Line 54  static inline int lduw(void *ptr) Line 55  static inline int lduw(void *ptr)
55  #endif  #endif
56  }  }
57    
58  static inline int ldsw(void *ptr)  static inline int ldsw_raw(void *ptr)
59  {  {
60  #ifdef __powerpc__  #ifdef __powerpc__
61      int val;      int val;
# Line 66  static inline int ldsw(void *ptr) Line 67  static inline int ldsw(void *ptr)
67  #endif  #endif
68  }  }
69    
70  static inline int ldl(void *ptr)  static inline int ldl_raw(void *ptr)
71  {  {
72  #ifdef __powerpc__  #ifdef __powerpc__
73      int val;      int val;
# Line 78  static inline int ldl(void *ptr) Line 79  static inline int ldl(void *ptr)
79  #endif  #endif
80  }  }
81    
82  static inline uint64_t ldq(void *ptr)  static inline uint64_t ldq_raw(void *ptr)
83  {  {
84      uint8_t *p = ptr;      uint8_t *p = ptr;
85      uint32_t v1, v2;      uint32_t v1, v2;
86      v1 = ldl(p);      v1 = ldl_raw(p);
87      v2 = ldl(p + 4);      v2 = ldl_raw(p + 4);
88      return v1 | ((uint64_t)v2 << 32);      return v1 | ((uint64_t)v2 << 32);
89  }  }
90    
91  static inline void stw(void *ptr, int v)  static inline void stw_raw(void *ptr, int v)
92  {  {
93  #ifdef __powerpc__  #ifdef __powerpc__
94      __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*(uint16_t *)ptr) : "r" (v), "r" (ptr));      __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*(uint16_t *)ptr) : "r" (v), "r" (ptr));
# Line 98  static inline void stw(void *ptr, int v) Line 99  static inline void stw(void *ptr, int v)
99  #endif  #endif
100  }  }
101    
102  static inline void stl(void *ptr, int v)  static inline void stl_raw(void *ptr, int v)
103  {  {
104  #ifdef __powerpc__  #ifdef __powerpc__
105      __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr));      __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr));
# Line 111  static inline void stl(void *ptr, int v) Line 112  static inline void stl(void *ptr, int v)
112  #endif  #endif
113  }  }
114    
115  static inline void stq(void *ptr, uint64_t v)  static inline void stq_raw(void *ptr, uint64_t v)
116  {  {
117      uint8_t *p = ptr;      uint8_t *p = ptr;
118      stl(p, (uint32_t)v);      stl_raw(p, (uint32_t)v);
119      stl(p + 4, v >> 32);      stl_raw(p + 4, v >> 32);
120  }  }
121    
122  /* float access */  /* float access */
123    
124  static inline float ldfl(void *ptr)  static inline float ldfl_raw(void *ptr)
125  {  {
126      union {      union {
127          float f;          float f;
128          uint32_t i;          uint32_t i;
129      } u;      } u;
130      u.i = ldl(ptr);      u.i = ldl_raw(ptr);
131      return u.f;      return u.f;
132  }  }
133    
134  static inline void stfl(void *ptr, float v)  static inline void stfl_raw(void *ptr, float v)
135  {  {
136      union {      union {
137          float f;          float f;
138          uint32_t i;          uint32_t i;
139      } u;      } u;
140      u.f = v;      u.f = v;
141      stl(ptr, u.i);      stl_raw(ptr, u.i);
142  }  }
143    
144    
145  #if defined(__arm__) && !defined(WORDS_BIGENDIAN)  #if defined(__arm__) && !defined(WORDS_BIGENDIAN)
146    
147  /* NOTE: arm is horrible as double 32 bit words are stored in big endian ! */  /* NOTE: arm is horrible as double 32 bit words are stored in big endian ! */
148  static inline double ldfq(void *ptr)  static inline double ldfq_raw(void *ptr)
149  {  {
150      union {      union {
151          double d;          double d;
152          uint32_t tab[2];          uint32_t tab[2];
153      } u;      } u;
154      u.tab[1] = ldl(ptr);      u.tab[1] = ldl_raw(ptr);
155      u.tab[0] = ldl(ptr + 4);      u.tab[0] = ldl_raw(ptr + 4);
156      return u.d;      return u.d;
157  }  }
158    
159  static inline void stfq(void *ptr, double v)  static inline void stfq_raw(void *ptr, double v)
160  {  {
161      union {      union {
162          double d;          double d;
163          uint32_t tab[2];          uint32_t tab[2];
164      } u;      } u;
165      u.d = v;      u.d = v;
166      stl(ptr, u.tab[1]);      stl_raw(ptr, u.tab[1]);
167      stl(ptr + 4, u.tab[0]);      stl_raw(ptr + 4, u.tab[0]);
168  }  }
169    
170  #else  #else
171  static inline double ldfq(void *ptr)  static inline double ldfq_raw(void *ptr)
172  {  {
173      union {      union {
174          double d;          double d;
175          uint64_t i;          uint64_t i;
176      } u;      } u;
177      u.i = ldq(ptr);      u.i = ldq_raw(ptr);
178      return u.d;      return u.d;
179  }  }
180    
181  static inline void stfq(void *ptr, double v)  static inline void stfq_raw(void *ptr, double v)
182  {  {
183      union {      union {
184          double d;          double d;
185          uint64_t i;          uint64_t i;
186      } u;      } u;
187      u.d = v;      u.d = v;
188      stq(ptr, u.i);      stq_raw(ptr, u.i);
189  }  }
190  #endif  #endif
191    
192  #elif defined(TARGET_WORDS_BIGENDIAN) && !defined(WORDS_BIGENDIAN)  #elif defined(TARGET_WORDS_BIGENDIAN) && !defined(WORDS_BIGENDIAN)
193    
194  static inline int lduw(void *ptr)  static inline int lduw_raw(void *ptr)
195  {  {
196      uint8_t *b = (uint8_t *) ptr;      uint8_t *b = (uint8_t *) ptr;
197      return (b[0]<<8|b[1]);      return (b[0]<<8|b[1]);
198  }  }
199    
200  static inline int ldsw(void *ptr)  static inline int ldsw_raw(void *ptr)
201  {  {
202      int8_t *b = (int8_t *) ptr;      int8_t *b = (int8_t *) ptr;
203      return (b[0]<<8|b[1]);      return (b[0]<<8|b[1]);
204  }  }
205    
206  static inline int ldl(void *ptr)  static inline int ldl_raw(void *ptr)
207  {  {
208      uint8_t *b = (uint8_t *) ptr;      uint8_t *b = (uint8_t *) ptr;
209      return (b[0]<<24|b[1]<<16|b[2]<<8|b[3]);      return (b[0]<<24|b[1]<<16|b[2]<<8|b[3]);
210  }  }
211    
212  static inline uint64_t ldq(void *ptr)  static inline uint64_t ldq_raw(void *ptr)
213  {  {
214      uint32_t a,b;      uint32_t a,b;
215      a = ldl (ptr);      a = ldl (ptr);
# Line 216  static inline uint64_t ldq(void *ptr) Line 217  static inline uint64_t ldq(void *ptr)
217      return (((uint64_t)a<<32)|b);      return (((uint64_t)a<<32)|b);
218  }  }
219    
220  static inline void stw(void *ptr, int v)  static inline void stw_raw(void *ptr, int v)
221  {  {
222      uint8_t *d = (uint8_t *) ptr;      uint8_t *d = (uint8_t *) ptr;
223      d[0] = v >> 8;      d[0] = v >> 8;
224      d[1] = v;      d[1] = v;
225  }  }
226    
227  static inline void stl(void *ptr, int v)  static inline void stl_raw(void *ptr, int v)
228  {  {
229      uint8_t *d = (uint8_t *) ptr;      uint8_t *d = (uint8_t *) ptr;
230      d[0] = v >> 24;      d[0] = v >> 24;
# Line 232  static inline void stl(void *ptr, int v) Line 233  static inline void stl(void *ptr, int v)
233      d[3] = v;      d[3] = v;
234  }  }
235    
236  static inline void stq(void *ptr, uint64_t v)  static inline void stq_raw(void *ptr, uint64_t v)
237  {  {
238      stl (ptr, v);      stl (ptr, v);
239      stl (ptr+4, v >> 32);      stl (ptr+4, v >> 32);
# Line 240  static inline void stq(void *ptr, uint64 Line 241  static inline void stq(void *ptr, uint64
241    
242  #else  #else
243    
244  static inline int lduw(void *ptr)  static inline int lduw_raw(void *ptr)
245  {  {
246      return *(uint16_t *)ptr;      return *(uint16_t *)ptr;
247  }  }
248    
249  static inline int ldsw(void *ptr)  static inline int ldsw_raw(void *ptr)
250  {  {
251      return *(int16_t *)ptr;      return *(int16_t *)ptr;
252  }  }
253    
254  static inline int ldl(void *ptr)  static inline int ldl_raw(void *ptr)
255  {  {
256      return *(uint32_t *)ptr;      return *(uint32_t *)ptr;
257  }  }
258    
259  static inline uint64_t ldq(void *ptr)  static inline uint64_t ldq_raw(void *ptr)
260  {  {
261      return *(uint64_t *)ptr;      return *(uint64_t *)ptr;
262  }  }
263    
264  static inline void stw(void *ptr, int v)  static inline void stw_raw(void *ptr, int v)
265  {  {
266      *(uint16_t *)ptr = v;      *(uint16_t *)ptr = v;
267  }  }
268    
269  static inline void stl(void *ptr, int v)  static inline void stl_raw(void *ptr, int v)
270  {  {
271      *(uint32_t *)ptr = v;      *(uint32_t *)ptr = v;
272  }  }
273    
274  static inline void stq(void *ptr, uint64_t v)  static inline void stq_raw(void *ptr, uint64_t v)
275  {  {
276      *(uint64_t *)ptr = v;      *(uint64_t *)ptr = v;
277  }  }
278    
279  /* float access */  /* float access */
280    
281  static inline float ldfl(void *ptr)  static inline float ldfl_raw(void *ptr)
282  {  {
283      return *(float *)ptr;      return *(float *)ptr;
284  }  }
285    
286  static inline double ldfq(void *ptr)  static inline double ldfq_raw(void *ptr)
287  {  {
288      return *(double *)ptr;      return *(double *)ptr;
289  }  }
290    
291  static inline void stfl(void *ptr, float v)  static inline void stfl_raw(void *ptr, float v)
292  {  {
293      *(float *)ptr = v;      *(float *)ptr = v;
294  }  }
295    
296  static inline void stfq(void *ptr, double v)  static inline void stfq_raw(void *ptr, double v)
297  {  {
298      *(double *)ptr = v;      *(double *)ptr = v;
299  }  }
300  #endif  #endif
301    
302    /* MMU memory access macros */
303    
304    #if defined(CONFIG_USER_ONLY)
305    
306    /* if user mode, no other memory access functions */
307    #define ldub(p) ldub_raw(p)
308    #define ldsb(p) ldsb_raw(p)
309    #define lduw(p) lduw_raw(p)
310    #define ldsw(p) ldsw_raw(p)
311    #define ldl(p) ldl_raw(p)
312    #define ldq(p) ldq_raw(p)
313    #define ldfl(p) ldfl_raw(p)
314    #define ldfq(p) ldfq_raw(p)
315    #define stb(p, v) stb_raw(p, v)
316    #define stw(p, v) stw_raw(p, v)
317    #define stl(p, v) stl_raw(p, v)
318    #define stq(p, v) stq_raw(p, v)
319    #define stfl(p, v) stfl_raw(p, v)
320    #define stfq(p, v) stfq_raw(p, v)
321    
322    #define ldub_code(p) ldub_raw(p)
323    #define ldsb_code(p) ldsb_raw(p)
324    #define lduw_code(p) lduw_raw(p)
325    #define ldsw_code(p) ldsw_raw(p)
326    #define ldl_code(p) ldl_raw(p)
327    
328    #define ldub_kernel(p) ldub_raw(p)
329    #define ldsb_kernel(p) ldsb_raw(p)
330    #define lduw_kernel(p) lduw_raw(p)
331    #define ldsw_kernel(p) ldsw_raw(p)
332    #define ldl_kernel(p) ldl_raw(p)
333    #define stb_kernel(p, v) stb_raw(p, v)
334    #define stw_kernel(p, v) stw_raw(p, v)
335    #define stl_kernel(p, v) stl_raw(p, v)
336    #define stq_kernel(p, v) stq_raw(p, v)
337    
338    #endif /* defined(CONFIG_USER_ONLY) */
339    
340  /* page related stuff */  /* page related stuff */
341    
342  #define TARGET_PAGE_SIZE (1 << TARGET_PAGE_BITS)  #define TARGET_PAGE_SIZE (1 << TARGET_PAGE_BITS)

Legend:
Removed from v.1.11  
changed lines
  Added in v.1.12

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26