URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [stable_0_2_0_rc2/] [or1ksim/] [toplevel.c] - Blame information for rev 293

Go to most recent revision | Details | Compare with Previous | View Log


/* 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 "config.h"
 
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <stdarg.h>
/* Added by CZ 24/05/01 */
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/poll.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/tcp.h>
#include <inttypes.h>
 
#ifdef HAVE_LIBREADLINE
#include <readline/readline.h>
#include <readline/history.h>
#endif /* HAVE_LIBREADLINE */
 
#include "arch.h"
#include "parse.h"
#include "abstract.h"
#include "labels.h"
#include "trace.h"
#include "execute.h"
#include "sim-config.h"
#include "spr_defs.h"
#include "dma.h"
 
#include "coff.h"
 
/* Added by CZ 24/05/01 */
#include "gdb.h"
#include <signal.h>
#include <errno.h>
typedef enum {
  false = 0,
  true = 1,
} Boolean;
unsigned int serverIP = 0;
unsigned int serverPort = 0;
unsigned int server_fd = 0;
unsigned int gdb_fd = 0;
void HandleServerSocket(Boolean);
void JTAGRequest(void);
void GDBRequest(void);
void ProtocolClean(int,int32_t);
static int gdb_read(void*,int);
static int gdb_write(void*,int);
void BlockJTAG(void);
 
/* CVS revision number. */
const char rcsrev[] = "$Revision: 1.36 $";
 
/* Continuos run versus single step tracing switch. */
int cont_run;
 
/* History of execution */
int histexec[HISTEXEC_LEN];
 
char *sim_commands [] = {
  "q",
  "t",
  "help",
  "de",
  "dm",
  "run",
  "pr",
  "pm",
  "pc",
  "reset",
  "break",
  "hist",
  "stats",
  "stall"
  "info",
  "r",
  "dv",
 
};
 
inline void debug(const char *format, ...)
{
  char *p;
  va_list ap;
 
  if (config.sim.debug) {
    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);
  } else {
#if DEBUG
  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
  }
}
 
/* Strip whitespace from the start and end of STRING.  Return a pointer
   into STRING. */
#ifndef whitespace
#define whitespace(a)   ((a) == '\t' ? 1 : ((a) == ' '? 1 : 0))
#endif
 
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;
}
 
void
ctrl_c(signum)
     int signum;
{
  extern int cpu_stalled;  /* CZ from debug_interface */
  cont_run = cpu_stalled ? 0 : 1;
  config.sim.iprompt = 1;
  cpu_stalled = 0;
  signal(SIGINT, ctrl_c);
}
 
