Unified · Split
| @@ -0,0 +1,1077 @@ | ||
| 1 | +/* | |
| 2 | + * i386 specific functions for TCC assembler | |
| 3 | + * | |
| 4 | + * Copyright (c) 2001, 2002 Fabrice Bellard | |
| 5 | + * | |
| 6 | + * This program is free software; you can redistribute it and/or modify | |
| 7 | + * it under the terms of the GNU General Public License as published by | |
| 8 | + * the Free Software Foundation; either version 2 of the License, or | |
| 9 | + * (at your option) any later version. | |
| 10 | + * | |
| 11 | + * This program 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 | |
| 14 | + * GNU General Public License for more details. | |
| 15 | + * | |
| 16 | + * You should have received a copy of the GNU General Public License | |
| 17 | + * along with this program; if not, write to the Free Software | |
| 18 | + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
| 19 | + */ | |
| 20 | + | |
| 21 | +#define MAX_OPERANDS 3 | |
| 22 | + | |
| 23 | +typedef struct ASMInstr { | |
| 24 | + uint16_t sym; | |
| 25 | + uint16_t opcode; | |
| 26 | + uint16_t instr_type; | |
| 27 | +#define OPC_JMP 0x01 /* jmp operand */ | |
| 28 | +#define OPC_B 0x02 /* only used zith OPC_WL */ | |
| 29 | +#define OPC_WL 0x04 /* accepts w, l or no suffix */ | |
| 30 | +#define OPC_BWL (OPC_B | OPC_WL) /* accepts b, w, l or no suffix */ | |
| 31 | +#define OPC_REG 0x08 /* register is added to opcode */ | |
| 32 | +#define OPC_MODRM 0x10 /* modrm encoding */ | |
| 33 | +#define OPC_FWAIT 0x20 /* add fwait opcode */ | |
| 34 | +#define OPC_TEST 0x40 /* test opcodes */ | |
| 35 | +#define OPC_SHIFT 0x80 /* shift opcodes */ | |
| 36 | +#define OPC_D16 0x0100 /* generate data16 prefix */ | |
| 37 | +#define OPC_ARITH 0x0200 /* arithmetic opcodes */ | |
| 38 | +#define OPC_SHORTJMP 0x0400 /* short jmp operand */ | |
| 39 | +#define OPC_FARITH 0x0800 /* FPU arithmetic opcodes */ | |
| 40 | +#define OPC_GROUP_SHIFT 13 | |
| 41 | + | |
| 42 | +/* in order to compress the operand type, we use specific operands and | |
| 43 | + we or only with EA */ | |
| 44 | +#define OPT_REG8 0 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 45 | +#define OPT_REG16 1 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 46 | +#define OPT_REG32 2 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 47 | +#define OPT_MMX 3 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 48 | +#define OPT_SSE 4 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 49 | +#define OPT_CR 5 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 50 | +#define OPT_TR 6 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 51 | +#define OPT_DB 7 /* warning: value is hardcoded from TOK_ASM_xxx */ | |
| 52 | +#define OPT_SEG 8 | |
| 53 | +#define OPT_ST 9 | |
| 54 | +#define OPT_IM8 10 | |
| 55 | +#define OPT_IM8S 11 | |
| 56 | +#define OPT_IM16 12 | |
| 57 | +#define OPT_IM32 13 | |
| 58 | +#define OPT_EAX 14 /* %al, %ax or %eax register */ | |
| 59 | +#define OPT_ST0 15 /* %st(0) register */ | |
| 60 | +#define OPT_CL 16 /* %cl register */ | |
| 61 | +#define OPT_DX 17 /* %dx register */ | |
| 62 | +#define OPT_ADDR 18 /* OP_EA with only offset */ | |
| 63 | +#define OPT_INDIR 19 /* *(expr) */ | |
| 64 | + | |
| 65 | +/* composite types */ | |
| 66 | +#define OPT_COMPOSITE_FIRST 20 | |
| 67 | +#define OPT_IM 20 /* IM8 | IM16 | IM32 */ | |
| 68 | +#define OPT_REG 21 /* REG8 | REG16 | REG32 */ | |
| 69 | +#define OPT_REGW 22 /* REG16 | REG32 */ | |
| 70 | +#define OPT_IMW 23 /* IM16 | IM32 */ | |
| 71 | + | |
| 72 | +/* can be ored with any OPT_xxx */ | |
| 73 | +#define OPT_EA 0x80 | |
| 74 | + | |
| 75 | + uint8_t nb_ops; | |
| 76 | + uint8_t op_type[MAX_OPERANDS]; /* see OP_xxx */ | |
| 77 | +} ASMInstr; | |
| 78 | + | |
| 79 | +typedef struct Operand { | |
| 80 | + uint32_t type; | |
| 81 | +#define OP_REG8 (1 << OPT_REG8) | |
| 82 | +#define OP_REG16 (1 << OPT_REG16) | |
| 83 | +#define OP_REG32 (1 << OPT_REG32) | |
| 84 | +#define OP_MMX (1 << OPT_MMX) | |
| 85 | +#define OP_SSE (1 << OPT_SSE) | |
| 86 | +#define OP_CR (1 << OPT_CR) | |
| 87 | +#define OP_TR (1 << OPT_TR) | |
| 88 | +#define OP_DB (1 << OPT_DB) | |
| 89 | +#define OP_SEG (1 << OPT_SEG) | |
| 90 | +#define OP_ST (1 << OPT_ST) | |
| 91 | +#define OP_IM8 (1 << OPT_IM8) | |
| 92 | +#define OP_IM8S (1 << OPT_IM8S) | |
| 93 | +#define OP_IM16 (1 << OPT_IM16) | |
| 94 | +#define OP_IM32 (1 << OPT_IM32) | |
| 95 | +#define OP_EAX (1 << OPT_EAX) | |
| 96 | +#define OP_ST0 (1 << OPT_ST0) | |
| 97 | +#define OP_CL (1 << OPT_CL) | |
| 98 | +#define OP_DX (1 << OPT_DX) | |
| 99 | +#define OP_ADDR (1 << OPT_ADDR) | |
| 100 | +#define OP_INDIR (1 << OPT_INDIR) | |
| 101 | + | |
| 102 | +#define OP_EA 0x40000000 | |
| 103 | +#define OP_REG (OP_REG8 | OP_REG16 | OP_REG32) | |
| 104 | +#define OP_IM OP_IM32 | |
| 105 | + int8_t reg; /* register, -1 if none */ | |
| 106 | + int8_t reg2; /* second register, -1 if none */ | |
| 107 | + uint8_t shift; | |
| 108 | + ExprValue e; | |
| 109 | +} Operand; | |
| 110 | + | |
| 111 | +static const uint8_t reg_to_size[5] = { | |
| 112 | + [OP_REG8] = 0, | |
| 113 | + [OP_REG16] = 1, | |
| 114 | + [OP_REG32] = 2, | |
| 115 | +}; | |
| 116 | + | |
| 117 | +#define WORD_PREFIX_OPCODE 0x66 | |
| 118 | + | |
| 119 | +#define NB_TEST_OPCODES 30 | |
| 120 | + | |
| 121 | +static const uint8_t test_bits[NB_TEST_OPCODES] = { | |
| 122 | + 0x00, /* o */ | |
| 123 | + 0x01, /* no */ | |
| 124 | + 0x02, /* b */ | |
| 125 | + 0x02, /* c */ | |
| 126 | + 0x02, /* nae */ | |
| 127 | + 0x03, /* nb */ | |
| 128 | + 0x03, /* nc */ | |
| 129 | + 0x03, /* ae */ | |
| 130 | + 0x04, /* e */ | |
| 131 | + 0x04, /* z */ | |
| 132 | + 0x05, /* ne */ | |
| 133 | + 0x05, /* nz */ | |
| 134 | + 0x06, /* be */ | |
| 135 | + 0x06, /* na */ | |
| 136 | + 0x07, /* nbe */ | |
| 137 | + 0x07, /* a */ | |
| 138 | + 0x08, /* s */ | |
| 139 | + 0x09, /* ns */ | |
| 140 | + 0x0a, /* p */ | |
| 141 | + 0x0a, /* pe */ | |
| 142 | + 0x0b, /* np */ | |
| 143 | + 0x0b, /* po */ | |
| 144 | + 0x0c, /* l */ | |
| 145 | + 0x0c, /* nge */ | |
| 146 | + 0x0d, /* nl */ | |
| 147 | + 0x0d, /* ge */ | |
| 148 | + 0x0e, /* le */ | |
| 149 | + 0x0e, /* ng */ | |
| 150 | + 0x0f, /* nle */ | |
| 151 | + 0x0f, /* g */ | |
| 152 | +}; | |
| 153 | + | |
| 154 | +static const ASMInstr asm_instrs[] = { | |
| 155 | +#define ALT(x) x | |
| 156 | +#define DEF_ASM_OP0(name, opcode) | |
| 157 | +#define DEF_ASM_OP0L(name, opcode, group, instr_type) { TOK_ASM_ ## name, opcode, (instr_type | group << OPC_GROUP_SHIFT), 0 }, | |
| 158 | +#define DEF_ASM_OP1(name, opcode, group, instr_type, op0) { TOK_ASM_ ## name, opcode, (instr_type | group << OPC_GROUP_SHIFT), 1, { op0 }}, | |
| 159 | +#define DEF_ASM_OP2(name, opcode, group, instr_type, op0, op1) { TOK_ASM_ ## name, opcode, (instr_type | group << OPC_GROUP_SHIFT), 2, { op0, op1 }}, | |
| 160 | +#define DEF_ASM_OP3(name, opcode, group, instr_type, op0, op1, op2) { TOK_ASM_ ## name, opcode, (instr_type | group << OPC_GROUP_SHIFT), 3, { op0, op1, op2 }}, | |
| 161 | +#include "i386-asm.h" | |
| 162 | + | |
| 163 | + /* last operation */ | |
| 164 | + { 0, }, | |
| 165 | +}; | |
| 166 | + | |
| 167 | +static const uint16_t op0_codes[] = { | |
| 168 | +#define ALT(x) | |
| 169 | +#define DEF_ASM_OP0(x, opcode) opcode, | |
| 170 | +#define DEF_ASM_OP0L(name, opcode, group, instr_type) | |
| 171 | +#define DEF_ASM_OP1(name, opcode, group, instr_type, op0) | |
| 172 | +#define DEF_ASM_OP2(name, opcode, group, instr_type, op0, op1) | |
| 173 | +#define DEF_ASM_OP3(name, opcode, group, instr_type, op0, op1, op2) | |
| 174 | +#include "i386-asm.h" | |
| 175 | +}; | |
| 176 | + | |
| 177 | +static inline int get_reg_shift(TCCState *s1) | |
| 178 | +{ | |
| 179 | + int shift, v; | |
| 180 | + | |
| 181 | + v = asm_int_expr(s1); | |
| 182 | + switch(v) { | |
| 183 | + case 1: | |
| 184 | + shift = 0; | |
| 185 | + break; | |
| 186 | + case 2: | |
| 187 | + shift = 1; | |
| 188 | + break; | |
| 189 | + case 4: | |
| 190 | + shift = 2; | |
| 191 | + break; | |
| 192 | + case 8: | |
| 193 | + shift = 3; | |
| 194 | + break; | |
| 195 | + default: | |
| 196 | + expect("1, 2, 4 or 8 constant"); | |
| 197 | + shift = 0; | |
| 198 | + break; | |
| 199 | + } | |
| 200 | + return shift; | |
| 201 | +} | |
| 202 | + | |
| 203 | +static int asm_parse_reg(void) | |
| 204 | +{ | |
| 205 | + int reg; | |
| 206 | + if (tok != '%') | |
| 207 | + goto error_32; | |
| 208 | + next(); | |
| 209 | + if (tok >= TOK_ASM_eax && tok <= TOK_ASM_edi) { | |
| 210 | + reg = tok - TOK_ASM_eax; | |
| 211 | + next(); | |
| 212 | + return reg; | |
| 213 | + } else { | |
| 214 | + error_32: | |
| 215 | + expect("32 bit register"); | |
| 216 | + return 0; | |
| 217 | + } | |
| 218 | +} | |
| 219 | + | |
| 220 | +static void parse_operand(TCCState *s1, Operand *op) | |
| 221 | +{ | |
| 222 | + ExprValue e; | |
| 223 | + int reg, indir; | |
| 224 | + const char *p; | |
| 225 | + | |
| 226 | + indir = 0; | |
| 227 | + if (tok == '*') { | |
| 228 | + next(); | |
| 229 | + indir = OP_INDIR; | |
| 230 | + } | |
| 231 | + | |
| 232 | + if (tok == '%') { | |
| 233 | + next(); | |
| 234 | + if (tok >= TOK_ASM_al && tok <= TOK_ASM_db7) { | |
| 235 | + reg = tok - TOK_ASM_al; | |
| 236 | + op->type = 1 << (reg >> 3); /* WARNING: do not change constant order */ | |
| 237 | + op->reg = reg & 7; | |
| 238 | + if ((op->type & OP_REG) && op->reg == TREG_EAX) | |
| 239 | + op->type |= OP_EAX; | |
| 240 | + else if (op->type == OP_REG8 && op->reg == TREG_ECX) | |
| 241 | + op->type |= OP_CL; | |
| 242 | + else if (op->type == OP_REG16 && op->reg == TREG_EDX) | |
| 243 | + op->type |= OP_DX; | |
| 244 | + } else if (tok >= TOK_ASM_dr0 && tok <= TOK_ASM_dr7) { | |
| 245 | + op->type = OP_DB; | |
| 246 | + op->reg = tok - TOK_ASM_dr0; | |
| 247 | + } else if (tok >= TOK_ASM_es && tok <= TOK_ASM_gs) { | |
| 248 | + op->type = OP_SEG; | |
| 249 | + op->reg = tok - TOK_ASM_es; | |
| 250 | + } else if (tok == TOK_ASM_st) { | |
| 251 | + op->type = OP_ST; | |
| 252 | + op->reg = 0; | |
| 253 | + next(); | |
| 254 | + if (tok == '(') { | |
| 255 | + next(); | |
| 256 | + if (tok != TOK_PPNUM) | |
| 257 | + goto reg_error; | |
| 258 | + p = tokc.cstr->data; | |
| 259 | + reg = p[0] - '0'; | |
| 260 | + if ((unsigned)reg >= 8 || p[1] != '\0') | |
| 261 | + goto reg_error; | |
| 262 | + op->reg = reg; | |
| 263 | + next(); | |
| 264 | + skip(')'); | |
| 265 | + } | |
| 266 | + if (op->reg == 0) | |
| 267 | + op->type |= OP_ST0; | |
| 268 | + goto no_skip; | |
| 269 | + } else { | |
| 270 | + reg_error: | |
| 271 | + error("unknown register"); | |
| 272 | + } | |
| 273 | + next(); | |
| 274 | + no_skip: ; | |
| 275 | + } else if (tok == '$') { | |
| 276 | + /* constant value */ | |
| 277 | + next(); | |
| 278 | + asm_expr(s1, &e); | |
| 279 | + op->type = OP_IM32; | |
| 280 | + op->e.v = e.v; | |
| 281 | + op->e.sym = e.sym; | |
| 282 | + if (!op->e.sym) { | |
| 283 | + if (op->e.v == (uint8_t)op->e.v) | |
| 284 | + op->type |= OP_IM8; | |
| 285 | + if (op->e.v == (int8_t)op->e.v) | |
| 286 | + op->type |= OP_IM8S; | |
| 287 | + if (op->e.v == (uint16_t)op->e.v) | |
| 288 | + op->type |= OP_IM16; | |
| 289 | + } | |
| 290 | + } else { | |
| 291 | + /* address(reg,reg2,shift) with all variants */ | |
| 292 | + op->type = OP_EA; | |
| 293 | + op->reg = -1; | |
| 294 | + op->reg2 = -1; | |
| 295 | + op->shift = 0; | |
| 296 | + if (tok != '(') { | |
| 297 | + asm_expr(s1, &e); | |
| 298 | + op->e.v = e.v; | |
| 299 | + op->e.sym = e.sym; | |
| 300 | + } else { | |
| 301 | + op->e.v = 0; | |
| 302 | + op->e.sym = NULL; | |
| 303 | + } | |
| 304 | + if (tok == '(') { | |
| 305 | + next(); | |
| 306 | + if (tok != ',') { | |
| 307 | + op->reg = asm_parse_reg(); | |
| 308 | + } | |
| 309 | + if (tok == ',') { | |
| 310 | + next(); | |
| 311 | + if (tok != ',') { | |
| 312 | + op->reg2 = asm_parse_reg(); | |
| 313 | + } | |
| 314 | + skip(','); | |
| 315 | + op->shift = get_reg_shift(s1); | |
| 316 | + } | |
| 317 | + skip(')'); | |
| 318 | + } | |
| 319 | + if (op->reg == -1 && op->reg2 == -1) | |
| 320 | + op->type |= OP_ADDR; | |
| 321 | + } | |
| 322 | + op->type |= indir; | |
| 323 | +} | |
| 324 | + | |
| 325 | +/* XXX: unify with C code output ? */ | |
| 326 | +static void gen_expr32(ExprValue *pe) | |
| 327 | +{ | |
| 328 | + if (pe->sym) | |
| 329 | + greloc(cur_text_section, pe->sym, ind, R_386_32); | |
| 330 | + gen_le32(pe->v); | |
| 331 | +} | |
| 332 | + | |
| 333 | +/* XXX: unify with C code output ? */ | |
| 334 | +static void gen_disp32(ExprValue *pe) | |
| 335 | +{ | |
| 336 | + Sym *sym; | |
| 337 | + sym = pe->sym; | |
| 338 | + if (sym) { | |
| 339 | + if (sym->r == cur_text_section->sh_num) { | |
| 340 | + /* same section: we can output an absolute value. Note | |
| 341 | + that the TCC compiler behaves differently here because | |
| 342 | + it always outputs a relocation to ease (future) code | |
| 343 | + elimination in the linker */ | |
| 344 | + gen_le32(pe->v + (long)sym->next - ind - 4); | |
| 345 | + } else { | |
| 346 | + greloc(cur_text_section, sym, ind, R_386_PC32); | |
| 347 | + gen_le32(pe->v - 4); | |
| 348 | + } | |
| 349 | + } else { | |
| 350 | + /* put an empty PC32 relocation */ | |
| 351 | + put_elf_reloc(symtab_section, cur_text_section, | |
| 352 | + ind, R_386_PC32, 0); | |
| 353 | + gen_le32(pe->v - 4); | |
| 354 | + } | |
| 355 | +} | |
| 356 | + | |
| 357 | + | |
| 358 | +static void gen_le16(int v) | |
| 359 | +{ | |
| 360 | + g(v); | |
| 361 | + g(v >> 8); | |
| 362 | +} | |
| 363 | + | |
| 364 | +/* generate the modrm operand */ | |
| 365 | +static inline void asm_modrm(int reg, Operand *op) | |
| 366 | +{ | |
| 367 | + int mod, reg1, reg2; | |
| 368 | + | |
| 369 | + if (op->type & (OP_REG | OP_MMX | OP_SSE)) { | |
| 370 | + g(0xc0 + (reg << 3) + op->reg); | |
| 371 | + } else if (op->reg == -1 && op->reg2 == -1) { | |
| 372 | + /* displacement only */ | |
| 373 | + g(0x05 + (reg << 3)); | |
| 374 | + gen_expr32(&op->e); | |
| 375 | + } else { | |
| 376 | + /* fist compute displacement encoding */ | |
| 377 | + if (op->e.v == 0 && !op->e.sym && op->reg != 5) { | |
| 378 | + mod = 0x00; | |
| 379 | + } else if (op->e.v == (int8_t)op->e.v && !op->e.sym) { | |
| 380 | + mod = 0x40; | |
| 381 | + } else { | |
| 382 | + mod = 0x80; | |
| 383 | + } | |
| 384 | + /* compute if sib byte needed */ | |
| 385 | + reg1 = op->reg; | |
| 386 | + if (op->reg2 != -1) | |
| 387 | + reg1 = 4; | |
| 388 | + g(mod + (reg << 3) + reg1); | |
| 389 | + if (reg1 == 4) { | |
| 390 | + /* add sib byte */ | |
| 391 | + reg2 = op->reg2; | |
| 392 | + if (reg2 == -1) | |
| 393 | + reg2 = 4; /* indicate no index */ | |
| 394 | + g((op->shift << 6) + (reg2 << 3) + op->reg); | |
| 395 | + } | |
| 396 | + | |
| 397 | + /* add offset */ | |
| 398 | + if (mod == 0x40) { | |
| 399 | + g(op->e.v); | |
| 400 | + } else if (mod == 0x80) { | |
| 401 | + gen_expr32(&op->e); | |
| 402 | + } | |
| 403 | + } | |
| 404 | +} | |
| 405 | + | |
| 406 | +static void asm_opcode(TCCState *s1, int opcode) | |
| 407 | +{ | |
| 408 | + const ASMInstr *pa; | |
| 409 | + int i, modrm_index, reg, v, op1, is_short_jmp; | |
| 410 | + int nb_ops, s, ss; | |
| 411 | + Operand ops[MAX_OPERANDS], *pop; | |
| 412 | + int op_type[3]; /* decoded op type */ | |
| 413 | + | |
| 414 | + /* get operands */ | |
| 415 | + pop = ops; | |
| 416 | + nb_ops = 0; | |
| 417 | + for(;;) { | |
| 418 | + if (tok == ';' || tok == TOK_LINEFEED) | |
| 419 | + break; | |
| 420 | + if (nb_ops >= MAX_OPERANDS) { | |
| 421 | + error("incorrect number of operands"); | |
| 422 | + } | |
| 423 | + parse_operand(s1, pop); | |
| 424 | + pop++; | |
| 425 | + nb_ops++; | |
| 426 | + if (tok != ',') | |
| 427 | + break; | |
| 428 | + next(); | |
| 429 | + } | |
| 430 | + | |
| 431 | + is_short_jmp = 0; | |
| 432 | + s = 0; /* avoid warning */ | |
| 433 | + | |
| 434 | + /* optimize matching by using a lookup table (no hashing is needed | |
| 435 | + !) */ | |
| 436 | + for(pa = asm_instrs; pa->sym != 0; pa++) { | |
| 437 | + s = 0; | |
| 438 | + if (pa->instr_type & OPC_FARITH) { | |
| 439 | + v = opcode - pa->sym; | |
| 440 | + if (!((unsigned)v < 8 * 6 && (v % 6) == 0)) | |
| 441 | + continue; | |
| 442 | + } else if (pa->instr_type & OPC_ARITH) { | |
| 443 | + if (!(opcode >= pa->sym && opcode < pa->sym + 8 * 4)) | |
| 444 | + continue; | |
| 445 | + goto compute_size; | |
| 446 | + } else if (pa->instr_type & OPC_SHIFT) { | |
| 447 | + if (!(opcode >= pa->sym && opcode < pa->sym + 7 * 4)) | |
| 448 | + continue; | |
| 449 | + goto compute_size; | |
| 450 | + } else if (pa->instr_type & OPC_TEST) { | |
| 451 | + if (!(opcode >= pa->sym && opcode < pa->sym + NB_TEST_OPCODES)) | |
| 452 | + continue; | |
| 453 | + } else if (pa->instr_type & OPC_B) { | |
| 454 | + if (!(opcode >= pa->sym && opcode <= pa->sym + 3)) | |
| 455 | + continue; | |
| 456 | + compute_size: | |
| 457 | + s = (opcode - pa->sym) & 3; | |
| 458 | + } else if (pa->instr_type & OPC_WL) { | |
| 459 | + if (!(opcode >= pa->sym && opcode <= pa->sym + 2)) | |
| 460 | + continue; | |
| 461 | + s = opcode - pa->sym + 1; | |
| 462 | + } else { | |
| 463 | + if (pa->sym != opcode) | |
| 464 | + continue; | |
| 465 | + } | |
| 466 | + if (pa->nb_ops != nb_ops) | |
| 467 | + continue; | |
| 468 | + /* now decode and check each operand */ | |
| 469 | + for(i = 0; i < nb_ops; i++) { | |
| 470 | + int op1, op2; | |
| 471 | + op1 = pa->op_type[i]; | |
| 472 | + op2 = op1 & 0x1f; | |
| 473 | + switch(op2) { | |
| 474 | + case OPT_IM: | |
| 475 | + v = OP_IM8 | OP_IM16 | OP_IM32; | |
| 476 | + break; | |
| 477 | + case OPT_REG: | |
| 478 | + v = OP_REG8 | OP_REG16 | OP_REG32; | |
| 479 | + break; | |
| 480 | + case OPT_REGW: | |
| 481 | + v = OP_REG16 | OP_REG32; | |
| 482 | + break; | |
| 483 | + case OPT_IMW: | |
| 484 | + v = OP_IM16 | OP_IM32; | |
| 485 | + break; | |
| 486 | + default: | |
| 487 | + v = 1 << op2; | |
| 488 | + break; | |
| 489 | + } | |
| 490 | + if (op1 & OPT_EA) | |
| 491 | + v |= OP_EA; | |
| 492 | + op_type[i] = v; | |
| 493 | + if ((ops[i].type & v) == 0) | |
| 494 | + goto next; | |
| 495 | + } | |
| 496 | + /* all is matching ! */ | |
| 497 | + break; | |
| 498 | + next: ; | |
| 499 | + } | |
| 500 | + if (pa->sym == 0) { | |
| 501 | + if (opcode >= TOK_ASM_pusha && opcode <= TOK_ASM_emms) { | |
| 502 | + int b; | |
| 503 | + b = op0_codes[opcode - TOK_ASM_pusha]; | |
| 504 | + if (b & 0xff00) | |
| 505 | + g(b >> 8); | |
| 506 | + g(b); | |
| 507 | + return; | |
| 508 | + } else { | |
| 509 | + error("unknown opcode '%s'", | |
| 510 | + get_tok_str(opcode, NULL)); | |
| 511 | + } | |
| 512 | + } | |
| 513 | + /* if the size is unknown, then evaluate it (OPC_B or OPC_WL case) */ | |
| 514 | + if (s == 3) { | |
| 515 | + for(i = 0; s == 3 && i < nb_ops; i++) { | |
| 516 | + if ((ops[i].type & OP_REG) && !(op_type[i] & (OP_CL | OP_DX))) | |
| 517 | + s = reg_to_size[ops[i].type & OP_REG]; | |
| 518 | + } | |
| 519 | + if (s == 3) { | |
| 520 | + error("cannot infer opcode suffix"); | |
| 521 | + } | |
| 522 | + } | |
| 523 | + | |
| 524 | + /* generate data16 prefix if needed */ | |
| 525 | + ss = s; | |
| 526 | + if (s == 1 || (pa->instr_type & OPC_D16)) | |
| 527 | + g(WORD_PREFIX_OPCODE); | |
| 528 | + else if (s == 2) | |
| 529 | + s = 1; | |
| 530 | + /* now generates the operation */ | |
| 531 | + if (pa->instr_type & OPC_FWAIT) | |
| 532 | + g(0x9b); | |
| 533 | + | |
| 534 | + v = pa->opcode; | |
| 535 | + if (v == 0x69 || v == 0x69) { | |
| 536 | + /* kludge for imul $im, %reg */ | |
| 537 | + nb_ops = 3; | |
| 538 | + ops[2] = ops[1]; | |
| 539 | + } else if (v == 0xcd && ops[0].e.v == 3 && !ops[0].e.sym) { | |
| 540 | + v--; /* int $3 case */ | |
| 541 | + nb_ops = 0; | |
| 542 | + } else if ((v == 0x06 || v == 0x07)) { | |
| 543 | + if (ops[0].reg >= 4) { | |
| 544 | + /* push/pop %fs or %gs */ | |
| 545 | + v = 0x0fa0 + (v - 0x06) + ((ops[0].reg - 4) << 3); | |
| 546 | + } else { | |
| 547 | + v += ops[0].reg << 3; | |
| 548 | + } | |
| 549 | + nb_ops = 0; | |
| 550 | + } else if (v <= 0x05) { | |
| 551 | + /* arith case */ | |
| 552 | + v += ((opcode - TOK_ASM_addb) >> 2) << 3; | |
| 553 | + } else if ((pa->instr_type & (OPC_FARITH | OPC_MODRM)) == OPC_FARITH) { | |
| 554 | + /* fpu arith case */ | |
| 555 | + v += ((opcode - pa->sym) / 6) << 3; | |
| 556 | + } | |
| 557 | + if (pa->instr_type & OPC_REG) { | |
| 558 | + for(i = 0; i < nb_ops; i++) { | |
| 559 | + if (op_type[i] & (OP_REG | OP_ST)) { | |
| 560 | + v += ops[i].reg; | |
| 561 | + break; | |
| 562 | + } | |
| 563 | + } | |
| 564 | + /* mov $im, %reg case */ | |
| 565 | + if (pa->opcode == 0xb0 && s >= 1) | |
| 566 | + v += 7; | |
| 567 | + } | |
| 568 | + if (pa->instr_type & OPC_B) | |
| 569 | + v += s; | |
| 570 | + if (pa->instr_type & OPC_TEST) | |
| 571 | + v += test_bits[opcode - pa->sym]; | |
| 572 | + if (pa->instr_type & OPC_SHORTJMP) { | |
| 573 | + Sym *sym; | |
| 574 | + int jmp_disp; | |
| 575 | + | |
| 576 | + /* see if we can really generate the jump with a byte offset */ | |
| 577 | + sym = ops[0].e.sym; | |
| 578 | + if (!sym) | |
| 579 | + goto no_short_jump; | |
| 580 | + if (sym->r != cur_text_section->sh_num) | |
| 581 | + goto no_short_jump; | |
| 582 | + jmp_disp = ops[0].e.v + (long)sym->next - ind - 2; | |
| 583 | + if (jmp_disp == (int8_t)jmp_disp) { | |
| 584 | + /* OK to generate jump */ | |
| 585 | + is_short_jmp = 1; | |
| 586 | + ops[0].e.v = jmp_disp; | |
| 587 | + } else { | |
| 588 | + no_short_jump: | |
| 589 | + if (pa->instr_type & OPC_JMP) { | |
| 590 | + /* long jump will be allowed. need to modify the | |
| 591 | + opcode slightly */ | |
| 592 | + if (v == 0xeb) | |
| 593 | + v = 0xe9; | |
| 594 | + else | |
| 595 | + v += 0x0f10; | |
| 596 | + } else { | |
| 597 | + error("invalid displacement"); | |
| 598 | + } | |
| 599 | + } | |
| 600 | + } | |
| 601 | + op1 = v >> 8; | |
| 602 | + if (op1) | |
| 603 | + g(op1); | |
| 604 | + g(v); | |
| 605 | + | |
| 606 | + /* search which operand will used for modrm */ | |
| 607 | + modrm_index = 0; | |
| 608 | + if (pa->instr_type & OPC_SHIFT) { | |
| 609 | + reg = (opcode - pa->sym) >> 2; | |
| 610 | + if (reg == 6) | |
| 611 | + reg = 7; | |
| 612 | + } else if (pa->instr_type & OPC_ARITH) { | |
| 613 | + reg = (opcode - pa->sym) >> 2; | |
| 614 | + } else if (pa->instr_type & OPC_FARITH) { | |
| 615 | + reg = (opcode - pa->sym) / 6; | |
| 616 | + } else { | |
| 617 | + reg = (pa->instr_type >> OPC_GROUP_SHIFT) & 7; | |
| 618 | + } | |
| 619 | + if (pa->instr_type & OPC_MODRM) { | |
| 620 | + /* first look for an ea operand */ | |
| 621 | + for(i = 0;i < nb_ops; i++) { | |
| 622 | + if (op_type[i] & OP_EA) | |
| 623 | + goto modrm_found; | |
| 624 | + } | |
| 625 | + /* then if not found, a register or indirection (shift instructions) */ | |
| 626 | + for(i = 0;i < nb_ops; i++) { | |
| 627 | + if (op_type[i] & (OP_REG | OP_MMX | OP_SSE | OP_INDIR)) | |
| 628 | + goto modrm_found; | |
| 629 | + } | |
| 630 | +#ifdef ASM_DEBUG | |
| 631 | + error("bad op table"); | |
| 632 | +#endif | |
| 633 | + modrm_found: | |
| 634 | + modrm_index = i; | |
| 635 | + /* if a register is used in another operand then it is | |
| 636 | + used instead of group */ | |
| 637 | + for(i = 0;i < nb_ops; i++) { | |
| 638 | + v = op_type[i]; | |
| 639 | + if (i != modrm_index && | |
| 640 | + (v & (OP_REG | OP_MMX | OP_SSE | OP_CR | OP_TR | OP_DB | OP_SEG))) { | |
| 641 | + reg = ops[i].reg; | |
| 642 | + break; | |
| 643 | + } | |
| 644 | + } | |
| 645 | + | |
| 646 | + asm_modrm(reg, &ops[modrm_index]); | |
| 647 | + } | |
| 648 | + | |
| 649 | + /* emit constants */ | |
| 650 | + if (pa->opcode == 0x9a || pa->opcode == 0xea) { | |
| 651 | + /* ljmp or lcall kludge */ | |
| 652 | + gen_expr32(&ops[1].e); | |
| 653 | + if (ops[0].e.sym) | |
| 654 | + error("cannot relocate"); | |
| 655 | + gen_le16(ops[0].e.v); | |
| 656 | + } else { | |
| 657 | + for(i = 0;i < nb_ops; i++) { | |
| 658 | + v = op_type[i]; | |
| 659 | + if (v & (OP_IM8 | OP_IM16 | OP_IM32 | OP_IM8S | OP_ADDR)) { | |
| 660 | + /* if multiple sizes are given it means we must look | |
| 661 | + at the op size */ | |
| 662 | + if (v == (OP_IM8 | OP_IM16 | OP_IM32) || | |
| 663 | + v == (OP_IM16 | OP_IM32)) { | |
| 664 | + if (ss == 0) | |
| 665 | + v = OP_IM8; | |
| 666 | + else if (ss == 1) | |
| 667 | + v = OP_IM16; | |
| 668 | + else | |
| 669 | + v = OP_IM32; | |
| 670 | + } | |
| 671 | + if (v & (OP_IM8 | OP_IM8S)) { | |
| 672 | + if (ops[i].e.sym) | |
| 673 | + goto error_relocate; | |
| 674 | + g(ops[i].e.v); | |
| 675 | + } else if (v & OP_IM16) { | |
| 676 | + if (ops[i].e.sym) { | |
| 677 | + error_relocate: | |
| 678 | + error("cannot relocate"); | |
| 679 | + } | |
| 680 | + gen_le16(ops[i].e.v); | |
| 681 | + } else { | |
| 682 | + if (pa->instr_type & (OPC_JMP | OPC_SHORTJMP)) { | |
| 683 | + if (is_short_jmp) | |
| 684 | + g(ops[i].e.v); | |
| 685 | + else | |
| 686 | + gen_disp32(&ops[i].e); | |
| 687 | + } else { | |
| 688 | + gen_expr32(&ops[i].e); | |
| 689 | + } | |
| 690 | + } | |
| 691 | + } | |
| 692 | + } | |
| 693 | + } | |
| 694 | +} | |
| 695 | + | |
| 696 | +#define NB_SAVED_REGS 3 | |
| 697 | +#define NB_ASM_REGS 8 | |
| 698 | + | |
| 699 | +/* return the constraint priority (we allocate first the lowest | |
| 700 | + numbered constraints) */ | |
| 701 | +static inline int constraint_priority(const char *str) | |
| 702 | +{ | |
| 703 | + int priority, c, pr; | |
| 704 | + | |
| 705 | + /* we take the lowest priority */ | |
| 706 | + priority = 0; | |
| 707 | + for(;;) { | |
| 708 | + c = *str; | |
| 709 | + if (c == '\0') | |
| 710 | + break; | |
| 711 | + str++; | |
| 712 | + switch(c) { | |
| 713 | + case 'a': | |
| 714 | + case 'b': | |
| 715 | + case 'c': | |
| 716 | + case 'd': | |
| 717 | + case 'S': | |
| 718 | + case 'D': | |
| 719 | + pr = 0; | |
| 720 | + break; | |
| 721 | + case 'q': | |
| 722 | + pr = 1; | |
| 723 | + break; | |
| 724 | + case 'r': | |
| 725 | + pr = 2; | |
| 726 | + break; | |
| 727 | + case 'N': | |
| 728 | + case 'M': | |
| 729 | + case 'I': | |
| 730 | + case 'i': | |
| 731 | + case 'm': | |
| 732 | + case 'g': | |
| 733 | + pr = 3; | |
| 734 | + break; | |
| 735 | + default: | |
| 736 | + error("unknown constraint '%c'", c); | |
| 737 | + pr = 0; | |
| 738 | + } | |
| 739 | + if (pr > priority) | |
| 740 | + priority = pr; | |
| 741 | + } | |
| 742 | + return priority; | |
| 743 | +} | |
| 744 | + | |
| 745 | +static void asm_compute_constraints(uint8_t *regs_allocated, | |
| 746 | + ASMOperand *operands, | |
| 747 | + int nb_operands1, int nb_outputs, | |
| 748 | + int is_output, | |
| 749 | + uint8_t *input_regs_allocated) | |
| 750 | +{ | |
| 751 | + ASMOperand *op; | |
| 752 | + int sorted_op[MAX_ASM_OPERANDS]; | |
| 753 | + int i, j, k, p1, p2, tmp, reg, c, base, nb_operands; | |
| 754 | + const char *str; | |
| 755 | + | |
| 756 | + if (is_output) { | |
| 757 | + base = 0; | |
| 758 | + nb_operands = nb_outputs; | |
| 759 | + } else { | |
| 760 | + base = nb_outputs; | |
| 761 | + nb_operands = nb_operands1 - nb_outputs; | |
| 762 | + } | |
| 763 | + | |
| 764 | + /* compute constraint priority and evaluate references to output | |
| 765 | + constraints if input constraints */ | |
| 766 | + for(i=0;i<nb_operands;i++) { | |
| 767 | + j = base + i; | |
| 768 | + op = &operands[j]; | |
| 769 | + str = op->constraint; | |
| 770 | + op->ref_index = -1; | |
| 771 | + op->reg = -1; | |
| 772 | + if (!is_output && (isnum(*str) || *str == '[')) { | |
| 773 | + /* this is a reference to another constraint */ | |
| 774 | + k = find_constraint(operands, nb_operands1, str, NULL); | |
| 775 | + if ((unsigned)k >= j) | |
| 776 | + error("invalid reference in constraint %d ('%s')", | |
| 777 | + j, str); | |
| 778 | + op->ref_index = k; | |
| 779 | + str = operands[k].constraint; | |
| 780 | + } | |
| 781 | + while (*str == '=' || *str == '&' || *str == '+') | |
| 782 | + str++; | |
| 783 | + op->priority = constraint_priority(str); | |
| 784 | + } | |
| 785 | + | |
| 786 | + /* sort operands according to their priority */ | |
| 787 | + for(i=0;i<nb_operands;i++) | |
| 788 | + sorted_op[i] = base + i; | |
| 789 | + for(i=0;i<nb_operands - 1;i++) { | |
| 790 | + for(j=i+1;j<nb_operands;j++) { | |
| 791 | + p1 = operands[sorted_op[i]].priority; | |
| 792 | + p2 = operands[sorted_op[j]].priority; | |
| 793 | + if (p2 < p1) { | |
| 794 | + tmp = sorted_op[i]; | |
| 795 | + sorted_op[i] = sorted_op[j]; | |
| 796 | + sorted_op[j] = tmp; | |
| 797 | + } | |
| 798 | + } | |
| 799 | + } | |
| 800 | + | |
| 801 | + memset(regs_allocated, 0, NB_ASM_REGS); | |
| 802 | + regs_allocated[4] = 1; /* esp cannot be used */ | |
| 803 | + regs_allocated[5] = 1; /* ebp cannot be used yet */ | |
| 804 | + | |
| 805 | + /* allocate registers and generate corresponding asm moves */ | |
| 806 | + for(i=0;i<nb_operands;i++) { | |
| 807 | + j = sorted_op[i]; | |
| 808 | + op = &operands[j]; | |
| 809 | + str = op->constraint; | |
| 810 | + | |
| 811 | + if (op->ref_index >= 0) { | |
| 812 | + str = operands[op->ref_index].constraint; | |
| 813 | + } | |
| 814 | + | |
| 815 | + while (*str == '=' || *str == '&' || *str == '+') | |
| 816 | + str++; | |
| 817 | + try_next: | |
| 818 | + c = *str++; | |
| 819 | + switch(c) { | |
| 820 | + case 'a': | |
| 821 | + reg = TREG_EAX; | |
| 822 | + goto alloc_reg; | |
| 823 | + case 'b': | |
| 824 | + reg = 3; | |
| 825 | + goto alloc_reg; | |
| 826 | + case 'c': | |
| 827 | + reg = TREG_ECX; | |
| 828 | + goto alloc_reg; | |
| 829 | + case 'd': | |
| 830 | + reg = TREG_EDX; | |
| 831 | + goto alloc_reg; | |
| 832 | + case 'S': | |
| 833 | + reg = 6; | |
| 834 | + goto alloc_reg; | |
| 835 | + case 'D': | |
| 836 | + reg = 7; | |
| 837 | + alloc_reg: | |
| 838 | + if (regs_allocated[reg]) | |
| 839 | + goto try_next; | |
| 840 | + goto reg_found; | |
| 841 | + case 'q': | |
| 842 | + /* eax, ebx, ecx or edx */ | |
| 843 | + for(reg = 0; reg < 4; reg++) { | |
| 844 | + if (!regs_allocated[reg]) | |
| 845 | + goto reg_found; | |
| 846 | + } | |
| 847 | + goto try_next; | |
| 848 | + case 'r': | |
| 849 | + /* any general register */ | |
| 850 | + for(reg = 0; reg < 8; reg++) { | |
| 851 | + if (!regs_allocated[reg]) | |
| 852 | + goto reg_found; | |
| 853 | + } | |
| 854 | + goto try_next; | |
| 855 | + reg_found: | |
| 856 | + /* now we can reload in the register */ | |
| 857 | + op->reg = reg; | |
| 858 | + regs_allocated[reg] = 1; | |
| 859 | + break; | |
| 860 | + case 'i': | |
| 861 | + if (!((op->vt->r & (VT_VALMASK | VT_LVAL)) == VT_CONST)) | |
| 862 | + goto try_next; | |
| 863 | + break; | |
| 864 | + case 'I': | |
| 865 | + case 'N': | |
| 866 | + case 'M': | |
| 867 | + if (!((op->vt->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST)) | |
| 868 | + goto try_next; | |
| 869 | + break; | |
| 870 | + case 'm': | |
| 871 | + case 'g': | |
| 872 | + /* nothing special to do because the operand is | |
| 873 | + already in memory */ | |
| 874 | + /* XXX: fix constant case */ | |
| 875 | + if (is_output) { | |
| 876 | + /* if it is a reference to a memory zone, it must lie | |
| 877 | + in a register, so we reserve the register in the | |
| 878 | + input registers and a load will be generated | |
| 879 | + later */ | |
| 880 | + if ((op->vt->r & VT_VALMASK) == VT_LLOCAL) { | |
| 881 | + /* any general register */ | |
| 882 | + for(reg = 0; reg < 8; reg++) { | |
| 883 | + if (!input_regs_allocated[reg]) | |
| 884 | + goto reg_found1; | |
| 885 | + } | |
| 886 | + goto try_next; | |
| 887 | + reg_found1: | |
| 888 | + /* now we can reload in the register */ | |
| 889 | + input_regs_allocated[reg] = 1; | |
| 890 | + op->reg = reg; | |
| 891 | + } | |
| 892 | + } | |
| 893 | + break; | |
| 894 | + default: | |
| 895 | + error("asm constraint %d ('%s') could not be satisfied", | |
| 896 | + j, op->constraint); | |
| 897 | + break; | |
| 898 | + } | |
| 899 | + } | |
| 900 | + | |
| 901 | + /* print sorted constraints */ | |
| 902 | +#ifdef ASM_DEBUG | |
| 903 | + if (is_output) | |
| 904 | + printf("outputs=\n"); | |
| 905 | + else | |
| 906 | + printf("inputs=\n"); | |
| 907 | + for(i=0;i<nb_operands;i++) { | |
| 908 | + j = sorted_op[i]; | |
| 909 | + op = &operands[j]; | |
| 910 | + printf("%%%d [%s]: \"%s\" r=0x%04x reg=%d\n", | |
| 911 | + j, | |
| 912 | + op->id ? get_tok_str(op->id, NULL) : "", | |
| 913 | + op->constraint, | |
| 914 | + op->vt->r, | |
| 915 | + op->reg); | |
| 916 | + } | |
| 917 | +#endif | |
| 918 | +} | |
| 919 | + | |
| 920 | +static void subst_asm_operand(CString *add_str, | |
| 921 | + SValue *sv, int modifier) | |
| 922 | +{ | |
| 923 | + int r, reg, size, val; | |
| 924 | + char buf[64]; | |
| 925 | + | |
| 926 | + r = sv->r; | |
| 927 | + if ((r & VT_VALMASK) == VT_CONST) { | |
| 928 | + if (!(r & VT_LVAL) && modifier != 'c' && modifier != 'n') | |
| 929 | + cstr_ccat(add_str, '$'); | |
| 930 | + if (r & VT_SYM) { | |
| 931 | + cstr_cat(add_str, get_tok_str(sv->sym->v, NULL)); | |
| 932 | + if (sv->c.i != 0) { | |
| 933 | + cstr_ccat(add_str, '+'); | |
| 934 | + } else { | |
| 935 | + return; | |
| 936 | + } | |
| 937 | + } | |
| 938 | + val = sv->c.i; | |
| 939 | + if (modifier == 'n') | |
| 940 | + val = -val; | |
| 941 | + snprintf(buf, sizeof(buf), "%d", sv->c.i); | |
| 942 | + cstr_cat(add_str, buf); | |
| 943 | + } else if ((r & VT_VALMASK) == VT_LOCAL) { | |
| 944 | + snprintf(buf, sizeof(buf), "%d(%%ebp)", sv->c.i); | |
| 945 | + cstr_cat(add_str, buf); | |
| 946 | + } else if (r & VT_LVAL) { | |
| 947 | + reg = r & VT_VALMASK; | |
| 948 | + if (reg >= VT_CONST) | |
| 949 | + error("internal compiler error"); | |
| 950 | + snprintf(buf, sizeof(buf), "(%%%s)", | |
| 951 | + get_tok_str(TOK_ASM_eax + reg, NULL)); | |
| 952 | + cstr_cat(add_str, buf); | |
| 953 | + } else { | |
| 954 | + /* register case */ | |
| 955 | + reg = r & VT_VALMASK; | |
| 956 | + if (reg >= VT_CONST) | |
| 957 | + error("internal compiler error"); | |
| 958 | + | |
| 959 | + /* choose register operand size */ | |
| 960 | + if ((sv->type.t & VT_BTYPE) == VT_BYTE) | |
| 961 | + size = 1; | |
| 962 | + else if ((sv->type.t & VT_BTYPE) == VT_SHORT) | |
| 963 | + size = 2; | |
| 964 | + else | |
| 965 | + size = 4; | |
| 966 | + if (size == 1 && reg >= 4) | |
| 967 | + size = 4; | |
| 968 | + | |
| 969 | + if (modifier == 'b') { | |
| 970 | + if (reg >= 4) | |
| 971 | + error("cannot use byte register"); | |
| 972 | + size = 1; | |
| 973 | + } else if (modifier == 'h') { | |
| 974 | + if (reg >= 4) | |
| 975 | + error("cannot use byte register"); | |
| 976 | + size = -1; | |
| 977 | + } else if (modifier == 'w') { | |
| 978 | + size = 2; | |
| 979 | + } | |
| 980 | + | |
| 981 | + switch(size) { | |
| 982 | + case -1: | |
| 983 | + reg = TOK_ASM_ah + reg; | |
| 984 | + break; | |
| 985 | + case 1: | |
| 986 | + reg = TOK_ASM_al + reg; | |
| 987 | + break; | |
| 988 | + case 2: | |
| 989 | + reg = TOK_ASM_ax + reg; | |
| 990 | + break; | |
| 991 | + default: | |
| 992 | + reg = TOK_ASM_eax + reg; | |
| 993 | + break; | |
| 994 | + } | |
| 995 | + snprintf(buf, sizeof(buf), "%%%s", get_tok_str(reg, NULL)); | |
| 996 | + cstr_cat(add_str, buf); | |
| 997 | + } | |
| 998 | +} | |
| 999 | + | |
| 1000 | +/* generate prolog and epilog code for asm statment */ | |
| 1001 | +static void asm_gen_code(ASMOperand *operands, int nb_operands, | |
| 1002 | + int nb_outputs, int is_output, | |
| 1003 | + uint8_t *clobber_regs) | |
| 1004 | +{ | |
| 1005 | + uint8_t regs_allocated[NB_ASM_REGS]; | |
| 1006 | + ASMOperand *op; | |
| 1007 | + int i, reg; | |
| 1008 | + static uint8_t reg_saved[NB_SAVED_REGS] = { 3, 6, 7 }; | |
| 1009 | + | |
| 1010 | + /* mark all used registers */ | |
| 1011 | + memcpy(regs_allocated, clobber_regs, sizeof(regs_allocated)); | |
| 1012 | + for(i = 0; i < nb_operands;i++) { | |
| 1013 | + op = &operands[i]; | |
| 1014 | + if (op->reg >= 0) | |
| 1015 | + regs_allocated[op->reg] = 1; | |
| 1016 | + } | |
| 1017 | + if (!is_output) { | |
| 1018 | + /* generate reg save code */ | |
| 1019 | + for(i = 0; i < NB_SAVED_REGS; i++) { | |
| 1020 | + reg = reg_saved[i]; | |
| 1021 | + if (regs_allocated[reg]) | |
| 1022 | + g(0x50 + reg); | |
| 1023 | + } | |
| 1024 | + | |
| 1025 | + /* generate load code */ | |
| 1026 | + for(i = nb_outputs ; i < nb_operands; i++) { | |
| 1027 | + op = &operands[i]; | |
| 1028 | + if (op->reg >= 0) { | |
| 1029 | + load(op->reg, op->vt); | |
| 1030 | + } | |
| 1031 | + } | |
| 1032 | + /* generate load code for output memory references */ | |
| 1033 | + for(i = 0 ; i < nb_outputs; i++) { | |
| 1034 | + op = &operands[i]; | |
| 1035 | + if (op->reg >= 0 && ((op->vt->r & VT_VALMASK) == VT_LLOCAL)) { | |
| 1036 | + SValue sv; | |
| 1037 | + sv = *op->vt; | |
| 1038 | + sv.r = (sv.r & ~VT_VALMASK) | VT_LOCAL; | |
| 1039 | + load(op->reg, &sv); | |
| 1040 | + } | |
| 1041 | + } | |
| 1042 | + } else { | |
| 1043 | + /* generate save code */ | |
| 1044 | + for(i = 0 ; i < nb_outputs; i++) { | |
| 1045 | + op = &operands[i]; | |
| 1046 | + if (op->reg >= 0 && ((op->vt->r & VT_VALMASK) != VT_LLOCAL)) { | |
| 1047 | + store(op->reg, op->vt); | |
| 1048 | + } | |
| 1049 | + } | |
| 1050 | + /* generate reg restore code */ | |
| 1051 | + for(i = NB_SAVED_REGS - 1; i >= 0; i--) { | |
| 1052 | + reg = reg_saved[i]; | |
| 1053 | + if (regs_allocated[reg]) | |
| 1054 | + g(0x58 + reg); | |
| 1055 | + } | |
| 1056 | + } | |
| 1057 | +} | |
| 1058 | + | |
| 1059 | +static void asm_clobber(uint8_t *clobber_regs, const char *str) | |
| 1060 | +{ | |
| 1061 | + int reg; | |
| 1062 | + TokenSym *ts; | |
| 1063 | + | |
| 1064 | + if (!strcmp(str, "memory") || | |
| 1065 | + !strcmp(str, "cc")) | |
| 1066 | + return; | |
| 1067 | + ts = tok_alloc(str, strlen(str)); | |
| 1068 | + reg = ts->tok; | |
| 1069 | + if (reg >= TOK_ASM_eax && reg <= TOK_ASM_edi) { | |
| 1070 | + reg -= TOK_ASM_eax; | |
| 1071 | + } else if (reg >= TOK_ASM_ax && reg <= TOK_ASM_di) { | |
| 1072 | + reg -= TOK_ASM_ax; | |
| 1073 | + } else { | |
| 1074 | + error("invalid clobber register '%s'", str); | |
| 1075 | + } | |
| 1076 | + clobber_regs[reg] = 1; | |
| 1077 | +} | |
| @@ -0,0 +1,444 @@ | ||
| 1 | + DEF_ASM_OP0(pusha, 0x60) /* must be first OP0 */ | |
| 2 | + DEF_ASM_OP0(popa, 0x61) | |
| 3 | + DEF_ASM_OP0(clc, 0xf8) | |
| 4 | + DEF_ASM_OP0(cld, 0xfc) | |
| 5 | + DEF_ASM_OP0(cli, 0xfa) | |
| 6 | + DEF_ASM_OP0(clts, 0x0f06) | |
| 7 | + DEF_ASM_OP0(cmc, 0xf5) | |
| 8 | + DEF_ASM_OP0(lahf, 0x9f) | |
| 9 | + DEF_ASM_OP0(sahf, 0x9e) | |
| 10 | + DEF_ASM_OP0(pushfl, 0x9c) | |
| 11 | + DEF_ASM_OP0(popfl, 0x9d) | |
| 12 | + DEF_ASM_OP0(pushf, 0x9c) | |
| 13 | + DEF_ASM_OP0(popf, 0x9d) | |
| 14 | + DEF_ASM_OP0(stc, 0xf9) | |
| 15 | + DEF_ASM_OP0(std, 0xfd) | |
| 16 | + DEF_ASM_OP0(sti, 0xfb) | |
| 17 | + DEF_ASM_OP0(aaa, 0x37) | |
| 18 | + DEF_ASM_OP0(aas, 0x3f) | |
| 19 | + DEF_ASM_OP0(daa, 0x27) | |
| 20 | + DEF_ASM_OP0(das, 0x2f) | |
| 21 | + DEF_ASM_OP0(aad, 0xd50a) | |
| 22 | + DEF_ASM_OP0(aam, 0xd40a) | |
| 23 | + DEF_ASM_OP0(cbw, 0x6698) | |
| 24 | + DEF_ASM_OP0(cwd, 0x6699) | |
| 25 | + DEF_ASM_OP0(cwde, 0x98) | |
| 26 | + DEF_ASM_OP0(cdq, 0x99) | |
| 27 | + DEF_ASM_OP0(cbtw, 0x6698) | |
| 28 | + DEF_ASM_OP0(cwtl, 0x98) | |
| 29 | + DEF_ASM_OP0(cwtd, 0x6699) | |
| 30 | + DEF_ASM_OP0(cltd, 0x99) | |
| 31 | + DEF_ASM_OP0(int3, 0xcc) | |
| 32 | + DEF_ASM_OP0(into, 0xce) | |
| 33 | + DEF_ASM_OP0(iret, 0xcf) | |
| 34 | + DEF_ASM_OP0(rsm, 0x0faa) | |
| 35 | + DEF_ASM_OP0(hlt, 0xf4) | |
| 36 | + DEF_ASM_OP0(wait, 0x9b) | |
| 37 | + DEF_ASM_OP0(nop, 0x90) | |
| 38 | + DEF_ASM_OP0(xlat, 0xd7) | |
| 39 | + | |
| 40 | + /* strings */ | |
| 41 | +ALT(DEF_ASM_OP0L(cmpsb, 0xa6, 0, OPC_BWL)) | |
| 42 | +ALT(DEF_ASM_OP0L(scmpb, 0xa6, 0, OPC_BWL)) | |
| 43 | + | |
| 44 | +ALT(DEF_ASM_OP0L(insb, 0x6c, 0, OPC_BWL)) | |
| 45 | +ALT(DEF_ASM_OP0L(outsb, 0x6e, 0, OPC_BWL)) | |
| 46 | + | |
| 47 | +ALT(DEF_ASM_OP0L(lodsb, 0xac, 0, OPC_BWL)) | |
| 48 | +ALT(DEF_ASM_OP0L(slodb, 0xac, 0, OPC_BWL)) | |
| 49 | + | |
| 50 | +ALT(DEF_ASM_OP0L(movsb, 0xa4, 0, OPC_BWL)) | |
| 51 | +ALT(DEF_ASM_OP0L(smovb, 0xa4, 0, OPC_BWL)) | |
| 52 | + | |
| 53 | +ALT(DEF_ASM_OP0L(scasb, 0xae, 0, OPC_BWL)) | |
| 54 | +ALT(DEF_ASM_OP0L(sscab, 0xae, 0, OPC_BWL)) | |
| 55 | + | |
| 56 | +ALT(DEF_ASM_OP0L(stosb, 0xaa, 0, OPC_BWL)) | |
| 57 | +ALT(DEF_ASM_OP0L(sstob, 0xaa, 0, OPC_BWL)) | |
| 58 | + | |
| 59 | + /* bits */ | |
| 60 | + | |
| 61 | +ALT(DEF_ASM_OP2(bsfw, 0x0fbc, 0, OPC_MODRM | OPC_WL, OPT_REGW | OPT_EA, OPT_REGW)) | |
| 62 | +ALT(DEF_ASM_OP2(bsrw, 0x0fbd, 0, OPC_MODRM | OPC_WL, OPT_REGW | OPT_EA, OPT_REGW)) | |
| 63 | + | |
| 64 | +ALT(DEF_ASM_OP2(btw, 0x0fa3, 0, OPC_MODRM | OPC_WL, OPT_REGW, OPT_REGW | OPT_EA)) | |
| 65 | +ALT(DEF_ASM_OP2(btw, 0x0fba, 4, OPC_MODRM | OPC_WL, OPT_IM8, OPT_REGW | OPT_EA)) | |
| 66 | + | |
| 67 | +ALT(DEF_ASM_OP2(btsw, 0x0fab, 0, OPC_MODRM | OPC_WL, OPT_REGW, OPT_REGW | OPT_EA)) | |
| 68 | +ALT(DEF_ASM_OP2(btsw, 0x0fba, 5, OPC_MODRM | OPC_WL, OPT_IM8, OPT_REGW | OPT_EA)) | |
| 69 | + | |
| 70 | +ALT(DEF_ASM_OP2(btrw, 0x0fb3, 0, OPC_MODRM | OPC_WL, OPT_REGW, OPT_REGW | OPT_EA)) | |
| 71 | +ALT(DEF_ASM_OP2(btrw, 0x0fba, 6, OPC_MODRM | OPC_WL, OPT_IM8, OPT_REGW | OPT_EA)) | |
| 72 | + | |
| 73 | +ALT(DEF_ASM_OP2(btcw, 0x0fbb, 0, OPC_MODRM | OPC_WL, OPT_REGW, OPT_REGW | OPT_EA)) | |
| 74 | +ALT(DEF_ASM_OP2(btcw, 0x0fba, 7, OPC_MODRM | OPC_WL, OPT_IM8, OPT_REGW | OPT_EA)) | |
| 75 | + | |
| 76 | + /* prefixes */ | |
| 77 | + DEF_ASM_OP0(aword, 0x67) | |
| 78 | + DEF_ASM_OP0(addr16, 0x67) | |
| 79 | + DEF_ASM_OP0(word, 0x66) | |
| 80 | + DEF_ASM_OP0(data16, 0x66) | |
| 81 | + DEF_ASM_OP0(lock, 0xf0) | |
| 82 | + DEF_ASM_OP0(rep, 0xf3) | |
| 83 | + DEF_ASM_OP0(repe, 0xf3) | |
| 84 | + DEF_ASM_OP0(repz, 0xf3) | |
| 85 | + DEF_ASM_OP0(repne, 0xf2) | |
| 86 | + DEF_ASM_OP0(repnz, 0xf2) | |
| 87 | + | |
| 88 | + DEF_ASM_OP0(invd, 0x0f08) | |
| 89 | + DEF_ASM_OP0(wbinvd, 0x0f09) | |
| 90 | + DEF_ASM_OP0(cpuid, 0x0fa2) | |
| 91 | + DEF_ASM_OP0(wrmsr, 0x0f30) | |
| 92 | + DEF_ASM_OP0(rdtsc, 0x0f31) | |
| 93 | + DEF_ASM_OP0(rdmsr, 0x0f32) | |
| 94 | + DEF_ASM_OP0(rdpmc, 0x0f33) | |
| 95 | + DEF_ASM_OP0(ud2, 0x0f0b) | |
| 96 | + | |
| 97 | + /* NOTE: we took the same order as gas opcode definition order */ | |
| 98 | +ALT(DEF_ASM_OP2(movb, 0xa0, 0, OPC_BWL, OPT_ADDR, OPT_EAX)) | |
| 99 | +ALT(DEF_ASM_OP2(movb, 0xa2, 0, OPC_BWL, OPT_EAX, OPT_ADDR)) | |
| 100 | +ALT(DEF_ASM_OP2(movb, 0x88, 0, OPC_MODRM | OPC_BWL, OPT_REG, OPT_EA | OPT_REG)) | |
| 101 | +ALT(DEF_ASM_OP2(movb, 0x8a, 0, OPC_MODRM | OPC_BWL, OPT_EA | OPT_REG, OPT_REG)) | |
| 102 | +ALT(DEF_ASM_OP2(movb, 0xb0, 0, OPC_REG | OPC_BWL, OPT_IM, OPT_REG)) | |
| 103 | +ALT(DEF_ASM_OP2(movb, 0xc6, 0, OPC_MODRM | OPC_BWL, OPT_IM, OPT_REG | OPT_EA)) | |
| 104 | + | |
| 105 | +ALT(DEF_ASM_OP2(movw, 0x8c, 0, OPC_MODRM | OPC_WL, OPT_SEG, OPT_EA | OPT_REG)) | |
| 106 | +ALT(DEF_ASM_OP2(movw, 0x8e, 0, OPC_MODRM | OPC_WL, OPT_EA | OPT_REG, OPT_SEG)) | |
| 107 | + | |
| 108 | +ALT(DEF_ASM_OP2(movw, 0x0f20, 0, OPC_MODRM | OPC_WL, OPT_CR, OPT_REG32)) | |
| 109 | +ALT(DEF_ASM_OP2(movw, 0x0f21, 0, OPC_MODRM | OPC_WL, OPT_DB, OPT_REG32)) | |
| 110 | +ALT(DEF_ASM_OP2(movw, 0x0f24, 0, OPC_MODRM | OPC_WL, OPT_TR, OPT_REG32)) | |
| 111 | +ALT(DEF_ASM_OP2(movw, 0x0f22, 0, OPC_MODRM | OPC_WL, OPT_REG32, OPT_CR)) | |
| 112 | +ALT(DEF_ASM_OP2(movw, 0x0f23, 0, OPC_MODRM | OPC_WL, OPT_REG32, OPT_DB)) | |
| 113 | +ALT(DEF_ASM_OP2(movw, 0x0f26, 0, OPC_MODRM | OPC_WL, OPT_REG32, OPT_TR)) | |
| 114 | + | |
| 115 | +ALT(DEF_ASM_OP2(movsbl, 0x0fbe, 0, OPC_MODRM, OPT_REG8 | OPT_EA, OPT_REG32)) | |
| 116 | +ALT(DEF_ASM_OP2(movsbw, 0x0fbe, 0, OPC_MODRM | OPC_D16, OPT_REG8 | OPT_EA, OPT_REG16)) | |
| 117 | +ALT(DEF_ASM_OP2(movswl, 0x0fbf, 0, OPC_MODRM, OPT_REG16 | OPT_EA, OPT_REG32)) | |
| 118 | +ALT(DEF_ASM_OP2(movzbw, 0x0fb6, 0, OPC_MODRM | OPC_WL, OPT_REG8 | OPT_EA, OPT_REGW)) | |
| 119 | +ALT(DEF_ASM_OP2(movzwl, 0x0fb7, 0, OPC_MODRM, OPT_REG16 | OPT_EA, OPT_REG32)) | |
| 120 | + | |
| 121 | +ALT(DEF_ASM_OP1(pushw, 0x50, 0, OPC_REG | OPC_WL, OPT_REGW)) | |
| 122 | +ALT(DEF_ASM_OP1(pushw, 0xff, 6, OPC_MODRM | OPC_WL, OPT_REGW | OPT_EA)) | |
| 123 | +ALT(DEF_ASM_OP1(push, 0x6a, 0, 0, OPT_IM8S)) | |
| 124 | +ALT(DEF_ASM_OP1(push, 0x68, 0, 0, OPT_IM32)) | |
| 125 | +ALT(DEF_ASM_OP1(push, 0x06, 0, 0, OPT_SEG)) | |
| 126 | + | |
| 127 | +ALT(DEF_ASM_OP1(popw, 0x58, 0, OPC_REG | OPC_WL, OPT_REGW)) | |
| 128 | +ALT(DEF_ASM_OP1(popw, 0x8f, 0, OPC_MODRM | OPC_WL, OPT_REGW | OPT_EA)) | |
| 129 | +ALT(DEF_ASM_OP1(pop, 0x07, 0, 0, OPT_SEG)) | |
| 130 | + | |
| 131 | +ALT(DEF_ASM_OP2(xchgw, 0x90, 0, OPC_REG | OPC_WL, OPT_REG, OPT_EAX)) | |
| 132 | +ALT(DEF_ASM_OP2(xchgw, 0x90, 0, OPC_REG | OPC_WL, OPT_EAX, OPT_REG)) | |
| 133 | +ALT(DEF_ASM_OP2(xchgb, 0x86, 0, OPC_MODRM | OPC_BWL, OPT_REG, OPT_EA | OPT_REG)) | |
| 134 | +ALT(DEF_ASM_OP2(xchgb, 0x86, 0, OPC_MODRM | OPC_BWL, OPT_EA | OPT_REG, OPT_REG)) | |
| 135 | + | |
| 136 | +ALT(DEF_ASM_OP2(inb, 0xe4, 0, OPC_BWL, OPT_IM8, OPT_EAX)) | |
| 137 | +ALT(DEF_ASM_OP1(inb, 0xe4, 0, OPC_BWL, OPT_IM8)) | |
| 138 | +ALT(DEF_ASM_OP2(inb, 0xec, 0, OPC_BWL, OPT_DX, OPT_EAX)) | |
| 139 | +ALT(DEF_ASM_OP1(inb, 0xec, 0, OPC_BWL, OPT_DX)) | |
| 140 | + | |
| 141 | +ALT(DEF_ASM_OP2(outb, 0xe6, 0, OPC_BWL, OPT_EAX, OPT_IM8)) | |
| 142 | +ALT(DEF_ASM_OP1(outb, 0xe6, 0, OPC_BWL, OPT_IM8)) | |
| 143 | +ALT(DEF_ASM_OP2(outb, 0xee, 0, OPC_BWL, OPT_EAX, OPT_DX)) | |
| 144 | +ALT(DEF_ASM_OP1(outb, 0xee, 0, OPC_BWL, OPT_DX)) | |
| 145 | + | |
| 146 | +ALT(DEF_ASM_OP2(leaw, 0x8d, 0, OPC_MODRM | OPC_WL, OPT_EA, OPT_REG)) | |
| 147 | + | |
| 148 | +ALT(DEF_ASM_OP2(les, 0xc4, 0, OPC_MODRM, OPT_EA, OPT_REG32)) | |
| 149 | +ALT(DEF_ASM_OP2(lds, 0xc5, 0, OPC_MODRM, OPT_EA, OPT_REG32)) | |
| 150 | +ALT(DEF_ASM_OP2(lss, 0x0fb2, 0, OPC_MODRM, OPT_EA, OPT_REG32)) | |
| 151 | +ALT(DEF_ASM_OP2(lfs, 0x0fb4, 0, OPC_MODRM, OPT_EA, OPT_REG32)) | |
| 152 | +ALT(DEF_ASM_OP2(lgs, 0x0fb5, 0, OPC_MODRM, OPT_EA, OPT_REG32)) | |
| 153 | + | |
| 154 | + /* arith */ | |
| 155 | +ALT(DEF_ASM_OP2(addb, 0x00, 0, OPC_ARITH | OPC_MODRM | OPC_BWL, OPT_REG, OPT_EA | OPT_REG)) /* XXX: use D bit ? */ | |
| 156 | +ALT(DEF_ASM_OP2(addb, 0x02, 0, OPC_ARITH | OPC_MODRM | OPC_BWL, OPT_EA | OPT_REG, OPT_REG)) | |
| 157 | +ALT(DEF_ASM_OP2(addb, 0x04, 0, OPC_ARITH | OPC_BWL, OPT_IM, OPT_EAX)) | |
| 158 | +ALT(DEF_ASM_OP2(addb, 0x80, 0, OPC_ARITH | OPC_MODRM | OPC_BWL, OPT_IM, OPT_EA | OPT_REG)) | |
| 159 | +ALT(DEF_ASM_OP2(addw, 0x83, 0, OPC_ARITH | OPC_MODRM | OPC_WL, OPT_IM8S, OPT_EA | OPT_REG)) | |
| 160 | + | |
| 161 | +ALT(DEF_ASM_OP2(testb, 0x84, 0, OPC_MODRM | OPC_BWL, OPT_EA | OPT_REG, OPT_REG)) | |
| 162 | +ALT(DEF_ASM_OP2(testb, 0x84, 0, OPC_MODRM | OPC_BWL, OPT_REG, OPT_EA | OPT_REG)) | |
| 163 | +ALT(DEF_ASM_OP2(testb, 0xa8, 0, OPC_BWL, OPT_IM, OPT_EAX)) | |
| 164 | +ALT(DEF_ASM_OP2(testb, 0xf6, 0, OPC_MODRM | OPC_BWL, OPT_IM, OPT_EA | OPT_REG)) | |
| 165 | + | |
| 166 | +ALT(DEF_ASM_OP1(incw, 0x40, 0, OPC_REG | OPC_WL, OPT_REGW)) | |
| 167 | +ALT(DEF_ASM_OP1(incb, 0xfe, 0, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 168 | +ALT(DEF_ASM_OP1(decw, 0x48, 0, OPC_REG | OPC_WL, OPT_REGW)) | |
| 169 | +ALT(DEF_ASM_OP1(decb, 0xfe, 1, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 170 | + | |
| 171 | +ALT(DEF_ASM_OP1(notb, 0xf6, 2, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 172 | +ALT(DEF_ASM_OP1(negb, 0xf6, 3, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 173 | + | |
| 174 | +ALT(DEF_ASM_OP1(mulb, 0xf6, 4, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 175 | +ALT(DEF_ASM_OP1(imulb, 0xf6, 5, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 176 | + | |
| 177 | +ALT(DEF_ASM_OP2(imulw, 0x0faf, 0, OPC_MODRM | OPC_WL, OPT_REG | OPT_EA, OPT_REG)) | |
| 178 | +ALT(DEF_ASM_OP3(imulw, 0x6b, 0, OPC_MODRM | OPC_WL, OPT_IM8S, OPT_REGW | OPT_EA, OPT_REGW)) | |
| 179 | +ALT(DEF_ASM_OP2(imulw, 0x6b, 0, OPC_MODRM | OPC_WL, OPT_IM8S, OPT_REGW)) | |
| 180 | +ALT(DEF_ASM_OP3(imulw, 0x69, 0, OPC_MODRM | OPC_WL, OPT_IMW, OPT_REGW | OPT_EA, OPT_REGW)) | |
| 181 | +ALT(DEF_ASM_OP2(imulw, 0x69, 0, OPC_MODRM | OPC_WL, OPT_IMW, OPT_REGW)) | |
| 182 | + | |
| 183 | +ALT(DEF_ASM_OP1(divb, 0xf6, 6, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 184 | +ALT(DEF_ASM_OP2(divb, 0xf6, 6, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA, OPT_EAX)) | |
| 185 | +ALT(DEF_ASM_OP1(idivb, 0xf6, 7, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA)) | |
| 186 | +ALT(DEF_ASM_OP2(idivb, 0xf6, 7, OPC_MODRM | OPC_BWL, OPT_REG | OPT_EA, OPT_EAX)) | |
| 187 | + | |
| 188 | + /* shifts */ | |
| 189 | +ALT(DEF_ASM_OP2(rolb, 0xc0, 0, OPC_MODRM | OPC_BWL | OPC_SHIFT, OPT_IM8, OPT_EA | OPT_REG)) | |
| 190 | +ALT(DEF_ASM_OP2(rolb, 0xd2, 0, OPC_MODRM | OPC_BWL | OPC_SHIFT, OPT_CL, OPT_EA | OPT_REG)) | |
| 191 | +ALT(DEF_ASM_OP1(rolb, 0xd0, 0, OPC_MODRM | OPC_BWL | OPC_SHIFT, OPT_EA | OPT_REG)) | |
| 192 | + | |
| 193 | +ALT(DEF_ASM_OP3(shldw, 0x0fa4, 0, OPC_MODRM | OPC_WL, OPT_IM8, OPT_REGW, OPT_EA | OPT_REGW)) | |
| 194 | +ALT(DEF_ASM_OP3(shldw, 0x0fa5, 0, OPC_MODRM | OPC_WL, OPT_CL, OPT_REGW, OPT_EA | OPT_REGW)) | |
| 195 | +ALT(DEF_ASM_OP2(shldw, 0x0fa5, 0, OPC_MODRM | OPC_WL, OPT_REGW, OPT_EA | OPT_REGW)) | |
| 196 | +ALT(DEF_ASM_OP3(shrdw, 0x0fac, 0, OPC_MODRM | OPC_WL, OPT_IM8, OPT_REGW, OPT_EA | OPT_REGW)) | |
| 197 | +ALT(DEF_ASM_OP3(shrdw, 0x0fad, 0, OPC_MODRM | OPC_WL, OPT_CL, OPT_REGW, OPT_EA | OPT_REGW)) | |
| 198 | +ALT(DEF_ASM_OP2(shrdw, 0x0fad, 0, OPC_MODRM | OPC_WL, OPT_REGW, OPT_EA | OPT_REGW)) | |
| 199 | + | |
| 200 | +ALT(DEF_ASM_OP1(call, 0xff, 2, OPC_MODRM, OPT_INDIR)) | |
| 201 | +ALT(DEF_ASM_OP1(call, 0xe8, 0, OPC_JMP, OPT_ADDR)) | |
| 202 | +ALT(DEF_ASM_OP1(jmp, 0xff, 4, OPC_MODRM, OPT_INDIR)) | |
| 203 | +ALT(DEF_ASM_OP1(jmp, 0xeb, 0, OPC_SHORTJMP | OPC_JMP, OPT_ADDR)) | |
| 204 | + | |
| 205 | +ALT(DEF_ASM_OP2(lcall, 0x9a, 0, 0, OPT_IM16, OPT_IM32)) | |
| 206 | +ALT(DEF_ASM_OP1(lcall, 0xff, 3, 0, OPT_EA)) | |
| 207 | +ALT(DEF_ASM_OP2(ljmp, 0xea, 0, 0, OPT_IM16, OPT_IM32)) | |
| 208 | +ALT(DEF_ASM_OP1(ljmp, 0xff, 5, 0, OPT_EA)) | |
| 209 | + | |
| 210 | +ALT(DEF_ASM_OP1(int, 0xcd, 0, 0, OPT_IM8)) | |
| 211 | +ALT(DEF_ASM_OP1(seto, 0x0f90, 0, OPC_MODRM | OPC_TEST, OPT_REG8 | OPT_EA)) | |
| 212 | + DEF_ASM_OP2(enter, 0xc8, 0, 0, OPT_IM16, OPT_IM8) | |
| 213 | + DEF_ASM_OP0(leave, 0xc9) | |
| 214 | + DEF_ASM_OP0(ret, 0xc3) | |
| 215 | +ALT(DEF_ASM_OP1(ret, 0xc2, 0, 0, OPT_IM16)) | |
| 216 | + DEF_ASM_OP0(lret, 0xcb) | |
| 217 | +ALT(DEF_ASM_OP1(lret, 0xca, 0, 0, OPT_IM16)) | |
| 218 | + | |
| 219 | +ALT(DEF_ASM_OP1(jo, 0x70, 0, OPC_SHORTJMP | OPC_JMP | OPC_TEST, OPT_ADDR)) | |
| 220 | + DEF_ASM_OP1(loopne, 0xe0, 0, OPC_SHORTJMP, OPT_ADDR) | |
| 221 | + DEF_ASM_OP1(loopnz, 0xe0, 0, OPC_SHORTJMP, OPT_ADDR) | |
| 222 | + DEF_ASM_OP1(loope, 0xe1, 0, OPC_SHORTJMP, OPT_ADDR) | |
| 223 | + DEF_ASM_OP1(loopz, 0xe1, 0, OPC_SHORTJMP, OPT_ADDR) | |
| 224 | + DEF_ASM_OP1(loop, 0xe2, 0, OPC_SHORTJMP, OPT_ADDR) | |
| 225 | + DEF_ASM_OP1(jecxz, 0xe3, 0, OPC_SHORTJMP, OPT_ADDR) | |
| 226 | + | |
| 227 | + /* float */ | |
| 228 | + /* specific fcomp handling */ | |
| 229 | +ALT(DEF_ASM_OP0L(fcomp, 0xd8d9, 0, 0)) | |
| 230 | + | |
| 231 | +ALT(DEF_ASM_OP1(fadd, 0xd8c0, 0, OPC_FARITH | OPC_REG, OPT_ST)) | |
| 232 | +ALT(DEF_ASM_OP2(fadd, 0xd8c0, 0, OPC_FARITH | OPC_REG, OPT_ST, OPT_ST0)) | |
| 233 | +ALT(DEF_ASM_OP0L(fadd, 0xdec1, 0, OPC_FARITH)) | |
| 234 | +ALT(DEF_ASM_OP1(faddp, 0xdec0, 0, OPC_FARITH | OPC_REG, OPT_ST)) | |
| 235 | +ALT(DEF_ASM_OP2(faddp, 0xdec0, 0, OPC_FARITH | OPC_REG, OPT_ST, OPT_ST0)) | |
| 236 | +ALT(DEF_ASM_OP2(faddp, 0xdec0, 0, OPC_FARITH | OPC_REG, OPT_ST0, OPT_ST)) | |
| 237 | +ALT(DEF_ASM_OP0L(faddp, 0xdec1, 0, OPC_FARITH)) | |
| 238 | +ALT(DEF_ASM_OP1(fadds, 0xd8, 0, OPC_FARITH | OPC_MODRM, OPT_EA)) | |
| 239 | +ALT(DEF_ASM_OP1(fiaddl, 0xda, 0, OPC_FARITH | OPC_MODRM, OPT_EA)) | |
| 240 | +ALT(DEF_ASM_OP1(faddl, 0xdc, 0, OPC_FARITH | OPC_MODRM, OPT_EA)) | |
| 241 | +ALT(DEF_ASM_OP1(fiadds, 0xde, 0, OPC_FARITH | OPC_MODRM, OPT_EA)) | |
| 242 | + | |
| 243 | + DEF_ASM_OP0(fucompp, 0xdae9) | |
| 244 | + DEF_ASM_OP0(ftst, 0xd9e4) | |
| 245 | + DEF_ASM_OP0(fxam, 0xd9e5) | |
| 246 | + DEF_ASM_OP0(fld1, 0xd9e8) | |
| 247 | + DEF_ASM_OP0(fldl2t, 0xd9e9) | |
| 248 | + DEF_ASM_OP0(fldl2e, 0xd9ea) | |
| 249 | + DEF_ASM_OP0(fldpi, 0xd9eb) | |
| 250 | + DEF_ASM_OP0(fldlg2, 0xd9ec) | |
| 251 | + DEF_ASM_OP0(fldln2, 0xd9ed) | |
| 252 | + DEF_ASM_OP0(fldz, 0xd9ee) | |
| 253 | + | |
| 254 | + DEF_ASM_OP0(f2xm1, 0xd9f0) | |
| 255 | + DEF_ASM_OP0(fyl2x, 0xd9f1) | |
| 256 | + DEF_ASM_OP0(fptan, 0xd9f2) | |
| 257 | + DEF_ASM_OP0(fpatan, 0xd9f3) | |
| 258 | + DEF_ASM_OP0(fxtract, 0xd9f4) | |
| 259 | + DEF_ASM_OP0(fprem1, 0xd9f5) | |
| 260 | + DEF_ASM_OP0(fdecstp, 0xd9f6) | |
| 261 | + DEF_ASM_OP0(fincstp, 0xd9f7) | |
| 262 | + DEF_ASM_OP0(fprem, 0xd9f8) | |
| 263 | + DEF_ASM_OP0(fyl2xp1, 0xd9f9) | |
| 264 | + DEF_ASM_OP0(fsqrt, 0xd9fa) | |
| 265 | + DEF_ASM_OP0(fsincos, 0xd9fb) | |
| 266 | + DEF_ASM_OP0(frndint, 0xd9fc) | |
| 267 | + DEF_ASM_OP0(fscale, 0xd9fd) | |
| 268 | + DEF_ASM_OP0(fsin, 0xd9fe) | |
| 269 | + DEF_ASM_OP0(fcos, 0xd9ff) | |
| 270 | + DEF_ASM_OP0(fchs, 0xd9e0) | |
| 271 | + DEF_ASM_OP0(fabs, 0xd9e1) | |
| 272 | + DEF_ASM_OP0(fninit, 0xdbe3) | |
| 273 | + DEF_ASM_OP0(fnclex, 0xdbe2) | |
| 274 | + DEF_ASM_OP0(fnop, 0xd9d0) | |
| 275 | + DEF_ASM_OP0(fwait, 0x9b) | |
| 276 | + | |
| 277 | + /* fp load */ | |
| 278 | + DEF_ASM_OP1(fld, 0xd9c0, 0, OPC_REG, OPT_ST) | |
| 279 | + DEF_ASM_OP1(fldl, 0xd9c0, 0, OPC_REG, OPT_ST) | |
| 280 | + DEF_ASM_OP1(flds, 0xd9, 0, OPC_MODRM, OPT_EA) | |
| 281 | +ALT(DEF_ASM_OP1(fldl, 0xdd, 0, OPC_MODRM, OPT_EA)) | |
| 282 | + DEF_ASM_OP1(fildl, 0xdb, 0, OPC_MODRM, OPT_EA) | |
| 283 | + DEF_ASM_OP1(fildq, 0xdf, 5, OPC_MODRM, OPT_EA) | |
| 284 | + DEF_ASM_OP1(fildll, 0xdf, 5, OPC_MODRM,OPT_EA) | |
| 285 | + DEF_ASM_OP1(fldt, 0xdb, 5, OPC_MODRM, OPT_EA) | |
| 286 | + DEF_ASM_OP1(fbld, 0xdf, 4, OPC_MODRM, OPT_EA) | |
| 287 | + | |
| 288 | + /* fp store */ | |
| 289 | + DEF_ASM_OP1(fst, 0xddd0, 0, OPC_REG, OPT_ST) | |
| 290 | + DEF_ASM_OP1(fstl, 0xddd0, 0, OPC_REG, OPT_ST) | |
| 291 | + DEF_ASM_OP1(fsts, 0xd9, 2, OPC_MODRM, OPT_EA) | |
| 292 | + DEF_ASM_OP1(fstps, 0xd9, 3, OPC_MODRM, OPT_EA) | |
| 293 | +ALT(DEF_ASM_OP1(fstl, 0xdd, 2, OPC_MODRM, OPT_EA)) | |
| 294 | + DEF_ASM_OP1(fstpl, 0xdd, 3, OPC_MODRM, OPT_EA) | |
| 295 | + DEF_ASM_OP1(fist, 0xdf, 2, OPC_MODRM, OPT_EA) | |
| 296 | + DEF_ASM_OP1(fistp, 0xdf, 3, OPC_MODRM, OPT_EA) | |
| 297 | + DEF_ASM_OP1(fistl, 0xdb, 2, OPC_MODRM, OPT_EA) | |
| 298 | + DEF_ASM_OP1(fistpl, 0xdb, 3, OPC_MODRM, OPT_EA) | |
| 299 | + | |
| 300 | + DEF_ASM_OP1(fstp, 0xddd8, 0, OPC_REG, OPT_ST) | |
| 301 | + DEF_ASM_OP1(fistpq, 0xdf, 7, OPC_MODRM, OPT_EA) | |
| 302 | + DEF_ASM_OP1(fistpll, 0xdf, 7, OPC_MODRM, OPT_EA) | |
| 303 | + DEF_ASM_OP1(fstpt, 0xdb, 7, OPC_MODRM, OPT_EA) | |
| 304 | + DEF_ASM_OP1(fbstp, 0xdf, 6, OPC_MODRM, OPT_EA) | |
| 305 | + | |
| 306 | + /* exchange */ | |
| 307 | + DEF_ASM_OP0(fxch, 0xd9c9) | |
| 308 | +ALT(DEF_ASM_OP1(fxch, 0xd9c8, 0, OPC_REG, OPT_ST)) | |
| 309 | + | |
| 310 | + /* misc FPU */ | |
| 311 | + DEF_ASM_OP1(fucom, 0xdde0, 0, OPC_REG, OPT_ST ) | |
| 312 | + DEF_ASM_OP1(fucomp, 0xdde8, 0, OPC_REG, OPT_ST ) | |
| 313 | + | |
| 314 | + DEF_ASM_OP0L(finit, 0xdbe3, 0, OPC_FWAIT) | |
| 315 | + DEF_ASM_OP1(fldcw, 0xd9, 5, OPC_MODRM, OPT_EA ) | |
| 316 | + DEF_ASM_OP1(fnstcw, 0xd9, 7, OPC_MODRM, OPT_EA ) | |
| 317 | + DEF_ASM_OP1(fstcw, 0xd9, 7, OPC_MODRM | OPC_FWAIT, OPT_EA ) | |
| 318 | + DEF_ASM_OP0(fnstsw, 0xdfe0) | |
| 319 | +ALT(DEF_ASM_OP1(fnstsw, 0xdfe0, 0, 0, OPT_EAX )) | |
| 320 | +ALT(DEF_ASM_OP1(fnstsw, 0xdd, 7, OPC_MODRM, OPT_EA )) | |
| 321 | + DEF_ASM_OP1(fstsw, 0xdfe0, 0, OPC_FWAIT, OPT_EAX ) | |
| 322 | +ALT(DEF_ASM_OP0L(fstsw, 0xdfe0, 0, OPC_FWAIT)) | |
| 323 | +ALT(DEF_ASM_OP1(fstsw, 0xdd, 7, OPC_MODRM | OPC_FWAIT, OPT_EA )) | |
| 324 | + DEF_ASM_OP0L(fclex, 0xdbe2, 0, OPC_FWAIT) | |
| 325 | + DEF_ASM_OP1(fnstenv, 0xd9, 6, OPC_MODRM, OPT_EA ) | |
| 326 | + DEF_ASM_OP1(fstenv, 0xd9, 6, OPC_MODRM | OPC_FWAIT, OPT_EA ) | |
| 327 | + DEF_ASM_OP1(fldenv, 0xd9, 4, OPC_MODRM, OPT_EA ) | |
| 328 | + DEF_ASM_OP1(fnsave, 0xdd, 6, OPC_MODRM, OPT_EA ) | |
| 329 | + DEF_ASM_OP1(fsave, 0xdd, 6, OPC_MODRM | OPC_FWAIT, OPT_EA ) | |
| 330 | + DEF_ASM_OP1(frstor, 0xdd, 4, OPC_MODRM, OPT_EA ) | |
| 331 | + DEF_ASM_OP1(ffree, 0xddc0, 4, OPC_REG, OPT_ST ) | |
| 332 | + DEF_ASM_OP1(ffreep, 0xdfc0, 4, OPC_REG, OPT_ST ) | |
| 333 | + | |
| 334 | + /* segments */ | |
| 335 | + DEF_ASM_OP2(arpl, 0x63, 0, OPC_MODRM, OPT_REG16, OPT_REG16 | OPT_EA) | |
| 336 | + DEF_ASM_OP2(lar, 0x0f02, 0, OPC_MODRM, OPT_REG32 | OPT_EA, OPT_REG32) | |
| 337 | + DEF_ASM_OP1(lgdt, 0x0f01, 2, OPC_MODRM, OPT_EA) | |
| 338 | + DEF_ASM_OP1(lidt, 0x0f01, 3, OPC_MODRM, OPT_EA) | |
| 339 | + DEF_ASM_OP1(lldt, 0x0f00, 2, OPC_MODRM, OPT_EA | OPT_REG) | |
| 340 | + DEF_ASM_OP1(lmsw, 0x0f01, 6, OPC_MODRM, OPT_EA | OPT_REG) | |
| 341 | +ALT(DEF_ASM_OP2(lslw, 0x0f03, 0, OPC_MODRM | OPC_WL, OPT_EA | OPT_REG, OPT_REG)) | |
| 342 | + DEF_ASM_OP1(ltr, 0x0f00, 3, OPC_MODRM, OPT_EA | OPT_REG) | |
| 343 | + DEF_ASM_OP1(sgdt, 0x0f01, 0, OPC_MODRM, OPT_EA) | |
| 344 | + DEF_ASM_OP1(sidt, 0x0f01, 1, OPC_MODRM, OPT_EA) | |
| 345 | + DEF_ASM_OP1(sldt, 0x0f00, 0, OPC_MODRM, OPT_REG | OPT_EA) | |
| 346 | + DEF_ASM_OP1(smsw, 0x0f01, 4, OPC_MODRM, OPT_REG | OPT_EA) | |
| 347 | + DEF_ASM_OP1(str, 0x0f00, 1, OPC_MODRM, OPT_REG16| OPT_EA) | |
| 348 | + DEF_ASM_OP1(verr, 0x0f00, 4, OPC_MODRM, OPT_REG | OPT_EA) | |
| 349 | + DEF_ASM_OP1(verw, 0x0f00, 5, OPC_MODRM, OPT_REG | OPT_EA) | |
| 350 | + | |
| 351 | + /* 486 */ | |
| 352 | + DEF_ASM_OP1(bswap, 0x0fc8, 0, OPC_REG, OPT_REG32 ) | |
| 353 | +ALT(DEF_ASM_OP2(xaddb, 0x0fc0, 0, OPC_MODRM | OPC_BWL, OPT_REG, OPT_REG | OPT_EA )) | |
| 354 | +ALT(DEF_ASM_OP2(cmpxchgb, 0x0fb0, 0, OPC_MODRM | OPC_BWL, OPT_REG, OPT_REG | OPT_EA )) | |
| 355 | + DEF_ASM_OP1(invlpg, 0x0f01, 7, OPC_MODRM, OPT_EA ) | |
| 356 | + | |
| 357 | + DEF_ASM_OP2(boundl, 0x62, 0, OPC_MODRM, OPT_REG32, OPT_EA) | |
| 358 | + DEF_ASM_OP2(boundw, 0x62, 0, OPC_MODRM | OPC_D16, OPT_REG16, OPT_EA) | |
| 359 | + | |
| 360 | + /* pentium */ | |
| 361 | + DEF_ASM_OP1(cmpxchg8b, 0x0fc7, 1, OPC_MODRM, OPT_EA ) | |
| 362 | + | |
| 363 | + /* pentium pro */ | |
| 364 | + ALT(DEF_ASM_OP2(cmovo, 0x0f40, 0, OPC_MODRM | OPC_TEST, OPT_REG32 | OPT_EA, OPT_REG32)) | |
| 365 | + | |
| 366 | + DEF_ASM_OP2(fcmovb, 0xdac0, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 367 | + DEF_ASM_OP2(fcmove, 0xdac8, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 368 | + DEF_ASM_OP2(fcmovbe, 0xdad0, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 369 | + DEF_ASM_OP2(fcmovu, 0xdad8, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 370 | + DEF_ASM_OP2(fcmovnb, 0xdbc0, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 371 | + DEF_ASM_OP2(fcmovne, 0xdbc8, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 372 | + DEF_ASM_OP2(fcmovnbe, 0xdbd0, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 373 | + DEF_ASM_OP2(fcmovnu, 0xdbd8, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 374 | + | |
| 375 | + DEF_ASM_OP2(fucomi, 0xdbe8, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 376 | + DEF_ASM_OP2(fcomi, 0xdbf0, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 377 | + DEF_ASM_OP2(fucomip, 0xdfe8, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 378 | + DEF_ASM_OP2(fcomip, 0xdff0, 0, OPC_REG, OPT_ST, OPT_ST0 ) | |
| 379 | + | |
| 380 | + /* mmx */ | |
| 381 | + DEF_ASM_OP0(emms, 0x0f77) /* must be last OP0 */ | |
| 382 | + DEF_ASM_OP2(movd, 0x0f6e, 0, OPC_MODRM, OPT_EA | OPT_REG32, OPT_MMX ) | |
| 383 | +ALT(DEF_ASM_OP2(movd, 0x0f7e, 0, OPC_MODRM, OPT_MMX, OPT_EA | OPT_REG32 )) | |
| 384 | + DEF_ASM_OP2(movq, 0x0f6f, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 385 | +ALT(DEF_ASM_OP2(movq, 0x0f7f, 0, OPC_MODRM, OPT_MMX, OPT_EA | OPT_MMX )) | |
| 386 | + DEF_ASM_OP2(packssdw, 0x0f6b, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 387 | + DEF_ASM_OP2(packsswb, 0x0f63, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 388 | + DEF_ASM_OP2(packuswb, 0x0f67, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 389 | + DEF_ASM_OP2(paddb, 0x0ffc, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 390 | + DEF_ASM_OP2(paddw, 0x0ffd, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 391 | + DEF_ASM_OP2(paddd, 0x0ffe, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 392 | + DEF_ASM_OP2(paddsb, 0x0fec, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 393 | + DEF_ASM_OP2(paddsw, 0x0fed, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 394 | + DEF_ASM_OP2(paddusb, 0x0fdc, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 395 | + DEF_ASM_OP2(paddusw, 0x0fdd, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 396 | + DEF_ASM_OP2(pand, 0x0fdb, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 397 | + DEF_ASM_OP2(pandn, 0x0fdf, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 398 | + DEF_ASM_OP2(pcmpeqb, 0x0f74, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 399 | + DEF_ASM_OP2(pcmpeqw, 0x0f75, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 400 | + DEF_ASM_OP2(pcmpeqd, 0x0f76, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 401 | + DEF_ASM_OP2(pcmpgtb, 0x0f64, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 402 | + DEF_ASM_OP2(pcmpgtw, 0x0f65, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 403 | + DEF_ASM_OP2(pcmpgtd, 0x0f66, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 404 | + DEF_ASM_OP2(pmaddwd, 0x0ff5, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 405 | + DEF_ASM_OP2(pmulhw, 0x0fe5, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 406 | + DEF_ASM_OP2(pmullw, 0x0fd5, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 407 | + DEF_ASM_OP2(por, 0x0feb, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 408 | + DEF_ASM_OP2(psllw, 0x0ff1, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 409 | +ALT(DEF_ASM_OP2(psllw, 0x0f71, 6, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 410 | + DEF_ASM_OP2(pslld, 0x0ff2, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 411 | +ALT(DEF_ASM_OP2(pslld, 0x0f72, 6, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 412 | + DEF_ASM_OP2(psllq, 0x0ff3, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 413 | +ALT(DEF_ASM_OP2(psllq, 0x0f73, 6, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 414 | + DEF_ASM_OP2(psraw, 0x0fe1, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 415 | +ALT(DEF_ASM_OP2(psraw, 0x0f71, 4, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 416 | + DEF_ASM_OP2(psrad, 0x0fe2, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 417 | +ALT(DEF_ASM_OP2(psrad, 0x0f72, 4, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 418 | + DEF_ASM_OP2(psrlw, 0x0fd1, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 419 | +ALT(DEF_ASM_OP2(psrlw, 0x0f71, 2, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 420 | + DEF_ASM_OP2(psrld, 0x0fd2, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 421 | +ALT(DEF_ASM_OP2(psrld, 0x0f72, 2, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 422 | + DEF_ASM_OP2(psrlq, 0x0fd3, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 423 | +ALT(DEF_ASM_OP2(psrlq, 0x0f73, 2, OPC_MODRM, OPT_IM8, OPT_MMX )) | |
| 424 | + DEF_ASM_OP2(psubb, 0x0ff8, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 425 | + DEF_ASM_OP2(psubw, 0x0ff9, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 426 | + DEF_ASM_OP2(psubd, 0x0ffa, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 427 | + DEF_ASM_OP2(psubsb, 0x0fe8, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 428 | + DEF_ASM_OP2(psubsw, 0x0fe9, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 429 | + DEF_ASM_OP2(psubusb, 0x0fd8, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 430 | + DEF_ASM_OP2(psubusw, 0x0fd9, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 431 | + DEF_ASM_OP2(punpckhbw, 0x0f68, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 432 | + DEF_ASM_OP2(punpckhwd, 0x0f69, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 433 | + DEF_ASM_OP2(punpckhdq, 0x0f6a, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 434 | + DEF_ASM_OP2(punpcklbw, 0x0f60, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 435 | + DEF_ASM_OP2(punpcklwd, 0x0f61, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 436 | + DEF_ASM_OP2(punpckldq, 0x0f62, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 437 | + DEF_ASM_OP2(pxor, 0x0fef, 0, OPC_MODRM, OPT_EA | OPT_MMX, OPT_MMX ) | |
| 438 | + | |
| 439 | +#undef ALT | |
| 440 | +#undef DEF_ASM_OP0 | |
| 441 | +#undef DEF_ASM_OP0L | |
| 442 | +#undef DEF_ASM_OP1 | |
| 443 | +#undef DEF_ASM_OP2 | |
| 444 | +#undef DEF_ASM_OP3 | |
| @@ -0,0 +1,744 @@ | ||
| 1 | +/* | |
| 2 | + * GAS like assembler for TCC | |
| 3 | + * | |
| 4 | + * Copyright (c) 2001, 2002 Fabrice Bellard | |
| 5 | + * | |
| 6 | + * This program is free software; you can redistribute it and/or modify | |
| 7 | + * it under the terms of the GNU General Public License as published by | |
| 8 | + * the Free Software Foundation; either version 2 of the License, or | |
| 9 | + * (at your option) any later version. | |
| 10 | + * | |
| 11 | + * This program 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 | |
| 14 | + * GNU General Public License for more details. | |
| 15 | + * | |
| 16 | + * You should have received a copy of the GNU General Public License | |
| 17 | + * along with this program; if not, write to the Free Software | |
| 18 | + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
| 19 | + */ | |
| 20 | + | |
| 21 | +static int asm_get_local_label_name(TCCState *s1, unsigned int n) | |
| 22 | +{ | |
| 23 | + char buf[64]; | |
| 24 | + TokenSym *ts; | |
| 25 | + | |
| 26 | + snprintf(buf, sizeof(buf), "L..%u", n); | |
| 27 | + ts = tok_alloc(buf, strlen(buf)); | |
| 28 | + return ts->tok; | |
| 29 | +} | |
| 30 | + | |
| 31 | +/* We do not use the C expression parser to handle symbols. Maybe the | |
| 32 | + C expression parser could be tweaked to do so. */ | |
| 33 | + | |
| 34 | +static void asm_expr_unary(TCCState *s1, ExprValue *pe) | |
| 35 | +{ | |
| 36 | + Sym *sym; | |
| 37 | + int op, n, label; | |
| 38 | + const char *p; | |
| 39 | + | |
| 40 | + switch(tok) { | |
| 41 | + case TOK_PPNUM: | |
| 42 | + p = tokc.cstr->data; | |
| 43 | + n = strtol(p, (char **)&p, 0); | |
| 44 | + if (*p == 'b' || *p == 'f') { | |
| 45 | + /* backward or forward label */ | |
| 46 | + label = asm_get_local_label_name(s1, n); | |
| 47 | + sym = label_find(label); | |
| 48 | + if (*p == 'b') { | |
| 49 | + /* backward : find the last corresponding defined label */ | |
| 50 | + if (sym && sym->r == 0) | |
| 51 | + sym = sym->prev_tok; | |
| 52 | + if (!sym) | |
| 53 | + error("local label '%d' not found backward", n); | |
| 54 | + } else { | |
| 55 | + /* forward */ | |
| 56 | + if (!sym || sym->r) { | |
| 57 | + /* if the last label is defined, then define a new one */ | |
| 58 | + sym = label_push(&s1->asm_labels, label, 0); | |
| 59 | + sym->type.t = VT_STATIC | VT_VOID; | |
| 60 | + } | |
| 61 | + } | |
| 62 | + pe->v = 0; | |
| 63 | + pe->sym = sym; | |
| 64 | + } else if (*p == '\0') { | |
| 65 | + pe->v = n; | |
| 66 | + pe->sym = NULL; | |
| 67 | + } else { | |
| 68 | + error("invalid number syntax"); | |
| 69 | + } | |
| 70 | + next(); | |
| 71 | + break; | |
| 72 | + case '+': | |
| 73 | + next(); | |
| 74 | + asm_expr_unary(s1, pe); | |
| 75 | + break; | |
| 76 | + case '-': | |
| 77 | + case '~': | |
| 78 | + op = tok; | |
| 79 | + next(); | |
| 80 | + asm_expr_unary(s1, pe); | |
| 81 | + if (pe->sym) | |
| 82 | + error("invalid operation with label"); | |
| 83 | + if (op == '-') | |
| 84 | + pe->v = -pe->v; | |
| 85 | + else | |
| 86 | + pe->v = ~pe->v; | |
| 87 | + break; | |
| 88 | + default: | |
| 89 | + if (tok >= TOK_IDENT) { | |
| 90 | + /* label case : if the label was not found, add one */ | |
| 91 | + sym = label_find(tok); | |
| 92 | + if (!sym) { | |
| 93 | + sym = label_push(&s1->asm_labels, tok, 0); | |
| 94 | + /* NOTE: by default, the symbol is global */ | |
| 95 | + sym->type.t = VT_VOID; | |
| 96 | + } | |
| 97 | + pe->v = 0; | |
| 98 | + pe->sym = sym; | |
| 99 | + next(); | |
| 100 | + } else { | |
| 101 | + error("bad expression syntax [%s]", get_tok_str(tok, &tokc)); | |
| 102 | + } | |
| 103 | + break; | |
| 104 | + } | |
| 105 | +} | |
| 106 | + | |
| 107 | +static void asm_expr_prod(TCCState *s1, ExprValue *pe) | |
| 108 | +{ | |
| 109 | + int op; | |
| 110 | + ExprValue e2; | |
| 111 | + | |
| 112 | + asm_expr_unary(s1, pe); | |
| 113 | + for(;;) { | |
| 114 | + op = tok; | |
| 115 | + if (op != '*' && op != '/' && op != '%' && | |
| 116 | + op != TOK_SHL && op != TOK_SAR) | |
| 117 | + break; | |
| 118 | + next(); | |
| 119 | + asm_expr_unary(s1, &e2); | |
| 120 | + if (pe->sym || e2.sym) | |
| 121 | + error("invalid operation with label"); | |
| 122 | + switch(op) { | |
| 123 | + case '*': | |
| 124 | + pe->v *= e2.v; | |
| 125 | + break; | |
| 126 | + case '/': | |
| 127 | + if (e2.v == 0) { | |
| 128 | + div_error: | |
| 129 | + error("division by zero"); | |
| 130 | + } | |
| 131 | + pe->v /= e2.v; | |
| 132 | + break; | |
| 133 | + case '%': | |
| 134 | + if (e2.v == 0) | |
| 135 | + goto div_error; | |
| 136 | + pe->v %= e2.v; | |
| 137 | + break; | |
| 138 | + case TOK_SHL: | |
| 139 | + pe->v <<= e2.v; | |
| 140 | + break; | |
| 141 | + default: | |
| 142 | + case TOK_SAR: | |
| 143 | + pe->v >>= e2.v; | |
| 144 | + break; | |
| 145 | + } | |
| 146 | + } | |
| 147 | +} | |
| 148 | + | |
| 149 | +static void asm_expr_logic(TCCState *s1, ExprValue *pe) | |
| 150 | +{ | |
| 151 | + int op; | |
| 152 | + ExprValue e2; | |
| 153 | + | |
| 154 | + asm_expr_prod(s1, pe); | |
| 155 | + for(;;) { | |
| 156 | + op = tok; | |
| 157 | + if (op != '&' && op != '|' && op != '^') | |
| 158 | + break; | |
| 159 | + next(); | |
| 160 | + asm_expr_prod(s1, &e2); | |
| 161 | + if (pe->sym || e2.sym) | |
| 162 | + error("invalid operation with label"); | |
| 163 | + switch(op) { | |
| 164 | + case '&': | |
| 165 | + pe->v &= e2.v; | |
| 166 | + break; | |
| 167 | + case '|': | |
| 168 | + pe->v |= e2.v; | |
| 169 | + break; | |
| 170 | + default: | |
| 171 | + case '^': | |
| 172 | + pe->v ^= e2.v; | |
| 173 | + break; | |
| 174 | + } | |
| 175 | + } | |
| 176 | +} | |
| 177 | + | |
| 178 | +static inline void asm_expr_sum(TCCState *s1, ExprValue *pe) | |
| 179 | +{ | |
| 180 | + int op; | |
| 181 | + ExprValue e2; | |
| 182 | + | |
| 183 | + asm_expr_logic(s1, pe); | |
| 184 | + for(;;) { | |
| 185 | + op = tok; | |
| 186 | + if (op != '+' && op != '-') | |
| 187 | + break; | |
| 188 | + next(); | |
| 189 | + asm_expr_logic(s1, &e2); | |
| 190 | + if (op == '+') { | |
| 191 | + if (pe->sym != NULL && e2.sym != NULL) | |
| 192 | + goto cannot_relocate; | |
| 193 | + pe->v += e2.v; | |
| 194 | + if (pe->sym == NULL && e2.sym != NULL) | |
| 195 | + pe->sym = e2.sym; | |
| 196 | + } else { | |
| 197 | + pe->v -= e2.v; | |
| 198 | + /* NOTE: we are less powerful than gas in that case | |
| 199 | + because we store only one symbol in the expression */ | |
| 200 | + if (!pe->sym && !e2.sym) { | |
| 201 | + /* OK */ | |
| 202 | + } else if (pe->sym && !e2.sym) { | |
| 203 | + /* OK */ | |
| 204 | + } else if (pe->sym && e2.sym) { | |
| 205 | + if (pe->sym == e2.sym) { | |
| 206 | + /* OK */ | |
| 207 | + } else if (pe->sym->r == e2.sym->r && pe->sym->r != 0) { | |
| 208 | + /* we also accept defined symbols in the same section */ | |
| 209 | + pe->v += (long)pe->sym->next - (long)e2.sym->next; | |
| 210 | + } else { | |
| 211 | + goto cannot_relocate; | |
| 212 | + } | |
| 213 | + pe->sym = NULL; /* same symbols can be substracted to NULL */ | |
| 214 | + } else { | |
| 215 | + cannot_relocate: | |
| 216 | + error("invalid operation with label"); | |
| 217 | + } | |
| 218 | + } | |
| 219 | + } | |
| 220 | +} | |
| 221 | + | |
| 222 | +static void asm_expr(TCCState *s1, ExprValue *pe) | |
| 223 | +{ | |
| 224 | + asm_expr_sum(s1, pe); | |
| 225 | +} | |
| 226 | + | |
| 227 | +static int asm_int_expr(TCCState *s1) | |
| 228 | +{ | |
| 229 | + ExprValue e; | |
| 230 | + asm_expr(s1, &e); | |
| 231 | + if (e.sym) | |
| 232 | + expect("constant"); | |
| 233 | + return e.v; | |
| 234 | +} | |
| 235 | + | |
| 236 | +/* NOTE: the same name space as C labels is used to avoid using too | |
| 237 | + much memory when storing labels in TokenStrings */ | |
| 238 | +static void asm_new_label(TCCState *s1, int label, int is_local) | |
| 239 | +{ | |
| 240 | + Sym *sym; | |
| 241 | + | |
| 242 | + sym = label_find(label); | |
| 243 | + if (sym) { | |
| 244 | + if (sym->r) { | |
| 245 | + /* the label is already defined */ | |
| 246 | + if (!is_local) { | |
| 247 | + error("assembler label '%s' already defined", | |
| 248 | + get_tok_str(label, NULL)); | |
| 249 | + } else { | |
| 250 | + /* redefinition of local labels is possible */ | |
| 251 | + goto new_label; | |
| 252 | + } | |
| 253 | + } | |
| 254 | + } else { | |
| 255 | + new_label: | |
| 256 | + sym = label_push(&s1->asm_labels, label, 0); | |
| 257 | + sym->type.t = VT_STATIC | VT_VOID; | |
| 258 | + } | |
| 259 | + sym->r = cur_text_section->sh_num; | |
| 260 | + sym->next = (void *)ind; | |
| 261 | +} | |
| 262 | + | |
| 263 | +static void asm_free_labels(TCCState *st) | |
| 264 | +{ | |
| 265 | + Sym *s, *s1; | |
| 266 | + for(s = st->asm_labels; s != NULL; s = s1) { | |
| 267 | + s1 = s->prev; | |
| 268 | + /* define symbol value in object file */ | |
| 269 | + if (s->r) { | |
| 270 | + put_extern_sym(s, st->sections[s->r], (long)s->next, 0); | |
| 271 | + } | |
| 272 | + /* remove label */ | |
| 273 | + table_ident[s->v - TOK_IDENT]->sym_label = NULL; | |
| 274 | + tcc_free(s); | |
| 275 | + } | |
| 276 | + st->asm_labels = NULL; | |
| 277 | +} | |
| 278 | + | |
| 279 | +static void asm_parse_directive(TCCState *s1) | |
| 280 | +{ | |
| 281 | + int n, offset, v, size, tok1; | |
| 282 | + Section *sec; | |
| 283 | + uint8_t *ptr; | |
| 284 | + | |
| 285 | + /* assembler directive */ | |
| 286 | + next(); | |
| 287 | + sec = cur_text_section; | |
| 288 | + switch(tok) { | |
| 289 | + case TOK_ASM_align: | |
| 290 | + case TOK_ASM_skip: | |
| 291 | + case TOK_ASM_space: | |
| 292 | + tok1 = tok; | |
| 293 | + next(); | |
| 294 | + n = asm_int_expr(s1); | |
| 295 | + if (tok1 == TOK_ASM_align) { | |
| 296 | + if (n < 0 || (n & (n-1)) != 0) | |
| 297 | + error("alignment must be a positive power of two"); | |
| 298 | + offset = (ind + n - 1) & -n; | |
| 299 | + size = offset - ind; | |
| 300 | + } else { | |
| 301 | + size = n; | |
| 302 | + } | |
| 303 | + v = 0; | |
| 304 | + if (tok == ',') { | |
| 305 | + next(); | |
| 306 | + v = asm_int_expr(s1); | |
| 307 | + } | |
| 308 | + if (sec->sh_type != SHT_NOBITS) { | |
| 309 | + sec->data_offset = ind; | |
| 310 | + ptr = section_ptr_add(sec, size); | |
| 311 | + memset(ptr, v, size); | |
| 312 | + } | |
| 313 | + ind += size; | |
| 314 | + break; | |
| 315 | + case TOK_ASM_byte: | |
| 316 | + size = 1; | |
| 317 | + goto asm_data; | |
| 318 | + case TOK_ASM_word: | |
| 319 | + case TOK_SHORT: | |
| 320 | + size = 2; | |
| 321 | + goto asm_data; | |
| 322 | + case TOK_LONG: | |
| 323 | + case TOK_INT: | |
| 324 | + size = 4; | |
| 325 | + asm_data: | |
| 326 | + next(); | |
| 327 | + for(;;) { | |
| 328 | + ExprValue e; | |
| 329 | + asm_expr(s1, &e); | |
| 330 | + if (sec->sh_type != SHT_NOBITS) { | |
| 331 | + if (size == 4) { | |
| 332 | + gen_expr32(&e); | |
| 333 | + } else { | |
| 334 | + if (e.sym) | |
| 335 | + expect("constant"); | |
| 336 | + if (size == 1) | |
| 337 | + g(e.v); | |
| 338 | + else | |
| 339 | + gen_le16(e.v); | |
| 340 | + } | |
| 341 | + } else { | |
| 342 | + ind += size; | |
| 343 | + } | |
| 344 | + if (tok != ',') | |
| 345 | + break; | |
| 346 | + next(); | |
| 347 | + } | |
| 348 | + break; | |
| 349 | + default: | |
| 350 | + error("unknown assembler directive .%s", get_tok_str(tok, NULL)); | |
| 351 | + break; | |
| 352 | + } | |
| 353 | +} | |
| 354 | + | |
| 355 | + | |
| 356 | +/* assemble a file */ | |
| 357 | +static int tcc_assemble_internal(TCCState *s1, int do_preprocess) | |
| 358 | +{ | |
| 359 | + int opcode; | |
| 360 | + | |
| 361 | +#if 0 | |
| 362 | + /* print stats about opcodes */ | |
| 363 | + { | |
| 364 | + const ASMInstr *pa; | |
| 365 | + int freq[4]; | |
| 366 | + int op_vals[500]; | |
| 367 | + int nb_op_vals, i, j; | |
| 368 | + | |
| 369 | + nb_op_vals = 0; | |
| 370 | + memset(freq, 0, sizeof(freq)); | |
| 371 | + for(pa = asm_instrs; pa->sym != 0; pa++) { | |
| 372 | + freq[pa->nb_ops]++; | |
| 373 | + for(i=0;i<pa->nb_ops;i++) { | |
| 374 | + for(j=0;j<nb_op_vals;j++) { | |
| 375 | + if (pa->op_type[i] == op_vals[j]) | |
| 376 | + goto found; | |
| 377 | + } | |
| 378 | + op_vals[nb_op_vals++] = pa->op_type[i]; | |
| 379 | + found: ; | |
| 380 | + } | |
| 381 | + } | |
| 382 | + for(i=0;i<nb_op_vals;i++) { | |
| 383 | + int v = op_vals[i]; | |
| 384 | + if ((v & (v - 1)) != 0) | |
| 385 | + printf("%3d: %08x\n", i, v); | |
| 386 | + } | |
| 387 | + printf("size=%d nb=%d f0=%d f1=%d f2=%d f3=%d\n", | |
| 388 | + sizeof(asm_instrs), sizeof(asm_instrs) / sizeof(ASMInstr), | |
| 389 | + freq[0], freq[1], freq[2], freq[3]); | |
| 390 | + } | |
| 391 | +#endif | |
| 392 | + | |
| 393 | + /* XXX: undefine C labels */ | |
| 394 | + | |
| 395 | + ch = file->buf_ptr[0]; | |
| 396 | + tok_flags = TOK_FLAG_BOL | TOK_FLAG_BOF; | |
| 397 | + parse_flags = 0; | |
| 398 | + if (do_preprocess) | |
| 399 | + parse_flags |= PARSE_FLAG_PREPROCESS; | |
| 400 | + next(); | |
| 401 | + for(;;) { | |
| 402 | + if (tok == TOK_EOF) | |
| 403 | + break; | |
| 404 | + parse_flags |= PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */ | |
| 405 | + redo: | |
| 406 | + if (tok == '#') { | |
| 407 | + /* horrible gas comment */ | |
| 408 | + while (tok != TOK_LINEFEED) | |
| 409 | + next(); | |
| 410 | + } else if (tok == '.') { | |
| 411 | + asm_parse_directive(s1); | |
| 412 | + } else if (tok == TOK_PPNUM) { | |
| 413 | + const char *p; | |
| 414 | + int n; | |
| 415 | + p = tokc.cstr->data; | |
| 416 | + n = strtol(p, (char **)&p, 10); | |
| 417 | + if (*p != '\0') | |
| 418 | + expect("':'"); | |
| 419 | + /* new local label */ | |
| 420 | + asm_new_label(s1, asm_get_local_label_name(s1, n), 1); | |
| 421 | + next(); | |
| 422 | + skip(':'); | |
| 423 | + goto redo; | |
| 424 | + } else if (tok >= TOK_IDENT) { | |
| 425 | + /* instruction or label */ | |
| 426 | + opcode = tok; | |
| 427 | + next(); | |
| 428 | + if (tok == ':') { | |
| 429 | + /* new label */ | |
| 430 | + asm_new_label(s1, opcode, 0); | |
| 431 | + next(); | |
| 432 | + goto redo; | |
| 433 | + } else { | |
| 434 | + asm_opcode(s1, opcode); | |
| 435 | + } | |
| 436 | + } | |
| 437 | + /* end of line */ | |
| 438 | + if (tok != ';' && tok != TOK_LINEFEED){ | |
| 439 | + expect("end of line"); | |
| 440 | + } | |
| 441 | + parse_flags &= ~PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */ | |
| 442 | + next(); | |
| 443 | + } | |
| 444 | + | |
| 445 | + asm_free_labels(s1); | |
| 446 | + | |
| 447 | + return 0; | |
| 448 | +} | |
| 449 | + | |
| 450 | +/* Assemble the current file */ | |
| 451 | +static int tcc_assemble(TCCState *s1, int do_preprocess) | |
| 452 | +{ | |
| 453 | + int ret; | |
| 454 | + | |
| 455 | + preprocess_init(s1); | |
| 456 | + | |
| 457 | + /* default section is text */ | |
| 458 | + cur_text_section = text_section; | |
| 459 | + ind = cur_text_section->data_offset; | |
| 460 | + | |
| 461 | + ret = tcc_assemble_internal(s1, do_preprocess); | |
| 462 | + | |
| 463 | + cur_text_section->data_offset = ind; | |
| 464 | + return ret; | |
| 465 | +} | |
| 466 | + | |
| 467 | +/********************************************************************/ | |
| 468 | +/* GCC inline asm support */ | |
| 469 | + | |
| 470 | +/* assemble the string 'str' in the current C compilation unit without | |
| 471 | + C preprocessing. NOTE: str is modified by modifying the '\0' at the | |
| 472 | + end */ | |
| 473 | +static void tcc_assemble_inline(TCCState *s1, char *str, int len) | |
| 474 | +{ | |
| 475 | + BufferedFile *bf, *saved_file; | |
| 476 | + int saved_parse_flags, *saved_macro_ptr; | |
| 477 | + | |
| 478 | + bf = tcc_malloc(sizeof(BufferedFile)); | |
| 479 | + memset(bf, 0, sizeof(BufferedFile)); | |
| 480 | + bf->fd = -1; | |
| 481 | + bf->buf_ptr = str; | |
| 482 | + bf->buf_end = str + len; | |
| 483 | + str[len] = CH_EOB; | |
| 484 | + /* same name as current file so that errors are correctly | |
| 485 | + reported */ | |
| 486 | + pstrcpy(bf->filename, sizeof(bf->filename), file->filename); | |
| 487 | + bf->line_num = file->line_num; | |
| 488 | + saved_file = file; | |
| 489 | + file = bf; | |
| 490 | + saved_parse_flags = parse_flags; | |
| 491 | + saved_macro_ptr = macro_ptr; | |
| 492 | + macro_ptr = NULL; | |
| 493 | + | |
| 494 | + tcc_assemble_internal(s1, 0); | |
| 495 | + | |
| 496 | + parse_flags = saved_parse_flags; | |
| 497 | + macro_ptr = saved_macro_ptr; | |
| 498 | + file = saved_file; | |
| 499 | + tcc_free(bf); | |
| 500 | +} | |
| 501 | + | |
| 502 | +/* find a constraint by its number or id (gcc 3 extended | |
| 503 | + syntax). return -1 if not found. Return in *pp in char after the | |
| 504 | + constraint */ | |
| 505 | +static int find_constraint(ASMOperand *operands, int nb_operands, | |
| 506 | + const char *name, const char **pp) | |
| 507 | +{ | |
| 508 | + int index; | |
| 509 | + TokenSym *ts; | |
| 510 | + const char *p; | |
| 511 | + | |
| 512 | + if (isnum(*name)) { | |
| 513 | + index = 0; | |
| 514 | + while (isnum(*name)) { | |
| 515 | + index = (index * 10) + (*name) - '0'; | |
| 516 | + name++; | |
| 517 | + } | |
| 518 | + if ((unsigned)index >= nb_operands) | |
| 519 | + index = -1; | |
| 520 | + } else if (*name == '[') { | |
| 521 | + name++; | |
| 522 | + p = strchr(name, ']'); | |
| 523 | + if (p) { | |
| 524 | + ts = tok_alloc(name, p - name); | |
| 525 | + for(index = 0; index < nb_operands; index++) { | |
| 526 | + if (operands[index].id == ts->tok) | |
| 527 | + goto found; | |
| 528 | + } | |
| 529 | + index = -1; | |
| 530 | + found: | |
| 531 | + name = p + 1; | |
| 532 | + } else { | |
| 533 | + index = -1; | |
| 534 | + } | |
| 535 | + } else { | |
| 536 | + index = -1; | |
| 537 | + } | |
| 538 | + if (pp) | |
| 539 | + *pp = name; | |
| 540 | + return index; | |
| 541 | +} | |
| 542 | + | |
| 543 | +static void subst_asm_operands(ASMOperand *operands, int nb_operands, | |
| 544 | + int nb_outputs, | |
| 545 | + CString *out_str, CString *in_str) | |
| 546 | +{ | |
| 547 | + int c, index, modifier; | |
| 548 | + const char *str; | |
| 549 | + ASMOperand *op; | |
| 550 | + SValue sv; | |
| 551 | + | |
| 552 | + cstr_new(out_str); | |
| 553 | + str = in_str->data; | |
| 554 | + for(;;) { | |
| 555 | + c = *str++; | |
| 556 | + if (c == '%') { | |
| 557 | + if (*str == '%') { | |
| 558 | + str++; | |
| 559 | + goto add_char; | |
| 560 | + } | |
| 561 | + modifier = 0; | |
| 562 | + if (*str == 'c' || *str == 'n' || | |
| 563 | + *str == 'b' || *str == 'w' || *str == 'h') | |
| 564 | + modifier = *str++; | |
| 565 | + index = find_constraint(operands, nb_operands, str, &str); | |
| 566 | + if (index < 0) | |
| 567 | + error("invalid operand reference after %%"); | |
| 568 | + op = &operands[index]; | |
| 569 | + sv = *op->vt; | |
| 570 | + if (op->reg >= 0) { | |
| 571 | + sv.r = op->reg; | |
| 572 | + if ((op->vt->r & VT_VALMASK) == VT_LLOCAL) | |
| 573 | + sv.r |= VT_LVAL; | |
| 574 | + } | |
| 575 | + subst_asm_operand(out_str, &sv, modifier); | |
| 576 | + } else { | |
| 577 | + add_char: | |
| 578 | + cstr_ccat(out_str, c); | |
| 579 | + if (c == '\0') | |
| 580 | + break; | |
| 581 | + } | |
| 582 | + } | |
| 583 | +} | |
| 584 | + | |
| 585 | + | |
| 586 | +static void parse_asm_operands(ASMOperand *operands, int *nb_operands_ptr, | |
| 587 | + int is_output) | |
| 588 | +{ | |
| 589 | + ASMOperand *op; | |
| 590 | + int nb_operands; | |
| 591 | + | |
| 592 | + if (tok != ':') { | |
| 593 | + nb_operands = *nb_operands_ptr; | |
| 594 | + for(;;) { | |
| 595 | + if (nb_operands >= MAX_ASM_OPERANDS) | |
| 596 | + error("too many asm operands"); | |
| 597 | + op = &operands[nb_operands++]; | |
| 598 | + op->id = 0; | |
| 599 | + if (tok == '[') { | |
| 600 | + next(); | |
| 601 | + if (tok < TOK_IDENT) | |
| 602 | + expect("identifier"); | |
| 603 | + op->id = tok; | |
| 604 | + next(); | |
| 605 | + skip(']'); | |
| 606 | + } | |
| 607 | + if (tok != TOK_STR) | |
| 608 | + expect("string constant"); | |
| 609 | + op->constraint = tcc_malloc(tokc.cstr->size); | |
| 610 | + strcpy(op->constraint, tokc.cstr->data); | |
| 611 | + next(); | |
| 612 | + skip('('); | |
| 613 | + gexpr(); | |
| 614 | + if (is_output) { | |
| 615 | + test_lvalue(); | |
| 616 | + } else { | |
| 617 | + /* we want to avoid LLOCAL case. note that it may come | |
| 618 | + from register storage, so we need to convert (reg) | |
| 619 | + case */ | |
| 620 | + if ((vtop->r & VT_LVAL) && | |
| 621 | + ((vtop->r & VT_VALMASK) == VT_LLOCAL || | |
| 622 | + (vtop->r & VT_VALMASK) < VT_CONST)) { | |
| 623 | + gv(RC_INT); | |
| 624 | + } | |
| 625 | + } | |
| 626 | + op->vt = vtop; | |
| 627 | + skip(')'); | |
| 628 | + if (tok == ',') { | |
| 629 | + next(); | |
| 630 | + } else { | |
| 631 | + break; | |
| 632 | + } | |
| 633 | + } | |
| 634 | + *nb_operands_ptr = nb_operands; | |
| 635 | + } | |
| 636 | +} | |
| 637 | + | |
| 638 | +/* parse the GCC asm() instruction */ | |
| 639 | +static void asm_instr(void) | |
| 640 | +{ | |
| 641 | + CString astr, astr1; | |
| 642 | + ASMOperand operands[MAX_ASM_OPERANDS]; | |
| 643 | + int nb_inputs, nb_outputs, nb_operands, i; | |
| 644 | + uint8_t input_regs_allocated[NB_ASM_REGS]; | |
| 645 | + uint8_t output_regs_allocated[NB_ASM_REGS]; | |
| 646 | + uint8_t clobber_regs[NB_ASM_REGS]; | |
| 647 | + | |
| 648 | + next(); | |
| 649 | + /* since we always generate the asm() instruction, we can ignore | |
| 650 | + volatile */ | |
| 651 | + if (tok == TOK_VOLATILE1 || tok == TOK_VOLATILE2 || tok == TOK_VOLATILE3) { | |
| 652 | + next(); | |
| 653 | + } | |
| 654 | + skip('('); | |
| 655 | + /* read the string */ | |
| 656 | + if (tok != TOK_STR) | |
| 657 | + expect("string constant"); | |
| 658 | + cstr_new(&astr); | |
| 659 | + while (tok == TOK_STR) { | |
| 660 | + /* XXX: add \0 handling too ? */ | |
| 661 | + cstr_cat(&astr, tokc.cstr->data); | |
| 662 | + next(); | |
| 663 | + } | |
| 664 | + cstr_ccat(&astr, '\0'); | |
| 665 | + nb_operands = 0; | |
| 666 | + nb_outputs = 0; | |
| 667 | + memset(clobber_regs, 0, sizeof(clobber_regs)); | |
| 668 | + if (tok == ':') { | |
| 669 | + next(); | |
| 670 | + /* output args */ | |
| 671 | + parse_asm_operands(operands, &nb_operands, 1); | |
| 672 | + nb_outputs = nb_operands; | |
| 673 | + if (tok == ':') { | |
| 674 | + next(); | |
| 675 | + /* input args */ | |
| 676 | + parse_asm_operands(operands, &nb_operands, 0); | |
| 677 | + if (tok == ':') { | |
| 678 | + /* clobber list */ | |
| 679 | + /* XXX: handle registers */ | |
| 680 | + next(); | |
| 681 | + for(;;) { | |
| 682 | + if (tok != TOK_STR) | |
| 683 | + expect("string constant"); | |
| 684 | + asm_clobber(clobber_regs, tokc.cstr->data); | |
| 685 | + next(); | |
| 686 | + if (tok == ',') { | |
| 687 | + next(); | |
| 688 | + } else { | |
| 689 | + break; | |
| 690 | + } | |
| 691 | + } | |
| 692 | + } | |
| 693 | + } | |
| 694 | + } | |
| 695 | + skip(')'); | |
| 696 | + /* NOTE: we do not eat the ';' so that we can restore the current | |
| 697 | + token after the assembler parsing */ | |
| 698 | + if (tok != ';') | |
| 699 | + expect("';'"); | |
| 700 | + nb_inputs = nb_operands - nb_outputs; | |
| 701 | + | |
| 702 | + /* save all values in the memory */ | |
| 703 | + save_regs(0); | |
| 704 | + | |
| 705 | + /* compute constraints */ | |
| 706 | + asm_compute_constraints(input_regs_allocated, | |
| 707 | + operands, nb_operands, nb_outputs, 0, | |
| 708 | + NULL); | |
| 709 | + asm_compute_constraints(output_regs_allocated, | |
| 710 | + operands, nb_operands, nb_outputs, 1, | |
| 711 | + input_regs_allocated); | |
| 712 | + | |
| 713 | + /* substitute the operands in the asm string */ | |
| 714 | +#ifdef ASM_DEBUG | |
| 715 | + printf("asm: \"%s\"\n", (char *)astr.data); | |
| 716 | +#endif | |
| 717 | + subst_asm_operands(operands, nb_operands, nb_outputs, &astr1, &astr); | |
| 718 | + cstr_free(&astr); | |
| 719 | +#ifdef ASM_DEBUG | |
| 720 | + printf("subst_asm: \"%s\"\n", (char *)astr1.data); | |
| 721 | +#endif | |
| 722 | + | |
| 723 | + /* generate loads */ | |
| 724 | + asm_gen_code(operands, nb_operands, nb_outputs, 0, clobber_regs); | |
| 725 | + | |
| 726 | + /* assemble the string with tcc internal assembler */ | |
| 727 | + tcc_assemble_inline(tcc_state, astr1.data, astr1.size - 1); | |
| 728 | + | |
| 729 | + /* restore the current C token */ | |
| 730 | + next(); | |
| 731 | + | |
| 732 | + /* store the output values if needed */ | |
| 733 | + asm_gen_code(operands, nb_operands, nb_outputs, 1, clobber_regs); | |
| 734 | + | |
| 735 | + /* free everything */ | |
| 736 | + for(i=0;i<nb_operands;i++) { | |
| 737 | + ASMOperand *op; | |
| 738 | + op = &operands[i]; | |
| 739 | + tcc_free(op->constraint); | |
| 740 | + vpop(); | |
| 741 | + } | |
| 742 | + cstr_free(&astr1); | |
| 743 | +} | |
| 744 | + | |