sim/example-synacor/interp.c

   1 /* Example synacor simulator.
   2
   3    Copyright (C) 2005-2021 Free Software Foundation, Inc.
   4    Contributed by Mike Frysinger.
   5
   6    This file is part of simulators.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /* This file contains the main glue logic between the sim core and the target
  22    specific simulator.  Normally this file will be kept small and the target
  23    details will live in other files.
  24
  25    For more specific details on these functions, see the sim/sim.h header
  26    file.  */
  27
  28 /* This must come before any other includes.  */
  29 #include "defs.h"
  30
  31 #include "sim-main.h"
  32 #include "sim-options.h"
  33 \f
  34 /* This function is the main loop.  It should process ticks and decode+execute
  35    a single instruction.
  36
  37    Usually you do not need to change things here.  */
  38
  39 void
  40 sim_engine_run (SIM_DESC sd,
  41                 int next_cpu_nr, /* ignore  */
  42                 int nr_cpus, /* ignore  */
  43                 int siggnal) /* ignore  */
  44 {
  45   SIM_CPU *cpu;
  46
  47   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  48
  49   cpu = STATE_CPU (sd, 0);
  50
  51   while (1)
  52     {
  53       step_once (cpu);
  54       if (sim_events_tick (sd))
  55         sim_events_process (sd);
  56     }
  57 }
  58 \f
  59 /* Initialize the simulator from scratch.  This is called once per lifetime of
  60    the simulation.  Think of it as a processor reset.
  61
  62    Usually all cpu-specific setup is handled in the initialize_cpu callback.
  63    If you want to do cpu-independent stuff, then it should go at the end (see
  64    where memory is initialized).  */
  65
  66 #define DEFAULT_MEM_SIZE (16 * 1024 * 1024)
  67
  68 static void
  69 free_state (SIM_DESC sd)
  70 {
  71   if (STATE_MODULES (sd) != NULL)
  72     sim_module_uninstall (sd);
  73   sim_cpu_free_all (sd);
  74   sim_state_free (sd);
  75 }
  76
  77 SIM_DESC
  78 sim_open (SIM_OPEN_KIND kind, host_callback *callback,
  79           struct bfd *abfd, char * const *argv)
  80 {
  81   char c;
  82   int i;
  83   SIM_DESC sd = sim_state_alloc (kind, callback);
  84
  85   /* Set default options before parsing user options.  */
  86   current_alignment = STRICT_ALIGNMENT;
  87   current_target_byte_order = BFD_ENDIAN_LITTLE;
  88
  89   /* The cpu data is kept in a separately allocated chunk of memory.  */
  90   if (sim_cpu_alloc_all (sd, 1) != SIM_RC_OK)
  91     {
  92       free_state (sd);
  93       return 0;
  94     }
  95
  96   if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
  97     {
  98       free_state (sd);
  99       return 0;
 100     }
 101
 102   /* XXX: Default to the Virtual environment.  */
 103   if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
 104     STATE_ENVIRONMENT (sd) = VIRTUAL_ENVIRONMENT;
 105
 106   /* The parser will print an error message for us, so we silently return.  */
 107   if (sim_parse_args (sd, argv) != SIM_RC_OK)
 108     {
 109       free_state (sd);
 110       return 0;
 111     }
 112
 113   /* Check for/establish the a reference program image.  */
 114   if (sim_analyze_program (sd,
 115                            (STATE_PROG_ARGV (sd) != NULL
 116                             ? *STATE_PROG_ARGV (sd)
 117                             : NULL), abfd) != SIM_RC_OK)
 118     {
 119       free_state (sd);
 120       return 0;
 121     }
 122
 123   /* Establish any remaining configuration options.  */
 124   if (sim_config (sd) != SIM_RC_OK)
 125     {
 126       free_state (sd);
 127       return 0;
 128     }
 129
 130   if (sim_post_argv_init (sd) != SIM_RC_OK)
 131     {
 132       free_state (sd);
 133       return 0;
 134     }
 135
 136   /* CPU specific initialization.  */
 137   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 138     {
 139       SIM_CPU *cpu = STATE_CPU (sd, i);
 140
 141       initialize_cpu (sd, cpu);
 142     }
 143
 144   /* Allocate external memory if none specified by user.
 145      Use address 4 here in case the user wanted address 0 unmapped.  */
 146   if (sim_core_read_buffer (sd, NULL, read_map, &c, 4, 1) == 0)
 147     sim_do_commandf (sd, "memory-size %#x", DEFAULT_MEM_SIZE);
 148
 149   return sd;
 150 }
 151 \f
 152 /* Prepare to run a program that has already been loaded into memory.
 153
 154    Usually you do not need to change things here.  */
 155
 156 SIM_RC
 157 sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
 158                      char * const *argv, char * const *env)
 159 {
 160   SIM_CPU *cpu = STATE_CPU (sd, 0);
 161   sim_cia addr;
 162
 163   /* Set the PC.  */
 164   if (abfd != NULL)
 165     addr = bfd_get_start_address (abfd);
 166   else
 167     addr = 0;
 168   sim_pc_set (cpu, addr);
 169
 170   /* Standalone mode (i.e. `run`) will take care of the argv for us in
 171      sim_open() -> sim_parse_args().  But in debug mode (i.e. 'target sim'
 172      with `gdb`), we need to handle it because the user can change the
 173      argv on the fly via gdb's 'run'.  */
 174   if (STATE_PROG_ARGV (sd) != argv)
 175     {
 176       freeargv (STATE_PROG_ARGV (sd));
 177       STATE_PROG_ARGV (sd) = dupargv (argv);
 178     }
 179
 180   return SIM_RC_OK;
 181 }