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 123

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>
 
#ifdef HAVE_LIBREADLINE
#include <readline/readline.h>
#include <readline/history.h>
#endif /* HAVE_LIBREADLINE */
 
#include "arch.h"
#include "parse.h"
#include "abstract.h"
#include "trace.h"
#include "execute.h"
#include "sim-config.h"
#include "spr_defs.h"
 
#include "coff.h"
 
/* Added by CZ 24/05/01 */
#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);
int GlobalMode = 0;   /* Start off in the orginal mode */
 
/* CVS revision number. */
const char rcsrev[] = "$Revision: 1.16 $";
 
/* 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",
  "info",
  "r",
  "dv",
 
};
 
void debug(const char *format, ...)
{
  char *p;
  va_list ap;
 
  if (config.simdebug) {
    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
  }
  return;
}
 
/* 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;
{
        cont_run = 1;
        config.iprompt = 1;
  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 ("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                       - 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("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();
 
main(argc, argv)
     int argc;
     char *argv[];
{
        char *linestr;
        char item1[500], b2[500];
        char *redirstr;
        int hush;
        unsigned long endaddr = 0xFFFFFFFF;
        int first_prompt = 1;
 
        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(" -bpb: disable branch prediction buffer analysis\n");
                printf(" -btic: disable branch prediction target insn cache analysis\n");
                printf(" -hazards: disable dependency hazards analysis\n");
                printf(" -history: disable instruction stream history analysis\n");
                printf(" -superscalar: disable superscalar analysis\n");
                printf(" -fast: disable BPB, BTIC, SLP, dependency hazards, history"
                       " analysis etc.\n");
                printf(" -upr <n>: set UPR to n\n");
                printf(" -ver <n>: set VR[VER] to n\n");
                printf(" -rev <n>: set VR[REV] to n\n");
                printf(" -loadmem[@<n>] <filename>: load memory with file, "
                       "optionally at address <n>\n"); /* (CZ) */
                printf(" -nosrv: do not launch JTAG proxy server\n"); /* (CZ) */
                printf(" -srv <n>: launch JTAG proxy server on port <n>\n"); /* (CZ) */
                printf(" -initmem <n | random>: initialize memory to value "
                       "<n> or random\n"); /* (CZ) */
                exit(-1);
        }
 
#ifdef HAVE_LIBREADLINE
  initialize_readline ();       /* Bind our completer. */
