Revision 8601c0b6 target-i386/cc_helper.c
| b/target-i386/cc_helper.c | ||
|---|---|---|
| 75 | 75 |
|
| 76 | 76 |
#endif |
| 77 | 77 |
|
| 78 |
static int compute_all_eflags(CPUX86State *env) |
|
| 79 |
{
|
|
| 80 |
return CC_SRC; |
|
| 81 |
} |
|
| 82 |
|
|
| 83 |
static int compute_c_eflags(CPUX86State *env) |
|
| 84 |
{
|
|
| 85 |
return CC_SRC & CC_C; |
|
| 86 |
} |
|
| 87 |
|
|
| 88 | 78 |
uint32_t helper_cc_compute_all(CPUX86State *env, int op) |
| 89 | 79 |
{
|
| 80 |
target_ulong dst = CC_DST, src1 = CC_SRC; |
|
| 81 |
|
|
| 90 | 82 |
switch (op) {
|
| 91 | 83 |
default: /* should never happen */ |
| 92 | 84 |
return 0; |
| 93 | 85 |
|
| 94 | 86 |
case CC_OP_EFLAGS: |
| 95 |
return compute_all_eflags(env);
|
|
| 87 |
return src1;
|
|
| 96 | 88 |
|
| 97 | 89 |
case CC_OP_MULB: |
| 98 |
return compute_all_mulb(env);
|
|
| 90 |
return compute_all_mulb(dst, src1);
|
|
| 99 | 91 |
case CC_OP_MULW: |
| 100 |
return compute_all_mulw(env);
|
|
| 92 |
return compute_all_mulw(dst, src1);
|
|
| 101 | 93 |
case CC_OP_MULL: |
| 102 |
return compute_all_mull(env);
|
|
| 94 |
return compute_all_mull(dst, src1);
|
|
| 103 | 95 |
|
| 104 | 96 |
case CC_OP_ADDB: |
| 105 |
return compute_all_addb(env);
|
|
| 97 |
return compute_all_addb(dst, src1);
|
|
| 106 | 98 |
case CC_OP_ADDW: |
| 107 |
return compute_all_addw(env);
|
|
| 99 |
return compute_all_addw(dst, src1);
|
|
| 108 | 100 |
case CC_OP_ADDL: |
| 109 |
return compute_all_addl(env);
|
|
| 101 |
return compute_all_addl(dst, src1);
|
|
| 110 | 102 |
|
| 111 | 103 |
case CC_OP_ADCB: |
| 112 |
return compute_all_adcb(env);
|
|
| 104 |
return compute_all_adcb(dst, src1);
|
|
| 113 | 105 |
case CC_OP_ADCW: |
| 114 |
return compute_all_adcw(env);
|
|
| 106 |
return compute_all_adcw(dst, src1);
|
|
| 115 | 107 |
case CC_OP_ADCL: |
| 116 |
return compute_all_adcl(env);
|
|
| 108 |
return compute_all_adcl(dst, src1);
|
|
| 117 | 109 |
|
| 118 | 110 |
case CC_OP_SUBB: |
| 119 |
return compute_all_subb(env);
|
|
| 111 |
return compute_all_subb(dst, src1);
|
|
| 120 | 112 |
case CC_OP_SUBW: |
| 121 |
return compute_all_subw(env);
|
|
| 113 |
return compute_all_subw(dst, src1);
|
|
| 122 | 114 |
case CC_OP_SUBL: |
| 123 |
return compute_all_subl(env);
|
|
| 115 |
return compute_all_subl(dst, src1);
|
|
| 124 | 116 |
|
| 125 | 117 |
case CC_OP_SBBB: |
| 126 |
return compute_all_sbbb(env);
|
|
| 118 |
return compute_all_sbbb(dst, src1);
|
|
| 127 | 119 |
case CC_OP_SBBW: |
| 128 |
return compute_all_sbbw(env);
|
|
| 120 |
return compute_all_sbbw(dst, src1);
|
|
| 129 | 121 |
case CC_OP_SBBL: |
| 130 |
return compute_all_sbbl(env);
|
|
| 122 |
return compute_all_sbbl(dst, src1);
|
|
| 131 | 123 |
|
| 132 | 124 |
case CC_OP_LOGICB: |
| 133 |
return compute_all_logicb(env);
|
|
| 125 |
return compute_all_logicb(dst, src1);
|
|
| 134 | 126 |
case CC_OP_LOGICW: |
| 135 |
return compute_all_logicw(env);
|
|
| 127 |
return compute_all_logicw(dst, src1);
|
|
| 136 | 128 |
case CC_OP_LOGICL: |
| 137 |
return compute_all_logicl(env);
|
|
| 129 |
return compute_all_logicl(dst, src1);
|
|
| 138 | 130 |
|
| 139 | 131 |
case CC_OP_INCB: |
| 140 |
return compute_all_incb(env);
|
|
| 132 |
return compute_all_incb(dst, src1);
|
|
| 141 | 133 |
case CC_OP_INCW: |
| 142 |
return compute_all_incw(env);
|
|
| 134 |
return compute_all_incw(dst, src1);
|
|
| 143 | 135 |
case CC_OP_INCL: |
| 144 |
return compute_all_incl(env);
|
|
| 136 |
return compute_all_incl(dst, src1);
|
|
| 145 | 137 |
|
| 146 | 138 |
case CC_OP_DECB: |
| 147 |
return compute_all_decb(env);
|
|
| 139 |
return compute_all_decb(dst, src1);
|
|
| 148 | 140 |
case CC_OP_DECW: |
| 149 |
return compute_all_decw(env);
|
|
| 141 |
return compute_all_decw(dst, src1);
|
|
| 150 | 142 |
case CC_OP_DECL: |
| 151 |
return compute_all_decl(env);
|
|
| 143 |
return compute_all_decl(dst, src1);
|
|
| 152 | 144 |
|
| 153 | 145 |
case CC_OP_SHLB: |
| 154 |
return compute_all_shlb(env);
|
|
| 146 |
return compute_all_shlb(dst, src1);
|
|
| 155 | 147 |
case CC_OP_SHLW: |
| 156 |
return compute_all_shlw(env);
|
|
| 148 |
return compute_all_shlw(dst, src1);
|
|
| 157 | 149 |
case CC_OP_SHLL: |
| 158 |
return compute_all_shll(env);
|
|
| 150 |
return compute_all_shll(dst, src1);
|
|
| 159 | 151 |
|
| 160 | 152 |
case CC_OP_SARB: |
| 161 |
return compute_all_sarb(env);
|
|
| 153 |
return compute_all_sarb(dst, src1);
|
|
| 162 | 154 |
case CC_OP_SARW: |
| 163 |
return compute_all_sarw(env);
|
|
| 155 |
return compute_all_sarw(dst, src1);
|
|
| 164 | 156 |
case CC_OP_SARL: |
| 165 |
return compute_all_sarl(env);
|
|
| 157 |
return compute_all_sarl(dst, src1);
|
|
| 166 | 158 |
|
| 167 | 159 |
#ifdef TARGET_X86_64 |
| 168 | 160 |
case CC_OP_MULQ: |
| 169 |
return compute_all_mulq(env); |
|
| 170 |
|
|
| 161 |
return compute_all_mulq(dst, src1); |
|
| 171 | 162 |
case CC_OP_ADDQ: |
| 172 |
return compute_all_addq(env); |
|
| 173 |
|
|
| 163 |
return compute_all_addq(dst, src1); |
|
| 174 | 164 |
case CC_OP_ADCQ: |
| 175 |
return compute_all_adcq(env); |
|
| 176 |
|
|
| 165 |
return compute_all_adcq(dst, src1); |
|
| 177 | 166 |
case CC_OP_SUBQ: |
| 178 |
return compute_all_subq(env); |
|
| 179 |
|
|
| 167 |
return compute_all_subq(dst, src1); |
|
| 180 | 168 |
case CC_OP_SBBQ: |
| 181 |
return compute_all_sbbq(env); |
|
| 182 |
|
|
| 169 |
return compute_all_sbbq(dst, src1); |
|
| 183 | 170 |
case CC_OP_LOGICQ: |
| 184 |
return compute_all_logicq(env); |
|
| 185 |
|
|
| 171 |
return compute_all_logicq(dst, src1); |
|
| 186 | 172 |
case CC_OP_INCQ: |
| 187 |
return compute_all_incq(env); |
|
| 188 |
|
|
| 173 |
return compute_all_incq(dst, src1); |
|
| 189 | 174 |
case CC_OP_DECQ: |
| 190 |
return compute_all_decq(env); |
|
| 191 |
|
|
| 175 |
return compute_all_decq(dst, src1); |
|
| 192 | 176 |
case CC_OP_SHLQ: |
| 193 |
return compute_all_shlq(env); |
|
| 194 |
|
|
| 177 |
return compute_all_shlq(dst, src1); |
|
| 195 | 178 |
case CC_OP_SARQ: |
| 196 |
return compute_all_sarq(env);
|
|
| 179 |
return compute_all_sarq(dst, src1);
|
|
| 197 | 180 |
#endif |
| 198 | 181 |
} |
| 199 | 182 |
} |
| ... | ... | |
| 205 | 188 |
|
| 206 | 189 |
uint32_t helper_cc_compute_c(CPUX86State *env, int op) |
| 207 | 190 |
{
|
| 191 |
target_ulong dst = CC_DST, src1 = CC_SRC; |
|
| 192 |
|
|
| 208 | 193 |
switch (op) {
|
| 209 | 194 |
default: /* should never happen */ |
| 195 |
case CC_OP_LOGICB: |
|
| 196 |
case CC_OP_LOGICW: |
|
| 197 |
case CC_OP_LOGICL: |
|
| 198 |
case CC_OP_LOGICQ: |
|
| 210 | 199 |
return 0; |
| 211 | 200 |
|
| 212 | 201 |
case CC_OP_EFLAGS: |
| 213 |
return compute_c_eflags(env); |
|
| 202 |
case CC_OP_SARB: |
|
| 203 |
case CC_OP_SARW: |
|
| 204 |
case CC_OP_SARL: |
|
| 205 |
case CC_OP_SARQ: |
|
| 206 |
return src1 & 1; |
|
| 207 |
|
|
| 208 |
case CC_OP_INCB: |
|
| 209 |
case CC_OP_INCW: |
|
| 210 |
case CC_OP_INCL: |
|
| 211 |
case CC_OP_INCQ: |
|
| 212 |
case CC_OP_DECB: |
|
| 213 |
case CC_OP_DECW: |
|
| 214 |
case CC_OP_DECL: |
|
| 215 |
case CC_OP_DECQ: |
|
| 216 |
return src1; |
|
| 214 | 217 |
|
| 215 | 218 |
case CC_OP_MULB: |
| 216 |
return compute_c_mull(env); |
|
| 217 | 219 |
case CC_OP_MULW: |
| 218 |
return compute_c_mull(env); |
|
| 219 | 220 |
case CC_OP_MULL: |
| 220 |
return compute_c_mull(env); |
|
| 221 |
case CC_OP_MULQ: |
|
| 222 |
return src1 != 0; |
|
| 221 | 223 |
|
| 222 | 224 |
case CC_OP_ADDB: |
| 223 |
return compute_c_addb(env);
|
|
| 225 |
return compute_c_addb(dst, src1);
|
|
| 224 | 226 |
case CC_OP_ADDW: |
| 225 |
return compute_c_addw(env);
|
|
| 227 |
return compute_c_addw(dst, src1);
|
|
| 226 | 228 |
case CC_OP_ADDL: |
| 227 |
return compute_c_addl(env);
|
|
| 229 |
return compute_c_addl(dst, src1);
|
|
| 228 | 230 |
|
| 229 | 231 |
case CC_OP_ADCB: |
| 230 |
return compute_c_adcb(env);
|
|
| 232 |
return compute_c_adcb(dst, src1);
|
|
| 231 | 233 |
case CC_OP_ADCW: |
| 232 |
return compute_c_adcw(env);
|
|
| 234 |
return compute_c_adcw(dst, src1);
|
|
| 233 | 235 |
case CC_OP_ADCL: |
| 234 |
return compute_c_adcl(env);
|
|
| 236 |
return compute_c_adcl(dst, src1);
|
|
| 235 | 237 |
|
| 236 | 238 |
case CC_OP_SUBB: |
| 237 |
return compute_c_subb(env);
|
|
| 239 |
return compute_c_subb(dst, src1);
|
|
| 238 | 240 |
case CC_OP_SUBW: |
| 239 |
return compute_c_subw(env);
|
|
| 241 |
return compute_c_subw(dst, src1);
|
|
| 240 | 242 |
case CC_OP_SUBL: |
| 241 |
return compute_c_subl(env);
|
|
| 243 |
return compute_c_subl(dst, src1);
|
|
| 242 | 244 |
|
| 243 | 245 |
case CC_OP_SBBB: |
| 244 |
return compute_c_sbbb(env);
|
|
| 246 |
return compute_c_sbbb(dst, src1);
|
|
| 245 | 247 |
case CC_OP_SBBW: |
| 246 |
return compute_c_sbbw(env);
|
|
| 248 |
return compute_c_sbbw(dst, src1);
|
|
| 247 | 249 |
case CC_OP_SBBL: |
| 248 |
return compute_c_sbbl(env); |
|
| 249 |
|
|
| 250 |
case CC_OP_LOGICB: |
|
| 251 |
return compute_c_logicb(); |
|
| 252 |
case CC_OP_LOGICW: |
|
| 253 |
return compute_c_logicw(); |
|
| 254 |
case CC_OP_LOGICL: |
|
| 255 |
return compute_c_logicl(); |
|
| 256 |
|
|
| 257 |
case CC_OP_INCB: |
|
| 258 |
return compute_c_incl(env); |
|
| 259 |
case CC_OP_INCW: |
|
| 260 |
return compute_c_incl(env); |
|
| 261 |
case CC_OP_INCL: |
|
| 262 |
return compute_c_incl(env); |
|
| 263 |
|
|
| 264 |
case CC_OP_DECB: |
|
| 265 |
return compute_c_incl(env); |
|
| 266 |
case CC_OP_DECW: |
|
| 267 |
return compute_c_incl(env); |
|
| 268 |
case CC_OP_DECL: |
|
| 269 |
return compute_c_incl(env); |
|
| 250 |
return compute_c_sbbl(dst, src1); |
|
| 270 | 251 |
|
| 271 | 252 |
case CC_OP_SHLB: |
| 272 |
return compute_c_shlb(env);
|
|
| 253 |
return compute_c_shlb(dst, src1);
|
|
| 273 | 254 |
case CC_OP_SHLW: |
| 274 |
return compute_c_shlw(env);
|
|
| 255 |
return compute_c_shlw(dst, src1);
|
|
| 275 | 256 |
case CC_OP_SHLL: |
| 276 |
return compute_c_shll(env); |
|
| 277 |
|
|
| 278 |
case CC_OP_SARB: |
|
| 279 |
return compute_c_sarl(env); |
|
| 280 |
case CC_OP_SARW: |
|
| 281 |
return compute_c_sarl(env); |
|
| 282 |
case CC_OP_SARL: |
|
| 283 |
return compute_c_sarl(env); |
|
| 257 |
return compute_c_shll(dst, src1); |
|
| 284 | 258 |
|
| 285 | 259 |
#ifdef TARGET_X86_64 |
| 286 |
case CC_OP_MULQ: |
|
| 287 |
return compute_c_mull(env); |
|
| 288 |
|
|
| 289 | 260 |
case CC_OP_ADDQ: |
| 290 |
return compute_c_addq(env); |
|
| 291 |
|
|
| 261 |
return compute_c_addq(dst, src1); |
|
| 292 | 262 |
case CC_OP_ADCQ: |
| 293 |
return compute_c_adcq(env); |
|
| 294 |
|
|
| 263 |
return compute_c_adcq(dst, src1); |
|
| 295 | 264 |
case CC_OP_SUBQ: |
| 296 |
return compute_c_subq(env); |
|
| 297 |
|
|
| 265 |
return compute_c_subq(dst, src1); |
|
| 298 | 266 |
case CC_OP_SBBQ: |
| 299 |
return compute_c_sbbq(env); |
|
| 300 |
|
|
| 301 |
case CC_OP_LOGICQ: |
|
| 302 |
return compute_c_logicq(); |
|
| 303 |
|
|
| 304 |
case CC_OP_INCQ: |
|
| 305 |
return compute_c_incl(env); |
|
| 306 |
|
|
| 307 |
case CC_OP_DECQ: |
|
| 308 |
return compute_c_incl(env); |
|
| 309 |
|
|
| 267 |
return compute_c_sbbq(dst, src1); |
|
| 310 | 268 |
case CC_OP_SHLQ: |
| 311 |
return compute_c_shlq(env); |
|
| 312 |
|
|
| 313 |
case CC_OP_SARQ: |
|
| 314 |
return compute_c_sarl(env); |
|
| 269 |
return compute_c_shlq(dst, src1); |
|
| 315 | 270 |
#endif |
| 316 | 271 |
} |
| 317 | 272 |
} |
Also available in: Unified diff