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

Subversion Repositories or1k

[/] [or1k/] [branches/] [stable_0_2_x/] [or1ksim/] [sim-config.c] - Blame information for rev 1595

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


/* sim-config.c -- Simulator configuration
   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 configuration. Eventually this one will be a lot bigger. */
 
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <ctype.h>
 
#include "config.h"
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
 
#include "port.h"
#include "arch.h"
#include "sim-config.h"
#include "abstract.h"
#include "opcode/or32.h"
#include "spr_defs.h"
#include "execute.h"
#include "sprs.h"
#include "pic.h"
#include "stats.h"
#include "icache_model.h"
#include "dcache_model.h"
 
#include "profiler.h"
#include "mprofiler.h"
#include "cuc.h"
 
#include "debug.h"
 
DEFAULT_DEBUG_CHANNEL(config);
 
#define WARNING(s) fprintf (stderr, "WARNING: config.%s: %s\n", cur_section->name, (s))
#define MERROR(s) {fprintf (stderr, "ERROR: %s\n", s); if (runtime.sim.init) exit (1);}
 
struct config config;
struct runtime runtime;
 
struct config_section *cur_section;
 
struct config_section *sections = NULL;
 
extern char *or1ksim_ver;
 
void init_defconfig(void)
{
  memset(&config, 0, sizeof(config));
  /* Sim */
  config.sim.exe_log = 0;
  config.sim.exe_log_type = EXE_LOG_HARDWARE;
  config.sim.exe_log_start = 0;
  config.sim.exe_log_end = 0;
  config.sim.exe_log_marker = 0;
  strcpy (config.sim.exe_log_fn, "executed.log");
  config.sim.profile = 0;
  config.sim.mprofile = 0;
 
  config.sim.debug = 0;
  config.sim.verbose = 1;
 
  strcpy (config.sim.prof_fn, "sim.profile");
  strcpy (config.sim.mprof_fn, "sim.mprofile");
  strcpy (config.sim.fstdout, "stdout.txt");
  strcpy (runtime.sim.script_fn, "(default)");
  config.sim.clkcycle_ps = 4000; /* 4000 for 4ns (250MHz) */
  if (config.sim.clkcycle_ps) config.sim.system_kfreq = (long)((1000000000.0 / (double)config.sim.clkcycle_ps));
  else config.sim.system_kfreq = INT_MAX;
  if (config.sim.system_kfreq <= 0) config.sim.system_kfreq = 1;
 
  /* IMMU & DMMU*/
  config.immu.enabled = 0;
  config.immu.hitdelay = 1;
  config.immu.missdelay = 1;
  config.immu.pagesize = 8192;
  config.dmmu.enabled = 0;
  config.dmmu.hitdelay = 1;
  config.dmmu.missdelay = 1;
  config.dmmu.pagesize = 8192;
 
  /* IC & DC */
  config.ic.enabled = 0;
  config.ic.hitdelay = 1;
  config.ic.missdelay = 1;
  config.ic.nways = 0;
  config.ic.nsets = 0;
  config.ic.ustates = 0;
  config.dc.enabled = 0;
  config.dc.load_hitdelay = 2;
  config.dc.load_missdelay = 2;
  config.dc.nways = 0;
  config.dc.nsets = 0;
  config.dc.ustates = 0;
  config.dc.store_hitdelay = 0;
  config.dc.store_missdelay = 0;
 
  /* CPU */
  config.cpu.superscalar = 0;
  config.sim.history = 0;
  config.cpu.hazards = 0;
  config.cpu.dependstats = 0;
  config.cpu.sbuf_len = 0;
  config.cpu.upr = SPR_UPR_UP | SPR_UPR_DCP | SPR_UPR_ICP | SPR_UPR_DMP
                 | SPR_UPR_IMP | SPR_UPR_OB32P | SPR_UPR_DUP | SPR_UPR_PICP
                 | SPR_UPR_PMP | SPR_UPR_TTP;
  config.cpu.sr = 0x00008001;
 
  /* Debug */
  config.debug.enabled = 0;
  config.debug.gdb_enabled = 0;
  config.debug.server_port = 0;
 
  /* VAPI */
  config.vapi.enabled = 0;
  strcpy (config.vapi.vapi_fn, "vapi.log");
 
  /* PM */
  config.pm.enabled = 0;
 
  /* CUC */
  strcpy (config.cuc.timings_fn, "virtex.tim");
  config.cuc.memory_order = MO_STRONG;
  config.cuc.calling_convention = 1;
  config.cuc.enable_bursts = 1;
  config.cuc.no_multicycle = 1;
 
  /* Configure runtime */
  memset(&runtime, 0, sizeof(runtime));
 
  /* Sim */
  runtime.sim.fexe_log = NULL;
  runtime.sim.iprompt = 0;
  runtime.sim.fprof = NULL;
  runtime.sim.fmprof = NULL;
  runtime.sim.init = 1;
  runtime.sim.fout = stdout;
  runtime.sim.script_file_specified = 0;
  runtime.simcmd.profile = 0;
  runtime.simcmd.mprofile = 0;
 
  /* VAPI */
  runtime.vapi.vapi_file = NULL;
  runtime.vapi.enabled = 0;
}
 
static void version(void)
{
  PRINTF ("\n");
  PRINTF ("OpenRISC 1000 (OR32) Architectural Simulator, version %s\n",
          or1ksim_ver);
  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 ("Copyright (C) 2002 Marko Mlinar, markom@opencores.org\n");
  PRINTF ("                   Simon Srot, simons@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");
}
 