#endif  
 
  if(!config.inhibit_server)
    {
      serverPort = config.server_port;
      if(server_fd = GetServerSocket("or1ksim","tcp",serverPort))
        printf("JTAG Proxy server started on port %d\n",serverPort);
    }
 
        print_config();
        signal(SIGINT, ctrl_c);
        initstats();
 
        /* Modified by CZ on 24/05/01 ... if a filename is
           specified, behave as the simulator always has. This way,
           no existing test suites should be broken. If a filename
           is not specified, default to the new style behavior. Let
           the simulator start up and execute garbage, the same way
           a real CPU would. This should maximize the reality of
           the capabilities. In this mode, we will expect that
           someone will attach to us over the JTAG Proxy interface
           and begin debugging that way. */
 
        if(config.filename)
          {
            endaddr = loadcode(config.filename, MEMORY_START, 0);
            if (endaddr == -1) {
              printf("Problems loading boot code.\n");
              exit(1);
            }
          }
        else
          {
            if(config.random_mem)
              {
                int n = 0;
                int len = sizeof(mem);
                unsigned int* mptr = (unsigned int*)mem;
                unsigned int val = 0;
                int seed = time(NULL);
 
                srandom(seed);
                /* Print out the seed just in case we ever need to debug */
                printf("Seeding random generator with value %d\n",seed);
 
                for(n=0;n<len;n+=sizeof(unsigned int))
                  {
                    val = random();
                    if(random() > RAND_MAX/2)
                      val |= 0x80000000;
                    *mptr++ = val;
                  }
              }
            else if(config.pattern_mem)
              {
                int n = 0;
                int len = sizeof(mem);
                unsigned int* mptr = (unsigned int*)mem;
 
                for(n=0;n<len;n+=sizeof(unsigned int))
                  *mptr++ = config.pattern_mem;
              }
            else
              memset(mem,0,sizeof(mem));
 
            if(config.memory)
              {
                MemoryBlock* block = config.memory;
 
                while(block)
                  {
                    int fd = open(block->file,O_RDONLY);
                    int len,i;
                    struct stat buf;
                    char *mptr = (char*)mem;
                    char buffer[8192];
 
                    if(fd < 0)
                      {
                        perror(block->file);
                        exit(1);
                      }
                    if(fstat(fd,&buf) < 0)
                      {
                        char sTemp[256];
 
                        sprintf(sTemp,"stat(\"%s\")",block->file);
                        perror(sTemp);
                        exit(1);
                      }
                    if(!S_ISREG(buf.st_mode))
                      {
                        fprintf(stderr,"File \"%s\" is not a regular file.\n",
                                block->file);
                        exit(1);
                      }
 
                    len = buf.st_size;
                    mptr += block->address;
                    for(i=0;i<len;)
                      {
                        int n = read(fd,buffer,sizeof(buffer));
 
                        switch(n)
                          {
                          case -1:
                            if(errno == EINTR)
                              continue;
                            perror(block->file);
                            exit(1);
                          case 0:
                            fprintf(stderr,"File \"%s\": premature end of file.\n",
                                    block->file);
                            exit(1);
                          default:
                            memcpy(mptr,buffer,n);
                            i+= n;
                            break;
                          }
                      }
                    close(fd);
                  }
              }
          }
        GlobalMode = config.filename == NULL; /* Old mode = 0, New mode = 1 */
 
        uart_reset();
        tick_reset();
        pm_reset();
        pic_reset();
        reset();
        if(!GlobalMode)  /* Only in old mode */
          set_reg32("r3", endaddr);
 
        while(1) {
                if (config.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 100000000 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);
                }
 
                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, "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(item2, 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 */
                        debugmem();
                } else
                if (strcmp(item1, "reset") == 0) {       /* reset simulator */
                        uart_reset();
                        tick_reset();
                        pm_reset();
                        pic_reset();
                        reset(); /* Old or new mode */
                } else
                if (strcmp(item1, "debug") == 0) {       /* debug mode */
                        config.simdebug ^= 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);
                        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 = 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 */
                        itlb_status(-1);
                        dtlb_status(-1);
                        bpb_info();
                        btic_info();
                        ic_info();
                        dc_info();
                        uart_status();
                        sprs_status();
                } else {
                        printf("%s: Unknown command.\n", linestr);
                }
 
                while(cont_run) {
                  extern int cycle_delay;  /* Added by CZ 27/05/01. Set during exception. */
 
                        if (!getsprbits(SPR_PMR, SPR_PMR_DME | SPR_PMR_SME)) {
                          if(cycle_delay <= 0)
                            {
                              cont_run--;
                              if(fetch()) {
                                cont_run = 0; /* memory breakpoint encountered */
                                break;
                              }
                              decode_execute(&iqueue[0]);
                              update_pc();
                              analysis();
                              if (!hush)
                                dumpreg();
                            }
                          else
                            cycle_delay--;
 
                          pic_clock();
                          dc_clock();
                          ic_clock();
                        }
                        if (!getsprbits(SPR_PMR, SPR_PMR_SME))
                          tick_clock();
                        pm_clock();
                        uart_clock();
                        HandleServerSocket(false); /* block & check_stdin = false */
                }
                hush = 0;
                fflush(stdout);
                freopen("/dev/fd/0", "w+", stdout);
 
                if (!config.iprompt && !GlobalMode)     /* non-interactive quit in old mode */
                        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
 
 
void debugmem() {
        int i;
        printf("starting to dump mem...\n");
        for(i=0; i<500; i++) {
                printf("i=%x :: ", i);
                if (mem[i].label)
                        printf("label: %s |", mem[i].label->name);
                printf("%s ", insn_name (mem[i].insn->insn_index));
                if(strlen(mem[i].insn->op1) != 0) printf("%s ", mem[i].insn->op1);
                if(strlen(mem[i].insn->op2) != 0) printf("%s ", mem[i].insn->op2);
                if(strlen(mem[i].insn->op3) != 0) printf("%s ", mem[i].insn->op3);
                if(strlen(mem[i].insn->op4) != 0) printf("%s ", mem[i].insn->op4);
                printf("\n");
        }
}
 
