projects / dragonfly.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
rename amd64 architecture to x86_64
[dragonfly.git] / sys / platform / pc64 / x86_64 / db_disasm.c
CommitLineData
d7f50089 1/*
c8fe38ae
MD		 2 * Copyright (c) 2008 The DragonFly Project. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 * 3. Neither the name of The DragonFly Project nor the names of its
15 * contributors may be used to endorse or promote products derived
16 * from this software without specific, prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
26 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
28 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * --
32 *
d7f50089
YY		 33 * Mach Operating System
34 * Copyright (c) 1991,1990 Carnegie Mellon University
35 * All Rights Reserved.
36 *
37 * Permission to use, copy, modify and distribute this software and its
38 * documentation is hereby granted, provided that both the copyright
39 * notice and this permission notice appear in all copies of the
40 * software, derivative works or modified versions, and any portions
41 * thereof, and that both notices appear in supporting documentation.
42 *
43 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
44 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
45 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
46 *
47 * Carnegie Mellon requests users of this software to return to
48 *
49 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
50 * School of Computer Science
51 * Carnegie Mellon University
52 * Pittsburgh PA 15213-3890
53 *
54 * any improvements or extensions that they make and grant Carnegie the
55 * rights to redistribute these changes.
d7f50089
YY		 56 */
57
58/*
59 * Instruction disassembler.
60 */
61#include <sys/param.h>
62
63#include <ddb/ddb.h>
64#include <ddb/db_access.h>
65#include <ddb/db_sym.h>
66
67/*
68 * Size attributes
69 */
70#define BYTE 0
71#define WORD 1
72#define LONG 2
73#define QUAD 3
74#define SNGL 4
75#define DBLR 5
76#define EXTR 6
77#define SDEP 7
78#define NONE 8
79
80/*
c8fe38ae
MD		 81 * REX prefix and bits
82 */
83#define REX_B 1
84#define REX_X 2
85#define REX_R 4
86#define REX_W 8
87#define REX 0x40
88
89/*
d7f50089
YY		 90 * Addressing modes
91 */
92#define E 1 /* general effective address */
93#define Eind 2 /* indirect address (jump, call) */
94#define Ew 3 /* address, word size */
95#define Eb 4 /* address, byte size */
96#define R 5 /* register, in 'reg' field */
97#define Rw 6 /* word register, in 'reg' field */
98#define Ri 7 /* register in instruction */
99#define S 8 /* segment reg, in 'reg' field */
100#define Si 9 /* segment reg, in instruction */
101#define A 10 /* accumulator */
102#define BX 11 /* (bx) */
103#define CL 12 /* cl, for shifts */
104#define DX 13 /* dx, for IO */
105#define SI 14 /* si */
106#define DI 15 /* di */
107#define CR 16 /* control register */
108#define DR 17 /* debug register */
109#define TR 18 /* test register */
110#define I 19 /* immediate, unsigned */
111#define Is 20 /* immediate, signed */
112#define Ib 21 /* byte immediate, unsigned */
113#define Ibs 22 /* byte immediate, signed */
114#define Iw 23 /* word immediate, unsigned */
c8fe38ae 115#define Ilq 24 /* long/quad immediate, unsigned */
d7f50089
YY		 116#define O 25 /* direct address */
117#define Db 26 /* byte displacement from EIP */
118#define Dl 27 /* long displacement from EIP */
119#define o1 28 /* constant 1 */
120#define o3 29 /* constant 3 */
121#define OS 30 /* immediate offset/segment */
122#define ST 31 /* FP stack top */
123#define STI 32 /* FP stack */
124#define X 33 /* extended FP op */
125#define XA 34 /* for 'fstcw %ax' */
c8fe38ae 126#define El 35 /* address, long/quad size */
d7f50089
YY		 127#define Ril 36 /* long register in instruction */
128#define Iba 37 /* byte immediate, don't print if 0xa */
c8fe38ae 129#define EL 38 /* address, explicitly long size */
d7f50089
YY		 130
131struct inst {
132 const char * i_name; /* name */
133 short i_has_modrm; /* has regmodrm byte */
134 short i_size; /* operand size */
135 int i_mode; /* addressing modes */
136 const void * i_extra; /* pointer to extra opcode table */
137};
138
139#define op1(x) (x)
140#define op2(x,y) ((x)|((y)<<8))
141#define op3(x,y,z) ((x)|((y)<<8)|((z)<<16))
142
143struct finst {
144 const char * f_name; /* name for memory instruction */
145 int f_size; /* size for memory instruction */
146 int f_rrmode; /* mode for rr instruction */
147 const void * f_rrname; /* name for rr instruction
148 (or pointer to table) */
149};
150
151static const char * const db_Grp6[] = {
152 "sldt",
153 "str",
154 "lldt",
155 "ltr",
156 "verr",
157 "verw",
158 "",
159 ""
160};
161
162static const char * const db_Grp7[] = {
163 "sgdt",
164 "sidt",
165 "lgdt",
166 "lidt",
167 "smsw",
168 "",
169 "lmsw",
170 "invlpg"
171};
172
173static const char * const db_Grp8[] = {
174 "",
175 "",
176 "",
177 "",
178 "bt",
179 "bts",
180 "btr",
181 "btc"
182};
183
184static const char * const db_Grp9[] = {
185 "",
186 "cmpxchg8b",
187 "",
188 "",
189 "",
190 "",
191 "",
192 ""
193};
194
195static const struct inst db_inst_0f0x[] = {
196/*00*/ { "", TRUE, NONE, op1(Ew), db_Grp6 },
197/*01*/ { "", TRUE, NONE, op1(Ew), db_Grp7 },
198/*02*/ { "lar", TRUE, LONG, op2(E,R), 0 },
199/*03*/ { "lsl", TRUE, LONG, op2(E,R), 0 },
200/*04*/ { "", FALSE, NONE, 0, 0 },
201/*05*/ { "", FALSE, NONE, 0, 0 },
202/*06*/ { "clts", FALSE, NONE, 0, 0 },
203/*07*/ { "", FALSE, NONE, 0, 0 },
204
205/*08*/ { "invd", FALSE, NONE, 0, 0 },
206/*09*/ { "wbinvd",FALSE, NONE, 0, 0 },
207/*0a*/ { "", FALSE, NONE, 0, 0 },
208/*0b*/ { "", FALSE, NONE, 0, 0 },
209/*0c*/ { "", FALSE, NONE, 0, 0 },
210/*0d*/ { "", FALSE, NONE, 0, 0 },
211/*0e*/ { "", FALSE, NONE, 0, 0 },
212/*0f*/ { "", FALSE, NONE, 0, 0 },
213};
214
215static const struct inst db_inst_0f2x[] = {
216/*20*/ { "mov", TRUE, LONG, op2(CR,El), 0 },
217/*21*/ { "mov", TRUE, LONG, op2(DR,El), 0 },
218/*22*/ { "mov", TRUE, LONG, op2(El,CR), 0 },
219/*23*/ { "mov", TRUE, LONG, op2(El,DR), 0 },
220/*24*/ { "mov", TRUE, LONG, op2(TR,El), 0 },
221/*25*/ { "", FALSE, NONE, 0, 0 },
222/*26*/ { "mov", TRUE, LONG, op2(El,TR), 0 },
223/*27*/ { "", FALSE, NONE, 0, 0 },
224
225/*28*/ { "", FALSE, NONE, 0, 0 },
226/*29*/ { "", FALSE, NONE, 0, 0 },
227/*2a*/ { "", FALSE, NONE, 0, 0 },
228/*2b*/ { "", FALSE, NONE, 0, 0 },
229/*2c*/ { "", FALSE, NONE, 0, 0 },
230/*2d*/ { "", FALSE, NONE, 0, 0 },
231/*2e*/ { "", FALSE, NONE, 0, 0 },
232/*2f*/ { "", FALSE, NONE, 0, 0 },
233};
234
235static const struct inst db_inst_0f3x[] = {
236/*30*/ { "wrmsr", FALSE, NONE, 0, 0 },
237/*31*/ { "rdtsc", FALSE, NONE, 0, 0 },
238/*32*/ { "rdmsr", FALSE, NONE, 0, 0 },
239/*33*/ { "rdpmc", FALSE, NONE, 0, 0 },
240/*34*/ { "", FALSE, NONE, 0, 0 },
241/*35*/ { "", FALSE, NONE, 0, 0 },
242/*36*/ { "", FALSE, NONE, 0, 0 },
243/*37*/ { "", FALSE, NONE, 0, 0 },
244
245/*38*/ { "", FALSE, NONE, 0, 0 },
246/*39*/ { "", FALSE, NONE, 0, 0 },
247/*3a*/ { "", FALSE, NONE, 0, 0 },
248/*3b*/ { "", FALSE, NONE, 0, 0 },
249/*3c*/ { "", FALSE, NONE, 0, 0 },
250/*3d*/ { "", FALSE, NONE, 0, 0 },
251/*3e*/ { "", FALSE, NONE, 0, 0 },
252/*3f*/ { "", FALSE, NONE, 0, 0 },
253};
254
c8fe38ae
MD		 255static const struct inst db_inst_0f4x[] = {
256/*40*/ { "cmovo", TRUE, NONE, op2(E, R), 0 },
257/*41*/ { "cmovno", TRUE, NONE, op2(E, R), 0 },
258/*42*/ { "cmovb", TRUE, NONE, op2(E, R), 0 },
259/*43*/ { "cmovnb", TRUE, NONE, op2(E, R), 0 },
260/*44*/ { "cmovz", TRUE, NONE, op2(E, R), 0 },
261/*45*/ { "cmovnz", TRUE, NONE, op2(E, R), 0 },
262/*46*/ { "cmovbe", TRUE, NONE, op2(E, R), 0 },
263/*47*/ { "cmovnbe",TRUE, NONE, op2(E, R), 0 },
264
265/*48*/ { "cmovs", TRUE, NONE, op2(E, R), 0 },
266/*49*/ { "cmovns", TRUE, NONE, op2(E, R), 0 },
267/*4a*/ { "cmovp", TRUE, NONE, op2(E, R), 0 },
268/*4b*/ { "cmovnp", TRUE, NONE, op2(E, R), 0 },
269/*4c*/ { "cmovl", TRUE, NONE, op2(E, R), 0 },
270/*4d*/ { "cmovnl", TRUE, NONE, op2(E, R), 0 },
271/*4e*/ { "cmovle", TRUE, NONE, op2(E, R), 0 },
272/*4f*/ { "cmovnle",TRUE, NONE, op2(E, R), 0 },
273};
274
d7f50089
YY		 275static const struct inst db_inst_0f8x[] = {
276/*80*/ { "jo", FALSE, NONE, op1(Dl), 0 },
277/*81*/ { "jno", FALSE, NONE, op1(Dl), 0 },
278/*82*/ { "jb", FALSE, NONE, op1(Dl), 0 },
279/*83*/ { "jnb", FALSE, NONE, op1(Dl), 0 },
280/*84*/ { "jz", FALSE, NONE, op1(Dl), 0 },
281/*85*/ { "jnz", FALSE, NONE, op1(Dl), 0 },
282/*86*/ { "jbe", FALSE, NONE, op1(Dl), 0 },
283/*87*/ { "jnbe", FALSE, NONE, op1(Dl), 0 },
284
285/*88*/ { "js", FALSE, NONE, op1(Dl), 0 },
286/*89*/ { "jns", FALSE, NONE, op1(Dl), 0 },
287/*8a*/ { "jp", FALSE, NONE, op1(Dl), 0 },
288/*8b*/ { "jnp", FALSE, NONE, op1(Dl), 0 },
289/*8c*/ { "jl", FALSE, NONE, op1(Dl), 0 },
290/*8d*/ { "jnl", FALSE, NONE, op1(Dl), 0 },
291/*8e*/ { "jle", FALSE, NONE, op1(Dl), 0 },
292/*8f*/ { "jnle", FALSE, NONE, op1(Dl), 0 },
293};
294
295static const struct inst db_inst_0f9x[] = {
296/*90*/ { "seto", TRUE, NONE, op1(Eb), 0 },
297/*91*/ { "setno", TRUE, NONE, op1(Eb), 0 },
298/*92*/ { "setb", TRUE, NONE, op1(Eb), 0 },
299/*93*/ { "setnb", TRUE, NONE, op1(Eb), 0 },
300/*94*/ { "setz", TRUE, NONE, op1(Eb), 0 },
301/*95*/ { "setnz", TRUE, NONE, op1(Eb), 0 },
302/*96*/ { "setbe", TRUE, NONE, op1(Eb), 0 },
303/*97*/ { "setnbe",TRUE, NONE, op1(Eb), 0 },
304
305/*98*/ { "sets", TRUE, NONE, op1(Eb), 0 },
306/*99*/ { "setns", TRUE, NONE, op1(Eb), 0 },
307/*9a*/ { "setp", TRUE, NONE, op1(Eb), 0 },
308/*9b*/ { "setnp", TRUE, NONE, op1(Eb), 0 },
309/*9c*/ { "setl", TRUE, NONE, op1(Eb), 0 },
310/*9d*/ { "setnl", TRUE, NONE, op1(Eb), 0 },
311/*9e*/ { "setle", TRUE, NONE, op1(Eb), 0 },
312/*9f*/ { "setnle",TRUE, NONE, op1(Eb), 0 },
313};
314
315static const struct inst db_inst_0fax[] = {
316/*a0*/ { "push", FALSE, NONE, op1(Si), 0 },
317/*a1*/ { "pop", FALSE, NONE, op1(Si), 0 },
318/*a2*/ { "cpuid", FALSE, NONE, 0, 0 },
319/*a3*/ { "bt", TRUE, LONG, op2(R,E), 0 },
320/*a4*/ { "shld", TRUE, LONG, op3(Ib,R,E), 0 },
321/*a5*/ { "shld", TRUE, LONG, op3(CL,R,E), 0 },
322/*a6*/ { "", FALSE, NONE, 0, 0 },
323/*a7*/ { "", FALSE, NONE, 0, 0 },
324
325/*a8*/ { "push", FALSE, NONE, op1(Si), 0 },
326/*a9*/ { "pop", FALSE, NONE, op1(Si), 0 },
327/*aa*/ { "rsm", FALSE, NONE, 0, 0 },
328/*ab*/ { "bts", TRUE, LONG, op2(R,E), 0 },
329/*ac*/ { "shrd", TRUE, LONG, op3(Ib,R,E), 0 },
330/*ad*/ { "shrd", TRUE, LONG, op3(CL,R,E), 0 },
331/*a6*/ { "", FALSE, NONE, 0, 0 },
332/*a7*/ { "imul", TRUE, LONG, op2(E,R), 0 },
333};
334
335static const struct inst db_inst_0fbx[] = {
336/*b0*/ { "cmpxchg",TRUE, BYTE, op2(R, E), 0 },
337/*b0*/ { "cmpxchg",TRUE, LONG, op2(R, E), 0 },
338/*b2*/ { "lss", TRUE, LONG, op2(E, R), 0 },
339/*b3*/ { "btr", TRUE, LONG, op2(R, E), 0 },
340/*b4*/ { "lfs", TRUE, LONG, op2(E, R), 0 },
341/*b5*/ { "lgs", TRUE, LONG, op2(E, R), 0 },
342/*b6*/ { "movzb", TRUE, LONG, op2(Eb, R), 0 },
343/*b7*/ { "movzw", TRUE, LONG, op2(Ew, R), 0 },
344
345/*b8*/ { "", FALSE, NONE, 0, 0 },
346/*b9*/ { "", FALSE, NONE, 0, 0 },
347/*ba*/ { "", TRUE, LONG, op2(Ib, E), db_Grp8 },
348/*bb*/ { "btc", TRUE, LONG, op2(R, E), 0 },
349/*bc*/ { "bsf", TRUE, LONG, op2(E, R), 0 },
350/*bd*/ { "bsr", TRUE, LONG, op2(E, R), 0 },
351/*be*/ { "movsb", TRUE, LONG, op2(Eb, R), 0 },
352/*bf*/ { "movsw", TRUE, LONG, op2(Ew, R), 0 },
353};
354
355static const struct inst db_inst_0fcx[] = {
356/*c0*/ { "xadd", TRUE, BYTE, op2(R, E), 0 },
357/*c1*/ { "xadd", TRUE, LONG, op2(R, E), 0 },
358/*c2*/ { "", FALSE, NONE, 0, 0 },
359/*c3*/ { "", FALSE, NONE, 0, 0 },
360/*c4*/ { "", FALSE, NONE, 0, 0 },
361/*c5*/ { "", FALSE, NONE, 0, 0 },
362/*c6*/ { "", FALSE, NONE, 0, 0 },
363/*c7*/ { "", TRUE, NONE, op1(E), db_Grp9 },
364/*c8*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
365/*c9*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
366/*ca*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
367/*cb*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
368/*cc*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
369/*cd*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
370/*ce*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
371/*cf*/ { "bswap", FALSE, LONG, op1(Ril), 0 },
372};
373
374static const struct inst * const db_inst_0f[] = {
375 db_inst_0f0x,
376 0,
377 db_inst_0f2x,
378 db_inst_0f3x,
c8fe38ae 379 db_inst_0f4x,
d7f50089
YY		 380 0,
381 0,
382 0,
383 db_inst_0f8x,
384 db_inst_0f9x,
385 db_inst_0fax,
386 db_inst_0fbx,
387 db_inst_0fcx,
388 0,
389 0,
390 0
391};
392
393static const char * const db_Esc92[] = {
394 "fnop", "", "", "", "", "", "", ""
395};
396static const char * const db_Esc94[] = {
397 "fchs", "fabs", "", "", "ftst", "fxam", "", ""
398};
399static const char * const db_Esc95[] = {
400 "fld1", "fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz",""
401};
402static const char * const db_Esc96[] = {
403 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp",
404 "fincstp"
405};
406static const char * const db_Esc97[] = {
407 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos"
408};
409
410static const char * const db_Esca5[] = {
411 "", "fucompp","", "", "", "", "", ""
412};
413
414static const char * const db_Escb4[] = {
415 "fneni","fndisi", "fnclex","fninit","fsetpm", "", "", ""
416};
417
418static const char * const db_Esce3[] = {
419 "", "fcompp","", "", "", "", "", ""
420};
421
422static const char * const db_Escf4[] = {
423 "fnstsw","", "", "", "", "", "", ""
424};
425
426static const struct finst db_Esc8[] = {
427/*0*/ { "fadd", SNGL, op2(STI,ST), 0 },
428/*1*/ { "fmul", SNGL, op2(STI,ST), 0 },
429/*2*/ { "fcom", SNGL, op2(STI,ST), 0 },
430/*3*/ { "fcomp", SNGL, op2(STI,ST), 0 },
431/*4*/ { "fsub", SNGL, op2(STI,ST), 0 },
432/*5*/ { "fsubr", SNGL, op2(STI,ST), 0 },
433/*6*/ { "fdiv", SNGL, op2(STI,ST), 0 },
434/*7*/ { "fdivr", SNGL, op2(STI,ST), 0 },
435};
436
437static const struct finst db_Esc9[] = {
438/*0*/ { "fld", SNGL, op1(STI), 0 },
439/*1*/ { "", NONE, op1(STI), "fxch" },
440/*2*/ { "fst", SNGL, op1(X), db_Esc92 },
441/*3*/ { "fstp", SNGL, 0, 0 },
442/*4*/ { "fldenv", NONE, op1(X), db_Esc94 },
443/*5*/ { "fldcw", NONE, op1(X), db_Esc95 },
444/*6*/ { "fnstenv",NONE, op1(X), db_Esc96 },
445/*7*/ { "fnstcw", NONE, op1(X), db_Esc97 },
446};
447
448static const struct finst db_Esca[] = {
449/*0*/ { "fiadd", LONG, 0, 0 },
450/*1*/ { "fimul", LONG, 0, 0 },
451/*2*/ { "ficom", LONG, 0, 0 },
452/*3*/ { "ficomp", LONG, 0, 0 },
453/*4*/ { "fisub", LONG, 0, 0 },
454/*5*/ { "fisubr", LONG, op1(X), db_Esca5 },
455/*6*/ { "fidiv", LONG, 0, 0 },
456/*7*/ { "fidivr", LONG, 0, 0 }
457};
458
459static const struct finst db_Escb[] = {
460/*0*/ { "fild", LONG, 0, 0 },
461/*1*/ { "", NONE, 0, 0 },
462/*2*/ { "fist", LONG, 0, 0 },
463/*3*/ { "fistp", LONG, 0, 0 },
464/*4*/ { "", WORD, op1(X), db_Escb4 },
465/*5*/ { "fld", EXTR, 0, 0 },
466/*6*/ { "", WORD, 0, 0 },
467/*7*/ { "fstp", EXTR, 0, 0 },
468};
469
470static const struct finst db_Escc[] = {
471/*0*/ { "fadd", DBLR, op2(ST,STI), 0 },
472/*1*/ { "fmul", DBLR, op2(ST,STI), 0 },
473/*2*/ { "fcom", DBLR, 0, 0 },
474/*3*/ { "fcomp", DBLR, 0, 0 },
475/*4*/ { "fsub", DBLR, op2(ST,STI), "fsubr" },
476/*5*/ { "fsubr", DBLR, op2(ST,STI), "fsub" },
477/*6*/ { "fdiv", DBLR, op2(ST,STI), "fdivr" },
478/*7*/ { "fdivr", DBLR, op2(ST,STI), "fdiv" },
479};
480
481static const struct finst db_Escd[] = {
482/*0*/ { "fld", DBLR, op1(STI), "ffree" },
483/*1*/ { "", NONE, 0, 0 },
484/*2*/ { "fst", DBLR, op1(STI), 0 },
485/*3*/ { "fstp", DBLR, op1(STI), 0 },
486/*4*/ { "frstor", NONE, op1(STI), "fucom" },
487/*5*/ { "", NONE, op1(STI), "fucomp" },
488/*6*/ { "fnsave", NONE, 0, 0 },
489/*7*/ { "fnstsw", NONE, 0, 0 },
490};
491
492static const struct finst db_Esce[] = {
493/*0*/ { "fiadd", WORD, op2(ST,STI), "faddp" },
494/*1*/ { "fimul", WORD, op2(ST,STI), "fmulp" },
495/*2*/ { "ficom", WORD, 0, 0 },
496/*3*/ { "ficomp", WORD, op1(X), db_Esce3 },
497/*4*/ { "fisub", WORD, op2(ST,STI), "fsubrp" },
498/*5*/ { "fisubr", WORD, op2(ST,STI), "fsubp" },
499/*6*/ { "fidiv", WORD, op2(ST,STI), "fdivrp" },
500/*7*/ { "fidivr", WORD, op2(ST,STI), "fdivp" },
501};
502
503static const struct finst db_Escf[] = {
504/*0*/ { "fild", WORD, 0, 0 },
505/*1*/ { "", NONE, 0, 0 },
506/*2*/ { "fist", WORD, 0, 0 },
507/*3*/ { "fistp", WORD, 0, 0 },
508/*4*/ { "fbld", NONE, op1(XA), db_Escf4 },
509/*5*/ { "fild", QUAD, 0, 0 },
510/*6*/ { "fbstp", NONE, 0, 0 },
511/*7*/ { "fistp", QUAD, 0, 0 },
512};
513
514static const struct finst * const db_Esc_inst[] = {
515 db_Esc8, db_Esc9, db_Esca, db_Escb,
516 db_Escc, db_Escd, db_Esce, db_Escf
517};
518
519static const char * const db_Grp1[] = {
520 "add",
521 "or",
522 "adc",
523 "sbb",
524 "and",
525 "sub",
526 "xor",
527 "cmp"
528};
529
530static const char * const db_Grp2[] = {
531 "rol",
532 "ror",
533 "rcl",
534 "rcr",
535 "shl",
536 "shr",
537 "shl",
538 "sar"
539};
540
541static const struct inst db_Grp3[] = {
542 { "test", TRUE, NONE, op2(I,E), 0 },
543 { "test", TRUE, NONE, op2(I,E), 0 },
544 { "not", TRUE, NONE, op1(E), 0 },
545 { "neg", TRUE, NONE, op1(E), 0 },
546 { "mul", TRUE, NONE, op2(E,A), 0 },
547 { "imul", TRUE, NONE, op2(E,A), 0 },
548 { "div", TRUE, NONE, op2(E,A), 0 },
549 { "idiv", TRUE, NONE, op2(E,A), 0 },
550};
551
552static const struct inst db_Grp4[] = {
553 { "inc", TRUE, BYTE, op1(E), 0 },
554 { "dec", TRUE, BYTE, op1(E), 0 },
555 { "", TRUE, NONE, 0, 0 },
556 { "", TRUE, NONE, 0, 0 },
557 { "", TRUE, NONE, 0, 0 },
558 { "", TRUE, NONE, 0, 0 },
559 { "", TRUE, NONE, 0, 0 },
560 { "", TRUE, NONE, 0, 0 }
561};
562
563static const struct inst db_Grp5[] = {
564 { "inc", TRUE, LONG, op1(E), 0 },
565 { "dec", TRUE, LONG, op1(E), 0 },
566 { "call", TRUE, LONG, op1(Eind),0 },
567 { "lcall", TRUE, LONG, op1(Eind),0 },
568 { "jmp", TRUE, LONG, op1(Eind),0 },
569 { "ljmp", TRUE, LONG, op1(Eind),0 },
570 { "push", TRUE, LONG, op1(E), 0 },
571 { "", TRUE, NONE, 0, 0 }
572};
573
574static const struct inst db_inst_table[256] = {
575/*00*/ { "add", TRUE, BYTE, op2(R, E), 0 },
576/*01*/ { "add", TRUE, LONG, op2(R, E), 0 },
577/*02*/ { "add", TRUE, BYTE, op2(E, R), 0 },
578/*03*/ { "add", TRUE, LONG, op2(E, R), 0 },
579/*04*/ { "add", FALSE, BYTE, op2(I, A), 0 },
580/*05*/ { "add", FALSE, LONG, op2(Is, A), 0 },
581/*06*/ { "push", FALSE, NONE, op1(Si), 0 },
582/*07*/ { "pop", FALSE, NONE, op1(Si), 0 },
583
584/*08*/ { "or", TRUE, BYTE, op2(R, E), 0 },
585/*09*/ { "or", TRUE, LONG, op2(R, E), 0 },
586/*0a*/ { "or", TRUE, BYTE, op2(E, R), 0 },
587/*0b*/ { "or", TRUE, LONG, op2(E, R), 0 },
588/*0c*/ { "or", FALSE, BYTE, op2(I, A), 0 },
589/*0d*/ { "or", FALSE, LONG, op2(I, A), 0 },
590/*0e*/ { "push", FALSE, NONE, op1(Si), 0 },
591/*0f*/ { "", FALSE, NONE, 0, 0 },
592
593/*10*/ { "adc", TRUE, BYTE, op2(R, E), 0 },
594/*11*/ { "adc", TRUE, LONG, op2(R, E), 0 },
595/*12*/ { "adc", TRUE, BYTE, op2(E, R), 0 },
596/*13*/ { "adc", TRUE, LONG, op2(E, R), 0 },
597/*14*/ { "adc", FALSE, BYTE, op2(I, A), 0 },
598/*15*/ { "adc", FALSE, LONG, op2(Is, A), 0 },
599/*16*/ { "push", FALSE, NONE, op1(Si), 0 },
600/*17*/ { "pop", FALSE, NONE, op1(Si), 0 },
601
602/*18*/ { "sbb", TRUE, BYTE, op2(R, E), 0 },
603/*19*/ { "sbb", TRUE, LONG, op2(R, E), 0 },
604/*1a*/ { "sbb", TRUE, BYTE, op2(E, R), 0 },
605/*1b*/ { "sbb", TRUE, LONG, op2(E, R), 0 },
606/*1c*/ { "sbb", FALSE, BYTE, op2(I, A), 0 },
607/*1d*/ { "sbb", FALSE, LONG, op2(Is, A), 0 },
608/*1e*/ { "push", FALSE, NONE, op1(Si), 0 },
609/*1f*/ { "pop", FALSE, NONE, op1(Si), 0 },
610
611/*20*/ { "and", TRUE, BYTE, op2(R, E), 0 },
612/*21*/ { "and", TRUE, LONG, op2(R, E), 0 },
613/*22*/ { "and", TRUE, BYTE, op2(E, R), 0 },
614/*23*/ { "and", TRUE, LONG, op2(E, R), 0 },
615/*24*/ { "and", FALSE, BYTE, op2(I, A), 0 },
616/*25*/ { "and", FALSE, LONG, op2(I, A), 0 },
617/*26*/ { "", FALSE, NONE, 0, 0 },
618/*27*/ { "daa", FALSE, NONE, 0, 0 },
619
620/*28*/ { "sub", TRUE, BYTE, op2(R, E), 0 },
621/*29*/ { "sub", TRUE, LONG, op2(R, E), 0 },
622/*2a*/ { "sub", TRUE, BYTE, op2(E, R), 0 },
623/*2b*/ { "sub", TRUE, LONG, op2(E, R), 0 },
624/*2c*/ { "sub", FALSE, BYTE, op2(I, A), 0 },
625/*2d*/ { "sub", FALSE, LONG, op2(Is, A), 0 },
626/*2e*/ { "", FALSE, NONE, 0, 0 },
627/*2f*/ { "das", FALSE, NONE, 0, 0 },
628
629/*30*/ { "xor", TRUE, BYTE, op2(R, E), 0 },
630/*31*/ { "xor", TRUE, LONG, op2(R, E), 0 },
631/*32*/ { "xor", TRUE, BYTE, op2(E, R), 0 },
632/*33*/ { "xor", TRUE, LONG, op2(E, R), 0 },
633/*34*/ { "xor", FALSE, BYTE, op2(I, A), 0 },
634/*35*/ { "xor", FALSE, LONG, op2(I, A), 0 },
635/*36*/ { "", FALSE, NONE, 0, 0 },
636/*37*/ { "aaa", FALSE, NONE, 0, 0 },
637
638/*38*/ { "cmp", TRUE, BYTE, op2(R, E), 0 },
639/*39*/ { "cmp", TRUE, LONG, op2(R, E), 0 },
640/*3a*/ { "cmp", TRUE, BYTE, op2(E, R), 0 },
641/*3b*/ { "cmp", TRUE, LONG, op2(E, R), 0 },
642/*3c*/ { "cmp", FALSE, BYTE, op2(I, A), 0 },
643/*3d*/ { "cmp", FALSE, LONG, op2(Is, A), 0 },
644/*3e*/ { "", FALSE, NONE, 0, 0 },
645/*3f*/ { "aas", FALSE, NONE, 0, 0 },
646
c8fe38ae
MD		 647/*40*/ { "rex", FALSE, NONE, 0, 0 },
648/*41*/ { "rex.b", FALSE, NONE, 0, 0 },
649/*42*/ { "rex.x", FALSE, NONE, 0, 0 },
650/*43*/ { "rex.xb", FALSE, NONE, 0, 0 },
651/*44*/ { "rex.r", FALSE, NONE, 0, 0 },
652/*45*/ { "rex.rb", FALSE, NONE, 0, 0 },
653/*46*/ { "rex.rx", FALSE, NONE, 0, 0 },
654/*47*/ { "rex.rxb", FALSE, NONE, 0, 0 },
655
656/*48*/ { "rex.w", FALSE, NONE, 0, 0 },
657/*49*/ { "rex.wb", FALSE, NONE, 0, 0 },
658/*4a*/ { "rex.wx", FALSE, NONE, 0, 0 },
659/*4b*/ { "rex.wxb", FALSE, NONE, 0, 0 },
660/*4c*/ { "rex.wr", FALSE, NONE, 0, 0 },
661/*4d*/ { "rex.wrb", FALSE, NONE, 0, 0 },
662/*4e*/ { "rex.wrx", FALSE, NONE, 0, 0 },
663/*4f*/ { "rex.wrxb", FALSE, NONE, 0, 0 },
d7f50089
YY		 664
665/*50*/ { "push", FALSE, LONG, op1(Ri), 0 },
666/*51*/ { "push", FALSE, LONG, op1(Ri), 0 },
667/*52*/ { "push", FALSE, LONG, op1(Ri), 0 },
668/*53*/ { "push", FALSE, LONG, op1(Ri), 0 },
669/*54*/ { "push", FALSE, LONG, op1(Ri), 0 },
670/*55*/ { "push", FALSE, LONG, op1(Ri), 0 },
671/*56*/ { "push", FALSE, LONG, op1(Ri), 0 },
672/*57*/ { "push", FALSE, LONG, op1(Ri), 0 },
673
674/*58*/ { "pop", FALSE, LONG, op1(Ri), 0 },
675/*59*/ { "pop", FALSE, LONG, op1(Ri), 0 },
676/*5a*/ { "pop", FALSE, LONG, op1(Ri), 0 },
677/*5b*/ { "pop", FALSE, LONG, op1(Ri), 0 },
678/*5c*/ { "pop", FALSE, LONG, op1(Ri), 0 },
679/*5d*/ { "pop", FALSE, LONG, op1(Ri), 0 },
680/*5e*/ { "pop", FALSE, LONG, op1(Ri), 0 },
681/*5f*/ { "pop", FALSE, LONG, op1(Ri), 0 },
682
683/*60*/ { "pusha", FALSE, LONG, 0, 0 },
684/*61*/ { "popa", FALSE, LONG, 0, 0 },
685/*62*/ { "bound", TRUE, LONG, op2(E, R), 0 },
c8fe38ae 686/*63*/ { "movslq", TRUE, NONE, op2(EL,R), 0 },
d7f50089
YY		 687
688/*64*/ { "", FALSE, NONE, 0, 0 },
689/*65*/ { "", FALSE, NONE, 0, 0 },
690/*66*/ { "", FALSE, NONE, 0, 0 },
691/*67*/ { "", FALSE, NONE, 0, 0 },
692
693/*68*/ { "push", FALSE, LONG, op1(I), 0 },
694/*69*/ { "imul", TRUE, LONG, op3(I,E,R), 0 },
695/*6a*/ { "push", FALSE, LONG, op1(Ibs), 0 },
696/*6b*/ { "imul", TRUE, LONG, op3(Ibs,E,R),0 },
697/*6c*/ { "ins", FALSE, BYTE, op2(DX, DI), 0 },
698/*6d*/ { "ins", FALSE, LONG, op2(DX, DI), 0 },
699/*6e*/ { "outs", FALSE, BYTE, op2(SI, DX), 0 },
700/*6f*/ { "outs", FALSE, LONG, op2(SI, DX), 0 },
701
702/*70*/ { "jo", FALSE, NONE, op1(Db), 0 },
703/*71*/ { "jno", FALSE, NONE, op1(Db), 0 },
704/*72*/ { "jb", FALSE, NONE, op1(Db), 0 },
705/*73*/ { "jnb", FALSE, NONE, op1(Db), 0 },
706/*74*/ { "jz", FALSE, NONE, op1(Db), 0 },
707/*75*/ { "jnz", FALSE, NONE, op1(Db), 0 },
708/*76*/ { "jbe", FALSE, NONE, op1(Db), 0 },
709/*77*/ { "jnbe", FALSE, NONE, op1(Db), 0 },
710
711/*78*/ { "js", FALSE, NONE, op1(Db), 0 },
712/*79*/ { "jns", FALSE, NONE, op1(Db), 0 },
713/*7a*/ { "jp", FALSE, NONE, op1(Db), 0 },
714/*7b*/ { "jnp", FALSE, NONE, op1(Db), 0 },
715/*7c*/ { "jl", FALSE, NONE, op1(Db), 0 },
716/*7d*/ { "jnl", FALSE, NONE, op1(Db), 0 },
717/*7e*/ { "jle", FALSE, NONE, op1(Db), 0 },
718/*7f*/ { "jnle", FALSE, NONE, op1(Db), 0 },
719
720/*80*/ { "", TRUE, BYTE, op2(I, E), db_Grp1 },
721/*81*/ { "", TRUE, LONG, op2(I, E), db_Grp1 },
722/*82*/ { "", TRUE, BYTE, op2(I, E), db_Grp1 },
723/*83*/ { "", TRUE, LONG, op2(Ibs,E), db_Grp1 },
724/*84*/ { "test", TRUE, BYTE, op2(R, E), 0 },
725/*85*/ { "test", TRUE, LONG, op2(R, E), 0 },
726/*86*/ { "xchg", TRUE, BYTE, op2(R, E), 0 },
727/*87*/ { "xchg", TRUE, LONG, op2(R, E), 0 },
728
729/*88*/ { "mov", TRUE, BYTE, op2(R, E), 0 },
730/*89*/ { "mov", TRUE, LONG, op2(R, E), 0 },
731/*8a*/ { "mov", TRUE, BYTE, op2(E, R), 0 },
732/*8b*/ { "mov", TRUE, LONG, op2(E, R), 0 },
733/*8c*/ { "mov", TRUE, NONE, op2(S, Ew), 0 },
734/*8d*/ { "lea", TRUE, LONG, op2(E, R), 0 },
735/*8e*/ { "mov", TRUE, NONE, op2(Ew, S), 0 },
736/*8f*/ { "pop", TRUE, LONG, op1(E), 0 },
737
738/*90*/ { "nop", FALSE, NONE, 0, 0 },
739/*91*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 },
740/*92*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 },
741/*93*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 },
742/*94*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 },
743/*95*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 },
744/*96*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 },
745/*97*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 },
746
747/*98*/ { "cbw", FALSE, SDEP, 0, "cwde" }, /* cbw/cwde */
748/*99*/ { "cwd", FALSE, SDEP, 0, "cdq" }, /* cwd/cdq */
749/*9a*/ { "lcall", FALSE, NONE, op1(OS), 0 },
750/*9b*/ { "wait", FALSE, NONE, 0, 0 },
751/*9c*/ { "pushf", FALSE, LONG, 0, 0 },
752/*9d*/ { "popf", FALSE, LONG, 0, 0 },
753/*9e*/ { "sahf", FALSE, NONE, 0, 0 },
754/*9f*/ { "lahf", FALSE, NONE, 0, 0 },
755
756/*a0*/ { "mov", FALSE, BYTE, op2(O, A), 0 },
757/*a1*/ { "mov", FALSE, LONG, op2(O, A), 0 },
758/*a2*/ { "mov", FALSE, BYTE, op2(A, O), 0 },
759/*a3*/ { "mov", FALSE, LONG, op2(A, O), 0 },
760/*a4*/ { "movs", FALSE, BYTE, op2(SI,DI), 0 },
761/*a5*/ { "movs", FALSE, LONG, op2(SI,DI), 0 },
762/*a6*/ { "cmps", FALSE, BYTE, op2(SI,DI), 0 },
763/*a7*/ { "cmps", FALSE, LONG, op2(SI,DI), 0 },
764
765/*a8*/ { "test", FALSE, BYTE, op2(I, A), 0 },
766/*a9*/ { "test", FALSE, LONG, op2(I, A), 0 },
767/*aa*/ { "stos", FALSE, BYTE, op1(DI), 0 },
768/*ab*/ { "stos", FALSE, LONG, op1(DI), 0 },
769/*ac*/ { "lods", FALSE, BYTE, op1(SI), 0 },
770/*ad*/ { "lods", FALSE, LONG, op1(SI), 0 },
771/*ae*/ { "scas", FALSE, BYTE, op1(SI), 0 },
772/*af*/ { "scas", FALSE, LONG, op1(SI), 0 },
773
774/*b0*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
775/*b1*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
776/*b2*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
777/*b3*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
778/*b4*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
779/*b5*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
780/*b6*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
781/*b7*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 },
782
c8fe38ae
MD		 783/*b8*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
784/*b9*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
785/*ba*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
786/*bb*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
787/*bc*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
788/*bd*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
789/*be*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
790/*bf*/ { "mov", FALSE, LONG, op2(Ilq, Ri), 0 },
d7f50089
YY		 791
792/*c0*/ { "", TRUE, BYTE, op2(Ib, E), db_Grp2 },
793/*c1*/ { "", TRUE, LONG, op2(Ib, E), db_Grp2 },
794/*c2*/ { "ret", FALSE, NONE, op1(Iw), 0 },
795/*c3*/ { "ret", FALSE, NONE, 0, 0 },
796/*c4*/ { "les", TRUE, LONG, op2(E, R), 0 },
797/*c5*/ { "lds", TRUE, LONG, op2(E, R), 0 },
798/*c6*/ { "mov", TRUE, BYTE, op2(I, E), 0 },
799/*c7*/ { "mov", TRUE, LONG, op2(I, E), 0 },
800
801/*c8*/ { "enter", FALSE, NONE, op2(Iw, Ib), 0 },
802/*c9*/ { "leave", FALSE, NONE, 0, 0 },
803/*ca*/ { "lret", FALSE, NONE, op1(Iw), 0 },
804/*cb*/ { "lret", FALSE, NONE, 0, 0 },
805/*cc*/ { "int", FALSE, NONE, op1(o3), 0 },
806/*cd*/ { "int", FALSE, NONE, op1(Ib), 0 },
807/*ce*/ { "into", FALSE, NONE, 0, 0 },
808/*cf*/ { "iret", FALSE, NONE, 0, 0 },
809
810/*d0*/ { "", TRUE, BYTE, op2(o1, E), db_Grp2 },
811/*d1*/ { "", TRUE, LONG, op2(o1, E), db_Grp2 },
812/*d2*/ { "", TRUE, BYTE, op2(CL, E), db_Grp2 },
813/*d3*/ { "", TRUE, LONG, op2(CL, E), db_Grp2 },
814/*d4*/ { "aam", FALSE, NONE, op1(Iba), 0 },
815/*d5*/ { "aad", FALSE, NONE, op1(Iba), 0 },
816/*d6*/ { ".byte\t0xd6", FALSE, NONE, 0, 0 },
817/*d7*/ { "xlat", FALSE, BYTE, op1(BX), 0 },
818
819/*d8*/ { "", TRUE, NONE, 0, db_Esc8 },
820/*d9*/ { "", TRUE, NONE, 0, db_Esc9 },
821/*da*/ { "", TRUE, NONE, 0, db_Esca },
822/*db*/ { "", TRUE, NONE, 0, db_Escb },
823/*dc*/ { "", TRUE, NONE, 0, db_Escc },
824/*dd*/ { "", TRUE, NONE, 0, db_Escd },
825/*de*/ { "", TRUE, NONE, 0, db_Esce },
826/*df*/ { "", TRUE, NONE, 0, db_Escf },
827
828/*e0*/ { "loopne",FALSE, NONE, op1(Db), 0 },
829/*e1*/ { "loope", FALSE, NONE, op1(Db), 0 },
830/*e2*/ { "loop", FALSE, NONE, op1(Db), 0 },
831/*e3*/ { "jcxz", FALSE, SDEP, op1(Db), "jecxz" },
832/*e4*/ { "in", FALSE, BYTE, op2(Ib, A), 0 },
833/*e5*/ { "in", FALSE, LONG, op2(Ib, A) , 0 },
834/*e6*/ { "out", FALSE, BYTE, op2(A, Ib), 0 },
835/*e7*/ { "out", FALSE, LONG, op2(A, Ib) , 0 },
836
837/*e8*/ { "call", FALSE, NONE, op1(Dl), 0 },
838/*e9*/ { "jmp", FALSE, NONE, op1(Dl), 0 },
839/*ea*/ { "ljmp", FALSE, NONE, op1(OS), 0 },
840/*eb*/ { "jmp", FALSE, NONE, op1(Db), 0 },
841/*ec*/ { "in", FALSE, BYTE, op2(DX, A), 0 },
842/*ed*/ { "in", FALSE, LONG, op2(DX, A) , 0 },
843/*ee*/ { "out", FALSE, BYTE, op2(A, DX), 0 },
844/*ef*/ { "out", FALSE, LONG, op2(A, DX) , 0 },
845
846/*f0*/ { "", FALSE, NONE, 0, 0 },
847/*f1*/ { ".byte\t0xf1", FALSE, NONE, 0, 0 },
848/*f2*/ { "", FALSE, NONE, 0, 0 },
849/*f3*/ { "", FALSE, NONE, 0, 0 },
850/*f4*/ { "hlt", FALSE, NONE, 0, 0 },
851/*f5*/ { "cmc", FALSE, NONE, 0, 0 },
852/*f6*/ { "", TRUE, BYTE, 0, db_Grp3 },
853/*f7*/ { "", TRUE, LONG, 0, db_Grp3 },
854
855/*f8*/ { "clc", FALSE, NONE, 0, 0 },
856/*f9*/ { "stc", FALSE, NONE, 0, 0 },
857/*fa*/ { "cli", FALSE, NONE, 0, 0 },
858/*fb*/ { "sti", FALSE, NONE, 0, 0 },
859/*fc*/ { "cld", FALSE, NONE, 0, 0 },
860/*fd*/ { "std", FALSE, NONE, 0, 0 },
861/*fe*/ { "", TRUE, NONE, 0, db_Grp4 },
862/*ff*/ { "", TRUE, NONE, 0, db_Grp5 },
863};
864
865static const struct inst db_bad_inst =
866 { "???", FALSE, NONE, 0, 0 }
867;
868
c8fe38ae
MD		 869#define f_mod(rex, byte) ((byte)>>6)
870#define f_reg(rex, byte) ((((byte)>>3)&0x7) | (rex & REX_R ? 0x8 : 0x0))
871#define f_rm(rex, byte) (((byte)&0x7) | (rex & REX_B ? 0x8 : 0x0))
d7f50089 872
c8fe38ae
MD		 873#define sib_ss(rex, byte) ((byte)>>6)
874#define sib_index(rex, byte) ((((byte)>>3)&0x7) | (rex & REX_X ? 0x8 : 0x0))
875#define sib_base(rex, byte) (((byte)&0x7) | (rex & REX_B ? 0x8 : 0x0))
d7f50089
YY		 876
877struct i_addr {
878 int is_reg; /* if reg, reg number is in 'disp' */
879 int disp;
880 const char * base;
881 const char * index;
882 int ss;
d7f50089
YY		 883};
884
c8fe38ae
MD		 885static const char * const db_reg[2][4][16] = {
886
887 {{"%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
888 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" },
889 { "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
890 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" },
891 { "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
892 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" },
893 { "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
894 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" }},
895
896 {{"%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
897 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" },
898 { "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
899 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" },
900 { "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
901 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" },
902 { "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
903 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" }}
d7f50089
YY		 904};
905
906static const char * const db_seg_reg[8] = {
907 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "", ""
908};
909
910/*
911 * lengths for size attributes
912 */
913static const int db_lengths[] = {
914 1, /* BYTE */
915 2, /* WORD */
916 4, /* LONG */
917 8, /* QUAD */
918 4, /* SNGL */
919 8, /* DBLR */
920 10, /* EXTR */
921};
922
923#define get_value_inc(result, loc, size, is_signed) \
924 result = db_get_value((loc), (size), (is_signed)); \
925 (loc) += (size);
926
927static db_addr_t
c8fe38ae
MD		 928 db_disasm_esc(db_addr_t loc, int inst, int rex, int short_addr,
929 int size, const char *seg);
930static void db_print_address(const char *seg, int size, int rex,
931 struct i_addr *addrp);
d7f50089 932static db_addr_t
c8fe38ae
MD		 933 db_read_address(db_addr_t loc, int short_addr, int rex, int regmodrm,
934 struct i_addr *addrp);
d7f50089
YY		 935
936/*
937 * Read address at location and return updated location.
938 */
939static db_addr_t
c8fe38ae
MD		 940db_read_address(loc, short_addr, rex, regmodrm, addrp)
941 db_addr_t loc;
942 int short_addr;
943 int rex;
944 int regmodrm;
945 struct i_addr * addrp; /* out */
d7f50089 946{
c8fe38ae 947 int mod, rm, sib, index, disp, size, have_sib;
d7f50089 948
c8fe38ae
MD		 949 mod = f_mod(rex, regmodrm);
950 rm = f_rm(rex, regmodrm);
d7f50089
YY		 951
952 if (mod == 3) {
953 addrp->is_reg = TRUE;
954 addrp->disp = rm;
955 return (loc);
956 }
957 addrp->is_reg = FALSE;
958 addrp->index = 0;
d7f50089 959
c8fe38ae
MD		 960 if (short_addr)
961 size = LONG;
962 else
963 size = QUAD;
964
965 if ((rm & 0x7) == 4) {
966 get_value_inc(sib, loc, 1, FALSE);
967 rm = sib_base(rex, sib);
968 index = sib_index(rex, sib);
969 if (index != 4)
970 addrp->index = db_reg[1][size][index];
971 addrp->ss = sib_ss(rex, sib);
972 have_sib = 1;
973 } else
974 have_sib = 0;
d7f50089 975
c8fe38ae
MD		 976 switch (mod) {
977 case 0:
978 if (rm == 5) {
979 get_value_inc(addrp->disp, loc, 4, FALSE);
980 if (have_sib)
981 addrp->base = 0;
982 else if (short_addr)
983 addrp->base = "%eip";
984 else
985 addrp->base = "%rip";
986 } else {
987 addrp->disp = 0;
988 addrp->base = db_reg[1][size][rm];
989 }
990 break;
991
992 case 1:
993 get_value_inc(disp, loc, 1, TRUE);
994 addrp->disp = disp;
995 addrp->base = db_reg[1][size][rm];
996 break;
997
998 case 2:
999 get_value_inc(disp, loc, 4, FALSE);
1000 addrp->disp = disp;
1001 addrp->base = db_reg[1][size][rm];
1002 break;
d7f50089
YY		 1003 }
1004 return (loc);
1005}
1006
1007static void
c8fe38ae
MD		 1008db_print_address(seg, size, rex, addrp)
1009 const char * seg;
1010 int size;
1011 int rex;
1012 struct i_addr * addrp;
d7f50089
YY		 1013{
1014 if (addrp->is_reg) {
c8fe38ae 1015 db_printf("%s", db_reg[rex != 0 ? 1 : 0][(size == LONG && (rex & REX_W)) ? QUAD : size][addrp->disp]);
d7f50089
YY		 1016 return;
1017 }
1018
1019 if (seg) {
1020 db_printf("%s:", seg);
d7f50089
YY		 1021 }
1022
c8fe38ae
MD		 1023 if (addrp->disp != 0 || (addrp->base == 0 && addrp->index == 0))
1024 db_printsym((db_addr_t)addrp->disp, DB_STGY_ANY);
d7f50089
YY		 1025 if (addrp->base != 0 || addrp->index != 0) {
1026 db_printf("(");
1027 if (addrp->base)
1028 db_printf("%s", addrp->base);
1029 if (addrp->index)
1030 db_printf(",%s,%d", addrp->index, 1<<addrp->ss);
1031 db_printf(")");
1032 }
1033}
1034
1035/*
1036 * Disassemble floating-point ("escape") instruction
1037 * and return updated location.
1038 */
1039static db_addr_t
c8fe38ae
MD		 1040db_disasm_esc(loc, inst, rex, short_addr, size, seg)
1041 db_addr_t loc;
1042 int inst;
1043 int rex;
1044 int short_addr;
1045 int size;
1046 const char * seg;
d7f50089
YY		 1047{
1048 int regmodrm;
1049 const struct finst * fp;
1050 int mod;
1051 struct i_addr address;
1052 const char * name;
1053
1054 get_value_inc(regmodrm, loc, 1, FALSE);
c8fe38ae
MD		 1055 fp = &db_Esc_inst[inst - 0xd8][f_reg(rex, regmodrm)];
1056 mod = f_mod(rex, regmodrm);
d7f50089
YY		 1057 if (mod != 3) {
1058 if (*fp->f_name == '\0') {
1059 db_printf("<bad instruction>");
1060 return (loc);
1061 }
1062 /*
1063 * Normal address modes.
1064 */
c8fe38ae 1065 loc = db_read_address(loc, short_addr, rex, regmodrm, &address);
d7f50089
YY		 1066 db_printf("%s", fp->f_name);
1067 switch(fp->f_size) {
1068 case SNGL:
1069 db_printf("s");
1070 break;
1071 case DBLR:
1072 db_printf("l");
1073 break;
1074 case EXTR:
1075 db_printf("t");
1076 break;
1077 case WORD:
1078 db_printf("s");
1079 break;
1080 case LONG:
1081 db_printf("l");
1082 break;
1083 case QUAD:
1084 db_printf("q");
1085 break;
1086 default:
1087 break;
1088 }
1089 db_printf("\t");
c8fe38ae 1090 db_print_address(seg, BYTE, rex, &address);
d7f50089
YY		 1091 }
1092 else {
1093 /*
1094 * 'reg-reg' - special formats
1095 */
1096 switch (fp->f_rrmode) {
1097 case op2(ST,STI):
1098 name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
c8fe38ae 1099 db_printf("%s\t%%st,%%st(%d)",name,f_rm(rex, regmodrm));
d7f50089
YY		 1100 break;
1101 case op2(STI,ST):
1102 name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
c8fe38ae 1103 db_printf("%s\t%%st(%d),%%st",name, f_rm(rex, regmodrm));
d7f50089
YY		 1104 break;
1105 case op1(STI):
1106 name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
c8fe38ae 1107 db_printf("%s\t%%st(%d)",name, f_rm(rex, regmodrm));
d7f50089
YY		 1108 break;
1109 case op1(X):
c8fe38ae 1110 name = ((const char * const *)fp->f_rrname)[f_rm(rex, regmodrm)];
d7f50089
YY		 1111 if (*name == '\0')
1112 goto bad;
1113 db_printf("%s", name);
1114 break;
1115 case op1(XA):
c8fe38ae 1116 name = ((const char * const *)fp->f_rrname)[f_rm(rex, regmodrm)];
d7f50089
YY		 1117 if (*name == '\0')
1118 goto bad;
1119 db_printf("%s\t%%ax", name);
1120 break;
1121 default:
1122 bad:
1123 db_printf("<bad instruction>");
1124 break;
1125 }
1126 }
1127
1128 return (loc);
1129}
1130
1131/*
1132 * Disassemble instruction at 'loc'. 'altfmt' specifies an
c8fe38ae
MD		 1133 * (optional) alternate format. Return address of start of
1134 * next instruction.
d7f50089
YY		 1135 */
1136db_addr_t
c8fe38ae
MD		 1137db_disasm(loc, altfmt, dummy)
1138 db_addr_t loc;
1139 boolean_t altfmt;
1140 db_regs_t *dummy;
d7f50089
YY		 1141{
1142 int inst;
1143 int size;
1144 int short_addr;
1145 const char * seg;
1146 const struct inst * ip;
1147 const char * i_name;
1148 int i_size;
1149 int i_mode;
c8fe38ae 1150 int rex = 0;
d7f50089
YY		 1151 int regmodrm = 0;
1152 boolean_t first;
1153 int displ;
1154 int prefix;
1155 int imm;
1156 int imm2;
c8fe38ae 1157 long imm64;
d7f50089
YY		 1158 int len;
1159 struct i_addr address;
1160
1161 get_value_inc(inst, loc, 1, FALSE);
c8fe38ae
MD		 1162 short_addr = FALSE;
1163 size = LONG;
d7f50089
YY		 1164 seg = 0;
1165
d7f50089
YY		 1166 /*
1167 * Get prefixes
1168 */
1169 prefix = TRUE;
1170 do {
1171 switch (inst) {
1172 case 0x66: /* data16 */
1173 size = WORD;
1174 break;
1175 case 0x67:
1176 short_addr = TRUE;
1177 break;
1178 case 0x26:
1179 seg = "%es";
1180 break;
1181 case 0x36:
1182 seg = "%ss";
1183 break;
1184 case 0x2e:
1185 seg = "%cs";
1186 break;
1187 case 0x3e:
1188 seg = "%ds";
1189 break;
1190 case 0x64:
1191 seg = "%fs";
1192 break;
1193 case 0x65:
1194 seg = "%gs";
1195 break;
1196 case 0xf0:
1197 db_printf("lock ");
1198 break;
1199 case 0xf2:
1200 db_printf("repne ");
1201 break;
1202 case 0xf3:
1203 db_printf("repe "); /* XXX repe VS rep */
1204 break;
1205 default:
1206 prefix = FALSE;
1207 break;
1208 }
c8fe38ae
MD		 1209 if (inst >= 0x40 && inst < 0x50) {
1210 rex = inst;
1211 prefix = TRUE;
1212 }
d7f50089
YY		 1213 if (prefix) {
1214 get_value_inc(inst, loc, 1, FALSE);
1215 }
1216 } while (prefix);
1217
1218 if (inst >= 0xd8 && inst <= 0xdf) {
c8fe38ae 1219 loc = db_disasm_esc(loc, inst, rex, short_addr, size, seg);
d7f50089
YY		 1220 db_printf("\n");
1221 return (loc);
1222 }
1223
1224 if (inst == 0x0f) {
1225 get_value_inc(inst, loc, 1, FALSE);
1226 ip = db_inst_0f[inst>>4];
1227 if (ip == 0) {
1228 ip = &db_bad_inst;
1229 }
1230 else {
1231 ip = &ip[inst&0xf];
1232 }
1233 }
1234 else
1235 ip = &db_inst_table[inst];
1236
1237 if (ip->i_has_modrm) {
1238 get_value_inc(regmodrm, loc, 1, FALSE);
c8fe38ae 1239 loc = db_read_address(loc, short_addr, rex, regmodrm, &address);
d7f50089
YY		 1240 }
1241
1242 i_name = ip->i_name;
1243 i_size = ip->i_size;
1244 i_mode = ip->i_mode;
1245
1246 if (ip->i_extra == db_Grp1 || ip->i_extra == db_Grp2 ||
1247 ip->i_extra == db_Grp6 || ip->i_extra == db_Grp7 ||
1248 ip->i_extra == db_Grp8 || ip->i_extra == db_Grp9) {
c8fe38ae 1249 i_name = ((const char * const *)ip->i_extra)[f_reg(rex, regmodrm)];
d7f50089
YY		 1250 }
1251 else if (ip->i_extra == db_Grp3) {
1252 ip = ip->i_extra;
c8fe38ae 1253 ip = &ip[f_reg(rex, regmodrm)];
d7f50089
YY		 1254 i_name = ip->i_name;
1255 i_mode = ip->i_mode;
1256 }
1257 else if (ip->i_extra == db_Grp4 || ip->i_extra == db_Grp5) {
1258 ip = ip->i_extra;
c8fe38ae 1259 ip = &ip[f_reg(rex, regmodrm)];
d7f50089
YY		 1260 i_name = ip->i_name;
1261 i_mode = ip->i_mode;
1262 i_size = ip->i_size;
1263 }
1264
1265 if (i_size == SDEP) {
1266 if (size == WORD)
1267 db_printf("%s", i_name);
1268 else
1269 db_printf("%s", (const char *)ip->i_extra);
1270 }
1271 else {
1272 db_printf("%s", i_name);
c8fe38ae
MD		 1273 if ((inst >= 0x50 && inst <= 0x5f) || inst == 0x68 || inst == 0x6a) {
1274 i_size = NONE;
1275 db_printf("q");
1276 }
d7f50089
YY		 1277 if (i_size != NONE) {
1278 if (i_size == BYTE) {
1279 db_printf("b");
1280 size = BYTE;
1281 }
1282 else if (i_size == WORD) {
1283 db_printf("w");
1284 size = WORD;
1285 }
1286 else if (size == WORD)
1287 db_printf("w");
c8fe38ae
MD		 1288 else {
1289 if (rex & REX_W)
1290 db_printf("q");
1291 else
1292 db_printf("l");
1293 }
d7f50089
YY		 1294 }
1295 }
1296 db_printf("\t");
1297 for (first = TRUE;
1298 i_mode != 0;
1299 i_mode >>= 8, first = FALSE)
1300 {
1301 if (!first)
1302 db_printf(",");
1303
1304 switch (i_mode & 0xFF) {
1305
1306 case E:
c8fe38ae 1307 db_print_address(seg, size, rex, &address);
d7f50089
YY		 1308 break;
1309
1310 case Eind:
1311 db_printf("*");
c8fe38ae 1312 db_print_address(seg, size, rex, &address);
d7f50089
YY		 1313 break;
1314
1315 case El:
c8fe38ae
MD		 1316 db_print_address(seg, (rex & REX_W) ? QUAD : LONG, rex, &address);
1317 break;
1318
1319 case EL:
1320 db_print_address(seg, LONG, 0, &address);
d7f50089
YY		 1321 break;
1322
1323 case Ew:
c8fe38ae 1324 db_print_address(seg, WORD, rex, &address);
d7f50089
YY		 1325 break;
1326
1327 case Eb:
c8fe38ae 1328 db_print_address(seg, BYTE, rex, &address);
d7f50089
YY		 1329 break;
1330
1331 case R:
c8fe38ae 1332 db_printf("%s", db_reg[rex != 0 ? 1 : 0][(size == LONG && (rex & REX_W)) ? QUAD : size][f_reg(rex, regmodrm)]);
d7f50089
YY		 1333 break;
1334
1335 case Rw:
c8fe38ae 1336 db_printf("%s", db_reg[rex != 0 ? 1 : 0][WORD][f_reg(rex, regmodrm)]);
d7f50089
YY		 1337 break;
1338
1339 case Ri:
c8fe38ae 1340 db_printf("%s", db_reg[0][QUAD][f_rm(rex, inst)]);
d7f50089
YY		 1341 break;
1342
1343 case Ril:
c8fe38ae 1344 db_printf("%s", db_reg[rex != 0 ? 1 : 0][(rex & REX_R) ? QUAD : LONG][f_rm(rex, inst)]);
d7f50089
YY		 1345 break;
1346
1347 case S:
c8fe38ae 1348 db_printf("%s", db_seg_reg[f_reg(rex, regmodrm)]);
d7f50089
YY		 1349 break;
1350
1351 case Si:
c8fe38ae 1352 db_printf("%s", db_seg_reg[f_reg(rex, inst)]);
d7f50089
YY		 1353 break;
1354
1355 case A:
c8fe38ae 1356 db_printf("%s", db_reg[rex != 0 ? 1 : 0][size][0]); /* acc */
d7f50089
YY		 1357 break;
1358
1359 case BX:
1360 if (seg)
1361 db_printf("%s:", seg);
1362 db_printf("(%s)", short_addr ? "%bx" : "%ebx");
1363 break;
1364
1365 case CL:
1366 db_printf("%%cl");
1367 break;
1368
1369 case DX:
1370 db_printf("%%dx");
1371 break;
1372
1373 case SI:
1374 if (seg)
1375 db_printf("%s:", seg);
c8fe38ae 1376 db_printf("(%s)", short_addr ? "%si" : "%rsi");
d7f50089
YY		 1377 break;
1378
1379 case DI:
c8fe38ae 1380 db_printf("%%es:(%s)", short_addr ? "%di" : "%rdi");
d7f50089
YY		 1381 break;
1382
1383 case CR:
c8fe38ae 1384 db_printf("%%cr%d", f_reg(rex, regmodrm));
d7f50089
YY		 1385 break;
1386
1387 case DR:
c8fe38ae 1388 db_printf("%%dr%d", f_reg(rex, regmodrm));
d7f50089
YY		 1389 break;
1390
1391 case TR:
c8fe38ae 1392 db_printf("%%tr%d", f_reg(rex, regmodrm));
d7f50089
YY		 1393 break;
1394
1395 case I:
1396 len = db_lengths[size];
1397 get_value_inc(imm, loc, len, FALSE);
1398 db_printf("$%#r", imm);
1399 break;
1400
1401 case Is:
c8fe38ae 1402 len = db_lengths[(size == LONG && (rex & REX_W)) ? QUAD : size];
d7f50089
YY		 1403 get_value_inc(imm, loc, len, FALSE);
1404 db_printf("$%+#r", imm);
1405 break;
1406
1407 case Ib:
1408 get_value_inc(imm, loc, 1, FALSE);
1409 db_printf("$%#r", imm);
1410 break;
1411
1412 case Iba:
1413 get_value_inc(imm, loc, 1, FALSE);
1414 if (imm != 0x0a)
1415 db_printf("$%#r", imm);
1416 break;
1417
1418 case Ibs:
1419 get_value_inc(imm, loc, 1, TRUE);
1420 if (size == WORD)
1421 imm &= 0xFFFF;
1422 db_printf("$%+#r", imm);
1423 break;
1424
1425 case Iw:
1426 get_value_inc(imm, loc, 2, FALSE);
1427 db_printf("$%#r", imm);
1428 break;
1429
c8fe38ae
MD		 1430 case Ilq:
1431 len = db_lengths[rex & REX_W ? QUAD : LONG];
1432 get_value_inc(imm64, loc, len, FALSE);
1433 db_printf("$%#lr", imm64);
1434 break;
1435
d7f50089
YY		 1436 case O:
1437 len = (short_addr ? 2 : 4);
1438 get_value_inc(displ, loc, len, FALSE);
1439 if (seg)
1440 db_printf("%s:%+#r",seg, displ);
1441 else
1442 db_printsym((db_addr_t)displ, DB_STGY_ANY);
1443 break;
1444
1445 case Db:
1446 get_value_inc(displ, loc, 1, TRUE);
1447 displ += loc;
1448 if (size == WORD)
1449 displ &= 0xFFFF;
1450 db_printsym((db_addr_t)displ, DB_STGY_XTRN);
1451 break;
1452
1453 case Dl:
c8fe38ae 1454 len = db_lengths[(size == LONG && (rex & REX_W)) ? QUAD : size];
d7f50089
YY		 1455 get_value_inc(displ, loc, len, FALSE);
1456 displ += loc;
1457 if (size == WORD)
1458 displ &= 0xFFFF;
1459 db_printsym((db_addr_t)displ, DB_STGY_XTRN);
1460 break;
1461
1462 case o1:
1463 db_printf("$1");
1464 break;
1465
1466 case o3:
1467 db_printf("$3");
1468 break;
1469
1470 case OS:
1471 len = db_lengths[size];
1472 get_value_inc(imm, loc, len, FALSE); /* offset */
1473 get_value_inc(imm2, loc, 2, FALSE); /* segment */
1474 db_printf("$%#r,%#r", imm2, imm);
1475 break;
1476 }
1477 }
1478 db_printf("\n");
1479 return (loc);
1480}
DragonFly Project GIT Source repo