int parse_args(int argc, char *argv[])
{
  argv++; argc--;
  while (argc) {
    if (strcmp(*argv, "profiler") == 0) {
      exit (main_profiler (argc, argv));
    } else
    if (strcmp(*argv, "mprofiler") == 0) {
      exit (main_mprofiler (argc, argv));
    } else
    if (*argv[0] != '-') {
      runtime.sim.filename = argv[0];
      argc--;
      argv++;
    } else
    if (strcmp(*argv, "-f") == 0 || strcmp(*argv, "--file") == 0) {
      argv++; argc--;
      if (argv[0]) {
        read_script_file(argv[0]);
        argv++; argc--;
      } else {
        fprintf(stderr, "Configure filename not specified!\n");
        return 1;
      }
    } else
    if (strcmp(*argv, "--nosrv") == 0) {  /* (CZ) */
      config.debug.gdb_enabled = 0;
      argv++; argc--;
    } else
    if (strcmp(*argv, "--srv") == 0) {  /* (CZ) */
      char *s;
      if(!--argc)
        return 1;
      config.debug.enabled = 1;
      config.debug.gdb_enabled = 1;
      config.debug.server_port = strtol(*(++argv),&s,10);
      if(*s)
        return 1;
      argv++; argc--;
    } else
    if (strcmp(*argv, "-i") == 0) {
      runtime.sim.iprompt = 1;
      argv++; argc--;
    } else
    if (strcmp(*argv, "-v") == 0) {
      version();
      exit(0);
    } else
    if (strcmp(*argv, "--enable-profile") == 0) {
      runtime.simcmd.profile = 1;
      argv++; argc--;
    } else
    if (strcmp(*argv, "--enable-mprofile") == 0) {
      runtime.simcmd.mprofile = 1;
      argv++; argc--;
    } else
    if (strcmp(*argv, "-d") == 0) {
      parse_dbchs(*(++argv));
      argv++; argc -= 2;
    } else {
      fprintf(stderr, "Unknown option: %s\n", *argv);
      return 1;
    }
  }
 
  if (!argc)
    return 0;
 
  return 0;
}
 
void print_config(void)
{
  if (config.sim.verbose) {
    char temp[20];
    PRINTF("Verbose on, ");
    if (config.sim.debug)
      PRINTF("simdebug on, ");
    else
      PRINTF("simdebug off, ");
    if (runtime.sim.iprompt)
      PRINTF("interactive prompt on\n");
    else
      PRINTF("interactive prompt off\n");
 
    PRINTF("Machine initialization...\n");
    generate_time_pretty (temp, config.sim.clkcycle_ps);
    PRINTF("Clock cycle: %s\n", temp);
    if (cpu_state.sprs[SPR_UPR] & SPR_UPR_DCP)
      PRINTF("Data cache present.\n");
    else
      PRINTF("No data cache.\n");
    if (cpu_state.sprs[SPR_UPR] & SPR_UPR_ICP)
      PRINTF("Insn cache tag present.\n");
    else
      PRINTF("No instruction cache.\n");
    if (config.bpb.enabled)
      PRINTF("BPB simulation on.\n");
    else
      PRINTF("BPB simulation off.\n");
    if (config.bpb.btic)
      PRINTF("BTIC simulation on.\n");
    else
      PRINTF("BTIC simulation off.\n");
  }
}
 
struct config_param {
  char *name;
  enum param_t type;
  void (*func)(union param_val, void *dat);
  struct config_param *next;
};
 
void base_include (union param_val val, void *dat) {
  read_script_file (val.str_val);
  cur_section = NULL;
}
 
/*----------------------------------------------[ Simulator configuration ]---*/
void sim_debug (union param_val val, void *dat) {
  config.sim.debug = val.int_val;
}
 
void sim_verbose (union param_val val, void *dat) {
  config.sim.verbose = val.int_val;
}
 
void sim_profile (union param_val val, void *dat) {
  config.sim.profile = val.int_val;
}
 
void sim_prof_fn (union param_val val, void *dat) {
  strcpy(config.sim.prof_fn, val.str_val);
}
 
void sim_mprofile (union param_val val, void *dat) {
  config.sim.mprofile = val.int_val;
}
 
void sim_mprof_fn (union param_val val, void *dat) {
  strcpy(config.sim.mprof_fn, val.str_val);
}
 
void sim_history (union param_val val, void *dat) {
  config.sim.history = val.int_val;
}
 
void sim_exe_log (union param_val val, void *dat) {
  config.sim.exe_log = val.int_val;
}
 
void sim_exe_log_type (union param_val val, void *dat) {
  if (strcmp (val.str_val, "default") == 0)
    config.sim.exe_log_type = EXE_LOG_HARDWARE;
  else if (strcmp (val.str_val, "hardware") == 0)
    config.sim.exe_log_type = EXE_LOG_HARDWARE;
  else if (strcmp (val.str_val, "simple") == 0)
    config.sim.exe_log_type = EXE_LOG_SIMPLE;
  else if (strcmp (val.str_val, "software") == 0) {
    config.sim.exe_log_type = EXE_LOG_SOFTWARE;
  } else {
    char tmp[200];
    sprintf (tmp, "invalid execution log type '%s'.\n", val.str_val);
    CONFIG_ERROR(tmp);
  }
}
 
void sim_exe_log_start (union param_val val, void *dat) {
  config.sim.exe_log_start = val.longlong_val;
}
 
void sim_exe_log_end (union param_val val, void *dat) {
  config.sim.exe_log_end = val.longlong_val;
}
 
void sim_exe_log_marker (union param_val val, void *dat) {
  config.sim.exe_log_marker = val.int_val;
}
 
void sim_exe_log_fn (union param_val val, void *dat) {
  strcpy(config.sim.exe_log_fn, val.str_val);
}
 
void sim_clkcycle (union param_val val, void *dat) {
  int len = strlen (val.str_val);
  int pos = len - 1;
  long time;
  if (len < 2) goto err;
  if (val.str_val[pos--] != 's') goto err;
  switch (val.str_val[pos--]) {
    case 'p': time = 1; break;
    case 'n': time = 1000; break;
    case 'u': time = 1000000; break;
    case 'm': time = 1000000000; break;
  default:
    goto err;
  }
  val.str_val[pos + 1] = 0;
  config.sim.clkcycle_ps = time * atol (val.str_val);
  return;
err:
  CONFIG_ERROR("invalid time format.");
}
 
