1/* Generic simulator halt/restart.
2   Copyright (C) 1997, 1998, 2007 Free Software Foundation, Inc.
3   Contributed by Cygnus Support.
4
5This file is part of GDB, the GNU debugger.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20#include <stdio.h>
21
22#include "sim-main.h"
23#include "sim-assert.h"
24
25/* Get the run state.
26   REASON/SIGRC are the values returned by sim_stop_reason.
27   ??? Should each cpu have its own copy?  */
28
29void
30sim_engine_get_run_state (SIM_DESC sd, enum sim_stop *reason, int *sigrc)
31{
32  sim_engine *engine = STATE_ENGINE (sd);
33  ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
34  *reason = engine->reason;
35  *sigrc = engine->sigrc;
36}
37
38/* Set the run state to REASON/SIGRC.
39   REASON/SIGRC are the values returned by sim_stop_reason.
40   ??? Should each cpu have its own copy?  */
41
42void
43sim_engine_set_run_state (SIM_DESC sd, enum sim_stop reason, int sigrc)
44{
45  sim_engine *engine = STATE_ENGINE (sd);
46  ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
47  engine->reason = reason;
48  engine->sigrc = sigrc;
49}
50
51/* Generic halt */
52
53void
54sim_engine_halt (SIM_DESC sd,
55		 sim_cpu *last_cpu,
56		 sim_cpu *next_cpu, /* NULL - use default */
57		 sim_cia cia,
58		 enum sim_stop reason,
59		 int sigrc)
60{
61  sim_engine *engine = STATE_ENGINE (sd);
62  ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
63  if (engine->jmpbuf != NULL)
64    {
65      jmp_buf *halt_buf = engine->jmpbuf;
66      engine->last_cpu = last_cpu;
67      engine->next_cpu = next_cpu;
68      engine->reason = reason;
69      engine->sigrc = sigrc;
70
71      SIM_ENGINE_HALT_HOOK (sd, last_cpu, cia);
72
73#ifdef SIM_CPU_EXCEPTION_SUSPEND
74      if (last_cpu != NULL && reason != sim_exited)
75	SIM_CPU_EXCEPTION_SUSPEND (sd, last_cpu, sim_signal_to_host (sd, sigrc));
76#endif
77
78      longjmp (*halt_buf, sim_engine_halt_jmpval);
79    }
80  else
81    {
82      sim_io_error (sd, "sim_halt - bad long jump");
83      abort ();
84    }
85}
86
87
88/* Generic restart */
89
90void
91sim_engine_restart (SIM_DESC sd,
92		    sim_cpu *last_cpu,
93		    sim_cpu *next_cpu,
94		    sim_cia cia)
95{
96  sim_engine *engine = STATE_ENGINE (sd);
97  ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
98  if (engine->jmpbuf != NULL)
99    {
100      jmp_buf *halt_buf = engine->jmpbuf;
101      engine->last_cpu = last_cpu;
102      engine->next_cpu = next_cpu;
103      SIM_ENGINE_RESTART_HOOK (sd, last_cpu, cia);
104      longjmp (*halt_buf, sim_engine_restart_jmpval);
105    }
106  else
107    sim_io_error (sd, "sim_restart - bad long jump");
108}
109
110
111/* Generic error code */
112
113void
114sim_engine_vabort (SIM_DESC sd,
115		   sim_cpu *cpu,
116		   sim_cia cia,
117		   const char *fmt,
118		   va_list ap)
119{
120  ASSERT (sd == NULL || STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
121  if (sd == NULL)
122    {
123      vfprintf (stderr, fmt, ap);
124      fprintf (stderr, "\nQuit\n");
125      abort ();
126    }
127  else if (STATE_ENGINE (sd)->jmpbuf == NULL)
128    {
129      sim_io_evprintf (sd, fmt, ap);
130      sim_io_eprintf (sd, "\n");
131      sim_io_error (sd, "Quit Simulator");
132      abort ();
133    }
134  else
135    {
136      sim_io_evprintf (sd, fmt, ap);
137      sim_io_eprintf (sd, "\n");
138      sim_engine_halt (sd, cpu, NULL, cia, sim_stopped, SIM_SIGABRT);
139    }
140}
141
142void
143sim_engine_abort (SIM_DESC sd,
144		  sim_cpu *cpu,
145		  sim_cia cia,
146		  const char *fmt,
147		  ...)
148{
149  va_list ap;
150  ASSERT (sd == NULL || STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
151  va_start(ap, fmt);
152  sim_engine_vabort (sd, cpu, cia, fmt, ap);
153  va_end (ap);
154}
155
156
157/* Generic next/last cpu */
158
159int
160sim_engine_last_cpu_nr (SIM_DESC sd)
161{
162  sim_engine *engine = STATE_ENGINE (sd);
163  if (engine->last_cpu != NULL)
164    return engine->last_cpu - STATE_CPU (sd, 0);
165  else
166    return MAX_NR_PROCESSORS;
167}
168
169int
170sim_engine_next_cpu_nr (SIM_DESC sd)
171{
172  sim_engine *engine = STATE_ENGINE (sd);
173  if (engine->next_cpu != NULL)
174    return engine->next_cpu - STATE_CPU (sd, 0);
175  else
176    return sim_engine_last_cpu_nr (sd) + 1;
177}
178
179int
180sim_engine_nr_cpus (SIM_DESC sd)
181{
182  sim_engine *engine = STATE_ENGINE (sd);
183  return engine->nr_cpus;
184}
185
186
187
188
189/* Initialization */
190
191static SIM_RC
192sim_engine_init (SIM_DESC sd)
193{
194  /* initialize the start/stop/resume engine */
195  sim_engine *engine = STATE_ENGINE (sd);
196  engine->jmpbuf = NULL;
197  engine->last_cpu = NULL;
198  engine->next_cpu = NULL;
199  engine->nr_cpus = MAX_NR_PROCESSORS;
200  engine->reason = sim_running;
201  engine->sigrc = 0;
202  engine->stepper = NULL; /* sim_events_init will clean it up */
203  return SIM_RC_OK;
204}
205
206
207SIM_RC
208sim_engine_install (SIM_DESC sd)
209{
210  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
211  sim_module_add_init_fn (sd, sim_engine_init);
212  return SIM_RC_OK;
213}
214