[apple/javascriptcore.git] / disassembler / udis86 / udis86_syn-att.c

/* udis86 - libudis86/syn-att.c
 *
 * Copyright (c) 2002-2009 Vivek Thampi
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, 
 * are permitted provided that the following conditions are met:
 * 
 *     * Redistributions of source code must retain the above copyright notice, 
 *       this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright notice, 
 *       this list of conditions and the following disclaimer in the documentation 
 *       and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "config.h"

#if USE(UDIS86)

#include "udis86_types.h"
#include "udis86_extern.h"
#include "udis86_decode.h"
#include "udis86_itab.h"
#include "udis86_syn.h"

/* -----------------------------------------------------------------------------
 * opr_cast() - Prints an operand cast.
 * -----------------------------------------------------------------------------
 */
static void 
opr_cast(struct ud* u, struct ud_operand* op)
{
  switch(op->size) {
	case 16 : case 32 :
		mkasm(u, "*");   break;
	default: break;
  }
}

/* -----------------------------------------------------------------------------
 * gen_operand() - Generates assembly output for each operand.
 * -----------------------------------------------------------------------------
 */
static void 
gen_operand(struct ud* u, struct ud_operand* op)
{
  switch(op->type) {
	case UD_OP_REG:
		mkasm(u, "%%%s", ud_reg_tab[op->base - UD_R_AL]);
		break;

	case UD_OP_MEM:
		if (u->br_far) opr_cast(u, op);
		if (u->pfx_seg)
			mkasm(u, "%%%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]);
		if (op->offset == 8) {
			if (op->lval.sbyte < 0)
				mkasm(u, "-0x%x", (-op->lval.sbyte) & 0xff);
			else
				mkasm(u, "0x%x", op->lval.sbyte);
		} 
		else if (op->offset == 16) {
			if (op->lval.sword < 0)
				mkasm(u, "-0x%x", (-op->lval.sword) & 0xffff);
			else
				mkasm(u, "0x%x", op->lval.sword);
		} else if (op->offset == 32) {
			if (op->lval.sdword < 0)
				mkasm(u, "-0x%x", (-op->lval.sdword) & 0xffffffff);
			else
				mkasm(u, "0x%x", op->lval.sdword);
		} else if (op->offset == 64) {
			if (op->lval.sdword < 0)
			    mkasm(u, "-0x" FMT64 "x", (uint64_t)-op->lval.sqword);
			else
			    mkasm(u, "0x" FMT64 "x", (uint64_t)op->lval.sqword);
		}

		if (op->base)
			mkasm(u, "(%%%s", ud_reg_tab[op->base - UD_R_AL]);
		if (op->index) {
			if (op->base)
				mkasm(u, ",");
			else mkasm(u, "(");
			mkasm(u, "%%%s", ud_reg_tab[op->index - UD_R_AL]);
		}
		if (op->scale)
			mkasm(u, ",%d", op->scale);
		if (op->base || op->index)
			mkasm(u, ")");
		break;

	case UD_OP_IMM: {
        int64_t  imm = 0;
        uint64_t sext_mask = 0xffffffffffffffffull;
        unsigned sext_size = op->size;

        switch (op->size) {
            case  8: imm = op->lval.sbyte; break;
            case 16: imm = op->lval.sword; break;
            case 32: imm = op->lval.sdword; break;
            case 64: imm = op->lval.sqword; break;
        }
        if ( P_SEXT( u->itab_entry->prefix ) ) {
            sext_size = u->operand[ 0 ].size; 
            if ( u->mnemonic == UD_Ipush )
                /* push sign-extends to operand size */
                sext_size = u->opr_mode; 
        }
        if ( sext_size < 64 )
            sext_mask = ( 1ull << sext_size ) - 1;
        mkasm( u, "$0x" FMT64 "x", (uint64_t)(imm & sext_mask) ); 

		break;
    }

	case UD_OP_JIMM:
		switch (op->size) {
			case  8:
				mkasm(u, "0x" FMT64 "x", (uint64_t)(u->pc + op->lval.sbyte)); 
				break;
			case 16:
				mkasm(u, "0x" FMT64 "x", (uint64_t)((u->pc + op->lval.sword) & 0xffff) );
				break;
			case 32:
                                if (u->dis_mode == 32)
                                    mkasm(u, "0x" FMT64 "x", (uint64_t)((u->pc + op->lval.sdword) & 0xffffffff));
                                else
                                    mkasm(u, "0x" FMT64 "x", (uint64_t)(u->pc + op->lval.sdword));
				break;
			default:break;
		}
		break;

	case UD_OP_PTR:
		switch (op->size) {
			case 32:
				mkasm(u, "$0x%x, $0x%x", op->lval.ptr.seg, 
					op->lval.ptr.off & 0xFFFF);
				break;
			case 48:
				mkasm(u, "$0x%x, $0x%lx", op->lval.ptr.seg, 
					(unsigned long)op->lval.ptr.off);
				break;
		}
		break;
			
	default: return;
  }
}

/* =============================================================================
 * translates to AT&T syntax 
 * =============================================================================
 */
extern void 
ud_translate_att(struct ud *u)
{
  int size = 0;

  /* check if P_OSO prefix is used */
  if (! P_OSO(u->itab_entry->prefix) && u->pfx_opr) {
	switch (u->dis_mode) {
		case 16: 
			mkasm(u, "o32 ");
			break;
		case 32:
		case 64:
 			mkasm(u, "o16 ");
			break;
	}
  }

  /* check if P_ASO prefix was used */
  if (! P_ASO(u->itab_entry->prefix) && u->pfx_adr) {
	switch (u->dis_mode) {
		case 16: 
			mkasm(u, "a32 ");
			break;
		case 32:
 			mkasm(u, "a16 ");
			break;
		case 64:
 			mkasm(u, "a32 ");
			break;
	}
  }

  if (u->pfx_lock)
  	mkasm(u,  "lock ");
  if (u->pfx_rep)
	mkasm(u,  "rep ");
  if (u->pfx_repne)
		mkasm(u,  "repne ");

  /* special instructions */
  switch (u->mnemonic) {
	case UD_Iretf: 
		mkasm(u, "lret "); 
		break;
	case UD_Idb:
		mkasm(u, ".byte 0x%x", u->operand[0].lval.ubyte);
		return;
	case UD_Ijmp:
	case UD_Icall:
		if (u->br_far) mkasm(u,  "l");
		mkasm(u, "%s", ud_lookup_mnemonic(u->mnemonic));
		break;
	case UD_Ibound:
	case UD_Ienter:
		if (u->operand[0].type != UD_NONE)
			gen_operand(u, &u->operand[0]);
		if (u->operand[1].type != UD_NONE) {
			mkasm(u, ",");
			gen_operand(u, &u->operand[1]);
		}
		return;
	default:
		mkasm(u, "%s", ud_lookup_mnemonic(u->mnemonic));
  }

  if (u->c1)
	size = u->operand[0].size;
  else if (u->c2)
	size = u->operand[1].size;
  else if (u->c3)
	size = u->operand[2].size;

  if (size == 8)
	mkasm(u, "b");
  else if (size == 16)
	mkasm(u, "w");
  else if (size == 64)
 	mkasm(u, "q");

  mkasm(u, " ");

  if (u->operand[2].type != UD_NONE) {
	gen_operand(u, &u->operand[2]);
	mkasm(u, ", ");
  }

  if (u->operand[1].type != UD_NONE) {
	gen_operand(u, &u->operand[1]);
	mkasm(u, ", ");
  }

  if (u->operand[0].type != UD_NONE)
	gen_operand(u, &u->operand[0]);
}

#endif // USE(UDIS86)
Commit	Line	Data
93a37866 A	1	/* udis86 - libudis86/syn-att.c
	2	*
	3	* Copyright (c) 2002-2009 Vivek Thampi
	4	* All rights reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without modification,
	7	* are permitted provided that the following conditions are met:
	8	*
	9	* * Redistributions of source code must retain the above copyright notice,
	10	* this list of conditions and the following disclaimer.
	11	* * Redistributions in binary form must reproduce the above copyright notice,
	12	* this list of conditions and the following disclaimer in the documentation
	13	* and/or other materials provided with the distribution.
	14	*
	15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	17	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	18	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
	19	* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	20	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	21	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
	22	* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	23	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	24	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	25	*/
	26	#include "config.h"
	27
	28	#if USE(UDIS86)
	29
	30	#include "udis86_types.h"
	31	#include "udis86_extern.h"
	32	#include "udis86_decode.h"
	33	#include "udis86_itab.h"
	34	#include "udis86_syn.h"
	35
	36	/* -----------------------------------------------------------------------------
	37	* opr_cast() - Prints an operand cast.
	38	* -----------------------------------------------------------------------------
	39	*/
	40	static void
	41	opr_cast(struct ud* u, struct ud_operand* op)
	42	{
	43	switch(op->size) {
	44	case 16 : case 32 :
	45	mkasm(u, "*"); break;
	46	default: break;
	47	}
	48	}
	49
	50	/* -----------------------------------------------------------------------------
	51	* gen_operand() - Generates assembly output for each operand.
	52	* -----------------------------------------------------------------------------
	53	*/
	54	static void
	55	gen_operand(struct ud* u, struct ud_operand* op)
	56	{
	57	switch(op->type) {
	58	case UD_OP_REG:
	59	mkasm(u, "%%%s", ud_reg_tab[op->base - UD_R_AL]);
	60	break;
	61
	62	case UD_OP_MEM:
	63	if (u->br_far) opr_cast(u, op);
	64	if (u->pfx_seg)
65	mkasm(u, "%%%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]);
66	if (op->offset == 8) {
67	if (op->lval.sbyte < 0)
68	mkasm(u, "-0x%x", (-op->lval.sbyte) & 0xff);
81345200 A	69	else
81345200 A	70	mkasm(u, "0x%x", op->lval.sbyte);
93a37866	71	}
81345200 A	72	else if (op->offset == 16) {
	73	if (op->lval.sword < 0)
	74	mkasm(u, "-0x%x", (-op->lval.sword) & 0xffff);
	75	else
	76	mkasm(u, "0x%x", op->lval.sword);
	77	} else if (op->offset == 32) {
	78	if (op->lval.sdword < 0)
	79	mkasm(u, "-0x%x", (-op->lval.sdword) & 0xffffffff);
	80	else
	81	mkasm(u, "0x%x", op->lval.sdword);
	82	} else if (op->offset == 64) {
	83	if (op->lval.sdword < 0)
	84	mkasm(u, "-0x" FMT64 "x", (uint64_t)-op->lval.sqword);
	85	else
	86	mkasm(u, "0x" FMT64 "x", (uint64_t)op->lval.sqword);
	87	}
93a37866 A	88
	89	if (op->base)
	90	mkasm(u, "(%%%s", ud_reg_tab[op->base - UD_R_AL]);
	91	if (op->index) {
	92	if (op->base)
	93	mkasm(u, ",");
	94	else mkasm(u, "(");
	95	mkasm(u, "%%%s", ud_reg_tab[op->index - UD_R_AL]);
	96	}
	97	if (op->scale)
	98	mkasm(u, ",%d", op->scale);
	99	if (op->base \|\| op->index)
	100	mkasm(u, ")");
	101	break;
	102
	103	case UD_OP_IMM: {
	104	int64_t imm = 0;
	105	uint64_t sext_mask = 0xffffffffffffffffull;
	106	unsigned sext_size = op->size;
	107
	108	switch (op->size) {
	109	case 8: imm = op->lval.sbyte; break;
	110	case 16: imm = op->lval.sword; break;
	111	case 32: imm = op->lval.sdword; break;
	112	case 64: imm = op->lval.sqword; break;
	113	}
	114	if ( P_SEXT( u->itab_entry->prefix ) ) {
	115	sext_size = u->operand[ 0 ].size;
	116	if ( u->mnemonic == UD_Ipush )
	117	/* push sign-extends to operand size */
	118	sext_size = u->opr_mode;
	119	}
	120	if ( sext_size < 64 )
	121	sext_mask = ( 1ull << sext_size ) - 1;
81345200	122	mkasm( u, "$0x" FMT64 "x", (uint64_t)(imm & sext_mask) );
93a37866 A	123
	124	break;
	125	}
	126
	127	case UD_OP_JIMM:
	128	switch (op->size) {
	129	case 8:
81345200	130	mkasm(u, "0x" FMT64 "x", (uint64_t)(u->pc + op->lval.sbyte));
93a37866 A	131	break;
93a37866 A	132	case 16:
81345200	133	mkasm(u, "0x" FMT64 "x", (uint64_t)((u->pc + op->lval.sword) & 0xffff) );
93a37866 A	134	break;
	135	case 32:
	136	if (u->dis_mode == 32)
81345200	137	mkasm(u, "0x" FMT64 "x", (uint64_t)((u->pc + op->lval.sdword) & 0xffffffff));
93a37866	138	else
81345200	139	mkasm(u, "0x" FMT64 "x", (uint64_t)(u->pc + op->lval.sdword));
93a37866 A	140	break;
	141	default:break;
	142	}
	143	break;
	144
	145	case UD_OP_PTR:
	146	switch (op->size) {
	147	case 32:
	148	mkasm(u, "$0x%x, $0x%x", op->lval.ptr.seg,
	149	op->lval.ptr.off & 0xFFFF);
	150	break;
	151	case 48:
	152	mkasm(u, "$0x%x, $0x%lx", op->lval.ptr.seg,
	153	(unsigned long)op->lval.ptr.off);
	154	break;
	155	}
	156	break;
	157
	158	default: return;
	159	}
	160	}
	161
	162	/* =============================================================================
	163	* translates to AT&T syntax
	164	* =============================================================================
	165	*/
	166	extern void
	167	ud_translate_att(struct ud *u)
	168	{
	169	int size = 0;
	170
	171	/* check if P_OSO prefix is used */
	172	if (! P_OSO(u->itab_entry->prefix) && u->pfx_opr) {
	173	switch (u->dis_mode) {
	174	case 16:
	175	mkasm(u, "o32 ");
	176	break;
	177	case 32:
	178	case 64:
	179	mkasm(u, "o16 ");
	180	break;
	181	}
	182	}
	183
	184	/* check if P_ASO prefix was used */
	185	if (! P_ASO(u->itab_entry->prefix) && u->pfx_adr) {
	186	switch (u->dis_mode) {
	187	case 16:
	188	mkasm(u, "a32 ");
	189	break;
	190	case 32:
	191	mkasm(u, "a16 ");
	192	break;
	193	case 64:
	194	mkasm(u, "a32 ");
	195	break;
	196	}
	197	}
	198
	199	if (u->pfx_lock)
	200	mkasm(u, "lock ");
	201	if (u->pfx_rep)
	202	mkasm(u, "rep ");
	203	if (u->pfx_repne)
204	mkasm(u, "repne ");
205
206	/* special instructions */
207	switch (u->mnemonic) {
208	case UD_Iretf:
209	mkasm(u, "lret ");
210	break;
211	case UD_Idb:
212	mkasm(u, ".byte 0x%x", u->operand[0].lval.ubyte);
213	return;
214	case UD_Ijmp:
215	case UD_Icall:
216	if (u->br_far) mkasm(u, "l");
217	mkasm(u, "%s", ud_lookup_mnemonic(u->mnemonic));
218	break;
219	case UD_Ibound:
220	case UD_Ienter:
221	if (u->operand[0].type != UD_NONE)
222	gen_operand(u, &u->operand[0]);
223	if (u->operand[1].type != UD_NONE) {
224	mkasm(u, ",");
225	gen_operand(u, &u->operand[1]);
226	}
227	return;
228	default:
229	mkasm(u, "%s", ud_lookup_mnemonic(u->mnemonic));
230	}
231
232	if (u->c1)
233	size = u->operand[0].size;
234	else if (u->c2)
235	size = u->operand[1].size;
236	else if (u->c3)
237	size = u->operand[2].size;
238
239	if (size == 8)
240	mkasm(u, "b");
241	else if (size == 16)
242	mkasm(u, "w");
243	else if (size == 64)
244	mkasm(u, "q");
245
246	mkasm(u, " ");
247
248	if (u->operand[2].type != UD_NONE) {
249	gen_operand(u, &u->operand[2]);
250	mkasm(u, ", ");
251	}
252
253	if (u->operand[1].type != UD_NONE) {
254	gen_operand(u, &u->operand[1]);
255	mkasm(u, ", ");
256	}
257
258	if (u->operand[0].type != UD_NONE)
259	gen_operand(u, &u->operand[0]);
260	}
261
262	#endif // USE(UDIS86)
263