Annotation of qemu/softmmu-semi.h, revision 1.1.1.4

1.1       root        1: /*
                      2:  * Helper routines to provide target memory access for semihosting
                      3:  * syscalls in system emulation mode.
                      4:  *
                      5:  * Copyright (c) 2007 CodeSourcery.
                      6:  *
1.1.1.3   root        7:  * This code is licensed under the GPL
1.1       root        8:  */
                      9: 
1.1.1.4 ! root       10: static inline uint32_t softmmu_tget32(CPUArchState *env, uint32_t addr)
1.1       root       11: {
                     12:     uint32_t val;
                     13: 
                     14:     cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 0);
                     15:     return tswap32(val);
                     16: }
1.1.1.4 ! root       17: static inline uint32_t softmmu_tget8(CPUArchState *env, uint32_t addr)
1.1       root       18: {
                     19:     uint8_t val;
                     20: 
                     21:     cpu_memory_rw_debug(env, addr, &val, 1, 0);
                     22:     return val;
                     23: }
                     24: 
                     25: #define get_user_u32(arg, p) ({ arg = softmmu_tget32(env, p) ; 0; })
                     26: #define get_user_u8(arg, p) ({ arg = softmmu_tget8(env, p) ; 0; })
                     27: #define get_user_ual(arg, p) get_user_u32(arg, p)
                     28: 
1.1.1.4 ! root       29: static inline void softmmu_tput32(CPUArchState *env, uint32_t addr, uint32_t val)
1.1       root       30: {
                     31:     val = tswap32(val);
                     32:     cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 1);
                     33: }
                     34: #define put_user_u32(arg, p) ({ softmmu_tput32(env, p, arg) ; 0; })
                     35: #define put_user_ual(arg, p) put_user_u32(arg, p)
                     36: 
1.1.1.4 ! root       37: static void *softmmu_lock_user(CPUArchState *env, uint32_t addr, uint32_t len,
1.1       root       38:                                int copy)
                     39: {
1.1.1.2   root       40:     uint8_t *p;
1.1       root       41:     /* TODO: Make this something that isn't fixed size.  */
                     42:     p = malloc(len);
                     43:     if (copy)
                     44:         cpu_memory_rw_debug(env, addr, p, len, 0);
                     45:     return p;
                     46: }
                     47: #define lock_user(type, p, len, copy) softmmu_lock_user(env, p, len, copy)
1.1.1.4 ! root       48: static char *softmmu_lock_user_string(CPUArchState *env, uint32_t addr)
1.1       root       49: {
                     50:     char *p;
                     51:     char *s;
                     52:     uint8_t c;
                     53:     /* TODO: Make this something that isn't fixed size.  */
                     54:     s = p = malloc(1024);
                     55:     do {
                     56:         cpu_memory_rw_debug(env, addr, &c, 1, 0);
                     57:         addr++;
                     58:         *(p++) = c;
                     59:     } while (c);
                     60:     return s;
                     61: }
                     62: #define lock_user_string(p) softmmu_lock_user_string(env, p)
1.1.1.4 ! root       63: static void softmmu_unlock_user(CPUArchState *env, void *p, target_ulong addr,
1.1       root       64:                                 target_ulong len)
                     65: {
                     66:     if (len)
                     67:         cpu_memory_rw_debug(env, addr, p, len, 1);
                     68:     free(p);
                     69: }
                     70: #define unlock_user(s, args, len) softmmu_unlock_user(env, s, args, len)

unix.superglobalmegacorp.com