← Back to branch summary

~ubuntu-bugs-auftrags-killer/qemu/proper-error-characters

« back to all changes in this revision

Viewing changes to target-i386/opreg_template.h

  • Committer: bellard
  • Date: 2008-02-01 10:50:11 UTC
  • Revision ID: git-v1:57fec1fee94aa9f7d2519e8c354f100fc36bc9fa
use the TCG code generator


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3944 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-i386/opreg_template.h
18
18
 * License along with this library; if not, write to the Free Software
19
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
20
 */
21
 
void OPPROTO glue(op_movl_A0,REGNAME)(void)
22
 
{
23
 
    A0 = (uint32_t)REG;
24
 
}
25
 
 
26
 
void OPPROTO glue(op_addl_A0,REGNAME)(void)
27
 
{
28
 
    A0 = (uint32_t)(A0 + REG);
29
 
}
30
 
 
31
 
void OPPROTO glue(glue(op_addl_A0,REGNAME),_s1)(void)
32
 
{
33
 
    A0 = (uint32_t)(A0 + (REG << 1));
34
 
}
35
 
 
36
 
void OPPROTO glue(glue(op_addl_A0,REGNAME),_s2)(void)
37
 
{
38
 
    A0 = (uint32_t)(A0 + (REG << 2));
39
 
}
40
 
 
41
 
void OPPROTO glue(glue(op_addl_A0,REGNAME),_s3)(void)
42
 
{
43
 
    A0 = (uint32_t)(A0 + (REG << 3));
44
 
}
45
 
 
46
 
#ifdef TARGET_X86_64
47
 
void OPPROTO glue(op_movq_A0,REGNAME)(void)
48
 
{
49
 
    A0 = REG;
50
 
}
51
 
 
52
 
void OPPROTO glue(op_addq_A0,REGNAME)(void)
53
 
{
54
 
    A0 = (A0 + REG);
55
 
}
56
 
 
57
 
void OPPROTO glue(glue(op_addq_A0,REGNAME),_s1)(void)
58
 
{
59
 
    A0 = (A0 + (REG << 1));
60
 
}
61
 
 
62
 
void OPPROTO glue(glue(op_addq_A0,REGNAME),_s2)(void)
63
 
{
64
 
    A0 = (A0 + (REG << 2));
65
 
}
66
 
 
67
 
void OPPROTO glue(glue(op_addq_A0,REGNAME),_s3)(void)
68
 
{
69
 
    A0 = (A0 + (REG << 3));
70
 
}
71
 
#endif
72
 
 
73
 
void OPPROTO glue(op_movl_T0,REGNAME)(void)
74
 
{
75
 
    T0 = REG;
76
 
}
77
 
 
78
 
void OPPROTO glue(op_movl_T1,REGNAME)(void)
79
 
{
80
 
    T1 = REG;
81
 
}
82
 
 
83
 
void OPPROTO glue(op_movh_T0,REGNAME)(void)
84
 
{
85
 
    T0 = REG >> 8;
86
 
}
87
 
 
88
 
void OPPROTO glue(op_movh_T1,REGNAME)(void)
89
 
{
90
 
    T1 = REG >> 8;
91
 
}
92
 
 
93
 
void OPPROTO glue(glue(op_movl,REGNAME),_T0)(void)
94
 
{
95
 
    REG = (uint32_t)T0;
96
 
}
97
 
 
98
 
void OPPROTO glue(glue(op_movl,REGNAME),_T1)(void)
99
 
{
100
 
    REG = (uint32_t)T1;
101
 
}
102
 
 
103
 
void OPPROTO glue(glue(op_movl,REGNAME),_A0)(void)
104
 
{
105
 
    REG = (uint32_t)A0;
106
 
}
107
 
 
108
 
#ifdef TARGET_X86_64
109
 
void OPPROTO glue(glue(op_movq,REGNAME),_T0)(void)
110
 
{
111
 
    REG = T0;
112
 
}
113
 
 
114
 
void OPPROTO glue(glue(op_movq,REGNAME),_T1)(void)
115
 
{
116
 
    REG = T1;
117
 
}
118
 
 
119
 
void OPPROTO glue(glue(op_movq,REGNAME),_A0)(void)
120
 
{
121
 
    REG = A0;
122
 
}
123
 
#endif
124
 
 
125
21
/* mov T1 to REG if T0 is true */
126
22
void OPPROTO glue(glue(op_cmovw,REGNAME),_T1_T0)(void)
127
23
{
132
28
 
133
29
void OPPROTO glue(glue(op_cmovl,REGNAME),_T1_T0)(void)
134
30
{
135
 
    if (T0)
136
 
        REG = (uint32_t)T1;
 
31
#ifdef TARGET_X86_64
 
32
    if (T0)
 
33
        REG = (uint32_t)T1;
 
34
    else
 
35
        REG = (uint32_t)REG;
 
36
#else
 
37
    if (T0)
 
38
        REG = (uint32_t)T1;
 
39
#endif
137
40
    FORCE_RET();
138
41
}
139
42
 
145
48
    FORCE_RET();
146
49
}
147
50
#endif
148
 
 
149
 
/* NOTE: T0 high order bits are ignored */
150
 
void OPPROTO glue(glue(op_movw,REGNAME),_T0)(void)
151
 
{
152
 
    REG = (REG & ~0xffff) | (T0 & 0xffff);
153
 
}
154
 
 
155
 
/* NOTE: T0 high order bits are ignored */
156
 
void OPPROTO glue(glue(op_movw,REGNAME),_T1)(void)
157
 
{
158
 
    REG = (REG & ~0xffff) | (T1 & 0xffff);
159
 
}
160
 
 
161
 
/* NOTE: A0 high order bits are ignored */
162
 
void OPPROTO glue(glue(op_movw,REGNAME),_A0)(void)
163
 
{
164
 
    REG = (REG & ~0xffff) | (A0 & 0xffff);
165
 
}
166
 
 
167
 
/* NOTE: T0 high order bits are ignored */
168
 
void OPPROTO glue(glue(op_movb,REGNAME),_T0)(void)
169
 
{
170
 
    REG = (REG & ~0xff) | (T0 & 0xff);
171
 
}
172
 
 
173
 
/* NOTE: T0 high order bits are ignored */
174
 
void OPPROTO glue(glue(op_movh,REGNAME),_T0)(void)
175
 
{
176
 
    REG = (REG & ~0xff00) | ((T0 & 0xff) << 8);
177
 
}
178
 
 
179
 
/* NOTE: T1 high order bits are ignored */
180
 
void OPPROTO glue(glue(op_movb,REGNAME),_T1)(void)
181
 
{
182
 
    REG = (REG & ~0xff) | (T1 & 0xff);
183
 
}
184
 
 
185
 
/* NOTE: T1 high order bits are ignored */
186
 
void OPPROTO glue(glue(op_movh,REGNAME),_T1)(void)
187
 
{
188
 
    REG = (REG & ~0xff00) | ((T1 & 0xff) << 8);
189
 
}
190