spim.c

用汇编语言编程源代码

      list_breakpoints ();
      prev_cmd = LIST_BKPT_CMD;
      return (0);

    case DUMPNATIVE_TEXT_CMD:
    case DUMP_TEXT_CMD:
      {
        FILE *fp = NULL;
        char *filename = NULL;
	int token = (redo ? prev_token : read_token ());
        int i;
        int words = 0;
	int dump_start;
	int dump_limit;

        if (token == Y_STR)
	  filename = (char *) yylval.p;
        else if (token == Y_NL)
	  filename = "spim.dump";
        else
          {
            fprintf (stderr, "usage: %s [ \"filename\" ]\n",
                     (cmd == DUMP_TEXT_CMD ? "dump" : "dumpnative"));
            return (0);
          }

        fp = fopen (filename, "wb");
        if (fp == NULL)
          {
            perror (filename);
            return (0);
          }

	dump_start = find_symbol_address (END_OF_TRAP_HANDLER_SYMBOL);
	if (dump_start != 0)
	  dump_start -= TEXT_BOT;
	dump_start = dump_start >> 2;

	user_kernel_text_segment (0);
	dump_limit = (current_text_pc() - TEXT_BOT) >> 2;

        for (i = dump_start; i < dump_limit; i++)
          {
            int32 code = inst_encode (text_seg[i]);
            if (cmd == DUMP_TEXT_CMD)
	      code = htonl (code);    /* dump in network byte order */
            fwrite (&code, 1, sizeof(code), fp);
            words++;
          }

        fclose (fp);
        fprintf (stderr, "Dumped %ld words starting at 0x%08lx to file %s\n",
                 words, (dump_start << 2) + TEXT_BOT, filename);
      }
      prev_cmd = cmd;
      return (0);

    default:
      while (read_token () != Y_NL) ;
      error ("Unknown spim command\n");
      return (0);
    }
}


/* Read a SPIM command with the scanner and return its ennuemerated
   value. */

#ifdef __STDC__
static int
read_assembly_command (void)
#else
static int
read_assembly_command ()
#endif
{
  int token = read_token ();

  if (token == Y_NL)		/* Blank line means redo */
    return (REDO_CMD);
  else if (token != Y_ID)	/* Better be a string */
    return (UNKNOWN_CMD);
  else if (str_prefix ((char *) yylval.p, "exit", 2))
    return (EXIT_CMD);
  else if (str_prefix ((char *) yylval.p, "quit", 2))
    return (EXIT_CMD);
  else if (str_prefix ((char *) yylval.p, "print", 1))
    return (PRINT_CMD);
  else if (str_prefix ((char *) yylval.p, "print_symbols", 7))
    return (PRINT_SYM_CMD);
  else if (str_prefix ((char *) yylval.p, "print_all_regs", 7))
    return (PRINT_ALL_REGS_CMD);
  else if (str_prefix ((char *) yylval.p, "run", 2))
    return (RUN_CMD);
  else if (str_prefix ((char *) yylval.p, "read", 2))
    return (READ_CMD);
  else if (str_prefix ((char *) yylval.p, "load", 2))
    return (READ_CMD);
  else if (str_prefix ((char *) yylval.p, "reinitialize", 6))
    return (REINITIALIZE_CMD);
  else if (str_prefix ((char *) yylval.p, "step", 1))
    return (STEP_CMD);
  else if (str_prefix ((char *) yylval.p, "help", 1))
    return (HELP_CMD);
  else if (str_prefix ((char *) yylval.p, "continue", 1))
    return (CONTINUE_CMD);
  else if (str_prefix ((char *) yylval.p, "breakpoint", 2))
    return (SET_BKPT_CMD);
  else if (str_prefix ((char *) yylval.p, "delete", 1))
    return (DELETE_BKPT_CMD);
  else if (str_prefix ((char *) yylval.p, "list", 2))
    return (LIST_BKPT_CMD);
  else if (str_prefix ((char *) yylval.p, "dumpnative", 5))
    return (DUMPNATIVE_TEXT_CMD);
  else if (str_prefix ((char *) yylval.p, "dump", 4))
    return (DUMP_TEXT_CMD);
  else if (*(char *) yylval.p == '?')
    return (HELP_CMD);
  else if (*(char *) yylval.p == '.')
    return (ASM_CMD);
  else
    return (UNKNOWN_CMD);
}


