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

Diff of /qemu/cpu-i386.h

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

revision 1.30 by bellard, Mon Jun 9 15:29:55 2003 UTC revision 1.31 by bellard, Sun Jun 15 20:02:25 2003 UTC
# Line 222  typedef struct CPUX86State { Line 222  typedef struct CPUX86State {
222      void *opaque;      void *opaque;
223  } CPUX86State;  } CPUX86State;
224    
 /* all CPU memory access use these macros */  
 static inline int ldub(void *ptr)  
 {  
     return *(uint8_t *)ptr;  
 }  
   
 static inline int ldsb(void *ptr)  
 {  
     return *(int8_t *)ptr;  
 }  
   
 static inline void stb(void *ptr, int v)  
 {  
     *(uint8_t *)ptr = v;  
 }  
   
 /* NOTE: on arm, putting 2 in /proc/sys/debug/alignment so that the  
    kernel handles unaligned load/stores may give better results, but  
    it is a system wide setting : bad */  
 #if defined(WORDS_BIGENDIAN) || defined(__arm__)  
   
 /* conservative code for little endian unaligned accesses */  
 static inline int lduw(void *ptr)  
 {  
 #ifdef __powerpc__  
     int val;  
     __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr));  
     return val;  
 #else  
     uint8_t *p = ptr;  
     return p[0] | (p[1] << 8);  
 #endif  
 }  
   
 static inline int ldsw(void *ptr)  
 {  
 #ifdef __powerpc__  
     int val;  
     __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr));  
     return (int16_t)val;  
 #else  
     uint8_t *p = ptr;  
     return (int16_t)(p[0] | (p[1] << 8));  
 #endif  
 }  
   
 static inline int ldl(void *ptr)  
 {  
 #ifdef __powerpc__  
     int val;  
     __asm__ __volatile__ ("lwbrx %0,0,%1" : "=r" (val) : "r" (ptr));  
     return val;  
 #else  
     uint8_t *p = ptr;  
     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);  
 #endif  
 }  
   
 static inline uint64_t ldq(void *ptr)  
 {  
     uint8_t *p = ptr;  
     uint32_t v1, v2;  
     v1 = ldl(p);  
     v2 = ldl(p + 4);  
     return v1 | ((uint64_t)v2 << 32);  
 }  
   
 static inline void stw(void *ptr, int v)  
 {  
 #ifdef __powerpc__  
     __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*(uint16_t *)ptr) : "r" (v), "r" (ptr));  
 #else  
     uint8_t *p = ptr;  
     p[0] = v;  
     p[1] = v >> 8;  
 #endif  
 }  
   
 static inline void stl(void *ptr, int v)  
 {  
 #ifdef __powerpc__  
     __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr));  
 #else  
     uint8_t *p = ptr;  
     p[0] = v;  
     p[1] = v >> 8;  
     p[2] = v >> 16;  
     p[3] = v >> 24;  
 #endif  
 }  
   
 static inline void stq(void *ptr, uint64_t v)  
 {  
     uint8_t *p = ptr;  
     stl(p, (uint32_t)v);  
     stl(p + 4, v >> 32);  
 }  
   
 /* float access */  
   
 static inline float ldfl(void *ptr)  
 {  
     union {  
         float f;  
         uint32_t i;  
     } u;  
     u.i = ldl(ptr);  
     return u.f;  
 }  
   
 static inline void stfl(void *ptr, float v)  
 {  
     union {  
         float f;  
         uint32_t i;  
     } u;  
     u.f = v;  
     stl(ptr, u.i);  
 }  
   
 #if defined(__arm__) && !defined(WORDS_BIGENDIAN)  
   
 /* NOTE: arm is horrible as double 32 bit words are stored in big endian ! */  
 static inline double ldfq(void *ptr)  
 {  
     union {  
         double d;  
         uint32_t tab[2];  
     } u;  
     u.tab[1] = ldl(ptr);  
     u.tab[0] = ldl(ptr + 4);  
     return u.d;  
 }  
   
 static inline void stfq(void *ptr, double v)  
 {  
     union {  
         double d;  
         uint32_t tab[2];  
     } u;  
     u.d = v;  
     stl(ptr, u.tab[1]);  
     stl(ptr + 4, u.tab[0]);  
 }  
   
 #else  
 static inline double ldfq(void *ptr)  
 {  
     union {  
         double d;  
         uint64_t i;  
     } u;  
     u.i = ldq(ptr);  
     return u.d;  
 }  
   
 static inline void stfq(void *ptr, double v)  
 {  
     union {  
         double d;  
         uint64_t i;  
     } u;  
     u.d = v;  
     stq(ptr, u.i);  
 }  
 #endif  
   
 #else  
   
 static inline int lduw(void *ptr)  
 {  
     return *(uint16_t *)ptr;  
 }  
   
 static inline int ldsw(void *ptr)  
 {  
     return *(int16_t *)ptr;  
 }  
   
 static inline int ldl(void *ptr)  
 {  
     return *(uint32_t *)ptr;  
 }  
   
 static inline uint64_t ldq(void *ptr)  
 {  
     return *(uint64_t *)ptr;  
 }  
   
 static inline void stw(void *ptr, int v)  
 {  
     *(uint16_t *)ptr = v;  
 }  
   
 static inline void stl(void *ptr, int v)  
 {  
     *(uint32_t *)ptr = v;  
 }  
   
 static inline void stq(void *ptr, uint64_t v)  
 {  
     *(uint64_t *)ptr = v;  
 }  
   
 /* float access */  
   
 static inline float ldfl(void *ptr)  
 {  
     return *(float *)ptr;  
 }  
   
 static inline double ldfq(void *ptr)  
 {  
     return *(double *)ptr;  
 }  
   
 static inline void stfl(void *ptr, float v)  
 {  
     *(float *)ptr = v;  
 }  
   
 static inline void stfq(void *ptr, double v)  
 {  
     *(double *)ptr = v;  
 }  
 #endif  
   
