H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1 | /* disasm.c where all the _work_ gets done in the Netwide Disassembler |
| 2 | * |
| 3 | * The Netwide Assembler is copyright (C) 1996 Simon Tatham and |
| 4 | * Julian Hall. All rights reserved. The software is |
| 5 | * redistributable under the licence given in the file "Licence" |
| 6 | * distributed in the NASM archive. |
| 7 | * |
| 8 | * initial version 27/iii/95 by Simon Tatham |
| 9 | */ |
| 10 | |
H. Peter Anvin | fe50195 | 2007-10-02 21:53:51 -0700 | [diff] [blame] | 11 | #include "compiler.h" |
| 12 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 13 | #include <stdio.h> |
| 14 | #include <string.h> |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 15 | #include <limits.h> |
Keith Kanios | b7a8954 | 2007-04-12 02:40:54 +0000 | [diff] [blame] | 16 | #include <inttypes.h> |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 17 | |
| 18 | #include "nasm.h" |
| 19 | #include "disasm.h" |
| 20 | #include "sync.h" |
| 21 | #include "insns.h" |
| 22 | |
| 23 | #include "names.c" |
| 24 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 25 | /* |
| 26 | * Flags that go into the `segment' field of `insn' structures |
| 27 | * during disassembly. |
| 28 | */ |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 29 | #define SEG_RELATIVE 1 |
| 30 | #define SEG_32BIT 2 |
| 31 | #define SEG_RMREG 4 |
| 32 | #define SEG_DISP8 8 |
| 33 | #define SEG_DISP16 16 |
| 34 | #define SEG_DISP32 32 |
| 35 | #define SEG_NODISP 64 |
| 36 | #define SEG_SIGNED 128 |
| 37 | #define SEG_64BIT 256 |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 38 | |
H. Peter Anvin | 232badb | 2002-06-06 02:41:20 +0000 | [diff] [blame] | 39 | #include "regdis.c" |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 40 | |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 41 | /* |
| 42 | * Prefix information |
| 43 | */ |
| 44 | struct prefix_info { |
| 45 | uint8_t osize; /* Operand size */ |
| 46 | uint8_t asize; /* Address size */ |
| 47 | uint8_t osp; /* Operand size prefix present */ |
| 48 | uint8_t asp; /* Address size prefix present */ |
| 49 | uint8_t rep; /* Rep prefix present */ |
| 50 | uint8_t seg; /* Segment override prefix present */ |
| 51 | uint8_t lock; /* Lock prefix present */ |
| 52 | uint8_t rex; /* Rex prefix present */ |
| 53 | }; |
| 54 | |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 55 | #define getu8(x) (*(uint8_t *)(x)) |
| 56 | #if defined(__i386__) || defined(__x86_64__) |
| 57 | /* Littleendian CPU which can handle unaligned references */ |
| 58 | #define getu16(x) (*(uint16_t *)(x)) |
| 59 | #define getu32(x) (*(uint32_t *)(x)) |
| 60 | #define getu64(x) (*(uint64_t *)(x)) |
| 61 | #else |
| 62 | static uint16_t getu16(uint8_t *data) |
| 63 | { |
| 64 | return (uint16_t)data[0] + ((uint16_t)data[1] << 8); |
| 65 | } |
| 66 | static uint32_t getu32(uint8_t *data) |
| 67 | { |
| 68 | return (uint32_t)getu16(data) + ((uint32_t)getu16(data+2) << 16); |
| 69 | } |
| 70 | static uint64_t getu64(uint8_t *data) |
| 71 | { |
| 72 | return (uint64_t)getu32(data) + ((uint64_t)getu32(data+4) << 32); |
| 73 | } |
| 74 | #endif |
| 75 | |
| 76 | #define gets8(x) ((int8_t)getu8(x)) |
| 77 | #define gets16(x) ((int16_t)getu16(x)) |
| 78 | #define gets32(x) ((int32_t)getu32(x)) |
| 79 | #define gets64(x) ((int64_t)getu64(x)) |
| 80 | |
| 81 | /* Important: regval must already have been adjusted for rex extensions */ |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 82 | static enum reg_enum whichreg(int32_t regflags, int regval, int rex) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 83 | { |
H. Peter Anvin | 0da6b58 | 2007-09-12 20:32:39 -0700 | [diff] [blame] | 84 | if (!(regflags & (REGISTER|REGMEM))) |
| 85 | return 0; /* Registers not permissible?! */ |
| 86 | |
| 87 | regflags |= REGISTER; |
| 88 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 89 | if (!(REG_AL & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 90 | return R_AL; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 91 | if (!(REG_AX & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 92 | return R_AX; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 93 | if (!(REG_EAX & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 94 | return R_EAX; |
H. Peter Anvin | 7cf03af | 2007-04-16 02:39:56 +0000 | [diff] [blame] | 95 | if (!(REG_RAX & ~regflags)) |
| 96 | return R_RAX; |
H. Peter Anvin | 10101f2 | 2003-02-24 23:22:45 +0000 | [diff] [blame] | 97 | if (!(REG_DL & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 98 | return R_DL; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 99 | if (!(REG_DX & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 100 | return R_DX; |
H. Peter Anvin | 10101f2 | 2003-02-24 23:22:45 +0000 | [diff] [blame] | 101 | if (!(REG_EDX & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 102 | return R_EDX; |
H. Peter Anvin | 7cf03af | 2007-04-16 02:39:56 +0000 | [diff] [blame] | 103 | if (!(REG_RDX & ~regflags)) |
| 104 | return R_RDX; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 105 | if (!(REG_CL & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 106 | return R_CL; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 107 | if (!(REG_CX & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 108 | return R_CX; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 109 | if (!(REG_ECX & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 110 | return R_ECX; |
H. Peter Anvin | 7cf03af | 2007-04-16 02:39:56 +0000 | [diff] [blame] | 111 | if (!(REG_RCX & ~regflags)) |
| 112 | return R_RCX; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 113 | if (!(FPU0 & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 114 | return R_ST0; |
H. Peter Anvin | d7ed89e | 2002-04-30 20:52:08 +0000 | [diff] [blame] | 115 | if (!(REG_CS & ~regflags)) |
H. Peter Anvin | 232badb | 2002-06-06 02:41:20 +0000 | [diff] [blame] | 116 | return (regval == 1) ? R_CS : 0; |
H. Peter Anvin | 76690a1 | 2002-04-30 20:52:49 +0000 | [diff] [blame] | 117 | if (!(REG_DESS & ~regflags)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 118 | return (regval == 0 || regval == 2 |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 119 | || regval == 3 ? rd_sreg[regval] : 0); |
H. Peter Anvin | 76690a1 | 2002-04-30 20:52:49 +0000 | [diff] [blame] | 120 | if (!(REG_FSGS & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 121 | return (regval == 4 || regval == 5 ? rd_sreg[regval] : 0); |
H. Peter Anvin | 232badb | 2002-06-06 02:41:20 +0000 | [diff] [blame] | 122 | if (!(REG_SEG67 & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 123 | return (regval == 6 || regval == 7 ? rd_sreg[regval] : 0); |
H. Peter Anvin | 232badb | 2002-06-06 02:41:20 +0000 | [diff] [blame] | 124 | |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 125 | /* All the entries below look up regval in an 16-entry array */ |
| 126 | if (regval < 0 || regval > 15) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 127 | return 0; |
H. Peter Anvin | 232badb | 2002-06-06 02:41:20 +0000 | [diff] [blame] | 128 | |
H. Peter Anvin | 0da6b58 | 2007-09-12 20:32:39 -0700 | [diff] [blame] | 129 | if (!(REG8 & ~regflags)) { |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 130 | if (rex & REX_P) |
| 131 | return rd_reg8_rex[regval]; |
| 132 | else |
| 133 | return rd_reg8[regval]; |
| 134 | } |
H. Peter Anvin | 0da6b58 | 2007-09-12 20:32:39 -0700 | [diff] [blame] | 135 | if (!(REG16 & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 136 | return rd_reg16[regval]; |
H. Peter Anvin | 0da6b58 | 2007-09-12 20:32:39 -0700 | [diff] [blame] | 137 | if (!(REG32 & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 138 | return rd_reg32[regval]; |
H. Peter Anvin | 0da6b58 | 2007-09-12 20:32:39 -0700 | [diff] [blame] | 139 | if (!(REG64 & ~regflags)) |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 140 | return rd_reg64[regval]; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 141 | if (!(REG_SREG & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 142 | return rd_sreg[regval & 7]; /* Ignore REX */ |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 143 | if (!(REG_CREG & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 144 | return rd_creg[regval]; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 145 | if (!(REG_DREG & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 146 | return rd_dreg[regval]; |
| 147 | if (!(REG_TREG & ~regflags)) { |
| 148 | if (rex & REX_P) |
| 149 | return 0; /* TR registers are ill-defined with rex */ |
| 150 | return rd_treg[regval]; |
| 151 | } |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 152 | if (!(FPUREG & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 153 | return rd_fpureg[regval & 7]; /* Ignore REX */ |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 154 | if (!(MMXREG & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 155 | return rd_mmxreg[regval & 7]; /* Ignore REX */ |
H. Peter Anvin | 4836e33 | 2002-04-30 20:56:43 +0000 | [diff] [blame] | 156 | if (!(XMMREG & ~regflags)) |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 157 | return rd_xmmreg[regval]; |
H. Peter Anvin | 232badb | 2002-06-06 02:41:20 +0000 | [diff] [blame] | 158 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 159 | return 0; |
| 160 | } |
| 161 | |
Keith Kanios | a6dfa78 | 2007-04-13 16:47:53 +0000 | [diff] [blame] | 162 | static const char *whichcond(int condval) |
H. Peter Anvin | eba20a7 | 2002-04-30 20:53:55 +0000 | [diff] [blame] | 163 | { |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 164 | static int conds[] = { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 165 | C_O, C_NO, C_C, C_NC, C_Z, C_NZ, C_NA, C_A, |
| 166 | C_S, C_NS, C_PE, C_PO, C_L, C_NL, C_NG, C_G |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 167 | }; |
| 168 | return conditions[conds[condval]]; |
| 169 | } |
| 170 | |
| 171 | /* |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 172 | * Process a DREX suffix |
| 173 | */ |
| 174 | static uint8_t *do_drex(uint8_t *data, insn *ins) |
| 175 | { |
| 176 | uint8_t drex = *data++; |
| 177 | operand *dst = &ins->oprs[ins->drexdst]; |
| 178 | |
| 179 | if ((drex & 8) != ((ins->rex & REX_OC) ? 8 : 0)) |
| 180 | return NULL; /* OC0 mismatch */ |
| 181 | ins->rex = (ins->rex & ~7) | (drex & 7); |
H. Peter Anvin | 7065309 | 2007-10-19 14:42:29 -0700 | [diff] [blame] | 182 | |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 183 | dst->segment = SEG_RMREG; |
| 184 | dst->basereg = drex >> 4; |
| 185 | return data; |
| 186 | } |
| 187 | |
| 188 | |
| 189 | /* |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 190 | * Process an effective address (ModRM) specification. |
| 191 | */ |
Keith Kanios | b7a8954 | 2007-04-12 02:40:54 +0000 | [diff] [blame] | 192 | static uint8_t *do_ea(uint8_t *data, int modrm, int asize, |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 193 | int segsize, operand * op, insn *ins) |
H. Peter Anvin | eba20a7 | 2002-04-30 20:53:55 +0000 | [diff] [blame] | 194 | { |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 195 | int mod, rm, scale, index, base; |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 196 | int rex; |
| 197 | uint8_t sib = 0; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 198 | |
| 199 | mod = (modrm >> 6) & 03; |
| 200 | rm = modrm & 07; |
| 201 | |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 202 | if (mod != 3 && rm == 4 && asize != 16) |
| 203 | sib = *data++; |
| 204 | |
| 205 | if (ins->rex & REX_D) { |
| 206 | data = do_drex(data, ins); |
| 207 | if (!data) |
| 208 | return NULL; |
| 209 | } |
| 210 | rex = ins->rex; |
| 211 | |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 212 | if (mod == 3) { /* pure register version */ |
H. Peter Anvin | 7cf03af | 2007-04-16 02:39:56 +0000 | [diff] [blame] | 213 | op->basereg = rm+(rex & REX_B ? 8 : 0); |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 214 | op->segment |= SEG_RMREG; |
| 215 | return data; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 216 | } |
| 217 | |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 218 | op->disp_size = 0; |
H. Peter Anvin | 99c4ecd | 2007-08-28 23:06:00 +0000 | [diff] [blame] | 219 | op->eaflags = 0; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 220 | |
| 221 | if (asize == 16) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 222 | /* |
| 223 | * <mod> specifies the displacement size (none, byte or |
| 224 | * word), and <rm> specifies the register combination. |
| 225 | * Exception: mod=0,rm=6 does not specify [BP] as one might |
| 226 | * expect, but instead specifies [disp16]. |
| 227 | */ |
| 228 | op->indexreg = op->basereg = -1; |
| 229 | op->scale = 1; /* always, in 16 bits */ |
| 230 | switch (rm) { |
| 231 | case 0: |
| 232 | op->basereg = R_BX; |
| 233 | op->indexreg = R_SI; |
| 234 | break; |
| 235 | case 1: |
| 236 | op->basereg = R_BX; |
| 237 | op->indexreg = R_DI; |
| 238 | break; |
| 239 | case 2: |
| 240 | op->basereg = R_BP; |
| 241 | op->indexreg = R_SI; |
| 242 | break; |
| 243 | case 3: |
| 244 | op->basereg = R_BP; |
| 245 | op->indexreg = R_DI; |
| 246 | break; |
| 247 | case 4: |
| 248 | op->basereg = R_SI; |
| 249 | break; |
| 250 | case 5: |
| 251 | op->basereg = R_DI; |
| 252 | break; |
| 253 | case 6: |
| 254 | op->basereg = R_BP; |
| 255 | break; |
| 256 | case 7: |
| 257 | op->basereg = R_BX; |
| 258 | break; |
| 259 | } |
| 260 | if (rm == 6 && mod == 0) { /* special case */ |
| 261 | op->basereg = -1; |
| 262 | if (segsize != 16) |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 263 | op->disp_size = 16; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 264 | mod = 2; /* fake disp16 */ |
| 265 | } |
| 266 | switch (mod) { |
| 267 | case 0: |
| 268 | op->segment |= SEG_NODISP; |
| 269 | break; |
| 270 | case 1: |
| 271 | op->segment |= SEG_DISP8; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 272 | op->offset = (int8_t)*data++; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 273 | break; |
| 274 | case 2: |
| 275 | op->segment |= SEG_DISP16; |
| 276 | op->offset = *data++; |
| 277 | op->offset |= ((unsigned)*data++) << 8; |
| 278 | break; |
| 279 | } |
| 280 | return data; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 281 | } else { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 282 | /* |
| 283 | * Once again, <mod> specifies displacement size (this time |
| 284 | * none, byte or *dword*), while <rm> specifies the base |
| 285 | * register. Again, [EBP] is missing, replaced by a pure |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 286 | * disp32 (this time that's mod=0,rm=*5*) in 32-bit mode, |
| 287 | * and RIP-relative addressing in 64-bit mode. |
| 288 | * |
| 289 | * However, rm=4 |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 290 | * indicates not a single base register, but instead the |
| 291 | * presence of a SIB byte... |
| 292 | */ |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 293 | int a64 = asize == 64; |
| 294 | |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 295 | op->indexreg = -1; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 296 | |
| 297 | if (a64) |
| 298 | op->basereg = rd_reg64[rm | ((rex & REX_B) ? 8 : 0)]; |
| 299 | else |
| 300 | op->basereg = rd_reg32[rm | ((rex & REX_B) ? 8 : 0)]; |
| 301 | |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 302 | if (rm == 5 && mod == 0) { |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 303 | if (segsize == 64) { |
H. Peter Anvin | 99c4ecd | 2007-08-28 23:06:00 +0000 | [diff] [blame] | 304 | op->eaflags |= EAF_REL; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 305 | op->segment |= SEG_RELATIVE; |
| 306 | mod = 2; /* fake disp32 */ |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 307 | } |
H. Peter Anvin | 99c4ecd | 2007-08-28 23:06:00 +0000 | [diff] [blame] | 308 | |
| 309 | if (asize != 64) |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 310 | op->disp_size = asize; |
H. Peter Anvin | 99c4ecd | 2007-08-28 23:06:00 +0000 | [diff] [blame] | 311 | |
| 312 | op->basereg = -1; |
| 313 | mod = 2; /* fake disp32 */ |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 314 | } |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 315 | |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 316 | if (rm == 4) { /* process SIB */ |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 317 | scale = (sib >> 6) & 03; |
| 318 | index = (sib >> 3) & 07; |
| 319 | base = sib & 07; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 320 | |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 321 | op->scale = 1 << scale; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 322 | |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 323 | if (index == 4) |
| 324 | op->indexreg = -1; /* ESP/RSP/R12 cannot be an index */ |
| 325 | else if (a64) |
| 326 | op->indexreg = rd_reg64[index | ((rex & REX_X) ? 8 : 0)]; |
| 327 | else |
| 328 | op->indexreg = rd_reg64[index | ((rex & REX_X) ? 8 : 0)]; |
| 329 | |
| 330 | if (base == 5 && mod == 0) { |
| 331 | op->basereg = -1; |
| 332 | mod = 2; /* Fake disp32 */ |
| 333 | } else if (a64) |
| 334 | op->basereg = rd_reg64[base | ((rex & REX_B) ? 8 : 0)]; |
| 335 | else |
| 336 | op->basereg = rd_reg32[base | ((rex & REX_B) ? 8 : 0)]; |
H. Peter Anvin | 99c4ecd | 2007-08-28 23:06:00 +0000 | [diff] [blame] | 337 | |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 338 | if (segsize == 16) |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 339 | op->disp_size = 32; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 340 | } |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 341 | |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 342 | switch (mod) { |
| 343 | case 0: |
| 344 | op->segment |= SEG_NODISP; |
| 345 | break; |
| 346 | case 1: |
| 347 | op->segment |= SEG_DISP8; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 348 | op->offset = gets8(data); |
| 349 | data++; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 350 | break; |
| 351 | case 2: |
| 352 | op->segment |= SEG_DISP32; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 353 | op->offset = getu32(data); |
| 354 | data += 4; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 355 | break; |
| 356 | } |
| 357 | return data; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 358 | } |
| 359 | } |
| 360 | |
| 361 | /* |
H. Peter Anvin | ef7468f | 2002-04-30 20:57:59 +0000 | [diff] [blame] | 362 | * Determine whether the instruction template in t corresponds to the data |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 363 | * stream in data. Return the number of bytes matched if so. |
| 364 | */ |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 365 | #define case4(x) case (x): case (x)+1: case (x)+2: case (x)+3 |
| 366 | |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 367 | static int matches(const struct itemplate *t, uint8_t *data, |
| 368 | const struct prefix_info *prefix, int segsize, insn *ins) |
H. Peter Anvin | eba20a7 | 2002-04-30 20:53:55 +0000 | [diff] [blame] | 369 | { |
Keith Kanios | b7a8954 | 2007-04-12 02:40:54 +0000 | [diff] [blame] | 370 | uint8_t *r = (uint8_t *)(t->code); |
| 371 | uint8_t *origdata = data; |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 372 | bool a_used = false, o_used = false; |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 373 | enum prefixes drep = 0; |
| 374 | uint8_t lock = prefix->lock; |
| 375 | int osize = prefix->osize; |
| 376 | int asize = prefix->asize; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 377 | int i, c; |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 378 | struct operand *opx; |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 379 | |
H. Peter Anvin | 7eb4a38 | 2007-09-17 15:49:30 -0700 | [diff] [blame] | 380 | for (i = 0; i < MAX_OPERANDS; i++) { |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 381 | ins->oprs[i].segment = ins->oprs[i].disp_size = |
H. Peter Anvin | 7eb4a38 | 2007-09-17 15:49:30 -0700 | [diff] [blame] | 382 | (segsize == 64 ? SEG_64BIT : segsize == 32 ? SEG_32BIT : 0); |
| 383 | } |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 384 | ins->condition = -1; |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 385 | ins->rex = prefix->rex; |
H. Peter Anvin | bb72f7f | 2007-11-12 22:55:27 -0800 | [diff] [blame] | 386 | memset(ins->prefixes, 0, sizeof ins->prefixes); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 387 | |
H. Peter Anvin | 0db11e2 | 2007-04-17 20:23:11 +0000 | [diff] [blame] | 388 | if (t->flags & (segsize == 64 ? IF_NOLONG : IF_LONG)) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 389 | return false; |
H. Peter Anvin | ef7468f | 2002-04-30 20:57:59 +0000 | [diff] [blame] | 390 | |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 391 | if (prefix->rep == 0xF2) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 392 | drep = P_REPNE; |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 393 | else if (prefix->rep == 0xF3) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 394 | drep = P_REP; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 395 | |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 396 | while ((c = *r++) != 0) { |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 397 | opx = &ins->oprs[c & 3]; |
| 398 | |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 399 | switch (c) { |
| 400 | case 01: |
| 401 | case 02: |
| 402 | case 03: |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 403 | while (c--) |
| 404 | if (*r++ != *data++) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 405 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 406 | break; |
| 407 | |
| 408 | case 04: |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 409 | switch (*data++) { |
| 410 | case 0x07: |
| 411 | ins->oprs[0].basereg = 0; |
| 412 | break; |
| 413 | case 0x17: |
| 414 | ins->oprs[0].basereg = 2; |
| 415 | break; |
| 416 | case 0x1F: |
| 417 | ins->oprs[0].basereg = 3; |
| 418 | break; |
| 419 | default: |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 420 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 421 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 422 | break; |
| 423 | |
| 424 | case 05: |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 425 | switch (*data++) { |
| 426 | case 0xA1: |
| 427 | ins->oprs[0].basereg = 4; |
| 428 | break; |
| 429 | case 0xA9: |
| 430 | ins->oprs[0].basereg = 5; |
| 431 | break; |
| 432 | default: |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 433 | return false; |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 434 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 435 | break; |
| 436 | |
| 437 | case 06: |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 438 | switch (*data++) { |
| 439 | case 0x06: |
| 440 | ins->oprs[0].basereg = 0; |
| 441 | break; |
| 442 | case 0x0E: |
| 443 | ins->oprs[0].basereg = 1; |
| 444 | break; |
| 445 | case 0x16: |
| 446 | ins->oprs[0].basereg = 2; |
| 447 | break; |
| 448 | case 0x1E: |
| 449 | ins->oprs[0].basereg = 3; |
| 450 | break; |
| 451 | default: |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 452 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 453 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 454 | break; |
| 455 | |
| 456 | case 07: |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 457 | switch (*data++) { |
| 458 | case 0xA0: |
| 459 | ins->oprs[0].basereg = 4; |
| 460 | break; |
| 461 | case 0xA8: |
| 462 | ins->oprs[0].basereg = 5; |
| 463 | break; |
| 464 | default: |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 465 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 466 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 467 | break; |
| 468 | |
| 469 | case4(010): |
| 470 | { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 471 | int t = *r++, d = *data++; |
| 472 | if (d < t || d > t + 7) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 473 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 474 | else { |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 475 | opx->basereg = (d-t)+ |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 476 | (ins->rex & REX_B ? 8 : 0); |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 477 | opx->segment |= SEG_RMREG; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 478 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 479 | break; |
| 480 | } |
| 481 | |
| 482 | case4(014): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 483 | opx->offset = (int8_t)*data++; |
| 484 | opx->segment |= SEG_SIGNED; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 485 | break; |
| 486 | |
| 487 | case4(020): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 488 | opx->offset = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 489 | break; |
| 490 | |
| 491 | case4(024): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 492 | opx->offset = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 493 | break; |
| 494 | |
| 495 | case4(030): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 496 | opx->offset = getu16(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 497 | data += 2; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 498 | break; |
| 499 | |
| 500 | case4(034): |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 501 | if (osize == 32) { |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 502 | opx->offset = getu32(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 503 | data += 4; |
| 504 | } else { |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 505 | opx->offset = getu16(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 506 | data += 2; |
| 507 | } |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 508 | if (segsize != asize) |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 509 | opx->disp_size = asize; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 510 | break; |
| 511 | |
| 512 | case4(040): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 513 | opx->offset = getu32(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 514 | data += 4; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 515 | break; |
| 516 | |
| 517 | case4(044): |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 518 | switch (asize) { |
| 519 | case 16: |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 520 | opx->offset = getu16(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 521 | data += 2; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 522 | if (segsize != 16) |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 523 | opx->disp_size = 16; |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 524 | break; |
| 525 | case 32: |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 526 | opx->offset = getu32(data); |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 527 | data += 4; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 528 | if (segsize == 16) |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 529 | opx->disp_size = 32; |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 530 | break; |
| 531 | case 64: |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 532 | opx->offset = getu64(data); |
| 533 | opx->disp_size = 64; |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 534 | data += 8; |
| 535 | break; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 536 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 537 | break; |
| 538 | |
| 539 | case4(050): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 540 | opx->offset = gets8(data++); |
| 541 | opx->segment |= SEG_RELATIVE; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 542 | break; |
| 543 | |
| 544 | case4(054): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 545 | opx->offset = getu64(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 546 | data += 8; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 547 | break; |
| 548 | |
| 549 | case4(060): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 550 | opx->offset = gets16(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 551 | data += 2; |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 552 | opx->segment |= SEG_RELATIVE; |
| 553 | opx->segment &= ~SEG_32BIT; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 554 | break; |
| 555 | |
| 556 | case4(064): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 557 | opx->segment |= SEG_RELATIVE; |
H. Peter Anvin | 7cf03af | 2007-04-16 02:39:56 +0000 | [diff] [blame] | 558 | if (osize == 16) { |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 559 | opx->offset = getu16(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 560 | data += 2; |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 561 | opx->segment &= ~(SEG_32BIT|SEG_64BIT); |
H. Peter Anvin | 7cf03af | 2007-04-16 02:39:56 +0000 | [diff] [blame] | 562 | } else if (osize == 32) { |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 563 | opx->offset = getu32(data); |
H. Peter Anvin | 7cf03af | 2007-04-16 02:39:56 +0000 | [diff] [blame] | 564 | data += 4; |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 565 | opx->segment &= ~SEG_64BIT; |
| 566 | opx->segment |= SEG_32BIT; |
H. Peter Anvin | 7065309 | 2007-10-19 14:42:29 -0700 | [diff] [blame] | 567 | } |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 568 | if (segsize != osize) { |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 569 | opx->type = |
| 570 | (opx->type & ~SIZE_MASK) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 571 | | ((osize == 16) ? BITS16 : BITS32); |
| 572 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 573 | break; |
| 574 | |
| 575 | case4(070): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 576 | opx->offset = getu32(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 577 | data += 4; |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 578 | opx->segment |= SEG_32BIT | SEG_RELATIVE; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 579 | break; |
| 580 | |
| 581 | case4(0100): |
| 582 | case4(0110): |
| 583 | case4(0120): |
| 584 | case4(0130): |
| 585 | { |
| 586 | int modrm = *data++; |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 587 | opx->segment |= SEG_RMREG; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 588 | data = do_ea(data, modrm, asize, segsize, |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 589 | &ins->oprs[(c >> 3) & 3], ins); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 590 | if (!data) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 591 | return false; |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 592 | opx->basereg = ((modrm >> 3)&7)+ |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 593 | (ins->rex & REX_R ? 8 : 0); |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 594 | break; |
| 595 | } |
| 596 | |
| 597 | case4(0140): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 598 | opx->offset = getu16(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 599 | data += 2; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 600 | break; |
| 601 | |
| 602 | case4(0150): |
H. Peter Anvin | a5fb908 | 2007-11-12 23:00:31 -0800 | [diff] [blame^] | 603 | opx->offset = getu32(data); |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 604 | data += 4; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 605 | break; |
| 606 | |
| 607 | case4(0160): |
| 608 | ins->rex |= REX_D; |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 609 | ins->drexdst = c & 3; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 610 | break; |
| 611 | |
| 612 | case4(0164): |
| 613 | ins->rex |= REX_D|REX_OC; |
| 614 | ins->drexdst = c & 3; |
| 615 | break; |
| 616 | |
| 617 | case 0170: |
H. Peter Anvin | 7eb4a38 | 2007-09-17 15:49:30 -0700 | [diff] [blame] | 618 | if (*data++) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 619 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 620 | break; |
| 621 | |
| 622 | case 0171: |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 623 | data = do_drex(data, ins); |
| 624 | if (!data) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 625 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 626 | break; |
| 627 | |
| 628 | case4(0200): |
| 629 | case4(0204): |
| 630 | case4(0210): |
| 631 | case4(0214): |
| 632 | case4(0220): |
| 633 | case4(0224): |
| 634 | case4(0230): |
| 635 | case4(0234): |
| 636 | { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 637 | int modrm = *data++; |
| 638 | if (((modrm >> 3) & 07) != (c & 07)) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 639 | return false; /* spare field doesn't match up */ |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 640 | data = do_ea(data, modrm, asize, segsize, |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 641 | &ins->oprs[(c >> 3) & 07], ins); |
| 642 | if (!data) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 643 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 644 | break; |
| 645 | } |
| 646 | |
| 647 | case 0310: |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 648 | if (asize != 16) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 649 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 650 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 651 | a_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 652 | break; |
| 653 | |
| 654 | case 0311: |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 655 | if (asize == 16) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 656 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 657 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 658 | a_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 659 | break; |
| 660 | |
| 661 | case 0312: |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 662 | if (asize != segsize) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 663 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 664 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 665 | a_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 666 | break; |
| 667 | |
| 668 | case 0313: |
H. Peter Anvin | ce2b397 | 2007-05-30 22:21:11 +0000 | [diff] [blame] | 669 | if (asize != 64) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 670 | return false; |
H. Peter Anvin | ce2b397 | 2007-05-30 22:21:11 +0000 | [diff] [blame] | 671 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 672 | a_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 673 | break; |
| 674 | |
| 675 | case 0314: |
H. Peter Anvin | 2344010 | 2007-11-12 21:02:33 -0800 | [diff] [blame] | 676 | if (prefix->rex & REX_B) |
| 677 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 678 | break; |
| 679 | |
| 680 | case 0315: |
H. Peter Anvin | 2344010 | 2007-11-12 21:02:33 -0800 | [diff] [blame] | 681 | if (prefix->rex & REX_X) |
| 682 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 683 | break; |
| 684 | |
| 685 | case 0316: |
H. Peter Anvin | 2344010 | 2007-11-12 21:02:33 -0800 | [diff] [blame] | 686 | if (prefix->rex & REX_R) |
| 687 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 688 | break; |
| 689 | |
| 690 | case 0317: |
H. Peter Anvin | 2344010 | 2007-11-12 21:02:33 -0800 | [diff] [blame] | 691 | if (prefix->rex & REX_W) |
| 692 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 693 | break; |
| 694 | |
| 695 | case 0320: |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 696 | if (osize != 16) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 697 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 698 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 699 | o_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 700 | break; |
| 701 | |
| 702 | case 0321: |
H. Peter Anvin | b061d59 | 2007-04-16 02:02:06 +0000 | [diff] [blame] | 703 | if (osize != 32) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 704 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 705 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 706 | o_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 707 | break; |
| 708 | |
| 709 | case 0322: |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 710 | if (osize != (segsize == 16) ? 16 : 32) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 711 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 712 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 713 | o_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 714 | break; |
| 715 | |
| 716 | case 0323: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 717 | ins->rex |= REX_W; /* 64-bit only instruction */ |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 718 | osize = 64; |
H. Peter Anvin | bb72f7f | 2007-11-12 22:55:27 -0800 | [diff] [blame] | 719 | o_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 720 | break; |
| 721 | |
| 722 | case 0324: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 723 | if (!(ins->rex & (REX_P|REX_W)) || osize != 64) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 724 | return false; |
H. Peter Anvin | bb72f7f | 2007-11-12 22:55:27 -0800 | [diff] [blame] | 725 | o_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 726 | break; |
| 727 | |
| 728 | case 0330: |
| 729 | { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 730 | int t = *r++, d = *data++; |
| 731 | if (d < t || d > t + 15) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 732 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 733 | else |
| 734 | ins->condition = d - t; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 735 | break; |
| 736 | } |
| 737 | |
| 738 | case 0331: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 739 | if (prefix->rep) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 740 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 741 | break; |
| 742 | |
| 743 | case 0332: |
H. Peter Anvin | cb9b690 | 2007-09-12 21:58:51 -0700 | [diff] [blame] | 744 | if (prefix->rep != 0xF2) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 745 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 746 | break; |
| 747 | |
| 748 | case 0333: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 749 | if (prefix->rep != 0xF3) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 750 | return false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 751 | drep = 0; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 752 | break; |
| 753 | |
| 754 | case 0334: |
H. Peter Anvin | 0db11e2 | 2007-04-17 20:23:11 +0000 | [diff] [blame] | 755 | if (lock) { |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 756 | ins->rex |= REX_R; |
H. Peter Anvin | 0db11e2 | 2007-04-17 20:23:11 +0000 | [diff] [blame] | 757 | lock = 0; |
| 758 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 759 | break; |
| 760 | |
| 761 | case 0335: |
H. Peter Anvin | cb9b690 | 2007-09-12 21:58:51 -0700 | [diff] [blame] | 762 | if (drep == P_REP) |
| 763 | drep = P_REPE; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 764 | break; |
| 765 | |
| 766 | case 0340: |
| 767 | return false; |
| 768 | |
| 769 | case 0364: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 770 | if (prefix->osp) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 771 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 772 | break; |
| 773 | |
| 774 | case 0365: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 775 | if (prefix->asp) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 776 | return false; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 777 | break; |
| 778 | |
| 779 | case 0366: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 780 | if (!prefix->osp) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 781 | return false; |
| 782 | o_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 783 | break; |
| 784 | |
| 785 | case 0367: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 786 | if (!prefix->asp) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 787 | return false; |
H. Peter Anvin | bb72f7f | 2007-11-12 22:55:27 -0800 | [diff] [blame] | 788 | a_used = true; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 789 | break; |
| 790 | |
| 791 | default: |
| 792 | return false; /* Unknown code */ |
H. Peter Anvin | 0db11e2 | 2007-04-17 20:23:11 +0000 | [diff] [blame] | 793 | } |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 794 | } |
| 795 | |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 796 | /* REX cannot be combined with DREX */ |
| 797 | if ((ins->rex & REX_D) && (prefix->rex)) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 798 | return false; |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 799 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 800 | /* |
H. Peter Anvin | ef7468f | 2002-04-30 20:57:59 +0000 | [diff] [blame] | 801 | * Check for unused rep or a/o prefixes. |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 802 | */ |
H. Peter Anvin | c5b9ce0 | 2007-09-22 21:49:51 -0700 | [diff] [blame] | 803 | for (i = 0; i < t->operands; i++) { |
| 804 | if (ins->oprs[i].segment != SEG_RMREG) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 805 | a_used = true; |
H. Peter Anvin | c5b9ce0 | 2007-09-22 21:49:51 -0700 | [diff] [blame] | 806 | } |
| 807 | |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 808 | if (lock) { |
| 809 | if (ins->prefixes[PPS_LREP]) |
| 810 | return false; |
| 811 | ins->prefixes[PPS_LREP] = P_LOCK; |
| 812 | } |
| 813 | if (drep) { |
| 814 | if (ins->prefixes[PPS_LREP]) |
| 815 | return false; |
| 816 | ins->prefixes[PPS_LREP] = drep; |
| 817 | } |
H. Peter Anvin | bb72f7f | 2007-11-12 22:55:27 -0800 | [diff] [blame] | 818 | if (!o_used) { |
| 819 | if (osize != ((segsize == 16) ? 16 : 32)) { |
| 820 | enum prefixes pfx = 0; |
| 821 | |
| 822 | switch (osize) { |
| 823 | case 16: |
| 824 | pfx = P_O16; |
| 825 | break; |
| 826 | case 32: |
| 827 | pfx = P_O32; |
| 828 | break; |
| 829 | case 64: |
| 830 | pfx = P_O64; |
| 831 | break; |
| 832 | } |
| 833 | |
| 834 | if (ins->prefixes[PPS_OSIZE]) |
| 835 | return false; |
| 836 | ins->prefixes[PPS_OSIZE] = pfx; |
| 837 | } |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 838 | } |
| 839 | if (!a_used && asize != segsize) { |
| 840 | if (ins->prefixes[PPS_ASIZE]) |
| 841 | return false; |
| 842 | ins->prefixes[PPS_ASIZE] = asize == 16 ? P_A16 : P_A32; |
| 843 | } |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 844 | |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 845 | /* Fix: check for redundant REX prefixes */ |
| 846 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 847 | return data - origdata; |
| 848 | } |
| 849 | |
Keith Kanios | a6dfa78 | 2007-04-13 16:47:53 +0000 | [diff] [blame] | 850 | int32_t disasm(uint8_t *data, char *output, int outbufsize, int segsize, |
Keith Kanios | b7a8954 | 2007-04-12 02:40:54 +0000 | [diff] [blame] | 851 | int32_t offset, int autosync, uint32_t prefer) |
H. Peter Anvin | eba20a7 | 2002-04-30 20:53:55 +0000 | [diff] [blame] | 852 | { |
H. Peter Anvin | 3360d79 | 2007-09-11 04:16:57 +0000 | [diff] [blame] | 853 | const struct itemplate * const *p, * const *best_p; |
H. Peter Anvin | 19e2010 | 2007-09-18 15:08:20 -0700 | [diff] [blame] | 854 | const struct disasm_index *ix; |
| 855 | uint8_t *dp; |
H. Peter Anvin | 4836e33 | 2002-04-30 20:56:43 +0000 | [diff] [blame] | 856 | int length, best_length = 0; |
Keith Kanios | a6dfa78 | 2007-04-13 16:47:53 +0000 | [diff] [blame] | 857 | char *segover; |
H. Peter Anvin | 19e2010 | 2007-09-18 15:08:20 -0700 | [diff] [blame] | 858 | int i, slen, colon, n; |
Keith Kanios | b7a8954 | 2007-04-12 02:40:54 +0000 | [diff] [blame] | 859 | uint8_t *origdata; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 860 | int works; |
H. Peter Anvin | ef7468f | 2002-04-30 20:57:59 +0000 | [diff] [blame] | 861 | insn tmp_ins, ins; |
Keith Kanios | b7a8954 | 2007-04-12 02:40:54 +0000 | [diff] [blame] | 862 | uint32_t goodness, best; |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 863 | int best_pref; |
| 864 | struct prefix_info prefix; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 865 | bool end_prefix; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 866 | |
H. Peter Anvin | bfb888c | 2007-09-11 04:26:44 +0000 | [diff] [blame] | 867 | memset(&ins, 0, sizeof ins); |
| 868 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 869 | /* |
| 870 | * Scan for prefixes. |
| 871 | */ |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 872 | memset(&prefix, 0, sizeof prefix); |
| 873 | prefix.asize = segsize; |
| 874 | prefix.osize = (segsize == 64) ? 32 : segsize; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 875 | segover = NULL; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 876 | origdata = data; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 877 | |
| 878 | for (end_prefix = false; !end_prefix; ) { |
| 879 | switch (*data) { |
| 880 | case 0xF2: |
| 881 | case 0xF3: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 882 | prefix.rep = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 883 | break; |
| 884 | case 0xF0: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 885 | prefix.lock = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 886 | break; |
| 887 | case 0x2E: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 888 | segover = "cs", prefix.seg = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 889 | break; |
| 890 | case 0x36: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 891 | segover = "ss", prefix.seg = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 892 | break; |
| 893 | case 0x3E: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 894 | segover = "ds", prefix.seg = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 895 | break; |
| 896 | case 0x26: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 897 | segover = "es", prefix.seg = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 898 | break; |
| 899 | case 0x64: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 900 | segover = "fs", prefix.seg = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 901 | break; |
| 902 | case 0x65: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 903 | segover = "gs", prefix.seg = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 904 | break; |
| 905 | case 0x66: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 906 | prefix.osize = (segsize == 16) ? 32 : 16; |
| 907 | prefix.osp = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 908 | break; |
| 909 | case 0x67: |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 910 | prefix.asize = (segsize == 32) ? 16 : 32; |
| 911 | prefix.asp = *data++; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 912 | break; |
| 913 | default: |
| 914 | if (segsize == 64 && (*data & 0xf0) == REX_P) { |
| 915 | prefix.rex = *data++; |
| 916 | if (prefix.rex & REX_W) |
| 917 | prefix.osize = 64; |
| 918 | end_prefix = true; |
| 919 | } else { |
| 920 | end_prefix = true; |
| 921 | } |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 922 | } |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 923 | } |
| 924 | |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 925 | best = -1; /* Worst possible */ |
H. Peter Anvin | 4836e33 | 2002-04-30 20:56:43 +0000 | [diff] [blame] | 926 | best_p = NULL; |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 927 | best_pref = INT_MAX; |
| 928 | |
H. Peter Anvin | 19e2010 | 2007-09-18 15:08:20 -0700 | [diff] [blame] | 929 | dp = data; |
| 930 | ix = itable + *dp++; |
Charles Crayne | 46b31b0 | 2007-10-18 21:17:20 -0700 | [diff] [blame] | 931 | while (ix->n == -1) { |
H. Peter Anvin | 19e2010 | 2007-09-18 15:08:20 -0700 | [diff] [blame] | 932 | ix = (const struct disasm_index *)ix->p + *dp++; |
| 933 | } |
| 934 | |
| 935 | p = (const struct itemplate * const *)ix->p; |
| 936 | for (n = ix->n; n; n--, p++) { |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 937 | if ((length = matches(*p, data, &prefix, segsize, &tmp_ins))) { |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 938 | works = true; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 939 | /* |
| 940 | * Final check to make sure the types of r/m match up. |
H. Peter Anvin | dbf130e | 2007-05-30 00:18:26 +0000 | [diff] [blame] | 941 | * XXX: Need to make sure this is actually correct. |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 942 | */ |
| 943 | for (i = 0; i < (*p)->operands; i++) { |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 944 | if (!((*p)->opd[i] & SAME_AS) && |
| 945 | ( |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 946 | /* If it's a mem-only EA but we have a |
| 947 | register, die. */ |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 948 | ((tmp_ins.oprs[i].segment & SEG_RMREG) && |
| 949 | !(MEMORY & ~(*p)->opd[i])) || |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 950 | /* If it's a reg-only EA but we have a memory |
| 951 | ref, die. */ |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 952 | (!(tmp_ins.oprs[i].segment & SEG_RMREG) && |
| 953 | !(REG_EA & ~(*p)->opd[i]) && |
| 954 | !((*p)->opd[i] & REG_SMASK)) || |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 955 | /* Register type mismatch (eg FS vs REG_DESS): |
| 956 | die. */ |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 957 | ((((*p)->opd[i] & (REGISTER | FPUREG)) || |
| 958 | (tmp_ins.oprs[i].segment & SEG_RMREG)) && |
| 959 | !whichreg((*p)->opd[i], |
| 960 | tmp_ins.oprs[i].basereg, tmp_ins.rex)) |
| 961 | )) { |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 962 | works = false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 963 | break; |
| 964 | } |
| 965 | } |
| 966 | |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 967 | /* |
| 968 | * Note: we always prefer instructions which incorporate |
| 969 | * prefixes in the instructions themselves. This is to allow |
| 970 | * e.g. PAUSE to be preferred to REP NOP, and deal with |
| 971 | * MMX/SSE instructions where prefixes are used to select |
| 972 | * between MMX and SSE register sets or outright opcode |
| 973 | * selection. |
| 974 | */ |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 975 | if (works) { |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 976 | int i, nprefix; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 977 | goodness = ((*p)->flags & IF_PFMASK) ^ prefer; |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 978 | nprefix = 0; |
| 979 | for (i = 0; i < MAXPREFIX; i++) |
| 980 | if (tmp_ins.prefixes[i]) |
| 981 | nprefix++; |
| 982 | if (nprefix < best_pref || |
| 983 | (nprefix == best_pref && goodness < best)) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 984 | /* This is the best one found so far */ |
| 985 | best = goodness; |
| 986 | best_p = p; |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 987 | best_pref = nprefix; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 988 | best_length = length; |
| 989 | ins = tmp_ins; |
| 990 | } |
| 991 | } |
| 992 | } |
H. Peter Anvin | 4836e33 | 2002-04-30 20:56:43 +0000 | [diff] [blame] | 993 | } |
H. Peter Anvin | eba20a7 | 2002-04-30 20:53:55 +0000 | [diff] [blame] | 994 | |
H. Peter Anvin | ef7468f | 2002-04-30 20:57:59 +0000 | [diff] [blame] | 995 | if (!best_p) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 996 | return 0; /* no instruction was matched */ |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 997 | |
H. Peter Anvin | 4836e33 | 2002-04-30 20:56:43 +0000 | [diff] [blame] | 998 | /* Pick the best match */ |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 999 | p = best_p; |
H. Peter Anvin | 4836e33 | 2002-04-30 20:56:43 +0000 | [diff] [blame] | 1000 | length = best_length; |
| 1001 | |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1002 | slen = 0; |
| 1003 | |
Ed Beroset | 64ab519 | 2004-12-15 23:32:57 +0000 | [diff] [blame] | 1004 | /* TODO: snprintf returns the value that the string would have if |
H. Peter Anvin | 7065309 | 2007-10-19 14:42:29 -0700 | [diff] [blame] | 1005 | * the buffer were long enough, and not the actual length of |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1006 | * the returned string, so each instance of using the return |
| 1007 | * value of snprintf should actually be checked to assure that |
| 1008 | * the return value is "sane." Maybe a macro wrapper could |
| 1009 | * be used for that purpose. |
| 1010 | */ |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 1011 | for (i = 0; i < MAXPREFIX; i++) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1012 | switch (ins.prefixes[i]) { |
H. Peter Anvin | 0db11e2 | 2007-04-17 20:23:11 +0000 | [diff] [blame] | 1013 | case P_LOCK: |
| 1014 | slen += snprintf(output + slen, outbufsize - slen, "lock "); |
| 1015 | break; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1016 | case P_REP: |
| 1017 | slen += snprintf(output + slen, outbufsize - slen, "rep "); |
| 1018 | break; |
| 1019 | case P_REPE: |
| 1020 | slen += snprintf(output + slen, outbufsize - slen, "repe "); |
| 1021 | break; |
| 1022 | case P_REPNE: |
| 1023 | slen += snprintf(output + slen, outbufsize - slen, "repne "); |
| 1024 | break; |
| 1025 | case P_A16: |
| 1026 | slen += snprintf(output + slen, outbufsize - slen, "a16 "); |
| 1027 | break; |
| 1028 | case P_A32: |
| 1029 | slen += snprintf(output + slen, outbufsize - slen, "a32 "); |
| 1030 | break; |
H. Peter Anvin | bb72f7f | 2007-11-12 22:55:27 -0800 | [diff] [blame] | 1031 | case P_A64: |
| 1032 | slen += snprintf(output + slen, outbufsize - slen, "a64 "); |
| 1033 | break; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1034 | case P_O16: |
| 1035 | slen += snprintf(output + slen, outbufsize - slen, "o16 "); |
| 1036 | break; |
| 1037 | case P_O32: |
| 1038 | slen += snprintf(output + slen, outbufsize - slen, "o32 "); |
| 1039 | break; |
H. Peter Anvin | bb72f7f | 2007-11-12 22:55:27 -0800 | [diff] [blame] | 1040 | case P_O64: |
| 1041 | slen += snprintf(output + slen, outbufsize - slen, "o64 "); |
| 1042 | break; |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 1043 | default: |
| 1044 | break; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1045 | } |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1046 | |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 1047 | for (i = 0; i < (int)elements(ico); i++) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1048 | if ((*p)->opcode == ico[i]) { |
| 1049 | slen += |
| 1050 | snprintf(output + slen, outbufsize - slen, "%s%s", icn[i], |
| 1051 | whichcond(ins.condition)); |
| 1052 | break; |
| 1053 | } |
H. Peter Anvin | 2ba7ed7 | 2007-09-11 22:13:17 +0000 | [diff] [blame] | 1054 | if (i >= (int)elements(ico)) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1055 | slen += |
| 1056 | snprintf(output + slen, outbufsize - slen, "%s", |
| 1057 | insn_names[(*p)->opcode]); |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 1058 | colon = false; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1059 | length += data - origdata; /* fix up for prefixes */ |
| 1060 | for (i = 0; i < (*p)->operands; i++) { |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1061 | opflags_t t = (*p)->opd[i]; |
| 1062 | const operand *o = &ins.oprs[i]; |
| 1063 | int64_t offs; |
| 1064 | |
| 1065 | if (t & SAME_AS) { |
| 1066 | o = &ins.oprs[t & ~SAME_AS]; |
| 1067 | t = (*p)->opd[t & ~SAME_AS]; |
| 1068 | } |
| 1069 | |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1070 | output[slen++] = (colon ? ':' : i == 0 ? ' ' : ','); |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1071 | |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1072 | offs = o->offset; |
| 1073 | if (o->segment & SEG_RELATIVE) { |
| 1074 | offs += offset + length; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1075 | /* |
| 1076 | * sort out wraparound |
| 1077 | */ |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1078 | if (!(o->segment & (SEG_32BIT|SEG_64BIT))) |
| 1079 | offs &= 0xffff; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1080 | /* |
| 1081 | * add sync marker, if autosync is on |
| 1082 | */ |
| 1083 | if (autosync) |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1084 | add_sync(offs, 0L); |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1085 | } |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1086 | |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1087 | if (t & COLON) |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 1088 | colon = true; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1089 | else |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 1090 | colon = false; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1091 | |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1092 | if ((t & (REGISTER | FPUREG)) || |
| 1093 | (o->segment & SEG_RMREG)) { |
| 1094 | enum reg_enum reg; |
| 1095 | reg = whichreg(t, o->basereg, ins.rex); |
| 1096 | if (t & TO) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1097 | slen += snprintf(output + slen, outbufsize - slen, "to "); |
| 1098 | slen += snprintf(output + slen, outbufsize - slen, "%s", |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1099 | reg_names[reg - EXPR_REG_START]); |
| 1100 | } else if (!(UNITY & ~t)) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1101 | output[slen++] = '1'; |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1102 | } else if (t & IMMEDIATE) { |
| 1103 | if (t & BITS8) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1104 | slen += |
| 1105 | snprintf(output + slen, outbufsize - slen, "byte "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1106 | if (o->segment & SEG_SIGNED) { |
| 1107 | if (offs < 0) { |
| 1108 | offs *= -1; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1109 | output[slen++] = '-'; |
| 1110 | } else |
| 1111 | output[slen++] = '+'; |
| 1112 | } |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1113 | } else if (t & BITS16) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1114 | slen += |
| 1115 | snprintf(output + slen, outbufsize - slen, "word "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1116 | } else if (t & BITS32) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1117 | slen += |
| 1118 | snprintf(output + slen, outbufsize - slen, "dword "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1119 | } else if (t & BITS64) { |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1120 | slen += |
| 1121 | snprintf(output + slen, outbufsize - slen, "qword "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1122 | } else if (t & NEAR) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1123 | slen += |
| 1124 | snprintf(output + slen, outbufsize - slen, "near "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1125 | } else if (t & SHORT) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1126 | slen += |
| 1127 | snprintf(output + slen, outbufsize - slen, "short "); |
| 1128 | } |
| 1129 | slen += |
Keith Kanios | 93f2e9a | 2007-04-14 00:10:59 +0000 | [diff] [blame] | 1130 | snprintf(output + slen, outbufsize - slen, "0x%"PRIx64"", |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1131 | offs); |
| 1132 | } else if (!(MEM_OFFS & ~t)) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1133 | slen += |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1134 | snprintf(output + slen, outbufsize - slen, |
| 1135 | "[%s%s%s0x%"PRIx64"]", |
H. Peter Anvin | 62cb606 | 2007-09-11 22:44:03 +0000 | [diff] [blame] | 1136 | (segover ? segover : ""), |
| 1137 | (segover ? ":" : ""), |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1138 | (o->disp_size == 64 ? "qword " : |
| 1139 | o->disp_size == 32 ? "dword " : |
| 1140 | o->disp_size == 16 ? "word " : ""), offs); |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1141 | segover = NULL; |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1142 | } else if (!(REGMEM & ~t)) { |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 1143 | int started = false; |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1144 | if (t & BITS8) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1145 | slen += |
| 1146 | snprintf(output + slen, outbufsize - slen, "byte "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1147 | if (t & BITS16) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1148 | slen += |
| 1149 | snprintf(output + slen, outbufsize - slen, "word "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1150 | if (t & BITS32) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1151 | slen += |
| 1152 | snprintf(output + slen, outbufsize - slen, "dword "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1153 | if (t & BITS64) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1154 | slen += |
| 1155 | snprintf(output + slen, outbufsize - slen, "qword "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1156 | if (t & BITS80) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1157 | slen += |
| 1158 | snprintf(output + slen, outbufsize - slen, "tword "); |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1159 | if (t & BITS128) |
| 1160 | slen += |
| 1161 | snprintf(output + slen, outbufsize - slen, "oword "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1162 | if (t & FAR) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1163 | slen += snprintf(output + slen, outbufsize - slen, "far "); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1164 | if (t & NEAR) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1165 | slen += |
| 1166 | snprintf(output + slen, outbufsize - slen, "near "); |
| 1167 | output[slen++] = '['; |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 1168 | if (o->disp_size) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1169 | slen += snprintf(output + slen, outbufsize - slen, "%s", |
H. Peter Anvin | de4b89b | 2007-10-01 15:41:25 -0700 | [diff] [blame] | 1170 | (o->disp_size == 64 ? "qword " : |
| 1171 | o->disp_size == 32 ? "dword " : |
| 1172 | o->disp_size == 16 ? "word " : |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1173 | "")); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1174 | if (o->eaflags & EAF_REL) |
H. Peter Anvin | 99c4ecd | 2007-08-28 23:06:00 +0000 | [diff] [blame] | 1175 | slen += snprintf(output + slen, outbufsize - slen, "rel "); |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1176 | if (segover) { |
| 1177 | slen += |
| 1178 | snprintf(output + slen, outbufsize - slen, "%s:", |
| 1179 | segover); |
| 1180 | segover = NULL; |
| 1181 | } |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1182 | if (o->basereg != -1) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1183 | slen += snprintf(output + slen, outbufsize - slen, "%s", |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1184 | reg_names[(o->basereg - |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1185 | EXPR_REG_START)]); |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 1186 | started = true; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1187 | } |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1188 | if (o->indexreg != -1) { |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1189 | if (started) |
| 1190 | output[slen++] = '+'; |
| 1191 | slen += snprintf(output + slen, outbufsize - slen, "%s", |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1192 | reg_names[(o->indexreg - |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1193 | EXPR_REG_START)]); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1194 | if (o->scale > 1) |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1195 | slen += |
| 1196 | snprintf(output + slen, outbufsize - slen, "*%d", |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1197 | o->scale); |
H. Peter Anvin | 6867acc | 2007-10-10 14:58:45 -0700 | [diff] [blame] | 1198 | started = true; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1199 | } |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1200 | |
| 1201 | |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1202 | if (o->segment & SEG_DISP8) { |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1203 | const char *prefix; |
| 1204 | uint8_t offset = offs; |
| 1205 | if ((int8_t)offset < 0) { |
| 1206 | prefix = "-"; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1207 | offset = -offset; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1208 | } else { |
| 1209 | prefix = "+"; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1210 | } |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1211 | slen += |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1212 | snprintf(output + slen, outbufsize - slen, "%s0x%"PRIx8"", |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1213 | prefix, offset); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1214 | } else if (o->segment & SEG_DISP16) { |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1215 | const char *prefix; |
| 1216 | uint16_t offset = offs; |
| 1217 | if ((int16_t)offset < 0 && started) { |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1218 | offset = -offset; |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1219 | prefix = "-"; |
| 1220 | } else { |
| 1221 | prefix = started ? "+" : ""; |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1222 | } |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1223 | slen += |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1224 | snprintf(output + slen, outbufsize - slen, |
| 1225 | "%s0x%"PRIx16"", prefix, offset); |
H. Peter Anvin | 7786c36 | 2007-09-17 18:45:44 -0700 | [diff] [blame] | 1226 | } else if (o->segment & SEG_DISP32) { |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1227 | if (prefix.asize == 64) { |
| 1228 | const char *prefix; |
| 1229 | uint64_t offset = (int64_t)(int32_t)offs; |
| 1230 | if ((int32_t)offs < 0 && started) { |
| 1231 | offset = -offset; |
| 1232 | prefix = "-"; |
| 1233 | } else { |
| 1234 | prefix = started ? "+" : ""; |
| 1235 | } |
| 1236 | slen += |
| 1237 | snprintf(output + slen, outbufsize - slen, |
| 1238 | "%s0x%"PRIx64"", prefix, offset); |
| 1239 | } else { |
| 1240 | const char *prefix; |
| 1241 | uint32_t offset = offs; |
| 1242 | if ((int32_t) offset < 0 && started) { |
H. Peter Anvin | 0ee0142 | 2007-04-16 01:18:30 +0000 | [diff] [blame] | 1243 | offset = -offset; |
| 1244 | prefix = "-"; |
| 1245 | } else { |
| 1246 | prefix = started ? "+" : ""; |
| 1247 | } |
| 1248 | slen += |
| 1249 | snprintf(output + slen, outbufsize - slen, |
| 1250 | "%s0x%"PRIx32"", prefix, offset); |
H. Peter Anvin | e8cdcdc | 2007-11-12 21:57:00 -0800 | [diff] [blame] | 1251 | } |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1252 | } |
| 1253 | output[slen++] = ']'; |
| 1254 | } else { |
| 1255 | slen += |
| 1256 | snprintf(output + slen, outbufsize - slen, "<operand%d>", |
| 1257 | i); |
| 1258 | } |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1259 | } |
| 1260 | output[slen] = '\0'; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1261 | if (segover) { /* unused segment override */ |
Keith Kanios | a6dfa78 | 2007-04-13 16:47:53 +0000 | [diff] [blame] | 1262 | char *p = output; |
H. Peter Anvin | e2c8018 | 2005-01-15 22:15:51 +0000 | [diff] [blame] | 1263 | int count = slen + 1; |
| 1264 | while (count--) |
| 1265 | p[count + 3] = p[count]; |
| 1266 | strncpy(output, segover, 2); |
| 1267 | output[2] = ' '; |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1268 | } |
| 1269 | return length; |
| 1270 | } |
| 1271 | |
Keith Kanios | a6dfa78 | 2007-04-13 16:47:53 +0000 | [diff] [blame] | 1272 | int32_t eatbyte(uint8_t *data, char *output, int outbufsize) |
H. Peter Anvin | eba20a7 | 2002-04-30 20:53:55 +0000 | [diff] [blame] | 1273 | { |
Ed Beroset | 9234817 | 2004-12-15 18:27:50 +0000 | [diff] [blame] | 1274 | snprintf(output, outbufsize, "db 0x%02X", *data); |
H. Peter Anvin | ea6e34d | 2002-04-30 20:51:32 +0000 | [diff] [blame] | 1275 | return 1; |
| 1276 | } |