dasm.c

gdb是linux下的一个远程调试环境.能让你很方便地调试linux下的代码.

   int ce;
   int cntl;

   ce = (int) ((instr->c >> 7) & 0x01);
   cntl = (int) (instr->c & 0x7f);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %x,0x%x,%s,%s",
                 opcode_name[instr->op], ce, cntl,
                 reg[instr->a], reg[instr->b]);
   (void) fprintf(stderr, "%s %x,0x%x,%s,%s",
                 opcode_name[instr->op], ce, cntl,
                 reg[instr->a], reg[instr->b]);
   }



/*
** Format:  <Mnemonic>  ce, cntl, ra, const8
**
** (See LOADM, LOADSET, STORE, STOREL, etc...)
*/
/*ARGSUSED*/

void
dasm_ce_cntl_ra_const8(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   int ce;
   int cntl;

   ce = (int) ((instr->c >> 7) & 0x01);
   cntl = (int) (instr->c & 0x7f);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %x,0x%x,%s,0x%x",
                 opcode_name[instr->op], ce, cntl,
                 reg[instr->a], instr->b);
   (void) fprintf(stderr, "%s %x,0x%x,%s,0x%x",
                 opcode_name[instr->op], ce, cntl,
                 reg[instr->a], instr->b);
   }



/*
** Format:  <Mnemonic>  rc, rb
**
** (See CLZ, DIV0)
*/
/*ARGSUSED*/

void
dasm_rc_rb(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->b]);
   (void) fprintf(stderr, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->b]);
   }



/*
** Format:  <Mnemonic>  rc, const8
**
** (See CLZ, DIV0)
*/
/*ARGSUSED*/

void
dasm_rc_const8(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,0x%x", opcode_name[instr->op],
                 reg[instr->c], instr->b);
   (void) fprintf(stderr, "%s %s,0x%x", opcode_name[instr->op],
                 reg[instr->c], instr->b);
   }



/*
** Format:  <Mnemonic>  rc, ra, rb
**
** (See ADD, AND, etc...)
*/
/*ARGSUSED*/

void
dasm_rc_ra_rb(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a], reg[instr->b]);
   (void) fprintf(stderr, "%s %s,%s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a], reg[instr->b]);
   }



/*
** Format:  <Mnemonic>  rc, ra, const8
**
** (See ADD, AND, etc...)
*/
/*ARGSUSED*/

void
dasm_rc_ra_const8(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s,0x%x", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a], instr->b);
   (void) fprintf(stderr, "%s %s,%s,0x%x", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a], instr->b);
   }



/*
** Format:  <Mnemonic>  vn, ra, rb
**
** (See ASEQ, ASGE, etc...)
**
** Note:  This function also prints out a "nop" if the
**        instruction is an ASEQ and RA == RB.
**
*/
/*ARGSUSED*/

void
dasm_vn_ra_rb(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if ((instr->op == ASEQ0) &&
       (instr->a == instr->b))  {
      if (io_config.echo_mode == (INT32) TRUE) 
      (void) fprintf(io_config.echo_file, "nop");
      (void) fprintf(stderr, "nop");
      } else {
	 if (io_config.echo_mode == (INT32) TRUE) 
         (void) fprintf(io_config.echo_file, "%s 0x%x,%s,%s", opcode_name[instr->op],
                       instr->c, reg[instr->a], reg[instr->b]);
         (void) fprintf(stderr, "%s 0x%x,%s,%s", opcode_name[instr->op],
                       instr->c, reg[instr->a], reg[instr->b]);
      }
   }


/*
** Format:  <Mnemonic>  vn, ra, const8
**
** (See ASEQ, ASGE, etc...)
*/
/*ARGSUSED*/

void
dasm_vn_ra_const8(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s 0x%x,%s,0x%x", opcode_name[instr->op],
                 instr->c, reg[instr->a], instr->b);
   (void) fprintf(stderr, "%s 0x%x,%s,0x%x", opcode_name[instr->op],
                 instr->c, reg[instr->a], instr->b);
   }



/*
** Format:  <Mnemonic>  rc, ra
**
** (See MFTBL)
*/
/*ARGSUSED*/

void
dasm_rc_ra(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a]);
   (void) fprintf(stderr, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a]);
   }



/*
** Format:  <Mnemonic>
**
** (See HALT, IRET)
*/
/*ARGSUSED*/

void
dasm_none(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   (void) fprintf(stderr, "%s", opcode_name[instr->op]);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s", opcode_name[instr->op]);
   }

void
dasm_one(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   (void) fprintf(stderr, "%s 0x%x", opcode_name[instr->op],(int) (instr->c & 0x3));
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s 0x%x", opcode_name[instr->op], (int) (instr->c & 0x3));
   }


/*
** Format:  <Mnemonic>  target
**
** (See JMP, etc...)
*/
/*ARGSUSED*/