void
version()
{
        printf ("\n");
        printf ("OpenRISC 1000 (OR16+OR32) Architectural Simulator, %s\n", rcsrev);
        printf ("Copyright (C) 1999 Damjan Lampret, lampret@opencores.org\n");
        printf ("Copyright (C) 2000 Damjan Lampret, lampret@opencores.org\n");
        printf ("                   Jimmy Chen-Min Chen, jimmy@ee.nctu.edu.tw\n");
        printf ("                   Johan Rydberg, johan.rydberg@insight.se\n");
        printf ("                   Marko Mlinar, markom@opencores.org\n");
  printf ("Copyright (C) 2001 Simon Srot, simons@opencores.org\n");
  printf ("                   Marko Mlinar, markom@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("de <fromaddr> [<toaddr>] - debug insn memory\n");
        printf("pm <addr> <value>        - patch memory location <addr> with <value>\n");
        printf("pc <value>               - patch PC register with <value>\n");
        printf("break <addr>             - toggle breakpoint at address <addr>\n");
        printf("reset                    - simulator reset\n");
        printf("hist                     - execution history\n");
        printf("stall                    - stalls the processor and gives control to the debugger\n");
        printf("stats <num|clear>        - execution statistics num or clear it.\n");
        printf("info                     - configuration info (caches etc.)\n");
        printf("dv <fromaddr> [<toaddr>] [<modname>] - dumps memory as verilog (use redirect)\n");
        printf("dh <fromaddr> [<toaddr>] - dumps memory as hex code (use redirect)\n");
        printf("<cmd> > <filename>       - redirect simulator stdout to <filename> (and not emulated printf)\n");
        printf("debug                    - toggles simulator debug mode\n");
        printf("help                     - available commands (this list)\n");
}
 
void debugmem( unsigned long from, unsigned long to );
 
main(argc, argv)
     int argc;
     char *argv[];
{
        char *linestr;
        char item1[500], b2[500], prev_str[500] = "";
        char *redirstr;
        int hush = 0;
        unsigned long endaddr = 0xFFFFFFFF;
        int first_prompt = 1;
        int trace_fd = 0;
 
        srand(getpid());
        init_defconfig();
        if (parse_args(argc, argv)) {
                printf("Usage: %s [options] <filename>\n", argv[0]);
                printf("Options:\n");
                printf(" -v                 version and copyright note\n");
                printf(" -i                 enable interactive command prompt\n");
                printf(" -f or --file       change script file [sim.cfg]\n");
                printf(" --nosrv            do not launch JTAG proxy server\n"); /* (CZ) */
                printf(" --srv <n>          launch JTAG proxy server on port <n>; [random]\n"); /* (CZ) */
                printf(" --profile          enable profiling\n");
                exit(-1);
        }
 
#ifdef HAVE_LIBREADLINE
  initialize_readline ();       /* Bind our completer. */
#endif
 
  /* Read configuration file.  */
  read_script_file(config.script_file);
  print_config();
  init_labels();
  init_breakpoints();
        signal(SIGINT, ctrl_c);
        initstats();
        build_automata();
 
  if(GDB_ENABLED) {
    serverPort = config.debug.server_port;
    if(server_fd = GetServerSocket("or1ksim","tcp",serverPort))
            printf("JTAG Proxy server started on port %d\n",serverPort);
  }
 
  if(config.sim.profile) {
    config.sim.fprof = fopen("sim.profile","wt+");
    if(!config.sim.fprof) {
      config.sim.profile = 0;
      printf("Problems opening profile file. Profiling disabled. \n");
    } else
      fprintf(config.sim.fprof, "+00000000 FFFFFFFF FFFFFFFF main\n");
  }
 
  /* Initialize memory */
  {
          extern struct dev_memarea *dev_list;
          int i;
          if (config.memory.type == MT_RANDOM) {
                  unsigned int val = 0;
 
      if (config.memory.random_seed == -1) {
        config.memory.random_seed = time(NULL);
        /* Print out the seed just in case we ever need to debug */
                    printf("Seeding random generator with value %d\n", config.memory.random_seed);
                  }
                  srandom(config.memory.random_seed);
 
                  for (cur_area = dev_list; cur_area; cur_area = cur_area->next)
        for(i = 0; i < cur_area->size; i++) {
          val = random();
          setsim_mem8(i + cur_area->addr_compare, val & 0xFF);
        }
    } else if(config.memory.type == MT_PATTERN) {
                  for (cur_area = dev_list; cur_area; cur_area = cur_area->next)
        for(i = 0; i < cur_area->size; i++)
          setsim_mem8(i + cur_area->addr_compare, config.memory.pattern);
    } else if (config.memory.type != MT_UNKNOWN) {
      fprintf(stderr, "Invalid memory configuration type.\n");
            exit(1);
    }
  }
 
        if(config.filename) {
          endaddr = loadcode(config.filename, 0, 0); /* MM170901 always load at address zero.  */
          if (endaddr == -1) {
            fprintf(stderr, "Problems loading boot code.\n");
            exit(1);
          }
        }
 
        /* Disable gdb debugging, if debug module is not available.  */
        if (!config.debug.enabled)
          config.debug.gdb_enabled = 0;
 
        uart_reset();
        dma_reset();
        eth_reset();
        tick_reset();
        pm_reset();
        pic_reset();
        mc_reset();
        reset();
 
        while(1) {
                if (config.sim.iprompt) {
                  if(server_fd)
                    {
                      printf ("(sim) ");
                      fflush(stdout);
                      HandleServerSocket(true);  /* block & check_stdin = true */
                    }
#ifdef HAVE_LIBREADLINE
                  /* Must disable readline in new mode. It isn't compatible
                     with non blocking environments */
                  if(!server_fd)
                    linestr = readline("(sim) ");
                  else
                    linestr = fgets(b2, sizeof b2, stdin);
#else
                  if(!server_fd)
                    printf ("(sim) ");
                  linestr = fgets(b2, sizeof b2, stdin);
#endif
                } else
                        strcpy(linestr = b2, "run -1 hush");
 
                if (!linestr)
                        break;
                linestr = stripwhite (linestr);
 
#ifdef HAVE_LIBREADLINE
                /* Readline only works in the old mode */
                if(!server_fd)
                  {
                    if (strlen(linestr) == 0) {
                      char *l = repeat_last_command ();
 
                      if (l) {
                        free (linestr);
                        linestr = l;
                      }
                    }
 
                    if (*linestr) {
                      add_history (linestr);
                    }
                  }
#endif /* HAVE_LIBREADLINE */
 
                if (redirstr = strstr(linestr, ">")) {
                        *redirstr = '\0';
                        strtoken(&redirstr[1], item1, 1);
                        freopen(item1, "w+", stdout);
                }
 
                if (linestr[0] == '\n')
                  strcpy (linestr, &prev_str[0]);
                else
                  strcpy (&prev_str[0], linestr);
 
                strtoken(linestr, item1, 1);
                if (strcmp(item1, "q") == 0) {   /* quit */
                  printf ("\n");
                  if (config.sim.profile) {
                    extern int cycles;
                    fprintf(config.sim.fprof,"-%08X FFFFFFFF\n", cycles);
                    fclose(config.sim.fprof);
                  }
                  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, 0);
                        printf("\n");
                } else
                if (strcmp(item1, "dv") == 0) {/* dump memory as verilog*/
                        char item2[20];
                        char item3[20];
                        char item4[20];
                        static int from = 0, to = 0;
 
                        strtoken(linestr, item2, 2);
                        strtoken(linestr, item3, 3);
                        strtoken(linestr, item4, 4);
 
                        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);
                        if (!strlen(item4))
                                strcpy(item4, "or1k_mem");
                        dumpverilog(item4, from, to);
                        printf("\n");
                } else
                if (strcmp(item1, "dh") == 0) {/* dump memory as hex*/
                        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);
                        dumphex(from, to);
                        printf("\n");
                } else
                if (strcmp(item1, "pm") == 0) {  /* patch memory */
                        char item2[20];
                        char item3[20];
                        static int addr = 0;
                        int breakpoint = 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), &breakpoint);
                } else
                if (strcmp(item1, "pr") == 0) {  /* patch regs */
                        char item2[20];
                        char item3[20];
 
                        strtoken(linestr, item2, 2);
                        strtoken(linestr, item3, 3);
                        set_reg32(strtoul(item2, NULL,0), strtoul(item3, NULL, 0));
                } else
                if (strcmp(item1, "pc") == 0) {  /* patch PC */
                        char item2[20];
 
                        strtoken(linestr, item2, 2);
                        pcnext = 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, "de") == 0) {  /* reset simulator */
                        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);
                        debugmem(from, to);
                        printf("\n");
                } else
                if (strcmp(item1, "reset") == 0) {       /* reset simulator */
                        uart_reset();
                        dma_reset();
                        eth_reset();
                        tick_reset();
                        pm_reset();
                        pic_reset();
                        reset(); /* Old or new mode */
                } else
                if (strcmp(item1, "debug") == 0) {       /* debug mode */
                        config.sim.debug ^= 1;
                } else
                if (strcmp(item1, "hist") == 0) {        /* dump history */
                        int i;
                        for(i = HISTEXEC_LEN; i; i--)
                                dumpmemory(histexec[i - 1], histexec[i - 1] + 4, 1);
                        printf("\n");
                } 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 = strtol(item2, NULL, 0);
                } else
                if(!strcmp(item1, "stall")) { /* Added by CZ 210801 */
                  extern int cpu_stalled;  /* CZ from debug_interface */
                  cpu_stalled = 1;
                  config.sim.iprompt = 0;
                  cont_run = -1;
                  hush = 1;
                } else
                if (!strcmp(item1, "trace")) { /* Added by CZ 210801 */
                  char item2[256];
 
                  strtoken(linestr, item2, 2);
                  if(trace_fd)
                    {
                      close(trace_fd);
                      trace_fd = 0;
                    }
                  if(strcmp(item2,"off")) /* if we're not being turned off */
                    {
                      if(item2[0])
                        trace_fd = open(item2,O_CREAT | O_NOCTTY |
                                        O_TRUNC | O_WRONLY, 0644);
                      else
                        trace_fd = dup(1);
                      if(trace_fd < 0)
                        {
                          perror(item2[0]?item2:"stdout");
                          trace_fd = 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 */
                        itlb_status(-1);
                        dtlb_status(-1);
                        bpb_info();
                        btic_info();
                        ic_info();
                        dc_info();
                        uart_status();
                        sprs_status();
                        dma_status();
                        eth_status();
                } else {
                        printf("%s: Unknown command.\n", linestr);
                }
 
                /* MM: 'run -1' means endless execution.  */
                while(cont_run != 0) {
                  int debug_slowdown = DEBUG_SLOWDOWN;
                  extern int cycle_delay;  /* Added by CZ 27/05/01. Set during exception. */
                  extern int cpu_stalled;  /* CZ from debug_interface */
 
                  if(GDB_ENABLED && cpu_stalled) {
              BlockJTAG();
              HandleServerSocket(false);
              continue;
            } else
              fprintf (stderr, "WARNING: CPU stalled and gdb connection not enabled.");
 
      if (!testsprbits(SPR_PMR, SPR_PMR_DME | SPR_PMR_SME)) {
        if(cycle_delay <= 0)
          {
            unsigned int addr;
            if (cont_run > 0) cont_run--;
            if(fetch()) {
              cont_run = 0; /* memory breakpoint encountered */
              break;
            }
            addr = iqueue[0].insn_addr;
 
            /* If trace_fd is non zero, we want
               to make sure that disassemble is called */
 
            decode_execute(&iqueue[0],trace_fd);
            if(trace_fd)
              {
                char sTemp[256];
                char sTemp2[256];
                unsigned long value;
                extern char *disassembled;
                extern unsigned long reg[];
 
                /* The objects passed to the
                   trace command should not be
                   hardcoded like this...instead
                   what to dump should be passed
                   on the command line.
 
                   FIX THIS LATER...
                */
                value = (evalsim_mem8(0x306bc) << 24) +
                  (evalsim_mem8(0x306bd) << 16) +
                  (evalsim_mem8(0x306be) << 8)
                  + evalsim_mem8(0x306bf);
 
                sprintf(sTemp,"0x%06x: %s",addr,disassembled);
                memset(sTemp2,' ',sizeof(sTemp2));
                strncpy(sTemp2,sTemp,strlen(sTemp));
                sprintf(&sTemp2[40],"<0x%08x,0x%08x> [0x%08x]\n",
                        reg[3],reg[4],value);
                write(trace_fd,sTemp2,strlen(sTemp2));
              }
            update_pc();
            analysis();
            if (!hush)
              dumpreg();
          }
        else
          cycle_delay--;
 
        pic_clock();
        dc_clock();
        ic_clock();
      }
      if (!testsprbits(SPR_PMR, SPR_PMR_SME))
        tick_clock();
      pm_clock();
      uart_clock();
      dma_clock();
      eth_clock();
 
      /*if (config.vapi.enabled)
        vapi_check();*/
      if (GDB_ENABLED && debug_slowdown-- == 0) {
        debug_slowdown = DEBUG_SLOWDOWN;
                          HandleServerSocket(false); /* block & check_stdin = false */
                        }
                }
                hush = 0;
                fflush(stdout);
                freopen("/dev/fd/0", "w+", stdout);
 
                if (!config.sim.iprompt) {      /* non-interactive quit */
                  if (config.sim.profile) {
                    extern int cycles;
                    fprintf(config.sim.fprof,"-%08X FFFFFFFF\n", cycles);
                    fclose(config.sim.fprof);
                  }
                  exit(0);
                }
#ifdef HAVE_LIBREADLINE
                if (linestr)
                        free (linestr);
#endif
 
        }
        exit(0);
}
 