void sim_stdout (union param_val val, void *dat) {
  strcpy(config.sim.fstdout, val.str_val);
}
 
void reg_sim_sec (void) {
  struct config_section *sec = reg_config_sec("sim", NULL, NULL);
 
  reg_config_param(sec, "debug", paramt_int, sim_debug);
  reg_config_param(sec, "verbose", paramt_int, sim_verbose);
  reg_config_param(sec, "profile", paramt_int, sim_profile);
  reg_config_param(sec, "prof_fn", paramt_str, sim_prof_fn);
  reg_config_param(sec, "mprofile", paramt_int, sim_mprofile);
  reg_config_param(sec, "mprof_fn", paramt_str, sim_mprof_fn);
  reg_config_param(sec, "history", paramt_int, sim_history);
  reg_config_param(sec, "exe_log", paramt_int, sim_exe_log);
  reg_config_param(sec, "exe_log_type", paramt_word, sim_exe_log_type);
  reg_config_param(sec, "exe_log_start", paramt_longlong, sim_exe_log_start);
  reg_config_param(sec, "exe_log_end", paramt_longlong, sim_exe_log_end);
  reg_config_param(sec, "exe_log_marker", paramt_int, sim_exe_log_marker);
  reg_config_param(sec, "exe_log_fn", paramt_str, sim_exe_log_fn);
  reg_config_param(sec, "clkcycle", paramt_word, sim_clkcycle);
  reg_config_param(sec, "stdout", paramt_str, sim_stdout);
}
 
/*----------------------------------------------------[ CPU configuration ]---*/
void cpu_ver (union param_val val, void *dat) {
  config.cpu.ver = val.int_val;
}
 
void cpu_rev (union param_val val, void *dat) {
  config.cpu.rev = val.int_val;
}
 
void cpu_upr (union param_val val, void *dat) {
  config.cpu.upr = val.int_val;
}
 
void cpu_sr (union param_val val, void *dat) {
  config.cpu.sr = val.int_val;
}
 
void cpu_hazards (union param_val val, void *dat) {
  config.cpu.hazards = val.int_val;
}
 
void cpu_superscalar (union param_val val, void *dat) {
  config.cpu.superscalar = val.int_val;
}
 
void cpu_dependstats (union param_val val, void *dat) {
  config.cpu.dependstats = val.int_val;
}
 
void cpu_sbuf_len (union param_val val, void *dat) {
  if (val.int_val >= MAX_SBUF_LEN) {
    config.cpu.sbuf_len = MAX_SBUF_LEN - 1;
    WARNING("sbuf_len too large; truncated.");
  } else if (val.int_val < 0) {
    config.cpu.sbuf_len = 0;
    WARNING("sbuf_len negative; disabled.");
  } else
    config.cpu.sbuf_len = val.int_val;
}
 
void reg_cpu_sec(void)
{
  struct config_section *sec = reg_config_sec("cpu", NULL, NULL);
 
  reg_config_param(sec, "ver", paramt_int, cpu_ver);
  reg_config_param(sec, "rev", paramt_int, cpu_rev);
  reg_config_param(sec, "upr", paramt_int, cpu_upr);
  reg_config_param(sec, "sr", paramt_int, cpu_sr);
  reg_config_param(sec, "hazards", paramt_int, cpu_hazards);
  reg_config_param(sec, "superscalar", paramt_int, cpu_superscalar);
  reg_config_param(sec, "dependstats", paramt_int, cpu_dependstats);
  reg_config_param(sec, "sbuf_len", paramt_int, cpu_sbuf_len);
}
 
void reg_config_secs(void)
{
  reg_config_param(reg_config_sec("base", NULL, NULL), "include", paramt_str,
                   base_include);
 
  reg_sim_sec();
  reg_cpu_sec();
  reg_memory_sec();
  reg_mc_sec();
  reg_uart_sec();
  reg_dma_sec();
  reg_debug_sec();
  reg_vapi_sec();
  reg_ethernet_sec();
  reg_immu_sec();
  reg_dmmu_sec();
  reg_ic_sec();
  reg_dc_sec();
  reg_gpio_sec();
  reg_bpb_sec();
  reg_pm_sec();
  reg_vga_sec();
  reg_fb_sec();
  reg_kbd_sec();
  reg_ata_sec();
  reg_cuc_sec();
}
 
/* Returns a user friendly string of type */
static char *get_paramt_str(enum param_t type)
{
  switch(type) {
  case paramt_int:
    return "integer";
  case paramt_longlong:
    return "longlong";
  case paramt_addr:
    return "address";
  case paramt_str:
    return "string";
  case paramt_word:
    return "word";
  case paramt_none:
    return "none";
  }
  return "";
}
 
void reg_config_param(struct config_section *sec, const char *param,
                      enum param_t type,
                      void (*param_cb)(union param_val, void *))
{
  struct config_param *new = malloc(sizeof(struct config_param));
 
  TRACE("Registering config param `%s' to section `%s', type %s\n", param,
        sec->name, get_paramt_str(type));
 
  if(!new) {
    fprintf(stderr, "Out-of-memory\n");
    exit(1);
  }
 
  if(!(new->name = strdup(param))) {
    fprintf(stderr, "Out-of-memory\n");
    exit(1);
  }
 
  new->func = param_cb;
  new->type = type;
 
  new->next = sec->params;
  sec->params = new;
}
 
struct config_section *reg_config_sec(const char *section,
                                      void *(*sec_start)(void),
                                      void (*sec_end)(void *))
{
  struct config_section *new = malloc(sizeof(struct config_section));
 
  TRACE("Registering config section `%s'\n", section);
 
  if(!new) {
    fprintf(stderr, "Out-of-memory\n");
    exit(1);
  }
 
  if(!(new->name = strdup(section))) {
    fprintf(stderr, "Out-of-memory\n");
    exit(1);
  }
 
  new->next = sections;
  new->sec_start = sec_start;
  new->sec_end = sec_end;
  new->params = NULL;
 
  sections = new;
 
  return new;
}
 