/* Return non-nil if STRING1 is a (proper) prefix of STRING2. */

#ifdef __STDC__
static int
str_prefix (char *s1, char *s2, int min_match)
#else
static int
str_prefix (s1, s2, min_match)
     char *s1, *s2;
     int min_match;
#endif
{
  for ( ; *s1 == *s2 && *s1 != '\0'; s1 ++, s2 ++) min_match --;
  return (*s1 == '\0' && min_match <= 0);
}


/* Read and return an integer from the current line of input.  If the
   line doesn't contain an integer, return 0.  In either case, flush the
   rest of the line, including the newline. */

#ifdef __STDC__
static int
get_opt_int (void)
#else
static int
get_opt_int ()
#endif
{
  int token;

  if ((token = read_token ()) == Y_INT)
    {
      flush_to_newline ();
      return (yylval.i);
    }
  else if (token == Y_NL)
    return (0);
  else
    {
      flush_to_newline ();
      return (0);
    }
}


/* Flush the rest of the input line up to and including the next newline. */

#ifdef __STDC__
static void
flush_to_newline (void)
#else
static void
flush_to_newline ()
#endif
{
  while (read_token () != Y_NL) ;
}


/* Print register number N.
   Return non-zero if register N was valid register string. */

#ifdef __STDC__
static int
print_reg (int reg_no)
#else
static int
print_reg (reg_no)
     int reg_no;
#endif
{
  write_output (message_out, "Reg %d = 0x%08x (%d)\n", reg_no, R[reg_no], R[reg_no]);
  return (1);
}


#ifdef __STDC__
static int
print_fp_reg (int reg_no)
#else
static int
print_fp_reg (reg_no)
     int reg_no;
#endif
{
  if ((reg_no & 1) == 0)
    write_output (message_out, "FP reg %d = %g (double)\n", reg_no, FPR_D (reg_no));
  write_output (message_out, "FP reg %d = %g (single)\n", reg_no, FPR_S (reg_no));
  return (1);
}


#ifdef __STDC__
static int
print_reg_from_string (char* reg_num)
#else
static int
print_reg_from_string (reg_num)
     char* reg_num;
#endif
{
  char s[100];
  char *s1 = s;

  /* Conver to lower case */
  while (*reg_num != '\0' && s1 - s < 100)
    *s1++ = tolower (*reg_num++);
  *s1 = '\0';
  /* Drop leading $ */
  if (s[0] == '$')
    s1 = s + 1;
  else
    s1 = s;

  if (streq (s1, "pc"))
    write_output (message_out, "PC = 0x%08x (%d)\n", PC, PC);
  else if (streq (s1, "hi"))
    write_output (message_out, "HI = 0x%08x (%d)\n", HI, HI);
  else if (streq (s1, "lo"))
    write_output (message_out, "LO = 0x%08x (%d)\n", LO, LO);
  else if (streq (s1, "fpcond"))
    write_output (message_out, "FpCond = 0x%08x (%d)\n", FpCond, FpCond);
  else if (streq (s1, "cause"))
    write_output (message_out, "Cause = 0x%08x (%d)\n", Cause, Cause);
  else if (streq (s1, "epc"))
    write_output (message_out, "EPC = 0x%08x (%d)\n", EPC, EPC);
  else if (streq (s1, "status"))
    write_output (message_out, "Status = 0x%08x (%d)\n",
		  Status_Reg, Status_Reg);
  else if (streq (s1, "badvaddr"))
    write_output (message_out, "BadVAddr = 0x%08x (%d)\n",
		  BadVAddr, BadVAddr);
  else if (streq (s1, "context"))
    write_output (message_out, "Context = 0x%08x (%d)\n",
		  Context, Context);
  else if (streq (s1, "prid"))
    write_output (message_out, "PRId = 0x%08x (%d)\n", PRId, PRId);
  else
    return (0);

  return (1);
}