void
dasm_atarget(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   INT32  const16;
   INT32  i_17_10;
   INT32  i_9_2;

   i_17_10 = ((INT32) instr->c) << 10;
   i_9_2 = ((INT32) instr->b) << 2;
   const16 = (i_17_10 | i_9_2);
   (void) fprintf(stderr, "%s 0x%lx", opcode_name[instr->op],
                 const16);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s 0x%lx", opcode_name[instr->op],
                 const16);
   }



/*
** Format:  <Mnemonic>  target+pc
**
** (See JMP, etc...)
*/

void
dasm_rtarget(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   INT32  const16;
   INT32  i_17_10;
   INT32  i_9_2;

   i_17_10 = ((INT32) instr->c) << 10;
   i_9_2 = ((INT32) instr->b) << 2;
   const16 = (i_17_10 | i_9_2);
   if ((const16 & 0x00020000) != 0)  /* Sign extend (bit 17) */
      const16 = (const16 | 0xfffc0000);
   (void) fprintf(stderr, "%s 0x%lx", opcode_name[instr->op],
                 (const16+pc));
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s 0x%lx", opcode_name[instr->op],
                 (const16+pc));
   }



/*
** Format:  <Mnemonic>  ra, target
**
** (See CALL, JMPFDEC, JMPT, etc...)
*/
/*ARGSUSED*/

void
dasm_ra_atarget(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   INT32  const16;
   INT32  i_17_10;
   INT32  i_9_2;

   i_17_10 = ((INT32) instr->c) << 10;
   i_9_2 = ((INT32) instr->b) << 2;
   const16 = (i_17_10 | i_9_2);
   (void) fprintf(stderr, "%s %s,0x%lx", opcode_name[instr->op],
                 reg[instr->a], const16);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,0x%lx", opcode_name[instr->op],
                 reg[instr->a], const16);
   }



/*
** Format:  <Mnemonic>  ra, target
**
** (See CALL, JMPFDEC, JMPT, etc...)
*/

void
dasm_ra_rtarget(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   INT32  const16;
   INT32  i_17_10;
   INT32  i_9_2;

   i_17_10 = ((INT32) instr->c) << 10;
   i_9_2 = ((INT32) instr->b) << 2;
   const16 = (i_17_10 | i_9_2);
   if ((const16 & 0x00020000) != 0)  /* Sign extend (bit 17) */
      const16 = (const16 | 0xfffc0000);
   (void) fprintf(stderr, "%s %s,0x%lx", opcode_name[instr->op],
                 reg[instr->a], (const16+pc));
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,0x%lx", opcode_name[instr->op],
                 reg[instr->a], (const16+pc));
   }



/*
** Format:  <Mnemonic>  ra, rb
**
** (See CALLI, JMPFI)
*/
/*ARGSUSED*/

void
dasm_ra_rb(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   (void) fprintf(stderr, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->a], reg[instr->b]);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->a], reg[instr->b]);
   }



/*
** Format:  <Mnemonic>  rb
**
** (See JMPI)
*/
/*ARGSUSED*/

void
dasm_rb(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   (void) fprintf(stderr, "%s %s", opcode_name[instr->op],
                 reg[instr->b]);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s", opcode_name[instr->op],
                 reg[instr->b]);
   }



/*
** Format:  <Mnemonic>  rc, spid
**
** (See MFSR)
*/
/*ARGSUSED*/

void
dasm_rc_spid(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   (void) fprintf(stderr, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], spreg[instr->a]);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], spreg[instr->a]);
   }



/*
** Format:  <Mnemonic>  spid, rb
**
** (See MTSR)
*/
/*ARGSUSED*/

void
dasm_spid_rb(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s", opcode_name[instr->op],
                 spreg[instr->a], reg[instr->b]);
   (void) fprintf(stderr, "%s %s,%s", opcode_name[instr->op],
                 spreg[instr->a], reg[instr->b]);
   }



/*
** Format:  <Mnemonic>  dc, ra, rb
**
** (See CLASS)
*/
/*ARGSUSED*/

void
dasm_dc_ra_rb(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   (void) fprintf(stderr, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a]);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s", opcode_name[instr->op],
                 reg[instr->c], reg[instr->a]);
   }



/*
** Format:  <Mnemonic>  rc, ra, UI, RND, FD, FS
**
** (See CONVERT)
*/
/*ARGSUSED*/

void
dasm_convert(instr, pc)
   struct   instr_t *instr;
   ADDR32   pc;
   {
   int ui;
   int rnd;
   int fd;
   int fs;

   ui = (int) ((instr->b >> 7) & 0x01);
   rnd = (int) ((instr->b >> 4) & 0x07);
   fd = (int) ((instr->b >> 2) & 0x03);
   fs = (int) (instr->b & 0x03);
   if (io_config.echo_mode == (INT32) TRUE) 
   (void) fprintf(io_config.echo_file, "%s %s,%s,%x,%x,%x,%x",
                 opcode_name[instr->op],
                 reg[instr->c], reg[instr->a],
                 ui, rnd, fd, fs);
   (void) fprintf(stderr, "%s %s,%s,%x,%x,%x,%x",
                 opcode_name[instr->op],
                 reg[instr->c], reg[instr->a],
                 ui, rnd, fd, fs);
   }