Statistics
| Branch: | Revision:

root / target-alpha / op_mem.h @ b03d0971

History | View | Annotate | Download (4.2 kB)

1
/*
2
 *  Alpha emulation cpu micro-operations for memory accesses for qemu.
3
 *
4
 *  Copyright (c) 2007 Jocelyn Mayer
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
20

    
21
//#define DEBUG_MEM_ACCESSES
22
#if defined (DEBUG_MEM_ACCESSES)
23
void helper_print_mem_EA (target_ulong EA);
24
#define print_mem_EA(EA) do { helper_print_mem_EA(EA); } while (0)
25
#else
26
#define print_mem_EA(EA) do { } while (0)
27
#endif
28

    
29
static always_inline uint32_t glue(ldl_l, MEMSUFFIX) (target_ulong EA)
30
{
31
    env->lock = EA;
32

    
33
    return glue(ldl, MEMSUFFIX)(EA);
34
}
35

    
36
static always_inline uint32_t glue(ldq_l, MEMSUFFIX) (target_ulong EA)
37
{
38
    env->lock = EA;
39

    
40
    return glue(ldq, MEMSUFFIX)(EA);
41
}
42

    
43
static always_inline void glue(stl_c, MEMSUFFIX) (target_ulong EA,
44
                                                  uint32_t data)
45
{
46
    if (EA == env->lock) {
47
        glue(stl, MEMSUFFIX)(EA, data);
48
        T0 = 0;
49
    } else {
50
        T0 = 1;
51
    }
52
    env->lock = -1;
53
}
54

    
55
static always_inline void glue(stq_c, MEMSUFFIX) (target_ulong EA,
56
                                                  uint64_t data)
57
{
58
    if (EA == env->lock) {
59
        glue(stq, MEMSUFFIX)(EA, data);
60
        T0 = 0;
61
    } else {
62
        T0 = 1;
63
    }
64
    env->lock = -1;
65
}
66

    
67
#define ALPHA_LD_OP(name, op)                                                 \
68
void OPPROTO glue(glue(op_ld, name), MEMSUFFIX) (void)                        \
69
{                                                                             \
70
    print_mem_EA(T0);                                                         \
71
    T1 = glue(op, MEMSUFFIX)(T0);                                             \
72
    RETURN();                                                                 \
73
}
74

    
75
#define ALPHA_ST_OP(name, op)                                                 \
76
void OPPROTO glue(glue(op_st, name), MEMSUFFIX) (void)                        \
77
{                                                                             \
78
    print_mem_EA(T0);                                                         \
79
    glue(op, MEMSUFFIX)(T0, T1);                                              \
80
    RETURN();                                                                 \
81
}
82

    
83
ALPHA_LD_OP(l, ldl);
84
ALPHA_ST_OP(l, stl);
85
ALPHA_LD_OP(q, ldq);
86
ALPHA_ST_OP(q, stq);
87

    
88
ALPHA_LD_OP(l_l, ldl_l);
89
ALPHA_LD_OP(q_l, ldq_l);
90
ALPHA_ST_OP(l_c, stl_c);
91
ALPHA_ST_OP(q_c, stq_c);
92

    
93
#define ALPHA_LDF_OP(name, op)                                                \
94
void OPPROTO glue(glue(op_ld, name), MEMSUFFIX) (void)                        \
95
{                                                                             \
96
    print_mem_EA(T0);                                                         \
97
    FT1 = glue(op, MEMSUFFIX)(T0);                                            \
98
    RETURN();                                                                 \
99
}
100

    
101
#define ALPHA_STF_OP(name, op)                                                \
102
void OPPROTO glue(glue(op_st, name), MEMSUFFIX) (void)                        \
103
{                                                                             \
104
    print_mem_EA(T0);                                                         \
105
    glue(op, MEMSUFFIX)(T0, FT1);                                             \
106
    RETURN();                                                                 \
107
}
108

    
109
ALPHA_LDF_OP(t, ldfq);
110
ALPHA_STF_OP(t, stfq);
111
ALPHA_LDF_OP(s, ldfl);
112
ALPHA_STF_OP(s, stfl);
113

    
114
/* VAX floating point */
115
ALPHA_LDF_OP(f, helper_ldff);
116
ALPHA_STF_OP(f, helper_stff);
117
ALPHA_LDF_OP(g, helper_ldfg);
118
ALPHA_STF_OP(g, helper_stfg);
119

    
120
#undef MEMSUFFIX