static void switch_param(char *param, struct config_param *cur_param)
{
  char *end_p;
  union param_val val;
 
    /* Skip over an = sign if it exists */
  if(*param == '=') {
    param++;
    while(*param && isspace(*param)) param++;
  }
 
  switch (cur_param->type) {
  case paramt_int:
    val.int_val = strtol(param, NULL, 0);
    break;
  case paramt_longlong:
    val.longlong_val = strtoll(param, NULL, 0);
    break;
  case paramt_addr:
    val.addr_val = strtoul(param, NULL, 0);
    break;
  case paramt_str:
    if(*param != '"') {
      CONFIG_ERROR("String value expected\n");
      return;
    }
 
    param++;
    end_p = param;
    while(*end_p && (*end_p != '"')) end_p++;
    *end_p = '\0';
    val.str_val = param;
    break;
  case paramt_word:
    end_p = param;
    while(*end_p && !isspace(*end_p)) end_p++;
    *end_p = '\0';
    val.str_val = param;
    break;
  case paramt_none:
    break;
  }
 
  cur_param->func(val, cur_section->dat);
}
 
/* Read environment from a script file. Does not fail - assumes default configuration instead.
   The syntax of script file is:
   param = value
   section x
     data
     param = value
   end
 
   Example:
   section mc
     memory_table_file = sim.mem
     enable = 1
     POC = 0x47892344
   end
 
 */
 
void read_script_file (char *filename)
{
  FILE *f;
  char *home = getenv("HOME");
  char ctmp[STR_SIZE];
  int local = 1;
  cur_section = NULL;
 
  sprintf(ctmp, "%s/.or1k/%s", home, filename);
  if ((f = fopen (filename, "rt")) || (home && (f = fopen (ctmp, "rt")))) {
    if (config.sim.verbose)
      PRINTF ("Reading script file from '%s'...\n", local ? filename : ctmp);
    strcpy (runtime.sim.script_fn, local ? filename : ctmp);
 
    while (!feof(f)) {
      char param[STR_SIZE];
      if (fscanf(f, "%s ", param) != 1) break;
      /* Is this a section? */
      if (strcmp (param, "section") == 0) {
        struct config_section *cur;
        cur_section = NULL;
        if (fscanf (f, "%s\n", param) != 1) {
          fprintf (stderr, "%s: ERROR: Section name required.\n", local ? filename : ctmp);
          exit (1);
        }
        TRACE("Came across section `%s'\n", param);
        for (cur = sections; cur; cur = cur->next)
          if (strcmp (cur->name, param) == 0) {
            cur_section = cur;
            break;
          }
        if (!cur) {
          fprintf (stderr, "WARNING: config: Unknown section: %s; ignoring.\n",
                   param);
          /* just skip section */
          while (fscanf (f, "%s\n", param) == 1 && strcmp (param, "end"));
        } else {
          cur->dat = NULL;
          if (cur->sec_start)
            cur->dat = cur->sec_start();
        }
      } else if (strcmp (param, "end") == 0) {
        if(cur_section->sec_end)
          cur_section->sec_end(cur_section->dat);
        cur_section = NULL;
      } else if (strncmp (param, "/*", 2) == 0) {
        char c0 = 0, c1 = 0;
        while (c0 != '*' || c1 != '/') {
          c0 = c1;
          c1 = fgetc(f);
          if (feof(f)) {
            fprintf (stderr, "%s: ERROR: Comment reached EOF.\n", local ? filename : ctmp);
            exit (1);
          }
        }
      } else {
        struct config_param *cur_param;
        char *cur_p;
        TRACE("Came across parameter `%s' in section `%s'\n", param,
              cur_section->name);
        for (cur_param = cur_section->params; cur_param; cur_param = cur_param->next)
          if (strcmp (cur_param->name, param) == 0) {
            break;
          }
        if (!cur_param) {
          char tmp[200];
          sprintf (tmp, "Invalid parameter: %s; ignoring.\n", param);
          WARNING(tmp);
          while (fgetc(f) != '\n' || feof(f));
          continue;
        }
 
        if(cur_param->type == paramt_none)
          continue;
 
        /* Parse parameter value */
        cur_p = fgets (param, STR_SIZE, f);
 
        while(*cur_p && isspace(*cur_p)) cur_p++;
 
        switch_param(cur_p, cur_param);
      }
    }
    fclose (f);
    runtime.sim.script_file_specified = 1;
  } else
    if (config.sim.verbose)
      fprintf (stderr, "WARNING: Cannot read script file from '%s',\nneither '%s'.\n", filename, ctmp);
}
 
/* Utility for execution of set sim command.  */
static int set_config (int argc, char **argv)
{
  struct config_section *cur;
  struct config_param *cur_param;
 
  if (argc < 2) return 1;
 
  PRINTF ("sec:%s\n", argv[1]);
  cur_section = NULL;
  for (cur = sections; cur; cur = cur->next)
    if (strcmp (cur->name, argv[1]) == 0) {
      cur_section = cur;
      break;
    }
 
  if (!cur_section) return 1;
 
  if (argc < 3) return 2;
 
  PRINTF ("item:%s\n", argv[2]);
  {
    for (cur_param = cur->params; cur_param; cur_param = cur_param->next)
      if (strcmp (cur_param->name, argv[2]) == 0) {
        break;
      }
    if (!cur_param) return 2;
 
    /* Parse parameter value */
    if (cur_param->type) {
      if (argc < 4) return 3;
      PRINTF ("params:%s\n", argv[3]);
    }
 
    switch_param(argv[3], cur_param);
  }
  return 0;
}
 