#define MAX_BUF_LEN 32000

#ifdef __STDC__
static void
print_all_regs (int hex_flag)
#else
static void
print_all_regs (hex_flag)
     int hex_flag;
#endif
{
  int max_buf_len = MAX_BUF_LEN;
  char buf[MAX_BUF_LEN];
  int count;
  registers_as_string (buf, &max_buf_len, &count, hex_flag, hex_flag);
  write_output (message_out, "%s\n", buf);
}



/* Print an error message. */

#ifdef __STDC__
void
error (char *fmt, ...)
#else
/*VARARGS0*/
void
error (va_alist)
va_dcl
#endif
{
  va_list args;
#ifndef __STDC__
  char *fmt;
#endif

#ifdef __STDC__
  va_start (args, fmt);
#else
  va_start (args);
  fmt = va_arg (args, char *);
#endif

#ifdef NO_VFPRINTF
  _doprnt (fmt, args, stderr);
#else
  vfprintf (stderr, fmt, args);
#endif
  va_end (args);
}


/* Print an error message and return to top level. */

#ifdef __STDC__
int*
run_error (char *fmt, ...)
#else
/*VARARGS0*/
int*
run_error (va_alist)
va_dcl
#endif
{
  va_list args;
#ifndef __STDC__
  char *fmt;
#endif

#ifdef __STDC__
  va_start (args, fmt);
#else
  va_start (args);
  fmt = va_arg (args, char *);
#endif

  console_to_spim ();

#ifdef VFPRINTF
  _doprnt (fmt, args, stderr);
#else
  vfprintf (stderr, fmt, args);
#endif
  va_end (args);
  longjmp (spim_top_level_env, 1);
  return (0);			/* So it can be used in expressions */
}



/* IO facilities: */

#ifdef __STDC__
void
write_output (port fp, char *fmt, ...)
#else
/*VARARGS0*/
void
write_output (va_alist)
va_dcl
#endif
{
  va_list args;
  FILE *f;
#ifndef __STDC__
  char *fmt;
  port fp;
#endif
  int restore_console_to_program = 0;

#ifdef __STDC__
  va_start (args, fmt);
  f = (FILE *) fp.f;
#else
  va_start (args);
  fp = va_arg (args, port);
  f = (FILE *) fp.f;
  fmt = va_arg (args, char *);
#endif

  if (console_state_saved)
    {
      restore_console_to_program = 1;
      console_to_spim ();
    }

  if (f != 0)
    {
#ifdef NO_VFPRINTF
      _doprnt (fmt, args, f);
#else
      vfprintf (f, fmt, args);
#endif
      fflush (f);
    }
  else
    {
#ifdef NO_VFPRINTF
      _doprnt (fmt, args, stdout);
#else
      vfprintf (stdout, fmt, args);
#endif
      fflush (stdout);
    }
  va_end (args);

  if (restore_console_to_program)
    console_to_program ();
}


/* Simulate the semantics of fgets (not gets) on Unix file. */

#ifdef __STDC__
void
read_input (char *str, int str_size)
#else
void
read_input (str, str_size)
     char *str;
     int str_size;
#endif
{
  char *ptr;
  int restore_console_to_program = 0;

  if (console_state_saved)
    {
      restore_console_to_program = 1;
      console_to_spim ();
    }

  ptr = str;

  while (1 < str_size)		/* Reserve space for null */
    {
      char buf[1];
      read ((int) console_in.i, buf, 1); /* Not in raw mode! */

      *ptr ++ = buf[0];
      str_size -= 1;

      if (buf[0] == '\n')
	break;
    }

  if (0 < str_size)
    *ptr = '\0';		/* Null terminate input */

  if (restore_console_to_program)
    console_to_program ();
}


