← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to target-i386/cc_helper_template.h

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-i386/cc_helper_template.h
1
 
/*
2
 
 *  x86 condition code helpers
3
 
 *
4
 
 *  Copyright (c) 2008 Fabrice Bellard
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, see <http://www.gnu.org/licenses/>.
18
 
 */
19
 
 
20
 
#define DATA_BITS (1 << (3 + SHIFT))
21
 
 
22
 
#if DATA_BITS == 8
23
 
#define SUFFIX b
24
 
#define DATA_TYPE uint8_t
25
 
#elif DATA_BITS == 16
26
 
#define SUFFIX w
27
 
#define DATA_TYPE uint16_t
28
 
#elif DATA_BITS == 32
29
 
#define SUFFIX l
30
 
#define DATA_TYPE uint32_t
31
 
#elif DATA_BITS == 64
32
 
#define SUFFIX q
33
 
#define DATA_TYPE uint64_t
34
 
#else
35
 
#error unhandled operand size
36
 
#endif
37
 
 
38
 
#define SIGN_MASK (((DATA_TYPE)1) << (DATA_BITS - 1))
39
 
 
40
 
/* dynamic flags computation */
41
 
 
42
 
static int glue(compute_all_add, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
43
 
{
44
 
    int cf, pf, af, zf, sf, of;
45
 
    DATA_TYPE src2 = dst - src1;
46
 
 
47
 
    cf = dst < src1;
48
 
    pf = parity_table[(uint8_t)dst];
49
 
    af = (dst ^ src1 ^ src2) & CC_A;
50
 
    zf = (dst == 0) * CC_Z;
51
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
52
 
    of = lshift((src1 ^ src2 ^ -1) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
53
 
    return cf | pf | af | zf | sf | of;
54
 
}
55
 
 
56
 
static int glue(compute_c_add, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
57
 
{
58
 
    return dst < src1;
59
 
}
60
 
 
61
 
static int glue(compute_all_adc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1,
62
 
                                         DATA_TYPE src3)
63
 
{
64
 
    int cf, pf, af, zf, sf, of;
65
 
    DATA_TYPE src2 = dst - src1 - src3;
66
 
 
67
 
    cf = (src3 ? dst <= src1 : dst < src1);
68
 
    pf = parity_table[(uint8_t)dst];
69
 
    af = (dst ^ src1 ^ src2) & 0x10;
70
 
    zf = (dst == 0) << 6;
71
 
    sf = lshift(dst, 8 - DATA_BITS) & 0x80;
72
 
    of = lshift((src1 ^ src2 ^ -1) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
73
 
    return cf | pf | af | zf | sf | of;
74
 
}
75
 
 
76
 
static int glue(compute_c_adc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1,
77
 
                                       DATA_TYPE src3)
78
 
{
79
 
    return src3 ? dst <= src1 : dst < src1;
80
 
}
81
 
 
82
 
static int glue(compute_all_sub, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2)
83
 
{
84
 
    int cf, pf, af, zf, sf, of;
85
 
    DATA_TYPE src1 = dst + src2;
86
 
 
87
 
    cf = src1 < src2;
88
 
    pf = parity_table[(uint8_t)dst];
89
 
    af = (dst ^ src1 ^ src2) & CC_A;
90
 
    zf = (dst == 0) * CC_Z;
91
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
92
 
    of = lshift((src1 ^ src2) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
93
 
    return cf | pf | af | zf | sf | of;
94
 
}
95
 
 
96
 
static int glue(compute_c_sub, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2)
97
 
{
98
 
    DATA_TYPE src1 = dst + src2;
99
 
 
100
 
    return src1 < src2;
101
 
}
102
 
 
103
 
static int glue(compute_all_sbb, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2,
104
 
                                         DATA_TYPE src3)
105
 
{
106
 
    int cf, pf, af, zf, sf, of;
107
 
    DATA_TYPE src1 = dst + src2 + src3;
108
 
 
109
 
    cf = (src3 ? src1 <= src2 : src1 < src2);
110
 
    pf = parity_table[(uint8_t)dst];
111
 
    af = (dst ^ src1 ^ src2) & 0x10;
112
 
    zf = (dst == 0) << 6;
113
 
    sf = lshift(dst, 8 - DATA_BITS) & 0x80;
114
 
    of = lshift((src1 ^ src2) & (src1 ^ dst), 12 - DATA_BITS) & CC_O;
115
 
    return cf | pf | af | zf | sf | of;
116
 
}
117
 
 
118
 
static int glue(compute_c_sbb, SUFFIX)(DATA_TYPE dst, DATA_TYPE src2,
119
 
                                       DATA_TYPE src3)
120
 
{
121
 
    DATA_TYPE src1 = dst + src2 + src3;
122
 
 
123
 
    return (src3 ? src1 <= src2 : src1 < src2);
124
 
}
125
 
 
126
 
static int glue(compute_all_logic, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
127
 
{
128
 
    int cf, pf, af, zf, sf, of;
129
 
 
130
 
    cf = 0;
131
 
    pf = parity_table[(uint8_t)dst];
132
 
    af = 0;
133
 
    zf = (dst == 0) * CC_Z;
134
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
135
 
    of = 0;
136
 
    return cf | pf | af | zf | sf | of;
137
 
}
138
 
 
139
 
static int glue(compute_all_inc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
140
 
{
141
 
    int cf, pf, af, zf, sf, of;
142
 
    DATA_TYPE src2;
143
 
 
144
 
    cf = src1;
145
 
    src1 = dst - 1;
146
 
    src2 = 1;
147
 
    pf = parity_table[(uint8_t)dst];
148
 
    af = (dst ^ src1 ^ src2) & CC_A;
149
 
    zf = (dst == 0) * CC_Z;
150
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
151
 
    of = (dst == SIGN_MASK) * CC_O;
152
 
    return cf | pf | af | zf | sf | of;
153
 
}
154
 
 
155
 
static int glue(compute_all_dec, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
156
 
{
157
 
    int cf, pf, af, zf, sf, of;
158
 
    DATA_TYPE src2;
159
 
 
160
 
    cf = src1;
161
 
    src1 = dst + 1;
162
 
    src2 = 1;
163
 
    pf = parity_table[(uint8_t)dst];
164
 
    af = (dst ^ src1 ^ src2) & CC_A;
165
 
    zf = (dst == 0) * CC_Z;
166
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
167
 
    of = (dst == SIGN_MASK - 1) * CC_O;
168
 
    return cf | pf | af | zf | sf | of;
169
 
}
170
 
 
171
 
static int glue(compute_all_shl, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
172
 
{
173
 
    int cf, pf, af, zf, sf, of;
174
 
 
175
 
    cf = (src1 >> (DATA_BITS - 1)) & CC_C;
176
 
    pf = parity_table[(uint8_t)dst];
177
 
    af = 0; /* undefined */
178
 
    zf = (dst == 0) * CC_Z;
179
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
180
 
    /* of is defined iff shift count == 1 */
181
 
    of = lshift(src1 ^ dst, 12 - DATA_BITS) & CC_O;
182
 
    return cf | pf | af | zf | sf | of;
183
 
}
184
 
 
185
 
static int glue(compute_c_shl, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
186
 
{
187
 
    return (src1 >> (DATA_BITS - 1)) & CC_C;
188
 
}
189
 
 
190
 
static int glue(compute_all_sar, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
191
 
{
192
 
    int cf, pf, af, zf, sf, of;
193
 
 
194
 
    cf = src1 & 1;
195
 
    pf = parity_table[(uint8_t)dst];
196
 
    af = 0; /* undefined */
197
 
    zf = (dst == 0) * CC_Z;
198
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
199
 
    /* of is defined iff shift count == 1 */
200
 
    of = lshift(src1 ^ dst, 12 - DATA_BITS) & CC_O;
201
 
    return cf | pf | af | zf | sf | of;
202
 
}
203
 
 
204
 
/* NOTE: we compute the flags like the P4. On olders CPUs, only OF and
205
 
   CF are modified and it is slower to do that.  Note as well that we
206
 
   don't truncate SRC1 for computing carry to DATA_TYPE.  */
207
 
static int glue(compute_all_mul, SUFFIX)(DATA_TYPE dst, target_long src1)
208
 
{
209
 
    int cf, pf, af, zf, sf, of;
210
 
 
211
 
    cf = (src1 != 0);
212
 
    pf = parity_table[(uint8_t)dst];
213
 
    af = 0; /* undefined */
214
 
    zf = (dst == 0) * CC_Z;
215
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
216
 
    of = cf * CC_O;
217
 
    return cf | pf | af | zf | sf | of;
218
 
}
219
 
 
220
 
static int glue(compute_all_bmilg, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
221
 
{
222
 
    int cf, pf, af, zf, sf, of;
223
 
 
224
 
    cf = (src1 == 0);
225
 
    pf = 0; /* undefined */
226
 
    af = 0; /* undefined */
227
 
    zf = (dst == 0) * CC_Z;
228
 
    sf = lshift(dst, 8 - DATA_BITS) & CC_S;
229
 
    of = 0;
230
 
    return cf | pf | af | zf | sf | of;
231
 
}
232
 
 
233
 
static int glue(compute_c_bmilg, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1)
234
 
{
235
 
    return src1 == 0;
236
 
}
237
 
 
238
 
#undef DATA_BITS
239
 
#undef SIGN_MASK
240
 
#undef DATA_TYPE
241
 
#undef DATA_MASK
242
 
#undef SUFFIX