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

Subversion Repositories or1k

[/] [or1k/] [tags/] [rel-0-3-0-rc2/] [or1ksim/] [sim-config.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* sim-config.c -- Simulator configuration
 
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
   Copyright (C) 2008 Embecosm Limited
 
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   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 3 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, see <http://www.gnu.org/licenses/>. */
 
/* This program is commented throughout in a fashion suitable for processing
   with Doxygen. */
 
/* Simulator configuration. Eventually this one will be a lot bigger. Updated
   to use argtable2 for argument parsing. */
 
 
/* Autoconf and/or portability configuration */
#include "config.h"
#include "port.h"
 
/* System includes */
#include <stdlib.h>
 
/* Package includes */
#include "sim-config.h"
#include "vapi.h"
#include "cuc.h"
#include "cpu-config.h"
#include "memory.h"
#include "dmmu.h"
#include "immu.h"
#include "dcache-model.h"
#include "icache-model.h"
#include "pic.h"
#include "pm.h"
#include "branch-predict.h"
#include "debug-unit.h"
#include "mc.h"
#include "16450.h"
#include "dma.h"
#include "eth.h"
#include "gpio.h"
#include "vga.h"
#include "fb.h"
#include "ps2kbd.h"
#include "atahost.h"
#include "generic.h"
#include "execute.h"
#include "spr-defs.h"
#include "debug.h"
#include "misc.h"
#include "argtable2.h"
 
 
struct config config;
struct runtime runtime;
 
struct config_section *cur_section;
 
struct config_section *sections = NULL;
 
/* Forward declarations */
static void read_script_file (const char *filename);
 
 
 
/*---------------------------------------------------------------------------*/
/*!Set default configuration parameters for fixed components
 
   These values are held in the global config variable. Parameter orders
   match the order in the corresponding section registration function and
   documentation.
 
   Also set some starting values for runtime elements.                       */
/*---------------------------------------------------------------------------*/
void
init_defconfig ()
{
  int  set_bits;                /* Temporaries for computing bit fields */
  int  way_bits;
 
  memset (&config, 0, sizeof (config));
 
  /* External linkage disabled here. */
  config.ext.class_ptr = NULL;
  config.ext.read_up   = NULL;
  config.ext.write_up  = NULL;
 
  /* Sim */
  config.sim.verbose        = 0;
  config.sim.debug          = 0;
  config.sim.profile        = 0;
  config.sim.prof_fn        = strdup ("sim.profile");
  config.sim.mprofile       = 0;
  config.sim.mprof_fn       = strdup ("sim.mprofile");
  config.sim.history        = 0;
  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;
  config.sim.exe_log_fn     = strdup ("executed.log");
  config.sim.clkcycle_ps    = 4000;     /* 4000 for 4ns (250MHz) */
 
  /* VAPI */
  config.vapi.enabled        = 0;
  config.vapi.server_port    = 50000;
  config.vapi.log_enabled    = 0;
  config.vapi.hide_device_id = 0;
  config.vapi.vapi_fn        = strdup ("vapi.log");
 
  /* CUC */
  config.cuc.calling_convention = 1;
  config.cuc.enable_bursts      = 1;
  config.cuc.no_multicycle      = 1;
  config.cuc.memory_order       = MO_STRONG;
  config.cuc.timings_fn         = strdup ("virtex.tim");
 
  /* CPU */
  cpu_state.sprs[SPR_VR]      = 0;
  cpu_state.sprs[SPR_UPR]     = SPR_UPR_UP | SPR_UPR_TTP;
  cpu_state.sprs[SPR_SR]      = SPR_SR_FO  | SPR_SR_SM;
  cpu_state.sprs[SPR_CPUCFGR] = SPR_CPUCFGR_OB32S;
  config.cpu.superscalar      = 0;
  config.cpu.hazards          = 0;
  config.cpu.dependstats      = 0;
  config.cpu.sbuf_len         = 0;
 
  /* Data cache (IC is set dynamically). Also set relevant SPR bits */
  config.dc.enabled         = 0;
  config.dc.nsets           = 1;
  config.dc.nways           = 1;
  config.dc.blocksize       = 1;
  config.dc.ustates         = 2;
  config.dc.load_hitdelay   = 2;
  config.dc.load_missdelay  = 2;
  config.dc.store_hitdelay  = 0;
  config.dc.store_missdelay = 0;
 
  if (config.dc.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_DCP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DCP;
    }
 
  set_bits = log2_int (config.dc.nsets);
  cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCS;
  cpu_state.sprs[SPR_DCCFGR] |= set_bits << SPR_DCCFGR_NCS_OFF;
 
  way_bits = log2_int (config.dc.nways);
  cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCW;
  cpu_state.sprs[SPR_DCCFGR] |= way_bits << SPR_DCCFGR_NCW_OFF;
 
  if (MIN_DC_BLOCK_SIZE == config.dc.blocksize)
    {
      cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_CBS;
    }
  else
    {
      cpu_state.sprs[SPR_DCCFGR] |= SPR_DCCFGR_CBS;
    }
 
  /* Power management */
  config.pm.enabled = 0;
 
  if (config.pm.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_PMP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PMP;
    }
 
  /* Programmable Interrupt Controller */
  config.pic.enabled      = 0;
  config.pic.edge_trigger = 1;
 
  if (config.pic.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_PICP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PICP;
    }
 
  /* Branch Prediction */
  config.bpb.enabled     = 0;
  config.bpb.btic        = 0;
  config.bpb.sbp_bnf_fwd = 0;
  config.bpb.sbp_bf_fwd  = 0;
  config.bpb.missdelay   = 0;
  config.bpb.hitdelay    = 0;
 
  /* Debug */
  config.debug.enabled     = 0;
  config.debug.gdb_enabled = 0;
  config.debug.rsp_enabled = 0;
  config.debug.server_port = 51000;
  config.debug.rsp_port    = 51000;
  config.debug.vapi_id     = 0;
 
  cpu_state.sprs[SPR_DCFGR] = SPR_DCFGR_WPCI |
                              MATCHPOINTS_TO_NDP (MAX_MATCHPOINTS);
 
  if (config.debug.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_DUP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DUP;
    }
 
  /* 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.fout                  = stdout;
 
  /* VAPI */
  runtime.vapi.vapi_file = NULL;
  runtime.vapi.enabled   = 0;
 
}       /* init_defconfig() */
 
 
/*---------------------------------------------------------------------------*/
/*! Parse the arguments for the standalone simulator
 
    Updated by Jeremy Bennett to use argtable2.
 
    @param[in] argc  Number of command args
    @param[in] argv  Vector of the command args
 
    @return  0 on success, 1 on failure                                      */
/*---------------------------------------------------------------------------*/
int
parse_args (int argc, char *argv[])
{
  struct arg_lit *vercop;
  struct arg_lit *help;
  struct arg_file *cfg_file;
  struct arg_lit *nosrv;
  struct arg_int *srv;
  struct arg_str *dbg;
  struct arg_lit *command;
  struct arg_lit *profile;
  struct arg_lit *mprofile;
  struct arg_file *load_file;
  struct arg_end *end;
 
  void *argtab[11];
  int nerrors;
 
  /* Specify each argument, with fall back values */
  vercop = arg_lit0 ("v", "version", "version and copyright notice");
  help = arg_lit0 ("h", "help", "print this help message");
  cfg_file = arg_file0 ("f", "file", "<file>",
                        "config file (default \"sim.cfg\")");
  cfg_file->filename[0] = "sim.cfg";
  nosrv = arg_lit0 (NULL, "nosrv", "do not launch JTAG proxy server");
  srv = arg_int0 (NULL, "srv", "<n>", "port number (default random)");
  srv->ival[0] = rand () % (65536 - 49152) + 49152;
  srv->hdr.flag |= ARG_HASOPTVALUE;
  dbg = arg_str0 ("d", "debug-config", "<str>", "Debug config string");
  command = arg_lit0 ("i", "interactive", "launch interactive prompt");
  profile = arg_lit0 (NULL, "enable-profile", "enable profiling");
  mprofile = arg_lit0 (NULL, "enable-mprofile", "enable memory profiling");
  load_file = arg_file0 (NULL, NULL, "<file>", "OR32 executable");
  end = arg_end (20);
 
  /* Set up the argument table */
  argtab[0] = vercop;
  argtab[1] = help;
  argtab[2] = cfg_file;
  argtab[3] = nosrv;
  argtab[4] = srv;
  argtab[5] = dbg, argtab[6] = command;
  argtab[7] = profile;
  argtab[8] = mprofile;
  argtab[9] = load_file;
  argtab[10] = end;
 
  /* Parse */
  nerrors = arg_parse (argc, argv, argtab);
 
  /* Special case here is if help or version is specified, we ignore any other
     errors and just print the help or version information and then give up. */
  if (vercop->count > 0)
    {
      PRINTF ("OpenRISC 1000 Architectural Simulator, version %s\n",
              PACKAGE_VERSION);
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  if (help->count > 0)
    {
      printf ("Usage:\n  %s ", argv[0]);
      arg_print_syntax (stdout, argtab, "\n\n");
      arg_print_glossary (stdout, argtab, "  %-25s %s\n");
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  /* Deal with any errors */
  if (0 != nerrors)
    {
      arg_print_errors (stderr, end, "or1ksim");
      printf ("\nUsage:\n  %s ", argv[0]);
      arg_print_syntaxv (stderr, argtab, "\n");
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  /* Process config file next, so any other command args will override */
  if (0 == cfg_file->count)
    {
      fprintf (stderr,
               "Warning: No config file given, default configuration used\n");
    }
 
  read_script_file (cfg_file->filename[0]);
 
 
  /* Remote debug server */
  if (nosrv->count > 0)
    {
      if (srv->count > 0)
        {
          fprintf (stderr,
                   "%s: cannot specify --nosrv with --srv. Ignoring --nosrv\n",
                   argv[0]);
        }
      else
        {
          config.debug.enabled = 0;
          config.debug.gdb_enabled = 0;
        }
    }
 
  if (srv->count > 0)
    {
      config.debug.enabled = 1;
      config.debug.gdb_enabled = 1;
      config.debug.server_port = srv->ival[0];
    }
 
  /* Runtime debug messages */
  if (dbg->count > 0)
    {
      parse_dbchs (dbg->sval[0]);
    }
 
  /* Interactive operation */
  runtime.sim.iprompt = command->count;
 
  /* Profiling requests */
  config.sim.profile = profile->count;
  config.sim.mprofile = mprofile->count;
 
  /* Executable file */
  if (load_file->count > 0)
    {
      runtime.sim.filename = strdup (load_file->filename[0]);
    }
  else
    {
      runtime.sim.filename = NULL;
    }
 
  arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
  return 0;                      /* Success */
 
}       /* parse_args() */
 
 
/*---------------------------------------------------------------------------*/
/*!Print the current configuration                                           */
/*---------------------------------------------------------------------------*/
void
print_config ()
{
  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_verbose (union param_val val, void *dat)
{
  config.sim.verbose = val.int_val;
}
 
 
/*---------------------------------------------------------------------------*/
/*!Set the simulator debug message level
 
   Value must be in the range 0 (no messages) to 9. Values outside this range
   are converted to the nearer end of the range with a warning.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
void
sim_debug (union param_val  val,
           void            *dat)
{
  if (val.int_val < 0)
    {
      fprintf (stderr,
               "Warning: Config debug value negative: 0 substituted\n");
      config.sim.debug = 0;
    }
  else if (val.int_val > 9)
    {
      fprintf (stderr,
               "Warning: Config debug value too large: 9 substituted\n");
      config.sim.debug = 9;
    }
  else
    {
      config.sim.debug = val.int_val;
    }
}       /* sim_debug() */
 
 
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)
{
  if (NULL != config.sim.prof_fn)
    {
      free (config.sim.prof_fn);
    }
 
  config.sim.prof_fn = strdup(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)
{
  if (NULL != config.sim.mprof_fn)
    {
      free (config.sim.mprof_fn);
    }
 
  config.sim.mprof_fn = strdup (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;
}
 
/*---------------------------------------------------------------------------*/
/*!Set the execution log type
 
   Value must be one of default, hardware, simple or software. Invalid values
   are ignored with a warning.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
void
sim_exe_log_type (union param_val  val,
                  void            *dat)
{
  if (strcasecmp (val.str_val, "default") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_HARDWARE;
    }
  else if (strcasecmp (val.str_val, "hardware") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_HARDWARE;
    }
  else if (strcasecmp (val.str_val, "simple") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_SIMPLE;
    }
  else if (strcasecmp (val.str_val, "software") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_SOFTWARE;
    }
  else
    {
      fprintf (stderr, "Warning: Execution log type %s invalid. Ignored",
               val.str_val);
    }
}       /* sim_exe_log_type() */
 
 
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)
{
  if (NULL != config.sim.exe_log_fn)
    {
      free (config.sim.exe_log_fn);
    }
 
  config.sim.exe_log_fn = strdup (val.str_val);
}
 
/*---------------------------------------------------------------------------*/
/*!Set the clock cycle time.
 
   Value must be an integer followed by one of ps, ns, us or ms.
 
   If a valid time is not presented, the value is unchanged.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
void
sim_clkcycle (union param_val  val,
              void            *dat)
{
  int len = strlen (val.str_val);
  int pos = len - 1;
  long time;
  if ((len < 2) || (val.str_val[pos--] != 's'))
    {
      fprintf (stderr, "Warning: Clock cycle time %s invalid: ignored\n",
               val.str_val);
      return;
    }
 
  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:
      fprintf (stderr, "Warning: Clock cycle time %s invalid: ignored\n",
               val.str_val);
      return;
    }
 
  val.str_val[pos + 1] = 0;
  time = time * atol (val.str_val);
 
  if (0 == time)
    {
      fprintf (stderr, "Warning: Clock cycle time of zero invalid: ignored\n");
      return;
    }
 
  config.sim.clkcycle_ps = time;
 
}       /* sim_clkcycle() */
 
 
/*---------------------------------------------------------------------------*/
/*!Register the functions to handle a section sim
 
   This section does not allocate dynamically a data structure holding its
   config information. It's all in the global config.sim data
   structure. Therefore it does not need a start and end function to
   initialize default values (although it might be clearer to do so). The
   default values are set in init_defconfig().
 
   New preferred parameter names are introduced (_file for filenames), but
   the legacy names (_fn) are also present for backwards compatibility       */
/*---------------------------------------------------------------------------*/
static void
reg_sim_sec ()
{
  struct config_section *sec = reg_config_sec ("sim", NULL, NULL);
 
  reg_config_param (sec, "verbose",        paramt_int,      sim_verbose);
  reg_config_param (sec, "debug",          paramt_int,      sim_debug);
  reg_config_param (sec, "profile",        paramt_int,      sim_profile);
  reg_config_param (sec, "prof_file",      paramt_str,      sim_prof_fn);
  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_file",     paramt_str,      sim_mprof_fn);
  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_file",   paramt_str,      sim_exe_log_fn);
  reg_config_param (sec, "exe_log_fn",     paramt_str,      sim_exe_log_fn);
  reg_config_param (sec, "clkcycle",       paramt_word,     sim_clkcycle);
 
}       /* reg_sim_sec() */
 
 
void
reg_config_secs (void)
{
  reg_config_param (reg_config_sec ("base", NULL, NULL), "include",
                    paramt_str, base_include);
 
  reg_generic_sec ();           /* JPB */
  reg_sim_sec ();
  reg_cpu_sec ();
  reg_pic_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 ();
}
 
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));
 
  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));
 
  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 != '"')
        {
          fprintf (stderr,
                   "Warning: String value for parameter expected: ignored\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
 
 */
 
static void
read_script_file (const 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);
 
      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);
                }
              for (cur = sections; cur; cur = cur->next)
                if (strcmp (cur->name, param) == 0)
                  {
                    cur_section = cur;
                    break;
                  }
              if (!cur)
                {
                  fprintf (stderr,
                           "Warning: Unknown config 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;
              for (cur_param = cur_section->params; cur_param;
                   cur_param = cur_param->next)
                if (strcmp (cur_param->name, param) == 0)
                  {
                    break;
                  }
              if (!cur_param)
                {
                  fprintf (stderr, "Warning: Invalid parameter: %s; ignored\n",
                           param);
                  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);
    }
  else if (config.sim.verbose)
    fprintf (stderr,
             "Warning: Cannot read script file from '%s' of '%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	1743	jeremybenn
3	645	markom	`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
4	1743	jeremybenn	`Copyright (C) 2008 Embecosm Limited`
5
6			`Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>`
7
8			`This file is part of OpenRISC 1000 Architectural Simulator.`
9
10			`This program is free software; you can redistribute it and/or modify it`
11			`under the terms of the GNU General Public License as published by the Free`
12			`Software Foundation; either version 3 of the License, or (at your option)`
13			`any later version.`
14
15			`This program is distributed in the hope that it will be useful, but WITHOUT`
16			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
17			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for`
18			`more details.`
19
20			`You should have received a copy of the GNU General Public License along`
21			`with this program. If not, see <http://www.gnu.org/licenses/>. */`
22	645	markom
23	1748	jeremybenn	`/* This program is commented throughout in a fashion suitable for processing`
24			`with Doxygen. */`
25	645	markom
26	1748	jeremybenn	`/* Simulator configuration. Eventually this one will be a lot bigger. Updated`
27			`to use argtable2 for argument parsing. */`
28	645	markom
29	1308	phoenix
30	1748	jeremybenn	`/* Autoconf and/or portability configuration */`
31	1350	nogj	`#include "config.h"`
32	1748	jeremybenn	`#include "port.h"`
33	1350	nogj
34	1748	jeremybenn	`/* System includes */`
35			`#include <stdlib.h>`
36	1350	nogj
37	1748	jeremybenn	`/* Package includes */`
38	645	markom	`#include "sim-config.h"`
39	1748	jeremybenn	`#include "vapi.h"`
40			`#include "cuc.h"`
41			`#include "cpu-config.h"`
42			`#include "memory.h"`
43			`#include "dmmu.h"`
44			`#include "immu.h"`
45			`#include "dcache-model.h"`
46			`#include "icache-model.h"`
47			`#include "pic.h"`
48			`#include "pm.h"`
49			`#include "branch-predict.h"`
50			`#include "debug-unit.h"`
51			`#include "mc.h"`
52			`#include "16450.h"`
53			`#include "dma.h"`
54			`#include "eth.h"`
55			`#include "gpio.h"`
56			`#include "vga.h"`
57			`#include "fb.h"`
58			`#include "ps2kbd.h"`
59			`#include "atahost.h"`
60			`#include "generic.h"`
61	1432	nogj	`#include "execute.h"`
62	1748	jeremybenn	`#include "spr-defs.h"`
63			`#include "debug.h"`
64			`#include "misc.h"`
65			`#include "argtable2.h"`
66	645	markom
67
68			`struct config config;`
69			`struct runtime runtime;`
70
71	1358	nogj	`struct config_section *cur_section;`
72	645	markom
73	1358	nogj	`struct config_section *sections = NULL;`
74
75	1748	jeremybenn	`/* Forward declarations */`
76			`static void read_script_file (const char *filename);`
77	1557	nogj
78	1748	jeremybenn
79
80			`/---------------------------------------------------------------------------/`
81			`/*!Set default configuration parameters for fixed components`
82
83			`These values are held in the global config variable. Parameter orders`
84			`match the order in the corresponding section registration function and`
85			`documentation.`
86
87			`Also set some starting values for runtime elements. */`
88			`/---------------------------------------------------------------------------/`
89			`void`
90			`init_defconfig ()`
91	645	markom	`{`
92	1748	jeremybenn	`int set_bits; /* Temporaries for computing bit fields */`
93			`int way_bits;`
94
95			`memset (&config, 0, sizeof (config));`
96
97			`/* External linkage disabled here. */`
98			`config.ext.class_ptr = NULL;`
99			`config.ext.read_up = NULL;`
100			`config.ext.write_up = NULL;`
101
102	645	markom	`/* Sim */`
103	1748	jeremybenn	`config.sim.verbose = 0;`
104			`config.sim.debug = 0;`
105			`config.sim.profile = 0;`
106			`config.sim.prof_fn = strdup ("sim.profile");`
107			`config.sim.mprofile = 0;`
108			`config.sim.mprof_fn = strdup ("sim.mprofile");`
109			`config.sim.history = 0;`
110			`config.sim.exe_log = 0;`
111			`config.sim.exe_log_type = EXE_LOG_HARDWARE;`
112			`config.sim.exe_log_start = 0;`
113			`config.sim.exe_log_end = 0;`
114	672	markom	`config.sim.exe_log_marker = 0;`
115	1748	jeremybenn	`config.sim.exe_log_fn = strdup ("executed.log");`
116			`config.sim.clkcycle_ps = 4000; /* 4000 for 4ns (250MHz) */`
117	645	markom
118	1748	jeremybenn	`/* VAPI */`
119			`config.vapi.enabled = 0;`
120			`config.vapi.server_port = 50000;`
121			`config.vapi.log_enabled = 0;`
122			`config.vapi.hide_device_id = 0;`
123			`config.vapi.vapi_fn = strdup ("vapi.log");`
124	876	rherveille
125	1748	jeremybenn	`/* CUC */`
126			`config.cuc.calling_convention = 1;`
127			`config.cuc.enable_bursts = 1;`
128			`config.cuc.no_multicycle = 1;`
129			`config.cuc.memory_order = MO_STRONG;`
130			`config.cuc.timings_fn = strdup ("virtex.tim");`
131
132	645	markom	`/* CPU */`
133	1748	jeremybenn	`cpu_state.sprs[SPR_VR] = 0;`
134			`cpu_state.sprs[SPR_UPR] = SPR_UPR_UP \| SPR_UPR_TTP;`
135			`cpu_state.sprs[SPR_SR] = SPR_SR_FO \| SPR_SR_SM;`
136			`cpu_state.sprs[SPR_CPUCFGR] = SPR_CPUCFGR_OB32S;`
137			`config.cpu.superscalar = 0;`
138			`config.cpu.hazards = 0;`
139			`config.cpu.dependstats = 0;`
140			`config.cpu.sbuf_len = 0;`
141	645	markom
142	1748	jeremybenn	`/* Data cache (IC is set dynamically). Also set relevant SPR bits */`
143			`config.dc.enabled = 0;`
144			`config.dc.nsets = 1;`
145			`config.dc.nways = 1;`
146			`config.dc.blocksize = 1;`
147			`config.dc.ustates = 2;`
148			`config.dc.load_hitdelay = 2;`
149			`config.dc.load_missdelay = 2;`
150			`config.dc.store_hitdelay = 0;`
151			`config.dc.store_missdelay = 0;`
152
153			`if (config.dc.enabled)`
154			`{`
155			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_DCP;`
156			`}`
157			`else`
158			`{`
159			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DCP;`
160			`}`
161
162			`set_bits = log2_int (config.dc.nsets);`
163			`cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCS;`
164			`cpu_state.sprs[SPR_DCCFGR] \|= set_bits << SPR_DCCFGR_NCS_OFF;`
165
166			`way_bits = log2_int (config.dc.nways);`
167			`cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCW;`
168			`cpu_state.sprs[SPR_DCCFGR] \|= way_bits << SPR_DCCFGR_NCW_OFF;`
169
170			`if (MIN_DC_BLOCK_SIZE == config.dc.blocksize)`
171			`{`
172			`cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_CBS;`
173			`}`
174			`else`
175			`{`
176			`cpu_state.sprs[SPR_DCCFGR] \|= SPR_DCCFGR_CBS;`
177			`}`
178
179			`/* Power management */`
180			`config.pm.enabled = 0;`
181
182			`if (config.pm.enabled)`
183			`{`
184			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_PMP;`
185			`}`
186			`else`
187			`{`
188			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PMP;`
189			`}`
190
191			`/* Programmable Interrupt Controller */`
192			`config.pic.enabled = 0;`
193			`config.pic.edge_trigger = 1;`
194
195			`if (config.pic.enabled)`
196			`{`
197			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_PICP;`
198			`}`
199			`else`
200			`{`
201			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PICP;`
202			`}`
203
204			`/* Branch Prediction */`
205			`config.bpb.enabled = 0;`
206			`config.bpb.btic = 0;`
207			`config.bpb.sbp_bnf_fwd = 0;`
208			`config.bpb.sbp_bf_fwd = 0;`
209			`config.bpb.missdelay = 0;`
210			`config.bpb.hitdelay = 0;`
211
212	645	markom	`/* Debug */`
213	1743	jeremybenn	`config.debug.enabled = 0;`
214	645	markom	`config.debug.gdb_enabled = 0;`
215	1751	jeremybenn	`config.debug.rsp_enabled = 0;`
216	1748	jeremybenn	`config.debug.server_port = 51000;`
217	1751	jeremybenn	`config.debug.rsp_port = 51000;`
218	1748	jeremybenn	`config.debug.vapi_id = 0;`
219	1743	jeremybenn
220	1748	jeremybenn	`cpu_state.sprs[SPR_DCFGR] = SPR_DCFGR_WPCI \|`
221			`MATCHPOINTS_TO_NDP (MAX_MATCHPOINTS);`
222	897	markom
223	1748	jeremybenn	`if (config.debug.enabled)`
224			`{`
225			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_DUP;`
226			`}`
227			`else`
228			`{`
229			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DUP;`
230			`}`
231	970	simons
232	645	markom	`/* Configure runtime */`
233	1748	jeremybenn	`memset (&runtime, 0, sizeof (runtime));`
234
235	645	markom	`/* Sim */`
236	1748	jeremybenn	`runtime.sim.fexe_log = NULL;`
237			`runtime.sim.iprompt = 0;`
238			`runtime.sim.fprof = NULL;`
239			`runtime.sim.fmprof = NULL;`
240			`runtime.sim.fout = stdout;`
241	645	markom
242			`/* VAPI */`
243			`runtime.vapi.vapi_file = NULL;`
244	1748	jeremybenn	`runtime.vapi.enabled = 0;`
245	645	markom
246	1748	jeremybenn	`} /* init_defconfig() */`
247
248
249			`/---------------------------------------------------------------------------/`
250			`/*! Parse the arguments for the standalone simulator`
251
252			`Updated by Jeremy Bennett to use argtable2.`
253
254			`@param[in] argc Number of command args`
255			`@param[in] argv Vector of the command args`
256
257			`@return 0 on success, 1 on failure */`
258			`/---------------------------------------------------------------------------/`
259			`int`
260			`parse_args (int argc, char *argv[])`
261	1557	nogj	`{`
262	1748	jeremybenn	`struct arg_lit *vercop;`
263			`struct arg_lit *help;`
264			`struct arg_file *cfg_file;`
265			`struct arg_lit *nosrv;`
266			`struct arg_int *srv;`
267			`struct arg_str *dbg;`
268			`struct arg_lit *command;`
269			`struct arg_lit *profile;`
270			`struct arg_lit *mprofile;`
271			`struct arg_file *load_file;`
272			`struct arg_end *end;`
273	1557	nogj
274	1748	jeremybenn	`void *argtab[11];`
275			`int nerrors;`
276
277			`/* Specify each argument, with fall back values */`
278			`vercop = arg_lit0 ("v", "version", "version and copyright notice");`
279			`help = arg_lit0 ("h", "help", "print this help message");`
280			`cfg_file = arg_file0 ("f", "file", "<file>",`
281			`"config file (default \"sim.cfg\")");`
282			`cfg_file->filename[0] = "sim.cfg";`
283			`nosrv = arg_lit0 (NULL, "nosrv", "do not launch JTAG proxy server");`
284			`srv = arg_int0 (NULL, "srv", "<n>", "port number (default random)");`
285			`srv->ival[0] = rand () % (65536 - 49152) + 49152;`
286			`srv->hdr.flag \|= ARG_HASOPTVALUE;`
287			`dbg = arg_str0 ("d", "debug-config", "<str>", "Debug config string");`
288			`command = arg_lit0 ("i", "interactive", "launch interactive prompt");`
289			`profile = arg_lit0 (NULL, "enable-profile", "enable profiling");`
290			`mprofile = arg_lit0 (NULL, "enable-mprofile", "enable memory profiling");`
291			`load_file = arg_file0 (NULL, NULL, "<file>", "OR32 executable");`
292			`end = arg_end (20);`
293
294			`/* Set up the argument table */`
295			`argtab[0] = vercop;`
296			`argtab[1] = help;`
297			`argtab[2] = cfg_file;`
298			`argtab[3] = nosrv;`
299			`argtab[4] = srv;`
300			`argtab[5] = dbg, argtab[6] = command;`
301			`argtab[7] = profile;`
302			`argtab[8] = mprofile;`
303			`argtab[9] = load_file;`
304			`argtab[10] = end;`
305
306			`/* Parse */`
307			`nerrors = arg_parse (argc, argv, argtab);`
308
309			`/* Special case here is if help or version is specified, we ignore any other`
310			`errors and just print the help or version information and then give up. */`
311			`if (vercop->count > 0)`
312			`{`
313			`PRINTF ("OpenRISC 1000 Architectural Simulator, version %s\n",`
314			`PACKAGE_VERSION);`
315
316			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
317			`return 1;`
318			`}`
319
320			`if (help->count > 0)`
321			`{`
322			`printf ("Usage:\n %s ", argv[0]);`
323			`arg_print_syntax (stdout, argtab, "\n\n");`
324			`arg_print_glossary (stdout, argtab, " %-25s %s\n");`
325
326			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
327			`return 1;`
328			`}`
329
330			`/* Deal with any errors */`
331			`if (0 != nerrors)`
332			`{`
333			`arg_print_errors (stderr, end, "or1ksim");`
334			`printf ("\nUsage:\n %s ", argv[0]);`
335			`arg_print_syntaxv (stderr, argtab, "\n");`
336
337			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
338			`return 1;`
339			`}`
340
341			`/* Process config file next, so any other command args will override */`
342			`if (0 == cfg_file->count)`
343			`{`
344			`fprintf (stderr,`
345	1751	jeremybenn	`"Warning: No config file given, default configuration used\n");`
346	1748	jeremybenn	`}`
347
348			`read_script_file (cfg_file->filename[0]);`
349
350
351			`/* Remote debug server */`
352			`if (nosrv->count > 0)`
353			`{`
354			`if (srv->count > 0)`
355			`{`
356			`fprintf (stderr,`
357			`"%s: cannot specify --nosrv with --srv. Ignoring --nosrv\n",`
358			`argv[0]);`
359			`}`
360			`else`
361			`{`
362			`config.debug.enabled = 0;`
363			`config.debug.gdb_enabled = 0;`
364			`}`
365			`}`
366
367			`if (srv->count > 0)`
368			`{`
369	645	markom	`config.debug.enabled = 1;`
370	1205	phoenix	`config.debug.gdb_enabled = 1;`
371	1748	jeremybenn	`config.debug.server_port = srv->ival[0];`
372	645	markom	`}`
373
374	1748	jeremybenn	`/* Runtime debug messages */`
375			`if (dbg->count > 0)`
376			`{`
377			`parse_dbchs (dbg->sval[0]);`
378			`}`
379
380			`/* Interactive operation */`
381			`runtime.sim.iprompt = command->count;`
382
383			`/* Profiling requests */`
384			`config.sim.profile = profile->count;`
385			`config.sim.mprofile = mprofile->count;`
386
387			`/* Executable file */`
388			`if (load_file->count > 0)`
389			`{`
390			`runtime.sim.filename = strdup (load_file->filename[0]);`
391			`}`
392			`else`
393			`{`
394			`runtime.sim.filename = NULL;`
395			`}`
396
397			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
398			`return 0; /* Success */`
399
400			`} /* parse_args() */`
401
402
403			`/---------------------------------------------------------------------------/`
404			`/!Print the current configuration /`
405			`/---------------------------------------------------------------------------/`
406			`void`
407			`print_config ()`
408	645	markom	`{`
409	1748	jeremybenn	`if (config.sim.verbose)`
410			`{`
411			`char temp[20];`
412			`PRINTF ("Verbose on, ");`
413			`if (config.sim.debug)`
414			`PRINTF ("simdebug on, ");`
415			`else`
416			`PRINTF ("simdebug off, ");`
417			`if (runtime.sim.iprompt)`
418			`PRINTF ("interactive prompt on\n");`
419			`else`
420			`PRINTF ("interactive prompt off\n");`
421
422			`PRINTF ("Machine initialization...\n");`
423			`generate_time_pretty (temp, config.sim.clkcycle_ps);`
424			`PRINTF ("Clock cycle: %s\n", temp);`
425			`if (cpu_state.sprs[SPR_UPR] & SPR_UPR_DCP)`
426			`PRINTF ("Data cache present.\n");`
427			`else`
428			`PRINTF ("No data cache.\n");`
429			`if (cpu_state.sprs[SPR_UPR] & SPR_UPR_ICP)`
430			`PRINTF ("Insn cache tag present.\n");`
431			`else`
432			`PRINTF ("No instruction cache.\n");`
433			`if (config.bpb.enabled)`
434			`PRINTF ("BPB simulation on.\n");`
435			`else`
436			`PRINTF ("BPB simulation off.\n");`
437			`if (config.bpb.btic)`
438			`PRINTF ("BTIC simulation on.\n");`
439			`else`
440			`PRINTF ("BTIC simulation off.\n");`
441			`}`
442	645	markom	`}`
443
444	1748	jeremybenn	`struct config_param`
445			`{`
446	1358	nogj	`char *name;`
447			`enum param_t type;`
448	1748	jeremybenn	`void (func) (union param_val, void dat);`
449	1358	nogj	`struct config_param *next;`
450	645	markom	`};`
451
452	1748	jeremybenn	`void`
453			`base_include (union param_val val, void *dat)`
454			`{`
455	1358	nogj	`read_script_file (val.str_val);`
456			`cur_section = NULL;`
457			`}`
458	645	markom
459	1748	jeremybenn	`/---------------------------------------------[ Simulator configuration ]---/`
460	645	markom
461	1748	jeremybenn
462			`void`
463			`sim_verbose (union param_val val, void *dat)`
464			`{`
465	1358	nogj	`config.sim.verbose = val.int_val;`
466			`}`
467	645	markom
468	1748	jeremybenn
469			`/---------------------------------------------------------------------------/`
470			`/*!Set the simulator debug message level`
471
472			`Value must be in the range 0 (no messages) to 9. Values outside this range`
473			`are converted to the nearer end of the range with a warning.`
474
475			`@param[in] val The value to use`
476			`@param[in] dat The config data structure (not used here) */`
477			`/---------------------------------------------------------------------------/`
478			`void`
479			`sim_debug (union param_val val,`
480			`void *dat)`
481			`{`
482			`if (val.int_val < 0)`
483			`{`
484	1751	jeremybenn	`fprintf (stderr,`
485			`"Warning: Config debug value negative: 0 substituted\n");`
486	1748	jeremybenn	`config.sim.debug = 0;`
487			`}`
488			`else if (val.int_val > 9)`
489			`{`
490	1751	jeremybenn	`fprintf (stderr,`
491			`"Warning: Config debug value too large: 9 substituted\n");`
492	1748	jeremybenn	`config.sim.debug = 9;`
493			`}`
494			`else`
495			`{`
496			`config.sim.debug = val.int_val;`
497			`}`
498			`} /* sim_debug() */`
499
500

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [rel-0-3-0-rc2/] [or1ksim/] [sim-config.c] - Blame information for rev 1765