225  #ifndef IN_OP_I386  #ifndef IN_OP_I386
226  void cpu_x86_outb(CPUX86State *env, int addr, int val);  void cpu_x86_outb(CPUX86State *env, int addr, int val);
227  void cpu_x86_outw(CPUX86State *env, int addr, int val);  void cpu_x86_outw(CPUX86State *env, int addr, int val);
# Line 482  int cpu_x86_signal_handler(int host_sign Line 255  int cpu_x86_signal_handler(int host_sign
255  #define X86_DUMP_CCOP 0x0002 /* dump qemu flag cache */  #define X86_DUMP_CCOP 0x0002 /* dump qemu flag cache */
256  void cpu_x86_dump_state(CPUX86State *env, FILE *f, int flags);  void cpu_x86_dump_state(CPUX86State *env, FILE *f, int flags);
257    
 /* page related stuff */  
258  #define TARGET_PAGE_BITS 12  #define TARGET_PAGE_BITS 12
259  #define TARGET_PAGE_SIZE (1 << TARGET_PAGE_BITS)  #include "cpu-all.h"
 #define TARGET_PAGE_MASK ~(TARGET_PAGE_SIZE - 1)  
 #define TARGET_PAGE_ALIGN(addr) (((addr) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK)  
   
 extern unsigned long real_host_page_size;  
 extern unsigned long host_page_bits;  
 extern unsigned long host_page_size;  
 extern unsigned long host_page_mask;  
   
 #define HOST_PAGE_ALIGN(addr) (((addr) + host_page_size - 1) & host_page_mask)  
   
 /* same as PROT_xxx */  
 #define PAGE_READ      0x0001  
 #define PAGE_WRITE     0x0002  
 #define PAGE_EXEC      0x0004  
 #define PAGE_BITS      (PAGE_READ | PAGE_WRITE | PAGE_EXEC)  
 #define PAGE_VALID     0x0008  
 /* original state of the write flag (used when tracking self-modifying  
    code */  
 #define PAGE_WRITE_ORG 0x0010  
   
 void page_dump(FILE *f);  
 int page_get_flags(unsigned long address);  
 void page_set_flags(unsigned long start, unsigned long end, int flags);  
 void page_unprotect_range(uint8_t *data, unsigned long data_size);  
260    
261  #endif /* CPU_I386_H */  #endif /* CPU_I386_H */

Legend:
Removed from v.1.30  
changed lines
  Added in v.1.31

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