/* Give the console to the program for IO. */

#ifdef __STDC__
static void
console_to_program (void)
#else
static void
console_to_program ()
#endif
{
  if (mapped_io && !console_state_saved)
    {
#ifdef USE_TERMIO
      struct termio params;

#ifdef DJGPP
      tcgetattr((int)console_in.i, &saved_console_state);
      params = saved_console_state;

      /* Note:  You must include the ICRNL option on DOS
		IUCLC and IXANY simply are not supported under DJGPP */
      params.c_iflag &= ~(ISTRIP|INLCR|IGNCR|IXON|IXOFF|INPCK|BRKINT|PARMRK);
      params.c_iflag |= ICRNL;
#else
      ioctl (console_in.i, TCGETA, (char *) &saved_console_state);
      params = saved_console_state;
      params.c_iflag &= ~(ISTRIP|IUCLC|INLCR|ICRNL|IGNCR|IXON|IXOFF|IXANY|INPCK|BRKINT|PARMRK);
#endif

      params.c_iflag |= IGNBRK|IGNPAR;
      /*params.c_oflag &= ~OPOST;*/
      params.c_cflag &= ~PARENB;
      params.c_cflag |= CREAD|CS8;
      params.c_lflag = 0;
      params.c_cc[VMIN] = 1;
      params.c_cc[VTIME] = 1;
#ifdef DJGPP
      tcsetattr((int)console_in.i, TCSANOW, &params);
#else
      ioctl ((int)console_in.i, TCSETA, (char *) &params);
#endif
#else
      int flags;
      ioctl ((int) console_in.i, TIOCGETP, (char *) &saved_console_state);
      flags = saved_console_state.sg_flags;
      saved_console_state.sg_flags = (flags | RAW) & ~(CRMOD|ECHO);
      ioctl ((int) console_in.i, TIOCSETP, (char *) &saved_console_state);
      saved_console_state.sg_flags = flags;
#endif
      console_state_saved = 1;
    }
}


/* Return the console to SPIM. */

#ifdef __STDC__
static void
console_to_spim (void)
#else
static void
console_to_spim ()
#endif
{
  if (mapped_io && console_state_saved)
#ifdef USE_TERMIO
#ifdef DJGPP
    tcsetattr((int)console_in.i, &saved_console_state);
#else
    ioctl ((int) console_in.i, TCSETA, (char *) &saved_console_state);
#endif
#else
    ioctl ((int) console_in.i, TIOCSETP, (char *) &saved_console_state);
#endif
  console_state_saved = 0;
}


#ifdef __STDC__
int
console_input_available (void)
#else
int
console_input_available ()
#endif
{
#ifndef __CYGWIN32__
  fd_set fdset;
  struct timeval timeout;

  if (mapped_io)
    {
      timeout.tv_sec = 0;
      timeout.tv_usec = 0;
      FD_ZERO (&fdset);
      FD_SET ((int) console_in.i, &fdset);
      return (select (sizeof (fdset) * 8, &fdset, NULL, NULL, &timeout));
    }
  else
#endif
    return (0);
}


#ifdef __STDC__
char
get_console_char (void)
#else
char
get_console_char ()
#endif
{
  char buf;

  read ((int) console_in.i, &buf, 1);

  if (buf == 3)			/* ^C */
    control_c_seen (0);
  return (buf);
}


#ifdef __STDC__
void
put_console_char (char c)
#else
void
put_console_char (c)
     char c;
#endif
{
  putc (c, (FILE *) console_out.f);
  fflush ((FILE *) console_out.f);
}

#ifdef __STDC__
static int
read_token ()
#else
static int
read_token ()
#endif
{
  int token = yylex ();

  if (token == 0)		/* End of file */
    {
      console_to_spim ();
      exit (0);
    }
  else
    {
      return (token);
    }
}