Subversion Repositories or1k

/* toplevel.c -- Top level simulator source file

   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org

This file is part of OpenRISC 1000 Architectural Simulator.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

/* Simulator commands. Help and version output. SIGINT processing.

Stdout redirection is specific to linux (I need to fix this). */

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <stdlib.h>

#include <signal.h>

#include <stdarg.h>

#include <readline/readline.h>

#include <readline/history.h>

#include "arch.h"

#include "parse.h"

#include "abstract.h"

#include "trace.h"

#include "execute.h"

/* CVS revision number. */

static const char rcsrev[] = "$Revision: 1.3 $";

/* Continuos run versus single step tracing switch. */

int cont_run;

/* History of execution */

int histexec[HISTEXEC_LEN];

char *sim_commands [] = {

  "q",

  "t",

  "help",

  "dm",

  "run",

  "pr",

  "pm",

  "pc",

  "brk",

  "hist",

  "stats",

  "info",

  "r",

};

void debug(const char *format, ...)

{

#if DEBUG

  char *p;

  va_list ap;

  if ((p = malloc(1000)) == NULL)

    return;

  va_start(ap, format);

  (void) vsnprintf(p, 1000, format, ap);

  va_end(ap);

  printf("%s\n", p);

  fflush(stdout);

  free(p);

#endif

  return;

}

void

ctrl_c(signum)

     int signum;

{

        cont_run = 1;

  signal(SIGINT, ctrl_c);

}

void

version()

{

        printf ("\n");

        printf ("OpenRISC 1000 Architectural Simulator, revision %s\n", rcsrev);

        printf ("Copyright (C) 1999  Damjan Lampret, lampret@opencores.org\n");

        printf ("Visit http://www.opencores.org for more information about ");

        printf ("OpenRISC 1000 and\nother open source cores.\n\n");

        printf ("This software comes with ABSOLUTELY NO WARRANTY; for ");

        printf ("details see COPYING.\nThis is free software, and you ");

        printf ("are welcome to redistribute it under certain\nconditions; ");

        printf ("for details see COPYING.\n");

}

void

help()

{

        printf("q                        - quit simulator\n");

        printf("r                        - display all registers\n");

        printf("t                        - execute next instruction\n");

        printf("run <cycles> [<hush>]    - execute <cycles> instructions, no reg dump if hush\n");

        printf("pr <r> <value>           - patch register <r> with <value>\n");

        printf("dm <fromaddr> [<toaddr>] - display memory from <fromaddr> to <toaddr>\n");

        printf("pm <addr> <value>        - patch memory location <addr> with <value>\n");

        printf("pc <value>               - patch PC register with <value>\n");

        printf("brk <addr>               - toggle breakpoint at address <addr>\n");

        printf("hist                     - execution history\n");

        printf("stats <num|clear>        - execution statistics num or clear it.\n");

        printf("info                     - configuration info (caches etc.)\n");

        printf("<cmd> > <filename>       - redirect simulator stdout to <filename> (and not emulated printf)\n");

        printf("help                     - available commands (this list)\n");

}

main(argc, argv)

     int argc;

     char *argv[];

