851 lines
17 KiB
C
851 lines
17 KiB
C
/* $NetBSD: kshell_disassem.c,v 1.6 1997/10/14 09:01:40 mark Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1994 Mark Brinicombe.
|
|
* Copyright (c) 1994 Brini.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software written for Brini by Mark Brinicombe
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. 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.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Brini.
|
|
* 4. The name of the company nor the name of the author may be used to
|
|
* endorse or promote products derived from this software without specific
|
|
* prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY BRINI ``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 BRINI 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.
|
|
*
|
|
* RiscBSD kernel project
|
|
*
|
|
* disassem.c
|
|
*
|
|
* Debug / Monitor disassembler
|
|
*
|
|
* Created : 09/10/94
|
|
*/
|
|
|
|
/*
|
|
* The disassembler now duplicates a lot of code with the debugger.
|
|
* The main reason there are two is that this one has extra interactive
|
|
* support for following branches durinhg disassembly and this one uses
|
|
* printf() with the one in db_disassem.c uses db_printf().
|
|
*/
|
|
|
|
|
|
/* Special compilation symbols
|
|
*
|
|
* DISASSEM_COLOUR - Use colour in dissassembly
|
|
*/
|
|
/*#define DISASSEM_COLOUR */
|
|
|
|
/* Include standard header files */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
|
|
/* Local header files */
|
|
|
|
#include <machine/katelib.h>
|
|
|
|
typedef u_int (*instruction_decoder) (u_int addr, u_int word);
|
|
|
|
typedef struct _opcodes {
|
|
u_int mask;
|
|
u_int pattern;
|
|
u_int colour;
|
|
instruction_decoder decoder;
|
|
} opcodes_struct;
|
|
|
|
static u_int instruction_swi __P((u_int addr, u_int word));
|
|
static u_int instruction_branch __P((u_int addr, u_int word));
|
|
static u_int instruction_mul __P((u_int addr, u_int word));
|
|
static u_int instruction_mla __P((u_int addr, u_int word));
|
|
static u_int instruction_ldrstr __P((u_int addr, u_int word));
|
|
static u_int instruction_ldmstm __P((u_int addr, u_int word));
|
|
static u_int instruction_dataproc __P((u_int addr, u_int word));
|
|
static u_int instruction_swap __P((u_int addr, u_int word));
|
|
static u_int instruction_mrs __P((u_int addr, u_int word));
|
|
static u_int instruction_msr __P((u_int addr, u_int word));
|
|
static u_int instruction_msrf __P((u_int addr, u_int word));
|
|
static u_int instruction_mrcmcr __P((u_int addr, u_int word));
|
|
static u_int instruction_cdp __P((u_int addr, u_int word));
|
|
static u_int instruction_cdt __P((u_int addr, u_int word));
|
|
static u_int instruction_fpabinop __P((u_int addr, u_int word));
|
|
static u_int instruction_fpaunop __P((u_int addr, u_int word));
|
|
static u_int instruction_ldfstf __P((u_int addr, u_int word));
|
|
|
|
/* Declare global variables */
|
|
|
|
opcodes_struct opcodes[] = {
|
|
{ 0x0f000000, 0x0f000000, 7, instruction_swi },
|
|
{ 0x0e000000, 0x0a000000, 7, instruction_branch },
|
|
{ 0x0fe000f0, 0x00000090, 7, instruction_mul },
|
|
{ 0x0fe000f0, 0x00200090, 7, instruction_mla },
|
|
{ 0x0e000000, 0x04000000, 7, instruction_ldrstr },
|
|
{ 0x0c000010, 0x04000000, 7, instruction_ldrstr },
|
|
{ 0x0e000000, 0x08000000, 6, instruction_ldmstm },
|
|
{ 0x0FB00FF0, 0x01000090, 7, instruction_swap },
|
|
{ 0x0FBF0FFF, 0x010F0000, 1, instruction_mrs },
|
|
{ 0x0DBFFFF0, 0x0129F000, 1, instruction_msr },
|
|
{ 0x0DBFFFF0, 0x0128F000, 1, instruction_msrf },
|
|
{ 0x0C000000, 0x00000000, 7, instruction_dataproc },
|
|
{ 0x0F008F10, 0x0E000100, 3, instruction_fpabinop },
|
|
{ 0x0F008F10, 0x0E008100, 3, instruction_fpaunop },
|
|
{ 0x0E000F00, 0x0C000100, 3, instruction_ldfstf },
|
|
{ 0x0F000010, 0x0E000010, 2, instruction_mrcmcr },
|
|
{ 0x0F000010, 0x0E000000, 2, instruction_cdp },
|
|
{ 0x0E000000, 0x0C000000, 2, instruction_cdt },
|
|
{ 0x00000000, 0x00000000, 0, NULL }
|
|
};
|
|
|
|
char *opcode_conditions[] = {
|
|
"EQ",
|
|
"NE",
|
|
"CS",
|
|
"CC",
|
|
"MI",
|
|
"PL",
|
|
"VS",
|
|
"VC",
|
|
"HI",
|
|
"LS",
|
|
"GE",
|
|
"LT",
|
|
"GT",
|
|
"LE",
|
|
"",
|
|
"NV"
|
|
};
|
|
|
|
char *opcode_data_procs[] = {
|
|
"AND",
|
|
"EOR",
|
|
"SUB",
|
|
"RSB",
|
|
"ADD",
|
|
"ADC",
|
|
"SBC",
|
|
"RSC",
|
|
"TST",
|
|
"TEQ",
|
|
"CMP",
|
|
"CMN",
|
|
"ORR",
|
|
"MOV",
|
|
"BIC",
|
|
"MVN"
|
|
};
|
|
|
|
char *opcode_shifts[] = {
|
|
"LSL",
|
|
"LSR",
|
|
"ASR",
|
|
"ROR"
|
|
};
|
|
|
|
char *opcode_block_transfers[] = {
|
|
"DA",
|
|
"IA",
|
|
"DB",
|
|
"IB"
|
|
};
|
|
|
|
char *opcode_stack_block_transfers[] = {
|
|
"FA",
|
|
"EA",
|
|
"FD",
|
|
"FA"
|
|
};
|
|
|
|
char *opcode_fpabinops[] = {
|
|
"ADF",
|
|
"MUF",
|
|
"SUF",
|
|
"RSF",
|
|
"DVF",
|
|
"RDF",
|
|
"POW",
|
|
"RPW",
|
|
"RMF",
|
|
"FML",
|
|
"FDV",
|
|
"FRD",
|
|
"POL",
|
|
"???",
|
|
"???",
|
|
"???",
|
|
"???"
|
|
};
|
|
|
|
char *opcode_fpaunops[] = {
|
|
"MVF",
|
|
"MNF",
|
|
"ABS",
|
|
"RND",
|
|
"SQT",
|
|
"LOG",
|
|
"LGN",
|
|
"EXP",
|
|
"SIN",
|
|
"COS",
|
|
"TAN",
|
|
"ASN",
|
|
"ACS",
|
|
"ATN",
|
|
"???",
|
|
"???",
|
|
"???"
|
|
};
|
|
|
|
char *opcode_fpaconstants[] = {
|
|
"0.0",
|
|
"1.0",
|
|
"2.0",
|
|
"3.0",
|
|
"4.0",
|
|
"5.0",
|
|
"0.5",
|
|
"10.0"
|
|
};
|
|
|
|
char *opcode_fpa_rounding[] = {
|
|
"",
|
|
"P",
|
|
"M",
|
|
"Z"
|
|
};
|
|
|
|
char *opcode_fpa_precision[] = {
|
|
"S",
|
|
"D",
|
|
"E",
|
|
"P"
|
|
};
|
|
|
|
#define opcode_condition(x) opcode_conditions[x >> 28]
|
|
|
|
#define opcode_s(x) ((x & 0x00100000) ? "S" : "")
|
|
|
|
#define opcode_b(x) ((x & 0x00400000) ? "B" : "")
|
|
|
|
#define opcode_t(x) ((x & 0x01200000) == 0x00200000 ? "T" : "")
|
|
|
|
#define opcode_dataproc(x) opcode_data_procs[(x >> 21) & 0x0f]
|
|
|
|
#define opcode_shift(x) opcode_shifts[(x >> 5) & 3]
|
|
|
|
#define opcode_blktrans(x) opcode_block_transfers[(x >> 23) & 3]
|
|
|
|
#define opcode_stkblktrans(x) opcode_stack_block_transfers[(x >> 23) & 3]
|
|
|
|
#define opcode_fpabinop(x) opcode_fpabinops[(x >> 20) & 0x0f]
|
|
|
|
#define opcode_fpaunop(x) opcode_fpaunops[(x >> 20) & 0x0f]
|
|
|
|
#define opcode_fpaimm(x) opcode_fpaconstants[x & 0x07]
|
|
|
|
#define opcode_fparnd(x) opcode_fpa_rounding[(x >> 5) & 0x03]
|
|
|
|
#define opcode_fpaprec(x) opcode_fpa_precision[(((x >> 18) & 2)|(x >> 7)) & 3]
|
|
|
|
/* Declare external variables */
|
|
|
|
extern caddr_t shell_ident;
|
|
|
|
int readhex __P((char *buf));
|
|
|
|
/* Local function prototypes */
|
|
|
|
u_int disassemble __P((u_char *addr));
|
|
static u_int do_disassemble __P((u_char *));
|
|
|
|
/* Now for the main code */
|
|
|
|
/* dis - disassembles memory */
|
|
|
|
void
|
|
shell_disassem(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
u_char *addr;
|
|
|
|
if (argc < 2) {
|
|
printf("Syntax: dis <addr>\n\r");
|
|
return;
|
|
}
|
|
|
|
/* Decode the one argument */
|
|
|
|
addr = (u_char *)readhex(argv[1]);
|
|
|
|
printf("Interactive disassembly\n\r");
|
|
|
|
do_disassemble(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
do_disassemble(addr)
|
|
u_char *addr;
|
|
{
|
|
u_int result;
|
|
int quit = 0;
|
|
int key = 0;
|
|
int count = 1;
|
|
|
|
do {
|
|
result = disassemble(addr);
|
|
|
|
--count;
|
|
|
|
if (count == 0) {
|
|
count = 1;
|
|
|
|
key = cngetc();
|
|
|
|
switch (key) {
|
|
case 'Q' :
|
|
case 'q' :
|
|
case 0x1b :
|
|
case 0x03 :
|
|
case 0x04 :
|
|
case 0x10b :
|
|
quit = 1;
|
|
break;
|
|
case 0x09 :
|
|
case 'r' :
|
|
case 'R' :
|
|
case 0x103 :
|
|
count = 16;
|
|
addr += 4;
|
|
break;
|
|
|
|
case 0x102 :
|
|
count = 16;
|
|
addr -= 124;
|
|
break;
|
|
|
|
case 0x0d :
|
|
case 0x101 :
|
|
addr = addr + 4;
|
|
break;
|
|
|
|
case 'B' :
|
|
case 'b' :
|
|
case 0x100:
|
|
addr = addr - 4;
|
|
break;
|
|
|
|
case '+' :
|
|
case '=' :
|
|
case 0x104 :
|
|
addr = addr + 0x80;
|
|
break;
|
|
|
|
case '-' :
|
|
case '_' :
|
|
case 0x105 :
|
|
addr = addr - 0x80;
|
|
break;
|
|
|
|
case ' ' :
|
|
quit = do_disassemble((u_char *)result);
|
|
break;
|
|
|
|
case 'J' :
|
|
case 'j' :
|
|
addr = (u_char *)result;
|
|
break;
|
|
|
|
case '/' :
|
|
case '?' :
|
|
printf("\'\xe3\' - Backwards 1 word\n\r");
|
|
printf("\'\xe4\' - Forwards 1 word\n\r");
|
|
printf("\'\xe5\' - Backwords 16 words\n\r");
|
|
printf("\'\xe6\' - Forwards 16 words\n\r");
|
|
printf("\'Q\' - Quit\n\r");
|
|
printf("\'B\' - Back a word\n\r");
|
|
printf("\'R\' - Disassemble 16 words\n\r");
|
|
printf("\'J\' - Jump to address\n\r");
|
|
printf("\' \' - Branch to address\n\r");
|
|
printf("<BS> - Return from branch\n\r");
|
|
printf("\'-\' - Skip backwards 128 words\n\r");
|
|
printf("\'+\' - Skip forwards 128 words\n\r");
|
|
break;
|
|
|
|
}
|
|
} else {
|
|
addr += 4;
|
|
}
|
|
} while (!quit && key != 0x08);
|
|
|
|
return(quit);
|
|
}
|
|
|
|
static void
|
|
printascii(byte)
|
|
int byte;
|
|
{
|
|
byte &= 0x7f;
|
|
if (byte < 0x20)
|
|
#ifdef DISASSEM_COLOUR
|
|
printf("\x1b[31m%c\x1b[0m", byte + '@');
|
|
#else
|
|
printf("%c", byte + '@');
|
|
#endif
|
|
else if (byte == 0x7f)
|
|
#ifdef DISASSEM_COLOUR
|
|
printf("\x1b[31m?\x1b[0m");
|
|
#else
|
|
printf("?");
|
|
#endif
|
|
else
|
|
printf("%c", byte);
|
|
}
|
|
|
|
|
|
u_int
|
|
disassemble(addr)
|
|
u_char *addr;
|
|
{
|
|
int loop;
|
|
u_int word;
|
|
u_int result = 0;
|
|
|
|
printf("%08x : ", (u_int)addr);
|
|
|
|
word = *((u_int *)addr);
|
|
|
|
for (loop = 0; loop < 4; ++loop)
|
|
printascii(addr[loop]);
|
|
|
|
printf(" : %08x : ", word);
|
|
|
|
loop = 0;
|
|
|
|
while (opcodes[loop].mask != 0) {
|
|
if ((word & opcodes[loop].mask) == opcodes[loop].pattern) {
|
|
#ifdef DISASSEM_COLOUR
|
|
printf("\x1b[3%dm", opcodes[loop].colour);
|
|
#endif
|
|
result = (*opcodes[loop].decoder)((u_int )addr, word);
|
|
#ifdef DISASSEM_COLOUR
|
|
printf("\x1b[0m");
|
|
#endif
|
|
break;
|
|
}
|
|
++loop;
|
|
}
|
|
|
|
if (opcodes[loop].mask == 0)
|
|
printf("Undefined instruction");
|
|
|
|
printf("\n\r");
|
|
return(result);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_swi(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("SWI%s\t0x%08x", opcode_condition(word), (word & 0x00ffffff));
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_branch(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
u_int branch;
|
|
|
|
branch = ((word << 2) & 0x03ffffff);
|
|
if (branch & 0x02000000)
|
|
branch |= 0xfc000000;
|
|
|
|
branch += addr + 8;
|
|
|
|
if (word & 0x01000000)
|
|
printf("BL%s\t0x%08x", opcode_condition(word), branch);
|
|
else
|
|
printf("B%s\t0x%08x", opcode_condition(word), branch);
|
|
|
|
return(branch);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_mul(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("MUL%s%s\t", opcode_condition(word), opcode_s(word));
|
|
|
|
printf("r%d, r%d, r%d", (word >> 16) & 0x0f, word & 0x0f,
|
|
(word >> 8) & 0x0f);
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_mla(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("MLA%s%s\t", opcode_condition(word), opcode_s(word));
|
|
|
|
printf("r%d, r%d, r%d, r%d", (word >> 16) & 0x0f, word & 0x0f,
|
|
(word >> 8) & 0x0f, (word >> 12) & 0x0f);
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static void
|
|
register_shift(word)
|
|
u_int word;
|
|
{
|
|
printf("r%d", (word & 0x0f));
|
|
if ((word & 0x00000ff0) == 0)
|
|
;
|
|
else if ((word & 0x00000ff0) == 0x00000060)
|
|
printf(", RRX");
|
|
else {
|
|
if (word & 0x10)
|
|
printf(", %s r%d", opcode_shift(word), (word >> 8) & 0x0f);
|
|
else
|
|
printf(", %s #%d", opcode_shift(word), (word >> 7) & 0x1f);
|
|
}
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_ldrstr(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("%s%s%s%s\t", (word & 0x00100000) ? "LDR" : "STR",
|
|
opcode_condition(word), opcode_b(word), opcode_t(word));
|
|
|
|
printf("r%d, ", (word >> 12) & 0x0f);
|
|
|
|
if (((word >> 16) & 0x0f) == 16)
|
|
{
|
|
/* u_int location;
|
|
|
|
location = addr + 8;
|
|
|
|
addr = */
|
|
}
|
|
else
|
|
{
|
|
printf("[r%d", (word >> 16) & 0x0f);
|
|
|
|
printf("%s, ", (word & (1 << 24)) ? "" : "]");
|
|
|
|
if (!(word & 0x00800000))
|
|
printf("-");
|
|
|
|
if (word & (1 << 25))
|
|
register_shift(word);
|
|
else
|
|
printf("#0x%04x", word & 0xfff);
|
|
|
|
if (word & (1 << 24))
|
|
printf("]");
|
|
|
|
if (word & (1 << 21))
|
|
printf("!");
|
|
}
|
|
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_ldmstm(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
int loop;
|
|
int start;
|
|
|
|
printf("%s%s%s\t", (word & 0x00100000) ? "LDM" : "STM",
|
|
opcode_condition(word), opcode_blktrans(word));
|
|
|
|
printf("r%d", (word >> 16) & 0x0f);
|
|
|
|
if (word & (1 << 21))
|
|
printf("!");
|
|
|
|
printf(", {");
|
|
|
|
start = -1;
|
|
|
|
for (loop = 0; loop < 17; ++loop)
|
|
{
|
|
if (start != -1)
|
|
{
|
|
if (!(word & (1 << loop)) || loop == 16)
|
|
{
|
|
if (start == loop - 1)
|
|
printf("r%d, ", start);
|
|
else
|
|
printf("r%d-r%d, ", start, loop - 1);
|
|
start = -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (word & (1 << loop))
|
|
start = loop;
|
|
}
|
|
|
|
}
|
|
printf("\x7f\x7f}");
|
|
|
|
if (word & (1 << 22))
|
|
printf("^");
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_dataproc(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
if ((word & 0x01800000) == 0x01000000)
|
|
word = word & ~(1<<20);
|
|
|
|
printf("%s%s%s\t", opcode_dataproc(word), opcode_condition(word),
|
|
opcode_s(word));
|
|
|
|
if ((word & 0x01800000) != 0x01000000)
|
|
printf("r%d, ", (word >> 12) & 0x0f);
|
|
|
|
if ((word & 0x01a00000) != 0x01a00000)
|
|
printf("r%d, ", (word >> 16) & 0x0f);
|
|
|
|
if (word & 0x02000000)
|
|
{
|
|
printf("#&%08x", (word & 0xff) << (((word >> 7) & 0x1e)));
|
|
}
|
|
else
|
|
{
|
|
register_shift(word);
|
|
}
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_swap(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("SWP%s%s\t", opcode_condition(word), opcode_b(word));
|
|
|
|
printf("r%d, r%d, [r%d]", (word >> 12) & 0x0f, (word & 0x0f),
|
|
(word >> 16) & 0x0f);
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_mrs(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("MRS%s\tr%d, ", opcode_condition(word), (word >> 12) & 0x0f);
|
|
|
|
printf("%s", (word & 0x00400000) ? "SPSR" : "CPSR");
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_msr(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("MSR%s\t", opcode_condition(word));
|
|
|
|
printf("%s, r%d", (word & 0x00400000) ? "SPSR" : "CPSR", word & 0x0f);
|
|
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_msrf(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("MSR%s\t", opcode_condition(word));
|
|
|
|
printf("%s_flg, ", (word & 0x00400000) ? "SPSR" : "CPSR");
|
|
|
|
if (word & 0x02000000)
|
|
printf("#0x%08x", (word & 0xff) << (32 - ((word >> 7) & 0x1e)));
|
|
else
|
|
printf("r%d", word &0x0f);
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_mrcmcr(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("%s%s\t", (word & (1 << 20)) ? "MRC" : "MCR",
|
|
opcode_condition(word));
|
|
|
|
printf("CP #%d, %d, ", (word >> 8) & 0x0f, (word >> 21) & 0x07);
|
|
|
|
printf("r%d, cr%d, cr%d", (word >> 12) & 0x0f, (word >> 16) & 0x0f,
|
|
word & 0x0f);
|
|
|
|
if (((word >> 5) & 0x07) != 0)
|
|
printf(", %d", (word >> 5) & 0x07);
|
|
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_cdp(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("CDP%s\t", opcode_condition(word));
|
|
|
|
printf("CP #%d, %d, ", (word >> 8) & 0x0f, (word >> 20) & 0x0f);
|
|
|
|
printf("cr%d, cr%d, cr%d", (word >> 12) & 0x0f, (word >> 16) & 0x0f,
|
|
word & 0x0f);
|
|
|
|
printf(", %d", (word >> 5) & 0x07);
|
|
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_cdt(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("%s%s%s\t", (word & (1 << 20)) ? "LDC" : "STC",
|
|
opcode_condition(word), (word & (1 << 22)) ? "L" : "");
|
|
|
|
printf("CP #%d, cr%d, ", (word >> 8) & 0x0f, (word >> 12) & 0x0f);
|
|
|
|
printf("[r%d", (word >> 16) & 0x0f);
|
|
|
|
printf("%s, ", (word & (1 << 24)) ? "" : "]");
|
|
|
|
if (!(word & (1 << 23)))
|
|
printf("-");
|
|
|
|
printf("#0x%02x", word & 0xff);
|
|
|
|
if (word & (1 << 24))
|
|
printf("]");
|
|
|
|
if (word & (1 << 21))
|
|
printf("!");
|
|
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_fpabinop(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("%s%s%s%s\t", opcode_fpabinop(word), opcode_condition(word),
|
|
opcode_fpaprec(word), opcode_fparnd(word));
|
|
|
|
printf("f%d, f%d, ", (word >> 12) & 0x07, (word >> 16) & 0x07);
|
|
|
|
if (word & (1 << 3))
|
|
printf("#%s", opcode_fpaimm(word));
|
|
else
|
|
printf("f%d", word & 0x07);
|
|
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_fpaunop(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("%s%s%s%s\t", opcode_fpaunop(word), opcode_condition(word),
|
|
opcode_fpaprec(word), opcode_fparnd(word));
|
|
|
|
printf("f%d, ", (word >> 12) & 0x07);
|
|
|
|
if (word & (1 << 3))
|
|
printf("#%s", opcode_fpaimm(word));
|
|
else
|
|
printf("f%d", word & 0x07);
|
|
|
|
return(addr);
|
|
}
|
|
|
|
|
|
static u_int
|
|
instruction_ldfstf(addr, word)
|
|
u_int addr;
|
|
u_int word;
|
|
{
|
|
printf("%s%s%s\t", (word & (1 << 20)) ? "LDF" : "STF",
|
|
opcode_condition(word), (word & (1 << 22)) ? "L" : "");
|
|
|
|
printf("f%d, [r%d", (word >> 12) & 0x07, (word >> 16) & 0x0f);
|
|
|
|
printf("%s, ", (word & (1 << 24)) ? "" : "]");
|
|
|
|
if (!(word & (1 << 23)))
|
|
printf("-");
|
|
|
|
printf("#0x%03x", (word & 0xff) << 2);
|
|
|
|
if (word & (1 << 24))
|
|
printf("]");
|
|
|
|
if (word & (1 << 21))
|
|
printf("!");
|
|
|
|
return(addr);
|
|
}
|
|
|
|
/* End of kshell_disassem.c */
|