#ifdef HAVE_LIBREADLINE
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);
}
 
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;
}
 
#endif
 
extern char *disassembled;
void debugmem( unsigned long from, unsigned long to )
{
  int i;
  printf("starting to dump mem...\n");
  for(i=from; i<to; ) {
    struct label_entry *entry;
    unsigned int _insn;
    printf("i=%x :: ", i);
 
    if (verify_memoryarea(i) && (entry = get_label(i)))
      printf("label: %s |", entry->name);
 
    iqueue[0].insn = _insn = evalsim_mem32(i);
    iqueue[0].insn_index = insn_decode(_insn);
    disassemble_insn (_insn);
    printf("%08x %s\n", _insn, disassembled);
                i += insn_len( iqueue[0].insn_index );
  }
}
 
static int tcp_level = 0;
 
/* Added by CZ 24/05/01 */
int GetServerSocket(const char* name,const char* proto,int port)
{
  struct servent *service;
  struct protoent *protocol;
  struct sockaddr_in sa;
  struct hostent *hp;
  int sockfd;
  char myname[256];
  int flags;
  char sTemp[256];
 
  /* First, get the protocol number of TCP */
  if(!(protocol = getprotobyname(proto)))
    {
      sprintf(sTemp,"Unable to load protocol \"%s\"",proto);
      perror(sTemp);
      return 0;
    }
  tcp_level = protocol->p_proto; /* Save for later */
 
  /* If we weren't passed a non standard port, get the port
     from the services directory. */
  if(!port)
    {
      if(service = getservbyname(name,protocol->p_name))
        port = ntohs(service->s_port);
    }
 
  /* Create the socket using the TCP protocol */
  if((sockfd = socket(PF_INET,SOCK_STREAM,protocol->p_proto)) < 0)
    {
      perror("Unable to create socket");
      return 0;
    }
 
  flags = 1;
  if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,(const char*)&flags,sizeof(int))
 < 0)
    {
      sprintf(sTemp,"Can not set SO_REUSEADDR option on socket %d",sockfd);
      perror(sTemp);
      close(sockfd);
      return 0;
    }
 
  /* The server should also be non blocking. Get the current flags. */
  if(fcntl(sockfd,F_GETFL,&flags) < 0)
    {
      sprintf(sTemp,"Unable to get flags for socket %d",sockfd);
      perror(sTemp);
      close(sockfd);
      return 0;
    }
 
  /* Set the nonblocking flag */
  if(fcntl(sockfd,F_SETFL, flags | O_NONBLOCK) < 0)
    {
      sprintf(sTemp,"Unable to set flags for socket %d to value 0x%08x",
              sockfd,flags | O_NONBLOCK);
      perror(sTemp);
      close(sockfd);
      return 0;
    }
 
  /* Find out what our address is */
  memset(&sa,0,sizeof(struct sockaddr_in));
  gethostname(myname,sizeof(myname));
  if(!(hp = gethostbyname(myname)))
    {
      perror("Unable to read hostname");
      close(sockfd);
      return 0;
    }
 
  /* Bind our socket to the appropriate address */
  sa.sin_family = hp->h_addrtype;
  sa.sin_port = htons(port);
  if(bind(sockfd,(struct sockaddr*)&sa,sizeof(struct sockaddr_in)) < 0)
    {
      sprintf(sTemp,"Unable to bind socket %d to port %d",sockfd,port);
      perror(sTemp);
      close(sockfd);
      return 0;
    }
  serverIP = sa.sin_addr.s_addr;
  flags = sizeof(struct sockaddr_in);
  if(getsockname(sockfd,(struct sockaddr*)&sa,&flags) < 0)
    {
      sprintf(sTemp,"Unable to get socket information for socket %d",sockfd);
      perror(sTemp);
      close(sockfd);
      return 0;
    }
  serverPort = ntohs(sa.sin_port);
 
  /* Set the backlog to 1 connections */
  if(listen(sockfd,1) < 0)
    {
      sprintf(sTemp,"Unable to set backlog on socket %d to %d",sockfd,1);
      perror(sTemp);
      close(sockfd);
      return 0;
    }
 
  return sockfd;
}
 