{

        char *linestr;

        char item1[500];

        char *redirstr;

        int hush;

        if (argc != 2)

    {

      printf("Usage: %s <filename>\n", argv[0]);

      exit(-1);

    }

  initialize_readline ();       /* Bind our completer. */

        version();

        init_defconfig();

        signal(SIGINT, ctrl_c);

        initstats();

        loadcode(argv[1]);

        reset();

        while(1)

    {

      linestr = readline("(sim) ");

      if (!linestr)

        {

          break;

        }

      linestr = stripwhite (linestr);

      if (strlen(linestr) == 0)

        {

          char *l = repeat_last_command ();

          if (l)

            {

              free (linestr);

              linestr = l;

            }

        }

      if (*linestr)

        {

          add_history (linestr);

        }

      if (redirstr = strstr(linestr, ">"))

        {

          *redirstr = '\0';

          strtoken(&redirstr[1], item1, 1);

          freopen(item1, "w+", stdout);

        }

                strtoken(linestr, item1, 1);

                if (strcmp(item1, "q") == 0)     /* quit */

                        exit(0);

                else

                if (strcmp(item1, "help") == 0)  /* help */

                        help();

                else

                if (strcmp(item1, "t") == 0) {   /* trace */

                        cont_run = 1;

                } else

                if (strcmp(item1, "dm") == 0) {  /* dump memory */

                        char item2[20];

                        char item3[20];

                        static int from = 0, to = 0;

                        strtoken(linestr, item2, 2);

                        strtoken(linestr, item3, 3);

                        if (strlen(item2)) {

                                if (item2[0] == '_')

                                        from = eval_label(item2);

                                else

                                        from = strtoul(item2, NULL, 0);

                                to = from + 0x40;

                        }

                        if (strlen(item3))

                                to = strtoul(item3, NULL, 0);

                        dumpmemory(from, to);

      printf("\n");

                } else

                if (strcmp(item1, "pm") == 0) {  /* patch memory */

                        char item2[20];

                        char item3[20];

                        static int addr = 0;

                        strtoken(linestr, item2, 2);

                        strtoken(linestr, item3, 3);

                        if (strlen(item2))

                                if (item2[0] == '_')

                                        addr = eval_label(item2);

                                else

                                        addr = strtoul(item2, NULL, 0);

                        set_mem32(addr, strtoul(item3, NULL, 0));

                } else

                if (strcmp(item1, "pr") == 0) {  /* patch regs */

                        char item2[20];

                        char item3[20];

                        strtoken(linestr, item2, 2);

                        strtoken(linestr, item3, 3);

                        set_reg32(item2, strtoul(item3, NULL, 0));

                } else

                if (strcmp(item1, "pc") == 0) {  /* patch PC */

                        char item2[20];

                        strtoken(linestr, item2, 2);

                        pctemp = strtoul(item2, NULL, 0);

                } else

                if (strcmp(item1, "break") == 0) {       /* set/clear breakpoint */

                        char item2[20];

                        strtoken(linestr, item2, 2);

                        set_insnbrkpoint(strtoul(item2, NULL, 0));

                } else

                if (strcmp(item1, "r") == 0) {   /* dump regs */

                        dumpreg();

                } else

                if (strcmp(item1, "hist") == 0) {        /* dump history */

                        int i;

                        for(i = HISTEXEC_LEN; i; i--)

                                dumpmemory(histexec[i - 1], histexec[i - 1] + 4);

                } else

                if (strcmp(item1, "run") == 0) { /* run */

                        char item2[20];

                        char item3[20];

                        strtoken(linestr, item2, 2);

                        strtoken(linestr, item3, 3);

                        if (strcmp(item3, "hush") == 0)

                                hush = 1;

                        else

                                hush = 0;

                        cont_run = strtoul(item2, NULL, 0);

                } else

                if (strcmp(item1, "stats") == 0) { /* stats */

                        char item2[20];

                        int i = 0;

                        strtoken(linestr, item2, 2);

                        if (strcmp(item2, "clear") == 0) {

                                initstats();

                                printf("Cleared.\n");

                        } else {

                                i = strtoul(item2, NULL, 0);

                                printstats(i);

                        }

                } else

                if (strcmp(item1, "info") == 0) { /* configuration info */

                        bpb_info();

                        btic_info();

                        ic_info();

                        dc_info();

                } else {

      printf("%s: Unknown command.\n", linestr);

    }

                while(cont_run) {

                        cont_run--;

                        fetch();

                        decode(&iqueue[0]);

                        execute();

                        if (!hush)

                                dumpreg();

                }

                hush = 0;

                fflush(stdout);

                freopen("/dev/fd/0", "w+", stdout);

    if (linestr)

      free (linestr);

        }

        exit(0);

}

char *command_generator ();

char **sim_completion ();

/* Tell the GNU readline library how to complete.  We want to try to complete

   on command names if this is the first word in the line, or on filenames

   if not. */

void initialize_readline ()

{

  /* Allow conditional parsing of the ~/.inputrc file. */

  rl_readline_name = "or1ksim";

  /* Tell the completer that we want a crack first. */

  rl_attempted_completion_function = (CPPFunction *)sim_completion;

}

/* Attempt to complete on the contents of TEXT.  START and END bound the

   region of rl_line_buffer that contains the word to complete.  TEXT is

   the word to complete.  We can use the entire contents of rl_line_buffer

   in case we want to do some simple parsing.  Return the array of matches,

   or NULL if there aren't any. */

char **

sim_completion (text, start, end)

     char *text;

     int start, end;

{

  char **matches;

  matches = (char **)NULL;

  /* If this word is at the start of the line, then it is a command

     to complete.  Otherwise it is the name of a file in the current

     directory. */

  if (start == 0)

    matches = completion_matches (text, command_generator);

  return (matches);

}

/* Generator function for command completion.  STATE lets us know whether

   to start from scratch; without any state (i.e. STATE == 0), then we

   start at the top of the list. */

char *

command_generator (text, state)

     char *text;

     int state;

{

  static int list_index, len;

  char *name;

  /* If this is a new word to complete, initialize now.  This includes

     saving the length of TEXT for efficiency, and initializing the index

     variable to 0. */

  if (!state)

    {

      list_index = 0;

      len = strlen (text);

    }

  /* Return the next name which partially matches from the command list. */

  while (name = sim_commands[list_index])

    {

      list_index++;

      if (strncmp (name, text, len) == 0)

        return (dupstr(name));

    }

  /* If no names matched, then return NULL. */

  return ((char *)NULL);

}

/* Strip whitespace from the start and end of STRING.  Return a pointer

   into STRING. */

char *

stripwhite (string)

     char *string;

{

  register char *s, *t;

  for (s = string; whitespace (*s); s++)

    ;

  if (*s == 0)

    return (s);

  t = s + strlen (s) - 1;

  while (t > s && whitespace (*t))

    t--;

  *++t = '\0';

  return s;

}

char *

dupstr (s)

     char *s;

{

  char *r;

  r = xmalloc (strlen (s) + 1);

  strcpy (r, s);

  return (r);

}

/* Repeats the last command.  */

char *

repeat_last_command ()

{

  int offset = where_history ();

  HIST_ENTRY *hist;

  if (hist = history_get (offset))

    {

      return dupstr (hist->line);

    }

  return 0;

}