/* Executes set sim command, displays error.  */
void set_config_command(int argc, char **argv)
{
  struct config_section *cur;
  struct config_param *cur_param;
 
  switch (set_config (argc, argv)) {
    case 1:
      PRINTF ("Invalid or missing section name.  One of valid sections must be specified:\n");
      for (cur = sections; cur; cur = cur->next)
        PRINTF ("%s ", cur->name);
      PRINTF ("\n");
      break;
    case 2:
      PRINTF ("Invalid or missing item name.  One of valid items must be specified:\n");
      for (cur_param = cur_section->params; cur_param; cur_param = cur_param->next)
        PRINTF ("%s ", cur_param->name);
      PRINTF ("\n");
      break;
    case 3:
      PRINTF ("Invalid parameters specified.\n");
      break;
  }
}
 

Line No.	Rev	Author	Line
1	1358	nogj	`/* sim-config.c -- Simulator configuration`
2	645	markom	`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 configuration. Eventually this one will be a lot bigger. */`
21
22			`#include <stdlib.h>`
23	805	markom	`#include <limits.h>`
24	1308	phoenix	`#include <string.h>`
25			`#include <ctype.h>`
26
27	1350	nogj	`#include "config.h"`
28
29			`#ifdef HAVE_INTTYPES_H`
30			`#include <inttypes.h>`
31			`#endif`
32
33			`#include "port.h"`
34			`#include "arch.h"`
35	645	markom	`#include "sim-config.h"`
36			`#include "abstract.h"`
37	1432	nogj	`#include "opcode/or32.h"`
38			`#include "spr_defs.h"`
39			`#include "execute.h"`
40	645	markom	`#include "sprs.h"`
41			`#include "pic.h"`
42			`#include "stats.h"`
43			`#include "icache_model.h"`
44			`#include "dcache_model.h"`
45
46			`#include "profiler.h"`
47			`#include "mprofiler.h"`
48	897	markom	`#include "cuc.h"`
49	645	markom
50	1358	nogj	`#include "debug.h"`
51
52	1459	nogj	`DEFAULT_DEBUG_CHANNEL(config);`
53
54	1358	nogj	`#define WARNING(s) fprintf (stderr, "WARNING: config.%s: %s\n", cur_section->name, (s))`
55	645	markom	`#define MERROR(s) {fprintf (stderr, "ERROR: %s\n", s); if (runtime.sim.init) exit (1);}`
56
57			`struct config config;`
58			`struct runtime runtime;`
59
60	1358	nogj	`struct config_section *cur_section;`
61	645	markom
62	1358	nogj	`struct config_section *sections = NULL;`
63
64	1557	nogj	`extern char *or1ksim_ver;`
65
66	1550	nogj	`void init_defconfig(void)`
67	645	markom	`{`
68			`memset(&config, 0, sizeof(config));`
69			`/* Sim */`
70			`config.sim.exe_log = 0;`
71	672	markom	`config.sim.exe_log_type = EXE_LOG_HARDWARE;`
72			`config.sim.exe_log_start = 0;`
73			`config.sim.exe_log_end = 0;`
74			`config.sim.exe_log_marker = 0;`
75	645	markom	`strcpy (config.sim.exe_log_fn, "executed.log");`
76	1098	markom	`config.sim.profile = 0;`
77			`config.sim.mprofile = 0;`
78	645	markom
79			`config.sim.debug = 0;`
80			`config.sim.verbose = 1;`
81
82			`strcpy (config.sim.prof_fn, "sim.profile");`
83			`strcpy (config.sim.mprof_fn, "sim.mprofile");`
84	823	ivang	`strcpy (config.sim.fstdout, "stdout.txt");`
85	645	markom	`strcpy (runtime.sim.script_fn, "(default)");`
86			`config.sim.clkcycle_ps = 4000; /* 4000 for 4ns (250MHz) */`
87	805	markom	`if (config.sim.clkcycle_ps) config.sim.system_kfreq = (long)((1000000000.0 / (double)config.sim.clkcycle_ps));`
88			`else config.sim.system_kfreq = INT_MAX;`
89			`if (config.sim.system_kfreq <= 0) config.sim.system_kfreq = 1;`
90	645	markom
91			`/* IMMU & DMMU*/`
92			`config.immu.enabled = 0;`
93	856	markom	`config.immu.hitdelay = 1;`
94			`config.immu.missdelay = 1;`
95	1595	nogj	`config.immu.pagesize = 8192;`
96	645	markom	`config.dmmu.enabled = 0;`
97	856	markom	`config.dmmu.hitdelay = 1;`
98			`config.dmmu.missdelay = 1;`
99	1595	nogj	`config.dmmu.pagesize = 8192;`
100	645	markom
101			`/* IC & DC */`
102			`config.ic.enabled = 0;`
103	856	markom	`config.ic.hitdelay = 1;`
104			`config.ic.missdelay = 1;`
105	645	markom	`config.ic.nways = 0;`
106			`config.ic.nsets = 0;`
107			`config.ic.ustates = 0;`
108			`config.dc.enabled = 0;`
109	856	markom	`config.dc.load_hitdelay = 2;`
110			`config.dc.load_missdelay = 2;`
111	645	markom	`config.dc.nways = 0;`
112			`config.dc.nsets = 0;`
113			`config.dc.ustates = 0;`
114			`config.dc.store_hitdelay = 0;`
115			`config.dc.store_missdelay = 0;`
116	876	rherveille
117	645	markom	`/* CPU */`
118			`config.cpu.superscalar = 0;`
119			`config.sim.history = 0;`
120			`config.cpu.hazards = 0;`
121			`config.cpu.dependstats = 0;`
122			`config.cpu.sbuf_len = 0;`
123			`config.cpu.upr = SPR_UPR_UP \| SPR_UPR_DCP \| SPR_UPR_ICP \| SPR_UPR_DMP`
124			`\| SPR_UPR_IMP \| SPR_UPR_OB32P \| SPR_UPR_DUP \| SPR_UPR_PICP`
125			`\| SPR_UPR_PMP \| SPR_UPR_TTP;`
126	912	lampret	`config.cpu.sr = 0x00008001;`
127	645	markom
128			`/* Debug */`
129			`config.debug.enabled = 0;`
130			`config.debug.gdb_enabled = 0;`
131			`config.debug.server_port = 0;`
132
133			`/* VAPI */`
134			`config.vapi.enabled = 0;`
135			`strcpy (config.vapi.vapi_fn, "vapi.log");`
136
137			`/* PM */`
138			`config.pm.enabled = 0;`
139	897	markom
140			`/* CUC */`
141			`strcpy (config.cuc.timings_fn, "virtex.tim");`
142			`config.cuc.memory_order = MO_STRONG;`
143			`config.cuc.calling_convention = 1;`
144			`config.cuc.enable_bursts = 1;`
145			`config.cuc.no_multicycle = 1;`
146	970	simons
147	645	markom	`/* Configure runtime */`
148			`memset(&runtime, 0, sizeof(runtime));`
149
150			`/* Sim */`
151			`runtime.sim.fexe_log = NULL;`
152			`runtime.sim.iprompt = 0;`
153			`runtime.sim.fprof = NULL;`
154			`runtime.sim.fmprof = NULL;`
155			`runtime.sim.init = 1;`
156	998	markom	`runtime.sim.fout = stdout;`
157	645	markom	`runtime.sim.script_file_specified = 0;`
158	883	markom	`runtime.simcmd.profile = 0;`
159			`runtime.simcmd.mprofile = 0;`
160	645	markom
161			`/* VAPI */`
162			`runtime.vapi.vapi_file = NULL;`
163			`runtime.vapi.enabled = 0;`
164			`}`
165
166	1557	nogj	`static void version(void)`
167			`{`
168			`PRINTF ("\n");`
169			`PRINTF ("OpenRISC 1000 (OR32) Architectural Simulator, version %s\n",`
170			`or1ksim_ver);`
171			`PRINTF ("Copyright (C) 1999 Damjan Lampret, lampret@opencores.org\n");`
172			`PRINTF ("Copyright (C) 2000 Damjan Lampret, lampret@opencores.org\n");`
173			`PRINTF (" Jimmy Chen-Min Chen, jimmy@ee.nctu.edu.tw\n");`
174			`PRINTF (" Johan Rydberg, johan.rydberg@insight.se\n");`
175			`PRINTF (" Marko Mlinar, markom@opencores.org\n");`
176			`PRINTF ("Copyright (C) 2001 Simon Srot, simons@opencores.org\n");`
177			`PRINTF (" Marko Mlinar, markom@opencores.org\n");`
178			`PRINTF ("Copyright (C) 2002 Marko Mlinar, markom@opencores.org\n");`
179			`PRINTF (" Simon Srot, simons@opencores.org\n");`
180			`PRINTF ("Visit http://www.opencores.org for more information about ");`
181			`PRINTF ("OpenRISC 1000 and\nother open source cores.\n\n");`
182			`PRINTF ("This software comes with ABSOLUTELY NO WARRANTY; for ");`
183			`PRINTF ("details see COPYING.\nThis is free software, and you ");`
184			`PRINTF ("are welcome to redistribute it under certain\nconditions; ");`
185			`PRINTF ("for details see COPYING.\n");`
186			`}`
187
188	645	markom	`int parse_args(int argc, char *argv[])`
189			`{`
190			`argv++; argc--;`
191			`while (argc) {`
192	847	markom	`if (strcmp(*argv, "profiler") == 0) {`
193			`exit (main_profiler (argc, argv));`
194			`} else`
195			`if (strcmp(*argv, "mprofiler") == 0) {`
196			`exit (main_mprofiler (argc, argv));`
197			`} else`
198			`if (*argv[0] != '-') {`
199	645	markom	`runtime.sim.filename = argv[0];`
200			`argc--;`
201			`argv++;`
202			`} else`
203			`if (strcmp(argv, "-f") == 0 \|\| strcmp(argv, "--file") == 0) {`
204			`argv++; argc--;`
205			`if (argv[0]) {`
206			`read_script_file(argv[0]);`
207			`argv++; argc--;`
208			`} else {`
209			`fprintf(stderr, "Configure filename not specified!\n");`
210			`return 1;`
211			`}`
212			`} else`
213			`if (strcmp(argv, "--nosrv") == 0) { / (CZ) */`
214			`config.debug.gdb_enabled = 0;`
215			`argv++; argc--;`
216			`} else`
217			`if (strcmp(argv, "--srv") == 0) { / (CZ) */`
218			`char *s;`
219			`if(!--argc)`
220			`return 1;`
221			`config.debug.enabled = 1;`
222	1205	phoenix	`config.debug.gdb_enabled = 1;`
223	645	markom	`config.debug.server_port = strtol(*(++argv),&s,10);`
224			`if(*s)`
225			`return 1;`
226			`argv++; argc--;`
227			`} else`
228			`if (strcmp(*argv, "-i") == 0) {`
229			`runtime.sim.iprompt = 1;`
230			`argv++; argc--;`
231			`} else`
232			`if (strcmp(*argv, "-v") == 0) {`
233			`version();`
234			`exit(0);`
235			`} else`
236	883	markom	`if (strcmp(*argv, "--enable-profile") == 0) {`
237			`runtime.simcmd.profile = 1;`
238	645	markom	`argv++; argc--;`
239			`} else`
240	883	markom	`if (strcmp(*argv, "--enable-mprofile") == 0) {`
241			`runtime.simcmd.mprofile = 1;`
242	645	markom	`argv++; argc--;`
243			`} else`
244	1389	nogj	`if (strcmp(*argv, "-d") == 0) {`
245			`parse_dbchs(*(++argv));`
246			`argv++; argc -= 2;`
247	645	markom	`} else {`
248			`fprintf(stderr, "Unknown option: %s\n", *argv);`
249			`return 1;`
250			`}`
251			`}`
252
253			`if (!argc)`
254			`return 0;`
255
256			`return 0;`
257			`}`
258
259	1550	nogj	`void print_config(void)`
260	645	markom	`{`
261			`if (config.sim.verbose) {`
262			`char temp[20];`
263	997	markom	`PRINTF("Verbose on, ");`
264	645	markom	`if (config.sim.debug)`
265	997	markom	`PRINTF("simdebug on, ");`
266	645	markom	`else`
267	997	markom	`PRINTF("simdebug off, ");`
268	645	markom	`if (runtime.sim.iprompt)`
269	997	markom	`PRINTF("interactive prompt on\n");`
270	645	markom	`else`
271	997	markom	`PRINTF("interactive prompt off\n");`
272	645	markom
273	997	markom	`PRINTF("Machine initialization...\n");`
274	645	markom	`generate_time_pretty (temp, config.sim.clkcycle_ps);`
275	997	markom	`PRINTF("Clock cycle: %s\n", temp);`
276	1506	nogj	`if (cpu_state.sprs[SPR_UPR] & SPR_UPR_DCP)`
277	997	markom	`PRINTF("Data cache present.\n");`
278	645	markom	`else`
279	997	markom	`PRINTF("No data cache.\n");`
280	1506	nogj	`if (cpu_state.sprs[SPR_UPR] & SPR_UPR_ICP)`
281	997	markom	`PRINTF("Insn cache tag present.\n");`
282	645	markom	`else`
283	997	markom	`PRINTF("No instruction cache.\n");`
284	645	markom	`if (config.bpb.enabled)`
285	997	markom	`PRINTF("BPB simulation on.\n");`
286	645	markom	`else`
287	997	markom	`PRINTF("BPB simulation off.\n");`
288	645	markom	`if (config.bpb.btic)`
289	997	markom	`PRINTF("BTIC simulation on.\n");`
290	645	markom	`else`
291	997	markom	`PRINTF("BTIC simulation off.\n");`
292	645	markom	`}`
293			`}`
294
295	1358	nogj	`struct config_param {`
296			`char *name;`
297			`enum param_t type;`
298			`void (func)(union param_val, void dat);`
299			`struct config_param *next;`
300	645	markom	`};`
301
302	1358	nogj	`void base_include (union param_val val, void *dat) {`
303			`read_script_file (val.str_val);`
304			`cur_section = NULL;`
305			`}`
306	645	markom
307	1358	nogj	`/----------------------------------------------[ Simulator configuration ]---/`
308			`void sim_debug (union param_val val, void *dat) {`
309			`config.sim.debug = val.int_val;`
310			`}`
311	645	markom
312	1358	nogj	`void sim_verbose (union param_val val, void *dat) {`
313			`config.sim.verbose = val.int_val;`
314			`}`
315	645	markom
316	1358	nogj	`void sim_profile (union param_val val, void *dat) {`
317			`config.sim.profile = val.int_val;`
318			`}`
319	645	markom
320	1358	nogj	`void sim_prof_fn (union param_val val, void *dat) {`
321			`strcpy(config.sim.prof_fn, val.str_val);`
322			`}`
323	876	rherveille
324	1358	nogj	`void sim_mprofile (union param_val val, void *dat) {`
325			`config.sim.mprofile = val.int_val;`
326	645	markom	`}`
327
328	1358	nogj	`void sim_mprof_fn (union param_val val, void *dat) {`
329			`strcpy(config.sim.mprof_fn, val.str_val);`
330	645	markom	`}`
331
332	1358	nogj	`void sim_history (union param_val val, void *dat) {`
333			`config.sim.history = val.int_val;`
334	645	markom	`}`
335
336	1358	nogj	`void sim_exe_log (union param_val val, void *dat) {`
337			`config.sim.exe_log = val.int_val;`
338	645	markom	`}`
339
340	1358	nogj	`void sim_exe_log_type (union param_val val, void *dat) {`
341			`if (strcmp (val.str_val, "default") == 0)`
342	672	markom	`config.sim.exe_log_type = EXE_LOG_HARDWARE;`
343	1358	nogj	`else if (strcmp (val.str_val, "hardware") == 0)`
344	672	markom	`config.sim.exe_log_type = EXE_LOG_HARDWARE;`
345	1358	nogj	`else if (strcmp (val.str_val, "simple") == 0)`
346	675	markom	`config.sim.exe_log_type = EXE_LOG_SIMPLE;`
347	1358	nogj	`else if (strcmp (val.str_val, "software") == 0) {`
348	672	markom	`config.sim.exe_log_type = EXE_LOG_SOFTWARE;`
349			`} else {`
350			`char tmp[200];`
351	1549	nogj	`sprintf (tmp, "invalid execution log type '%s'.\n", val.str_val);`
352	1358	nogj	`CONFIG_ERROR(tmp);`
353	672	markom	`}`
354			`}`
355
356	1358	nogj	`void sim_exe_log_start (union param_val val, void *dat) {`
357	1580	nogj	`config.sim.exe_log_start = val.longlong_val;`
358	645	markom	`}`
359
360	1358	nogj	`void sim_exe_log_end (union param_val val, void *dat) {`
361	1580	nogj	`config.sim.exe_log_end = val.longlong_val;`
362	645	markom	`}`
363
364	1358	nogj	`void sim_exe_log_marker (union param_val val, void *dat) {`
365			`config.sim.exe_log_marker = val.int_val;`
366	645	markom	`}`
367
368	1358	nogj	`void sim_exe_log_fn (union param_val val, void *dat) {`
369			`strcpy(config.sim.exe_log_fn, val.str_val);`
370	645	markom	`}`
371
372	1358	nogj	`void sim_clkcycle (union param_val val, void *dat) {`
373			`int len = strlen (val.str_val);`
374			`int pos = len - 1;`
375			`long time;`
376			`if (len < 2) goto err;`
377			`if (val.str_val[pos--] != 's') goto err;`
378			`switch (val.str_val[pos--]) {`
379			`case 'p': time = 1; break;`
380			`case 'n': time = 1000; break;`
381			`case 'u': time = 1000000; break;`
382			`case 'm': time = 1000000000; break;`
383			`default:`
384			`goto err;`
385			`}`
386			`val.str_val[pos + 1] = 0;`
387			`config.sim.clkcycle_ps = time * atol (val.str_val);`
388			`return;`
389			`err:`
390			`CONFIG_ERROR("invalid time format.");`
391	645	markom	`}`
392
393	1358	nogj	`void sim_stdout (union param_val val, void *dat) {`
394			`strcpy(config.sim.fstdout, val.str_val);`
395	645	markom	`}`
396
397	1358	nogj	`void reg_sim_sec (void) {`
398			`struct config_section *sec = reg_config_sec("sim", NULL, NULL);`
399	645	markom
400	1358	nogj	`reg_config_param(sec, "debug", paramt_int, sim_debug);`
401			`reg_config_param(sec, "verbose", paramt_int, sim_verbose);`
402			`reg_config_param(sec, "profile", paramt_int, sim_profile);`
403			`reg_config_param(sec, "prof_fn", paramt_str, sim_prof_fn);`
404			`reg_config_param(sec, "mprofile", paramt_int, sim_mprofile);`
405			`reg_config_param(sec, "mprof_fn", paramt_str, sim_mprof_fn);`
406			`reg_config_param(sec, "history", paramt_int, sim_history);`
407			`reg_config_param(sec, "exe_log", paramt_int, sim_exe_log);`
408			`reg_config_param(sec, "exe_log_type", paramt_word, sim_exe_log_type);`
409	1580	nogj	`reg_config_param(sec, "exe_log_start", paramt_longlong, sim_exe_log_start);`
410			`reg_config_param(sec, "exe_log_end", paramt_longlong, sim_exe_log_end);`
411	1358	nogj	`reg_config_param(sec, "exe_log_marker", paramt_int, sim_exe_log_marker);`
412			`reg_config_param(sec, "exe_log_fn", paramt_str, sim_exe_log_fn);`
413			`reg_config_param(sec, "clkcycle", paramt_word, sim_clkcycle);`
414			`reg_config_param(sec, "stdout", paramt_str, sim_stdout);`
415	645	markom	`}`
416
417	1358	nogj	`/----------------------------------------------------[ CPU configuration ]---/`
418			`void cpu_ver (union param_val val, void *dat) {`
419			`config.cpu.ver = val.int_val;`
420	645	markom	`}`
421
422	1358	nogj	`void cpu_rev (union param_val val, void *dat) {`
423			`config.cpu.rev = val.int_val;`
424	645	markom	`}`
425
426	1358	nogj	`void cpu_upr (union param_val val, void *dat) {`
427			`config.cpu.upr = val.int_val;`
428	725	ivang	`}`
429
430	1358	nogj	`void cpu_sr (union param_val val, void *dat) {`
431			`config.cpu.sr = val.int_val;`
432	645	markom	`}`
433
434	1358	nogj	`void cpu_hazards (union param_val val, void *dat) {`
435			`config.cpu.hazards = val.int_val;`
436	645	markom	`}`
437
438	1358	nogj	`void cpu_superscalar (union param_val val, void *dat) {`
439			`config.cpu.superscalar = val.int_val;`
440	645	markom	`}`
441
442	1358	nogj	`void cpu_dependstats (union param_val val, void *dat) {`
443			`config.cpu.dependstats = val.int_val;`
444	645	markom	`}`
445
446	1358	nogj	`void cpu_sbuf_len (union param_val val, void *dat) {`
447			`if (val.int_val >= MAX_SBUF_LEN) {`
448			`config.cpu.sbuf_len = MAX_SBUF_LEN - 1;`
449			`WARNING("sbuf_len too large; truncated.");`
450			`} else if (val.int_val < 0) {`
451			`config.cpu.sbuf_len = 0;`
452			`WARNING("sbuf_len negative; disabled.");`
453			`} else`
454			`config.cpu.sbuf_len = val.int_val;`
455	723	ivang	`}`
456
457	1358	nogj	`void reg_cpu_sec(void)`
458			`{`
459			`struct config_section *sec = reg_config_sec("cpu", NULL, NULL);`
460	723	ivang
461	1358	nogj	`reg_config_param(sec, "ver", paramt_int, cpu_ver);`
462			`reg_config_param(sec, "rev", paramt_int, cpu_rev);`
463			`reg_config_param(sec, "upr", paramt_int, cpu_upr);`
464			`reg_config_param(sec, "sr", paramt_int, cpu_sr);`
465			`reg_config_param(sec, "hazards", paramt_int, cpu_hazards);`
466			`reg_config_param(sec, "superscalar", paramt_int, cpu_superscalar);`
467			`reg_config_param(sec, "dependstats", paramt_int, cpu_dependstats);`
468			`reg_config_param(sec, "sbuf_len", paramt_int, cpu_sbuf_len);`
469	645	markom	`}`
470
471	1358	nogj	`void reg_config_secs(void)`
472			`{`
473			`reg_config_param(reg_config_sec("base", NULL, NULL), "include", paramt_str,`
474			`base_include);`
475	645	markom
476	1358	nogj	`reg_sim_sec();`
477			`reg_cpu_sec();`
478			`reg_memory_sec();`
479			`reg_mc_sec();`
480			`reg_uart_sec();`
481			`reg_dma_sec();`
482			`reg_debug_sec();`
483			`reg_vapi_sec();`
484			`reg_ethernet_sec();`
485			`reg_immu_sec();`
486			`reg_dmmu_sec();`
487			`reg_ic_sec();`
488			`reg_dc_sec();`
489			`reg_gpio_sec();`
490			`reg_bpb_sec();`
491			`reg_pm_sec();`
492			`reg_vga_sec();`
493			`reg_fb_sec();`
494			`reg_kbd_sec();`
495			`reg_ata_sec();`
496			`reg_cuc_sec();`
497	645	markom	`}`
498
499	1459	nogj	`/* Returns a user friendly string of type */`
500			`static char *get_paramt_str(enum param_t type)`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [branches/] [stable_0_2_x/] [or1ksim/] [sim-config.c] - Blame information for rev 1595