void BlockJTAG()
{
  struct pollfd fds[2];
  int n = 0;
 
  fds[n].fd = server_fd;
  fds[n].events = POLLIN;
  fds[n++].revents = 0;
  if(gdb_fd)
    {
      fds[n].fd = gdb_fd;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
  poll(fds,n,-1);
}
 
void HandleServerSocket(Boolean block)
{
  struct pollfd fds[3];
  int n = 0;
  int timeout = block ? -1 : 0;
  int server_index = -1;
  int gdb_index = -1;
  Boolean data_on_stdin = false;
  int o_serv_fd = server_fd;
 
  if(!o_serv_fd && !gdb_fd)
    return;
 
  if(o_serv_fd)
    {
      fds[n].fd = o_serv_fd;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
  if(gdb_fd)
    {
      fds[n].fd = gdb_fd;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
  if(block)
    {
      fds[n].fd = 0;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
 
  while(!data_on_stdin)
    {
      switch(poll(fds,n,timeout))
        {
        case -1:
          if(errno == EINTR)
            continue;
          perror("poll");
          server_fd = 0;
          break;
        case 0: /* Nothing interesting going on */
          data_on_stdin = true; /* Can only get here if nonblocking */
          break;
        default:
          /* Make sure to handle the gdb port first! */
          if((fds[0].revents && (gdb_fd && !o_serv_fd) ||
              fds[1].revents && (server_fd && gdb_fd)))
            {
              int revents = o_serv_fd ? fds[1].revents : fds[0].revents;
 
              if(revents & POLLIN)
                GDBRequest();
              else /* Error Occurred */
                {
                  fprintf(stderr,"Received flags 0x%08x on gdb socket. Shutting down.\n",revents);
                  close(gdb_fd);
                  gdb_fd = 0;
                }
            }
          if(fds[0].revents && o_serv_fd)
            {
              if(fds[0].revents & POLLIN)
                JTAGRequest();
              else /* Error Occurred */
                {
                  fprintf(stderr,"Received flags 0x%08x on server. Shutting down.\n",fds[0].revents);
                  close(o_serv_fd);
                  server_fd = 0;
                  serverPort = 0;
                  serverIP = 0;
                }
            }
          if(fds[2].revents || (fds[1].revents && !gdb_fd))
            data_on_stdin = true;
          break;
        } /* End of switch statement */
    } /* End of while statement */
}
 
void JTAGRequest()
{
  struct sockaddr_in sa;
  struct sockaddr* addr = (struct sockaddr*)&sa;
  int n = sizeof(struct sockaddr_in);
  int fd = accept(server_fd,addr,&n);
  int on_off = 0; /* Turn off Nagel's algorithm on the socket */
  int flags;
  char sTemp[256];
 
  if(fd < 0)
    {
      /* This is valid, because a connection could have started,
         and then terminated due to a protocol error or user
         initiation before the accept could take place. */
      if(errno != EWOULDBLOCK && errno != EAGAIN)
        {
          perror("accept");
          close(server_fd);
          server_fd = 0;
          serverPort = 0;
          serverIP = 0;
        }
      return;
    }
 
  if(gdb_fd)
    {
      close(fd);
      return;
    }
 
  if(fcntl(fd,F_GETFL,&flags) < 0)
    {
      sprintf(sTemp,"Unable to get flags for gdb socket %d",fd);
      perror(sTemp);
      close(fd);
      return;
    }
 
  if(fcntl(fd,F_SETFL, flags | O_NONBLOCK) < 0)
    {
      sprintf(sTemp,"Unable to set flags for gdb socket %d to value 0x%08x",
              fd,flags | O_NONBLOCK);
      perror(sTemp);
      close(fd);
      return;
    }
 
  if(setsockopt(fd,tcp_level,TCP_NODELAY,&on_off,sizeof(int)) < 0)
    {
      sprintf(sTemp,"Unable to disable Nagel's algorithm for socket %d.\nsetsockopt",fd);
      perror(sTemp);
      close(fd);
      return;
    }
 
  gdb_fd = fd;
}
 
void GDBRequest()
{
  JTAGProxyWriteMessage msg_write;
  JTAGProxyReadMessage msg_read;
  JTAGProxyChainMessage msg_chain;
  JTAGProxyWriteResponse resp_write;
  JTAGProxyReadResponse resp_read;
  JTAGProxyChainResponse resp_chain;
  JTAGProxyBlockWriteMessage *msg_bwrite;
  JTAGProxyBlockReadMessage msg_bread;
  JTAGProxyBlockWriteResponse resp_bwrite;
  JTAGProxyBlockReadResponse *resp_bread;
  char *buf;
  unsigned long long data;
  int err = 0;
  uint32_t command,length;
  int len,i;
 
  /* First, we must read the incomming command */
  if(gdb_read(&command,sizeof(uint32_t)) < 0)
    {
      if(gdb_fd)
        {
          perror("gdb socket - 1");
          close(gdb_fd);
          gdb_fd = 0;
        }
      return;
    }
  if(gdb_read(&length,sizeof(uint32_t)) < 0)
    {
      if(gdb_fd)
        {
          perror("gdb socket - 2");
          close(gdb_fd);
          gdb_fd = 0;
        }
      return;
    }
  length = ntohl(length);
 
  /* Now, verify the protocol and implement the command */
  switch(ntohl(command))
    {
    case JTAG_COMMAND_WRITE:
      if(length != sizeof(msg_write) - 8)
        {
          ProtocolClean(length,JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char*)&msg_write;
      if(gdb_read(&buf[8],length) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 3");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_write.address = ntohl(msg_write.address);
      msg_write.data_H = ntohl(msg_write.data_H);
      msg_write.data_L = ntohl(msg_write.data_L);
      err = DebugSetRegister(msg_write.address,msg_write.data_L);
      resp_write.status = htonl(err);
      if(gdb_write(&resp_write,sizeof(resp_write)) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 4");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    case JTAG_COMMAND_READ:
      if(length != sizeof(msg_read) - 8)
        {
          ProtocolClean(length,JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char*)&msg_read;
      if(gdb_read(&buf[8],length) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 5");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_read.address = ntohl(msg_read.address);
      err = DebugGetRegister(msg_read.address,&resp_read.data_L);
      resp_read.status = htonl(err);
      resp_read.data_H = 0;
      resp_read.data_L = htonl(resp_read.data_L);
      if(gdb_write(&resp_read,sizeof(resp_read)) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 6");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    case JTAG_COMMAND_BLOCK_WRITE:
      if(length < sizeof(JTAGProxyBlockWriteMessage)-8)
        {
          ProtocolClean(length,JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      if(!(buf = (char*)malloc(8+length)))
        {
          ProtocolClean(length,JTAG_PROXY_OUT_OF_MEMORY);
          return;
        }
      msg_bwrite = (JTAGProxyBlockWriteMessage*)buf;
      if(gdb_read(&buf[8],length) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 5");
              close(gdb_fd);
              gdb_fd = 0;
            }
          free(buf);
          return;
        }
      msg_bwrite->address = ntohl(msg_bwrite->address);
      msg_bwrite->nRegisters = ntohl(msg_bwrite->nRegisters);
      for(i=0;i<msg_bwrite->nRegisters;i++)
        {
          int t_err = 0;
 
          msg_bwrite->data[i] = ntohl(msg_bwrite->data[i]);
          t_err = DebugSetRegister(msg_bwrite->address+i,msg_bwrite->data[i]);
          err = err ? err : t_err;
        }
      resp_bwrite.status = htonl(err);
      free(buf);
      buf = NULL;
      msg_bwrite = NULL;
      if(gdb_write(&resp_bwrite,sizeof(resp_bwrite)) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 4");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    case JTAG_COMMAND_BLOCK_READ:
      if(length != sizeof(msg_bread) - 8)
        {
          ProtocolClean(length,JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char*)&msg_bread;
      if(gdb_read(&buf[8],length) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 5");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_bread.address = ntohl(msg_bread.address);
      msg_bread.nRegisters = ntohl(msg_bread.nRegisters);
      len = sizeof(JTAGProxyBlockReadResponse) + 4*(msg_bread.nRegisters-1);
      if(!(buf = (char*)malloc(len)))
        {
          ProtocolClean(0,JTAG_PROXY_OUT_OF_MEMORY);
          return;
        }
      resp_bread = (JTAGProxyBlockReadResponse*)buf;
      for(i=0;i<msg_bread.nRegisters;i++)
        {
          int t_err;
 
          t_err = DebugGetRegister(msg_bread.address+i,&resp_bread->data[i]);
          resp_bread->data[i] = htonl(resp_bread->data[i]);
          err = err ? err : t_err;
        }
      resp_bread->status = htonl(err);
      resp_bread->nRegisters = htonl(msg_bread.nRegisters);
      if(gdb_write(resp_bread,len) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 6");
              close(gdb_fd);
              gdb_fd = 0;
            }
          free(buf);
          return;
        }
      free(buf);
      buf = NULL;
      resp_bread = NULL;
      break;
    case JTAG_COMMAND_CHAIN:
      if(length != sizeof(msg_chain) - 8)
        {
          ProtocolClean(length,JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char*)&msg_chain;
      if(gdb_read(&buf[8],sizeof(msg_chain)-8) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 7");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_chain.chain = htonl(msg_chain.chain);
      err = DebugSetChain(msg_chain.chain);
      resp_chain.status = htonl(err);
      if(gdb_write(&resp_chain,sizeof(resp_chain)) < 0)
        {
          if(gdb_fd)
            {
              perror("gdb socket - 8");
              close(gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    default:
      ProtocolClean(length,JTAG_PROXY_COMMAND_NOT_IMPLEMENTED);
      break;
    }
}
 
void ProtocolClean(int length,int32_t err)
{
  char buf[4096];
 
  err = htonl(err);
  if((gdb_read(buf,length) < 0) ||
      (gdb_write(&err,sizeof(err)) < 0) && gdb_fd)
    {
      perror("gdb socket - 9");
      close(gdb_fd);
      gdb_fd = 0;
    }
}
 
static int gdb_write(void* buf,int len)
{
  int n;
  char* w_buf = (char*)buf;
  struct pollfd block;
 
  while(len)
    {
      if((n = write(gdb_fd,w_buf,len)) < 0)
        {
          switch(errno)
            {
            case EWOULDBLOCK: /* or EAGAIN */
              /* We've been called on a descriptor marked
                 for nonblocking I/O. We better simulate
                 blocking behavior. */
              block.fd = gdb_fd;
              block.events = POLLOUT;
              block.revents = 0;
              poll(&block,1,-1);
              continue;
            case EINTR:
              continue;
            case EPIPE:
              close(gdb_fd);
              gdb_fd = 0;
              return -1;
            default:
              return -1;
            }
        }
      else
        {
          len -= n;
          w_buf += n;
        }
    }
  return 0;
}
 
static int gdb_read(void* buf,int len)
{
  int n;
  char* r_buf = (char*)buf;
  struct pollfd block;
 
  while(len)
    {
      if((n = read(gdb_fd,r_buf,len)) < 0)
        {
          switch(errno)
            {
            case EWOULDBLOCK: /* or EAGAIN */
              /* We've been called on a descriptor marked
                 for nonblocking I/O. We better simulate
                 blocking behavior. */
              block.fd = gdb_fd;
              block.events = POLLIN;
              block.revents = 0;
              poll(&block,1,-1);
              continue;
            case EINTR:
              continue;
            default:
              return -1;
            }
        }
      else if(n == 0)
        {
          close(gdb_fd);
          gdb_fd = 0;
          return -1;
        }
      else
        {
          len -= n;
          r_buf += n;
        }
    }
  return 0;
}

Line No.	Rev	Author	Line
1	2	cvs	`/* toplevel.c -- Top level simulator source file`
2			`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
3
4			`This file is part of OpenRISC 1000 Architectural Simulator.`
5
6			`This program is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2 of the License, or`
9			`(at your option) any later version.`
10
11			`This program is distributed in the hope that it will be useful,`
12			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`GNU General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */`
19
20			`/* Simulator commands. Help and version output. SIGINT processing.`
21			`Stdout redirection is specific to linux (I need to fix this). */`
22
23	16	jrydberg	`#include "config.h"`
24
25	2	cvs	`#include <stdio.h>`
26			`#include <ctype.h>`
27			`#include <string.h>`
28			`#include <stdlib.h>`
29	46	lampret	`#include <unistd.h>`
30	2	cvs	`#include <signal.h>`
31			`#include <stdarg.h>`
32	123	markom	`/* Added by CZ 24/05/01 */`
33			`#include <sys/stat.h>`
34			`#include <sys/types.h>`
35			`#include <sys/socket.h>`
36			`#include <netinet/in.h>`
37			`#include <sys/select.h>`
38			`#include <sys/poll.h>`
39			`#include <fcntl.h>`
40			`#include <netdb.h>`
41			`#include <netinet/tcp.h>`
42	127	chris	`#include <inttypes.h>`
43	2	cvs
44	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
45	7	jrydberg	`#include <readline/readline.h>`
46			`#include <readline/history.h>`
47	16	jrydberg	`#endif /* HAVE_LIBREADLINE */`
48	7	jrydberg
49	2	cvs	`#include "arch.h"`
50			`#include "parse.h"`
51			`#include "abstract.h"`
52	261	markom	`#include "labels.h"`
53	2	cvs	`#include "trace.h"`
54			`#include "execute.h"`
55	69	lampret	`#include "sim-config.h"`
56	103	lampret	`#include "spr_defs.h"`
57	212	erez	`#include "dma.h"`
58	2	cvs
59	28	lampret	`#include "coff.h"`
60
61	123	markom	`/* Added by CZ 24/05/01 */`
62	127	chris	`#include "gdb.h"`
63	123	markom	`#include <signal.h>`
64			`#include <errno.h>`
65			`typedef enum {`
66			`false = 0,`
67			`true = 1,`
68			`} Boolean;`
69			`unsigned int serverIP = 0;`
70			`unsigned int serverPort = 0;`
71			`unsigned int server_fd = 0;`
72			`unsigned int gdb_fd = 0;`
73			`void HandleServerSocket(Boolean);`
74			`void JTAGRequest(void);`
75			`void GDBRequest(void);`
76	127	chris	`void ProtocolClean(int,int32_t);`
77			`static int gdb_read(void*,int);`
78			`static int gdb_write(void*,int);`
79			`void BlockJTAG(void);`
80
81	2	cvs	`/* CVS revision number. */`
82	293	markom	`const char rcsrev[] = "$Revision: 1.36 $";`
83	2	cvs
84			`/* Continuos run versus single step tracing switch. */`
85			`int cont_run;`
86
87			`/* History of execution */`
88			`int histexec[HISTEXEC_LEN];`
89
90	7	jrydberg	`char *sim_commands [] = {`
91			`"q",`
92			`"t",`
93			`"help",`
94	21	cmchen	`"de",`
95	7	jrydberg	`"dm",`
96			`"run",`
97			`"pr",`
98			`"pm",`
99			`"pc",`
100	18	lampret	`"reset",`
101			`"break",`
102	7	jrydberg	`"hist",`
103			`"stats",`
104	181	chris	`"stall"`
105	7	jrydberg	`"info",`
106			`"r",`
107	54	lampret	`"dv",`
108	7	jrydberg
109			`};`
110
111	167	markom	`inline void debug(const char *format, ...)`
112	2	cvs	`{`
113	7	jrydberg	`char *p;`
114			`va_list ap;`
115	2	cvs
116	264	markom	`if (config.sim.debug) {`
117	69	lampret	`if ((p = malloc(1000)) == NULL)`
118			`return;`
119			`va_start(ap, format);`
120			`(void) vsnprintf(p, 1000, format, ap);`
121			`va_end(ap);`
122			`printf("%s\n", p);`
123			`fflush(stdout);`
124			`free(p);`
125			`} else {`
126			`#if DEBUG`
127	7	jrydberg	`if ((p = malloc(1000)) == NULL)`
128			`return;`
129			`va_start(ap, format);`
130			`(void) vsnprintf(p, 1000, format, ap);`
131			`va_end(ap);`
132			`printf("%s\n", p);`
133			`fflush(stdout);`
134			`free(p);`
135	2	cvs	`#endif`
136	69	lampret	`}`
137	2	cvs	`}`
138
139	30	lampret	`/* Strip whitespace from the start and end of STRING. Return a pointer`
140			`into STRING. */`
141			`#ifndef whitespace`
142			`#define whitespace(a) ((a) == '\t' ? 1 : ((a) == ' '? 1 : 0))`
143			`#endif`
144
145			`char *`
146			`stripwhite (string)`
147			`char *string;`
148			`{`
149			`register char s, t;`
150
151			`for (s = string; whitespace (*s); s++)`
152			`;`
153
154			`if (*s == 0)`
155			`return (s);`
156
157			`t = s + strlen (s) - 1;`
158			`while (t > s && whitespace (*t))`
159			`t--;`
160			`*++t = '\0';`
161
162			`return s;`
163			`}`
164
165	7	jrydberg	`void`
166			`ctrl_c(signum)`
167			`int signum;`
168	2	cvs	`{`
169	181	chris	`extern int cpu_stalled; /* CZ from debug_interface */`
170			`cont_run = cpu_stalled ? 0 : 1;`
171	264	markom	`config.sim.iprompt = 1;`
172	181	chris	`cpu_stalled = 0;`
173	7	jrydberg	`signal(SIGINT, ctrl_c);`
174	2	cvs	`}`
175
176	7	jrydberg	`void`
177			`version()`
178	2	cvs	`{`
179	7	jrydberg	`printf ("\n");`
180	18	lampret	`printf ("OpenRISC 1000 (OR16+OR32) Architectural Simulator, %s\n", rcsrev);`
181			`printf ("Copyright (C) 1999 Damjan Lampret, lampret@opencores.org\n");`
182			`printf ("Copyright (C) 2000 Damjan Lampret, lampret@opencores.org\n");`
183	21	cmchen	`printf (" Jimmy Chen-Min Chen, jimmy@ee.nctu.edu.tw\n");`
184	18	lampret	`printf (" Johan Rydberg, johan.rydberg@insight.se\n");`
185	264	markom	`printf (" Marko Mlinar, markom@opencores.org\n");`
186			`printf ("Copyright (C) 2001 Simon Srot, simons@opencores.org\n");`
187			`printf (" Marko Mlinar, markom@opencores.org\n");`
188	7	jrydberg	`printf ("Visit http://www.opencores.org for more information about ");`
189			`printf ("OpenRISC 1000 and\nother open source cores.\n\n");`
190			`printf ("This software comes with ABSOLUTELY NO WARRANTY; for ");`
191			`printf ("details see COPYING.\nThis is free software, and you ");`
192			`printf ("are welcome to redistribute it under certain\nconditions; ");`
193			`printf ("for details see COPYING.\n");`
194	2	cvs	`}`
195
196	7	jrydberg	`void`
197			`help()`
198	2	cvs	`{`
199			`printf("q - quit simulator\n");`
200			`printf("r - display all registers\n");`
201			`printf("t - execute next instruction\n");`
202			`printf("run <cycles> [<hush>] - execute <cycles> instructions, no reg dump if hush\n");`
203			`printf("pr <r> <value> - patch register <r> with <value>\n");`
204			`printf("dm <fromaddr> [<toaddr>] - display memory from <fromaddr> to <toaddr>\n");`
205	257	erez	`printf("de <fromaddr> [<toaddr>] - debug insn memory\n");`
206	2	cvs	`printf("pm <addr> <value> - patch memory location <addr> with <value>\n");`
207			`printf("pc <value> - patch PC register with <value>\n");`
208	18	lampret	`printf("break <addr> - toggle breakpoint at address <addr>\n");`
209			`printf("reset - simulator reset\n");`
210	2	cvs	`printf("hist - execution history\n");`
211	181	chris	`printf("stall - stalls the processor and gives control to the debugger\n");`
212	6	lampret	`printf("stats <num\|clear> - execution statistics num or clear it.\n");`
213			`printf("info - configuration info (caches etc.)\n");`
214	54	lampret	`printf("dv <fromaddr> [<toaddr>] [<modname>] - dumps memory as verilog (use redirect)\n");`
215	86	lampret	`printf("dh <fromaddr> [<toaddr>] - dumps memory as hex code (use redirect)\n");`
216	2	cvs	`printf("<cmd> > <filename> - redirect simulator stdout to <filename> (and not emulated printf)\n");`
217	69	lampret	`printf("debug - toggles simulator debug mode\n");`
218	2	cvs	`printf("help - available commands (this list)\n");`
219			`}`
220
221	257	erez	`void debugmem( unsigned long from, unsigned long to );`
222	21	cmchen
223	7	jrydberg	`main(argc, argv)`
224			`int argc;`
225			`char *argv[];`
226	2	cvs	`{`
227	7	jrydberg	`char *linestr;`
228	167	markom	`char item1[500], b2[500], prev_str[500] = "";`
229	2	cvs	`char *redirstr;`
230	261	markom	`int hush = 0;`
231	123	markom	`unsigned long endaddr = 0xFFFFFFFF;`
232			`int first_prompt = 1;`
233	181	chris	`int trace_fd = 0;`
234	123	markom
235	103	lampret	`srand(getpid());`
236			`init_defconfig();`
237	123	markom	`if (parse_args(argc, argv)) {`
238	221	markom	`printf("Usage: %s [options] <filename>\n", argv[0]);`
239	103	lampret	`printf("Options:\n");`
240	264	markom	`printf(" -v version and copyright note\n");`
241			`printf(" -i enable interactive command prompt\n");`
242			`printf(" -f or --file change script file [sim.cfg]\n");`
243			`printf(" --nosrv do not launch JTAG proxy server\n"); /* (CZ) */`
244			`printf(" --srv <n> launch JTAG proxy server on port <n>; [random]\n"); /* (CZ) */`
245			`printf(" --profile enable profiling\n");`
246	103	lampret	`exit(-1);`
247			`}`
248	7	jrydberg
249	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
250	7	jrydberg	`initialize_readline (); /* Bind our completer. */`
251	264	markom	`#endif`
252	269	markom
253			`/* Read configuration file. */`
254			`read_script_file(config.script_file);`
255			`print_config();`
256			`init_labels();`
257			`init_breakpoints();`
258			`signal(SIGINT, ctrl_c);`
259			`initstats();`
260			`build_automata();`
261
262			`if(GDB_ENABLED) {`
263			`serverPort = config.debug.server_port;`
264			`if(server_fd = GetServerSocket("or1ksim","tcp",serverPort))`
265			`printf("JTAG Proxy server started on port %d\n",serverPort);`
266			`}`
267	123	markom
268	264	markom	`if(config.sim.profile) {`
269			`config.sim.fprof = fopen("sim.profile","wt+");`
270			`if(!config.sim.fprof) {`
271			`config.sim.profile = 0;`
272	173	markom	`printf("Problems opening profile file. Profiling disabled. \n");`
273			`} else`
274	264	markom	`fprintf(config.sim.fprof, "+00000000 FFFFFFFF FFFFFFFF main\n");`
275	173	markom	`}`
276	263	markom
277	262	markom	`/* Initialize memory */`
278			`{`
279	221	markom	`extern struct dev_memarea *dev_list;`
280			`int i;`
281	269	markom	`if (config.memory.type == MT_RANDOM) {`
282	221	markom	`unsigned int val = 0;`
283	123	markom
284	262	markom	`if (config.memory.random_seed == -1) {`
285			`config.memory.random_seed = time(NULL);`
286			`/* Print out the seed just in case we ever need to debug */`
287			`printf("Seeding random generator with value %d\n", config.memory.random_seed);`
288			`}`
289			`srandom(config.memory.random_seed);`
290
291	221	markom	`for (cur_area = dev_list; cur_area; cur_area = cur_area->next)`
292			`for(i = 0; i < cur_area->size; i++) {`
293			`val = random();`
294	262	markom	`setsim_mem8(i + cur_area->addr_compare, val & 0xFF);`
295	221	markom	`}`
296	262	markom	`} else if(config.memory.type == MT_PATTERN) {`
297	221	markom	`for (cur_area = dev_list; cur_area; cur_area = cur_area->next)`
298			`for(i = 0; i < cur_area->size; i++)`
299	262	markom	`setsim_mem8(i + cur_area->addr_compare, config.memory.pattern);`
300	269	markom	`} else if (config.memory.type != MT_UNKNOWN) {`
301	262	markom	`fprintf(stderr, "Invalid memory configuration type.\n");`
302			`exit(1);`
303	221	markom	`}`
304	242	markom	`}`
305	262	markom
306			`if(config.filename) {`
307			`endaddr = loadcode(config.filename, 0, 0); /* MM170901 always load at address zero. */`
308			`if (endaddr == -1) {`
309			`fprintf(stderr, "Problems loading boot code.\n");`
310			`exit(1);`
311			`}`
312			`}`
313	269	markom
314			`/* Disable gdb debugging, if debug module is not available. */`
315			`if (!config.debug.enabled)`
316			`config.debug.gdb_enabled = 0;`
317	221	markom
318	30	lampret	`uart_reset();`
319	212	erez	`dma_reset();`
320	257	erez	`eth_reset();`
321	92	lampret	`tick_reset();`
322	103	lampret	`pm_reset();`
323	242	markom	`pic_reset();`
324	261	markom	`mc_reset();`
325	2	cvs	`reset();`
326	7	jrydberg
327	103	lampret	`while(1) {`
328	264	markom	`if (config.sim.iprompt) {`
329	123	markom	`if(server_fd)`
330			`{`
331			`printf ("(sim) ");`
332			`fflush(stdout);`
333			`HandleServerSocket(true); /* block & check_stdin = true */`
334			`}`
335	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
336	123	markom	`/* Must disable readline in new mode. It isn't compatible`
337			`with non blocking environments */`
338			`if(!server_fd)`
339			`linestr = readline("(sim) ");`
340			`else`
341			`linestr = fgets(b2, sizeof b2, stdin);`
342	16	jrydberg	`#else`
343	123	markom	`if(!server_fd)`
344			`printf ("(sim) ");`
345			`linestr = fgets(b2, sizeof b2, stdin);`
346	16	jrydberg	`#endif`
347	103	lampret	`} else`
348	173	markom	`strcpy(linestr = b2, "run -1 hush");`
349	7	jrydberg
350	103	lampret	`if (!linestr)`
351			`break;`
352			`linestr = stripwhite (linestr);`
353	7	jrydberg
354	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
355	123	markom	`/* Readline only works in the old mode */`
356			`if(!server_fd)`
357			`{`
358			`if (strlen(linestr) == 0) {`
359			`char *l = repeat_last_command ();`
360
361			`if (l) {`
362			`free (linestr);`
363			`linestr = l;`
364			`}`
365			`}`
366
367			`if (*linestr) {`
368			`add_history (linestr);`
369			`}`
370			`}`
371	16	jrydberg	`#endif /* HAVE_LIBREADLINE */`
372	2	cvs
373	103	lampret	`if (redirstr = strstr(linestr, ">")) {`
374			`*redirstr = '\0';`
375			`strtoken(&redirstr[1], item1, 1);`
376			`freopen(item1, "w+", stdout);`
377			`}`
378	2	cvs
379	167	markom	`if (linestr[0] == '\n')`
380			`strcpy (linestr, &prev_str[0]);`
381			`else`
382			`strcpy (&prev_str[0], linestr);`
383
384	2	cvs	`strtoken(linestr, item1, 1);`
385	167	markom	`if (strcmp(item1, "q") == 0) { /* quit */`
386			`printf ("\n");`
387	264	markom	`if (config.sim.profile) {`
388	173	markom	`extern int cycles;`
389	264	markom	`fprintf(config.sim.fprof,"-%08X FFFFFFFF\n", cycles);`
390			`fclose(config.sim.fprof);`
391	173	markom	`}`
392	167	markom	`exit(0);`
393			`} else`
394	2	cvs	`if (strcmp(item1, "help") == 0) /* help */`
395			`help();`
396			`else`
397			`if (strcmp(item1, "t") == 0) { /* trace */`
398			`cont_run = 1;`
399			`} else`
400			`if (strcmp(item1, "dm") == 0) { /* dump memory */`
401			`char item2[20];`
402			`char item3[20];`
403			`static int from = 0, to = 0;`
404
405			`strtoken(linestr, item2, 2);`
406			`strtoken(linestr, item3, 3);`
407
408			`if (strlen(item2)) {`
409			`if (item2[0] == '_')`
410			`from = eval_label(item2);`
411			`else`
412			`from = strtoul(item2, NULL, 0);`
413			`to = from + 0x40;`
414			`}`
415			`if (strlen(item3))`
416			`to = strtoul(item3, NULL, 0);`
417	167	markom	`dumpmemory(from, to, 0);`
418	54	lampret	`printf("\n");`
419	2	cvs	`} else`
420	54	lampret	`if (strcmp(item1, "dv") == 0) {/* dump memory as verilog*/`
421			`char item2[20];`
422			`char item3[20];`
423			`char item4[20];`
424			`static int from = 0, to = 0;`
425
426			`strtoken(linestr, item2, 2);`
427			`strtoken(linestr, item3, 3);`
428			`strtoken(linestr, item4, 4);`
429
430			`if (strlen(item2)) {`
431			`if (item2[0] == '_')`
432			`from = eval_label(item2);`
433			`else`
434			`from = strtoul(item2, NULL, 0);`
435			`to = from + 0x40;`
436			`}`
437			`if (strlen(item3))`
438			`to = strtoul(item3, NULL, 0);`
439			`if (!strlen(item4))`
440			`strcpy(item4, "or1k_mem");`
441			`dumpverilog(item4, from, to);`
442			`printf("\n");`
443			`} else`
444	86	lampret	`if (strcmp(item1, "dh") == 0) {/* dump memory as hex*/`
445			`char item2[20];`
446			`char item3[20];`
447			`static int from = 0, to = 0;`
448
449			`strtoken(linestr, item2, 2);`
450			`strtoken(linestr, item3, 3);`
451
452			`if (strlen(item2)) {`
453			`if (item2[0] == '_')`
454			`from = eval_label(item2);`
455			`else`
456			`from = strtoul(item2, NULL, 0);`
457			`to = from + 0x40;`
458			`}`
459			`if (strlen(item3))`
460			`to = strtoul(item3, NULL, 0);`
461			`dumphex(from, to);`
462			`printf("\n");`
463			`} else`
464	2	cvs	`if (strcmp(item1, "pm") == 0) { /* patch memory */`
465			`char item2[20];`
466			`char item3[20];`
467			`static int addr = 0;`
468	123	markom	`int breakpoint = 0;`
469
470	2	cvs	`strtoken(linestr, item2, 2);`
471			`strtoken(linestr, item3, 3);`
472			`if (strlen(item2))`
473			`if (item2[0] == '_')`
474			`addr = eval_label(item2);`
475			`else`
476			`addr = strtoul(item2, NULL, 0);`
477	123	markom	`set_mem32(addr, strtoul(item3, NULL, 0), &breakpoint);`
478	2	cvs	`} else`
479			`if (strcmp(item1, "pr") == 0) { /* patch regs */`
480			`char item2[20];`
481			`char item3[20];`
482
483			`strtoken(linestr, item2, 2);`
484			`strtoken(linestr, item3, 3);`
485	138	markom	`set_reg32(strtoul(item2, NULL,0), strtoul(item3, NULL, 0));`
486	2	cvs	`} else`
487			`if (strcmp(item1, "pc") == 0) { /* patch PC */`
488			`char item2[20];`
489
490			`strtoken(linestr, item2, 2);`
491	86	lampret	`pcnext = strtoul(item2, NULL, 0);`
492	2	cvs	`} else`
493	7	jrydberg	`if (strcmp(item1, "break") == 0) { /* set/clear breakpoint */`
494	2	cvs	`char item2[20];`
495
496			`strtoken(linestr, item2, 2);`
497			`set_insnbrkpoint(strtoul(item2, NULL, 0));`
498			`} else`
499			`if (strcmp(item1, "r") == 0) { /* dump regs */`
500			`dumpreg();`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [stable_0_2_0_rc2/] [or1ksim/] [toplevel.c] - Blame information for rev 293