/* 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;
    }
 
  /* 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 HandleServerSocket(Boolean block)
{
  struct pollfd fds[2];
  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:
          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[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[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,SOL_TCP,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()
{
  /* Debug interface simulation should go here. */
}

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	2	cvs
43	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
44	7	jrydberg	`#include <readline/readline.h>`
45			`#include <readline/history.h>`
46	16	jrydberg	`#endif /* HAVE_LIBREADLINE */`
47	7	jrydberg
48	2	cvs	`#include "arch.h"`
49			`#include "parse.h"`
50			`#include "abstract.h"`
51			`#include "trace.h"`
52			`#include "execute.h"`
53	69	lampret	`#include "sim-config.h"`
54	103	lampret	`#include "spr_defs.h"`
55	2	cvs
56	28	lampret	`#include "coff.h"`
57
58	123	markom	`/* Added by CZ 24/05/01 */`
59			`#include <signal.h>`
60			`#include <errno.h>`
61			`typedef enum {`
62			`false = 0,`
63			`true = 1,`
64			`} Boolean;`
65			`unsigned int serverIP = 0;`
66			`unsigned int serverPort = 0;`
67			`unsigned int server_fd = 0;`
68			`unsigned int gdb_fd = 0;`
69			`void HandleServerSocket(Boolean);`
70			`void JTAGRequest(void);`
71			`void GDBRequest(void);`
72			`int GlobalMode = 0; /* Start off in the orginal mode */`
73
74	2	cvs	`/* CVS revision number. */`
75	123	markom	`const char rcsrev[] = "$Revision: 1.16 $";`
76	2	cvs
77			`/* Continuos run versus single step tracing switch. */`
78			`int cont_run;`
79
80			`/* History of execution */`
81			`int histexec[HISTEXEC_LEN];`
82
83	7	jrydberg	`char *sim_commands [] = {`
84			`"q",`
85			`"t",`
86			`"help",`
87	21	cmchen	`"de",`
88	7	jrydberg	`"dm",`
89			`"run",`
90			`"pr",`
91			`"pm",`
92			`"pc",`
93	18	lampret	`"reset",`
94			`"break",`
95	7	jrydberg	`"hist",`
96			`"stats",`
97			`"info",`
98			`"r",`
99	54	lampret	`"dv",`
100	7	jrydberg
101			`};`
102
103	2	cvs	`void debug(const char *format, ...)`
104			`{`
105	7	jrydberg	`char *p;`
106			`va_list ap;`
107	2	cvs
108	69	lampret	`if (config.simdebug) {`
109			`if ((p = malloc(1000)) == NULL)`
110			`return;`
111			`va_start(ap, format);`
112			`(void) vsnprintf(p, 1000, format, ap);`
113			`va_end(ap);`
114			`printf("%s\n", p);`
115			`fflush(stdout);`
116			`free(p);`
117			`} else {`
118			`#if DEBUG`
119	7	jrydberg	`if ((p = malloc(1000)) == NULL)`
120			`return;`
121			`va_start(ap, format);`
122			`(void) vsnprintf(p, 1000, format, ap);`
123			`va_end(ap);`
124			`printf("%s\n", p);`
125			`fflush(stdout);`
126			`free(p);`
127	2	cvs	`#endif`
128	69	lampret	`}`
129	7	jrydberg	`return;`
130	2	cvs	`}`
131
132	30	lampret	`/* Strip whitespace from the start and end of STRING. Return a pointer`
133			`into STRING. */`
134			`#ifndef whitespace`
135			`#define whitespace(a) ((a) == '\t' ? 1 : ((a) == ' '? 1 : 0))`
136			`#endif`
137
138			`char *`
139			`stripwhite (string)`
140			`char *string;`
141			`{`
142			`register char s, t;`
143
144			`for (s = string; whitespace (*s); s++)`
145			`;`
146
147			`if (*s == 0)`
148			`return (s);`
149
150			`t = s + strlen (s) - 1;`
151			`while (t > s && whitespace (*t))`
152			`t--;`
153			`*++t = '\0';`
154
155			`return s;`
156			`}`
157
158	7	jrydberg	`void`
159			`ctrl_c(signum)`
160			`int signum;`
161	2	cvs	`{`
162			`cont_run = 1;`
163	123	markom	`config.iprompt = 1;`
164	7	jrydberg	`signal(SIGINT, ctrl_c);`
165	2	cvs	`}`
166
167	7	jrydberg	`void`
168			`version()`
169	2	cvs	`{`
170	7	jrydberg	`printf ("\n");`
171	18	lampret	`printf ("OpenRISC 1000 (OR16+OR32) Architectural Simulator, %s\n", rcsrev);`
172			`printf ("Copyright (C) 1999 Damjan Lampret, lampret@opencores.org\n");`
173			`printf ("Copyright (C) 2000 Damjan Lampret, lampret@opencores.org\n");`
174	21	cmchen	`printf (" Jimmy Chen-Min Chen, jimmy@ee.nctu.edu.tw\n");`
175	18	lampret	`printf (" Johan Rydberg, johan.rydberg@insight.se\n");`
176	7	jrydberg	`printf ("Visit http://www.opencores.org for more information about ");`
177			`printf ("OpenRISC 1000 and\nother open source cores.\n\n");`
178			`printf ("This software comes with ABSOLUTELY NO WARRANTY; for ");`
179			`printf ("details see COPYING.\nThis is free software, and you ");`
180			`printf ("are welcome to redistribute it under certain\nconditions; ");`
181			`printf ("for details see COPYING.\n");`
182	2	cvs	`}`
183
184	7	jrydberg	`void`
185			`help()`
186	2	cvs	`{`
187			`printf("q - quit simulator\n");`
188			`printf("r - display all registers\n");`
189			`printf("t - execute next instruction\n");`
190			`printf("run <cycles> [<hush>] - execute <cycles> instructions, no reg dump if hush\n");`
191			`printf("pr <r> <value> - patch register <r> with <value>\n");`
192			`printf("dm <fromaddr> [<toaddr>] - display memory from <fromaddr> to <toaddr>\n");`
193	21	cmchen	`printf("de - debug insn memory\n");`
194	2	cvs	`printf("pm <addr> <value> - patch memory location <addr> with <value>\n");`
195			`printf("pc <value> - patch PC register with <value>\n");`
196	18	lampret	`printf("break <addr> - toggle breakpoint at address <addr>\n");`
197			`printf("reset - simulator reset\n");`
198	2	cvs	`printf("hist - execution history\n");`
199	6	lampret	`printf("stats <num\|clear> - execution statistics num or clear it.\n");`
200			`printf("info - configuration info (caches etc.)\n");`
201	54	lampret	`printf("dv <fromaddr> [<toaddr>] [<modname>] - dumps memory as verilog (use redirect)\n");`
202	86	lampret	`printf("dh <fromaddr> [<toaddr>] - dumps memory as hex code (use redirect)\n");`
203	2	cvs	`printf("<cmd> > <filename> - redirect simulator stdout to <filename> (and not emulated printf)\n");`
204	69	lampret	`printf("debug - toggles simulator debug mode\n");`
205	2	cvs	`printf("help - available commands (this list)\n");`
206			`}`
207
208	21	cmchen	`void debugmem();`
209
210	7	jrydberg	`main(argc, argv)`
211			`int argc;`
212			`char *argv[];`
213	2	cvs	`{`
214	7	jrydberg	`char *linestr;`
215	16	jrydberg	`char item1[500], b2[500];`
216	2	cvs	`char *redirstr;`
217			`int hush;`
218	123	markom	`unsigned long endaddr = 0xFFFFFFFF;`
219			`int first_prompt = 1;`
220
221	103	lampret	`srand(getpid());`
222			`init_defconfig();`
223	123	markom	`if (parse_args(argc, argv)) {`
224	103	lampret	`printf("Usage: %s [options] <filename>\n", argv[0]);`
225			`printf("Options:\n");`
226			`printf(" -v: version and copyright note\n");`
227			`printf(" -i: enable interactive command prompt\n");`
228			`printf(" -bpb: disable branch prediction buffer analysis\n");`
229			`printf(" -btic: disable branch prediction target insn cache analysis\n");`
230			`printf(" -hazards: disable dependency hazards analysis\n");`
231			`printf(" -history: disable instruction stream history analysis\n");`
232			`printf(" -superscalar: disable superscalar analysis\n");`
233	123	markom	`printf(" -fast: disable BPB, BTIC, SLP, dependency hazards, history"`
234			`" analysis etc.\n");`
235	103	lampret	`printf(" -upr <n>: set UPR to n\n");`
236			`printf(" -ver <n>: set VR[VER] to n\n");`
237			`printf(" -rev <n>: set VR[REV] to n\n");`
238	123	markom	`printf(" -loadmem[@<n>] <filename>: load memory with file, "`
239			`"optionally at address <n>\n"); /* (CZ) */`
240			`printf(" -nosrv: do not launch JTAG proxy server\n"); /* (CZ) */`
241			`printf(" -srv <n>: launch JTAG proxy server on port <n>\n"); /* (CZ) */`
242			`printf(" -initmem <n \| random>: initialize memory to value "`
243			`"<n> or random\n"); /* (CZ) */`
244	103	lampret	`exit(-1);`
245			`}`
246	7	jrydberg
247	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
248	7	jrydberg	`initialize_readline (); /* Bind our completer. */`
249	16	jrydberg	`#endif`
250	123	markom
251			`if(!config.inhibit_server)`
252			`{`
253			`serverPort = config.server_port;`
254			`if(server_fd = GetServerSocket("or1ksim","tcp",serverPort))`
255			`printf("JTAG Proxy server started on port %d\n",serverPort);`
256			`}`
257	16	jrydberg
258	103	lampret	`print_config();`
259	2	cvs	`signal(SIGINT, ctrl_c);`
260			`initstats();`
261	123	markom
262			`/* Modified by CZ on 24/05/01 ... if a filename is`
263			`specified, behave as the simulator always has. This way,`
264			`no existing test suites should be broken. If a filename`
265			`is not specified, default to the new style behavior. Let`
266			`the simulator start up and execute garbage, the same way`
267			`a real CPU would. This should maximize the reality of`
268			`the capabilities. In this mode, we will expect that`
269			`someone will attach to us over the JTAG Proxy interface`
270			`and begin debugging that way. */`
271
272			`if(config.filename)`
273			`{`
274			`endaddr = loadcode(config.filename, MEMORY_START, 0);`
275			`if (endaddr == -1) {`
276			`printf("Problems loading boot code.\n");`
277			`exit(1);`
278			`}`
279			`}`
280			`else`
281			`{`
282			`if(config.random_mem)`
283			`{`
284			`int n = 0;`
285			`int len = sizeof(mem);`
286			`unsigned int* mptr = (unsigned int*)mem;`
287			`unsigned int val = 0;`
288			`int seed = time(NULL);`
289
290			`srandom(seed);`
291			`/* Print out the seed just in case we ever need to debug */`
292			`printf("Seeding random generator with value %d\n",seed);`
293
294			`for(n=0;n<len;n+=sizeof(unsigned int))`
295			`{`
296			`val = random();`
297			`if(random() > RAND_MAX/2)`
298			`val \|= 0x80000000;`
299			`*mptr++ = val;`
300			`}`
301			`}`
302			`else if(config.pattern_mem)`
303			`{`
304			`int n = 0;`
305			`int len = sizeof(mem);`
306			`unsigned int* mptr = (unsigned int*)mem;`
307
308			`for(n=0;n<len;n+=sizeof(unsigned int))`
309			`*mptr++ = config.pattern_mem;`
310			`}`
311			`else`
312			`memset(mem,0,sizeof(mem));`
313
314			`if(config.memory)`
315			`{`
316			`MemoryBlock* block = config.memory;`
317
318			`while(block)`
319			`{`
320			`int fd = open(block->file,O_RDONLY);`
321			`int len,i;`
322			`struct stat buf;`
323			`char mptr = (char)mem;`
324			`char buffer[8192];`
325
326			`if(fd < 0)`
327			`{`
328			`perror(block->file);`
329			`exit(1);`
330			`}`
331			`if(fstat(fd,&buf) < 0)`
332			`{`
333			`char sTemp[256];`
334
335			`sprintf(sTemp,"stat(\"%s\")",block->file);`
336			`perror(sTemp);`
337			`exit(1);`
338			`}`
339			`if(!S_ISREG(buf.st_mode))`
340			`{`
341			`fprintf(stderr,"File \"%s\" is not a regular file.\n",`
342			`block->file);`
343			`exit(1);`
344			`}`
345
346			`len = buf.st_size;`
347			`mptr += block->address;`
348			`for(i=0;i<len;)`
349			`{`
350			`int n = read(fd,buffer,sizeof(buffer));`
351
352			`switch(n)`
353			`{`
354			`case -1:`
355			`if(errno == EINTR)`
356			`continue;`
357			`perror(block->file);`
358			`exit(1);`
359			`case 0:`
360			`fprintf(stderr,"File \"%s\": premature end of file.\n",`
361			`block->file);`
362			`exit(1);`
363			`default:`
364			`memcpy(mptr,buffer,n);`
365			`i+= n;`
366			`break;`
367			`}`
368			`}`
369			`close(fd);`
370			`}`
371			`}`
372			`}`
373			`GlobalMode = config.filename == NULL; /* Old mode = 0, New mode = 1 */`
374
375	30	lampret	`uart_reset();`
376	92	lampret	`tick_reset();`
377	103	lampret	`pm_reset();`
378			`pic_reset();`
379	2	cvs	`reset();`
380	123	markom	`if(!GlobalMode) /* Only in old mode */`
381			`set_reg32("r3", endaddr);`
382	7	jrydberg
383	103	lampret	`while(1) {`
384			`if (config.iprompt) {`
385	123	markom	`if(server_fd)`
386			`{`
387			`printf ("(sim) ");`
388			`fflush(stdout);`
389			`HandleServerSocket(true); /* block & check_stdin = true */`
390			`}`
391	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
392	123	markom	`/* Must disable readline in new mode. It isn't compatible`
393			`with non blocking environments */`
394			`if(!server_fd)`
395			`linestr = readline("(sim) ");`
396			`else`
397			`linestr = fgets(b2, sizeof b2, stdin);`
398	16	jrydberg	`#else`
399	123	markom	`if(!server_fd)`
400			`printf ("(sim) ");`
401			`linestr = fgets(b2, sizeof b2, stdin);`
402	16	jrydberg	`#endif`
403	103	lampret	`} else`
404			`strcpy(linestr = b2, "run 100000000 hush");`
405	7	jrydberg
406	103	lampret	`if (!linestr)`
407			`break;`
408			`linestr = stripwhite (linestr);`
409	7	jrydberg
410	16	jrydberg	`#ifdef HAVE_LIBREADLINE`
411	123	markom	`/* Readline only works in the old mode */`
412			`if(!server_fd)`
413			`{`
414			`if (strlen(linestr) == 0) {`
415			`char *l = repeat_last_command ();`
416
417			`if (l) {`
418			`free (linestr);`
419			`linestr = l;`
420			`}`
421			`}`
422
423			`if (*linestr) {`
424			`add_history (linestr);`
425			`}`
426			`}`
427	16	jrydberg	`#endif /* HAVE_LIBREADLINE */`
428	2	cvs
429	103	lampret	`if (redirstr = strstr(linestr, ">")) {`
430			`*redirstr = '\0';`
431			`strtoken(&redirstr[1], item1, 1);`
432			`freopen(item1, "w+", stdout);`
433			`}`
434	2	cvs
435			`strtoken(linestr, item1, 1);`
436			`if (strcmp(item1, "q") == 0) /* quit */`
437			`exit(0);`
438			`else`
439			`if (strcmp(item1, "help") == 0) /* help */`
440			`help();`
441			`else`
442			`if (strcmp(item1, "t") == 0) { /* trace */`
443			`cont_run = 1;`
444			`} else`
445			`if (strcmp(item1, "dm") == 0) { /* dump memory */`
446			`char item2[20];`
447			`char item3[20];`
448			`static int from = 0, to = 0;`
449
450			`strtoken(linestr, item2, 2);`
451			`strtoken(linestr, item3, 3);`
452
453			`if (strlen(item2)) {`
454			`if (item2[0] == '_')`
455			`from = eval_label(item2);`
456			`else`
457			`from = strtoul(item2, NULL, 0);`
458			`to = from + 0x40;`
459			`}`
460			`if (strlen(item3))`
461			`to = strtoul(item3, NULL, 0);`
462			`dumpmemory(from, to);`
463	54	lampret	`printf("\n");`
464	2	cvs	`} else`
465	54	lampret	`if (strcmp(item1, "dv") == 0) {/* dump memory as verilog*/`
466			`char item2[20];`
467			`char item3[20];`
468			`char item4[20];`
469			`static int from = 0, to = 0;`
470
471			`strtoken(linestr, item2, 2);`
472			`strtoken(linestr, item3, 3);`
473			`strtoken(linestr, item4, 4);`
474
475			`if (strlen(item2)) {`
476			`if (item2[0] == '_')`
477			`from = eval_label(item2);`
478			`else`
479			`from = strtoul(item2, NULL, 0);`
480			`to = from + 0x40;`
481			`}`
482			`if (strlen(item3))`
483			`to = strtoul(item3, NULL, 0);`
484			`if (!strlen(item4))`
485			`strcpy(item4, "or1k_mem");`
486			`dumpverilog(item4, from, to);`
487			`printf("\n");`
488			`} else`
489	86	lampret	`if (strcmp(item1, "dh") == 0) {/* dump memory as hex*/`
490			`char item2[20];`
491			`char item3[20];`
492			`static int from = 0, to = 0;`
493
494			`strtoken(linestr, item2, 2);`
495			`strtoken(linestr, item3, 3);`
496
497			`if (strlen(item2)) {`
498			`if (item2[0] == '_')`
499			`from = eval_label(item2);`
500			`else`

Browse

Tools

Subversion Repositories or1k

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