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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [sim/] [ppc/] [sim_calls.c] - Blame information for rev 1771

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

Line No. Rev Author Line
1 106 markom
/*  This file is part of the program psim.
2
 
3
    Copyright (C) 1994-1996,1998, Andrew Cagney <cagney@highland.com.au>
4
 
5
    This program is free software; you can redistribute it and/or modify
6
    it under the terms of the GNU General Public License as published by
7
    the Free Software Foundation; either version 2 of the License, or
8
    (at your option) any later version.
9
 
10
    This program is distributed in the hope that it will be useful,
11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
    GNU General Public License for more details.
14
 
15
    You should have received a copy of the GNU General Public License
16
    along with this program; if not, write to the Free Software
17
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
 
19
    */
20
 
21
 
22
#include <signal.h> /* FIXME - should be machine dependant version */
23
#include <stdarg.h>
24
#include <ctype.h>
25
 
26
#include "psim.h"
27
#include "options.h"
28
 
29
#undef printf_filtered /* blow away the mapping */
30
 
31
#ifdef HAVE_STDLIB_H
32
#include <stdlib.h>
33
#endif
34
 
35
#ifdef HAVE_STRING_H
36
#include <string.h>
37
#else
38
#ifdef HAVE_STRINGS_H
39
#include <strings.h>
40
#endif
41
#endif
42
 
43
#include "defs.h"
44
#include "bfd.h"
45
#include "callback.h"
46
#include "remote-sim.h"
47
 
48
/* Define the rate at which the simulator should poll the host
49
   for a quit. */
50
#ifndef POLL_QUIT_INTERVAL
51
#define POLL_QUIT_INTERVAL 0x20
52
#endif
53
 
54
static int poll_quit_count = POLL_QUIT_INTERVAL;
55
 
56
/* Structures used by the simulator, for gdb just have static structures */
57
 
58
static psim *simulator;
59
static device *root_device;
60
static host_callback *callbacks;
61
 
62
/* We use GDB's reg_names array to map GDB register numbers onto
63
   names, which we can then look up in the register table.
64
 
65
   We used to just use the REGISTER_NAMES macro, from GDB's
66
   target-dependent header files.  That was kind of nice, because it
67
   meant that libsim.a had only a compile-time dependency on GDB;
68
   using reg_names directly means that there are now link-time and
69
   run-time dependencies too.
70
 
71
   However, the GDB PPC back-end now modifies the reg_names array when
72
   the user runs the `set processor' command, which affects the
73
   meanings of the register numbers.  So the sim needs to see the
74
   register names GDB is actually using.
75
 
76
   Perhaps the host_callback structure could contain a pointer to the
77
   register name table; that would be cleaner.  */
78
 
79
SIM_DESC
80
sim_open (SIM_OPEN_KIND kind,
81
          host_callback *callback,
82
          struct _bfd *abfd,
83
          char **argv)
84
{
85
  callbacks = callback;
86
 
87
  /* Note: The simulation is not created by sim_open() because
88
     complete information is not yet available */
89
  /* trace the call */
90
  TRACE(trace_gdb, ("sim_open called\n"));
91
 
92
  if (root_device != NULL)
93
    sim_io_printf_filtered("Warning - re-open of simulator leaks memory\n");
94
  root_device = psim_tree();
95
  simulator = NULL;
96
 
97
  psim_options(root_device, argv + 1);
98
 
99
  if (ppc_trace[trace_opts])
100
    print_options ();
101
 
102
  /* fudge our descriptor for now */
103
  return (SIM_DESC) 1;
104
}
105
 
106
 
107
void
108
sim_close (SIM_DESC sd, int quitting)
109
{
110
  TRACE(trace_gdb, ("sim_close(quitting=%d) called\n", quitting));
111
  if (ppc_trace[trace_print_info] && simulator != NULL)
112
    psim_print_info (simulator, ppc_trace[trace_print_info]);
113
}
114
 
115
 
116
SIM_RC
117
sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty)
118
{
119
  TRACE(trace_gdb, ("sim_load(prog=%s, from_tty=%d) called\n",
120
                    prog, from_tty));
121
  ASSERT(prog != NULL);
122
 
123
  /* create the simulator */
124
  TRACE(trace_gdb, ("sim_load() - first time, create the simulator\n"));
125
  simulator = psim_create(prog, root_device);
126
 
127
  /* bring in all the data section */
128
  psim_init(simulator);
129
 
130
  /* get the start address */
131
  if (abfd == NULL)
132
    {
133
      abfd = bfd_openr (prog, 0);
134
      if (abfd == NULL)
135
        error ("psim: can't open \"%s\": %s\n",
136
               prog, bfd_errmsg (bfd_get_error ()));
137
      if (!bfd_check_format (abfd, bfd_object))
138
        {
139
          const char *errmsg = bfd_errmsg (bfd_get_error ());
140
          bfd_close (abfd);
141
          error ("psim: \"%s\" is not an object file: %s\n",
142
                 prog, errmsg);
143
        }
144
      bfd_close (abfd);
145
    }
146
 
147
  return SIM_RC_OK;
148
}
149
 
150
 
151
int
152
sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
153
{
154
  int result = psim_read_memory(simulator, MAX_NR_PROCESSORS,
155
                                buf, mem, length);
156
  TRACE(trace_gdb, ("sim_read(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
157
                    (long)mem, (long)buf, length, result));
158
  return result;
159
}
160
 
161
 
162
int
163
sim_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
164
{
165
  int result = psim_write_memory(simulator, MAX_NR_PROCESSORS,
166
                                 buf, mem, length,
167
                                 1/*violate_ro*/);
168
  TRACE(trace_gdb, ("sim_write(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
169
                    (long)mem, (long)buf, length, result));
170
  return result;
171
}
172
 
173
 
174
int
175
sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
176
{
177
  char *regname;
178
 
179
  if (simulator == NULL) {
180
    return 0;
181
  }
182
 
183
  /* GDB will sometimes ask for the contents of a register named "";
184
     we ignore such requests, and leave garbage in *BUF.  In
185
     REG_NAMES, the empty string means "the register with this
186
     number is not present in the currently selected architecture
187
     variant."  That's following the kludge we're using for the MIPS
188
     processors.  But there are loops that just walk through the
189
     entire list of names and try to get everything.  */
190
  regname = REGISTER_NAME (regno);
191
  if (! regname || regname[0] == '\0')
192
    return -1;
193
 
194
  TRACE(trace_gdb, ("sim_fetch_register(regno=%d(%s), buf=0x%lx)\n",
195
                    regno, regname, (long)buf));
196
  psim_read_register(simulator, MAX_NR_PROCESSORS,
197
                     buf, regname, raw_transfer);
198
  return -1;
199
}
200
 
201
 
202
int
203
sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
204
{
205
  char *regname;
206
 
207
  if (simulator == NULL)
208
    return 0;
209
 
210
  /* See comments in sim_fetch_register, above.  */
211
  regname = REGISTER_NAME (regno);
212
  if (! regname || regname[0] == '\0')
213
    return -1;
214
 
215
  TRACE(trace_gdb, ("sim_store_register(regno=%d(%s), buf=0x%lx)\n",
216
                    regno, regname, (long)buf));
217
  psim_write_register(simulator, MAX_NR_PROCESSORS,
218
                      buf, regname, raw_transfer);
219
  return -1;
220
}
221
 
222
 
223
void
224
sim_info (SIM_DESC sd, int verbose)
225
{
226
  TRACE(trace_gdb, ("sim_info(verbose=%d) called\n", verbose));
227
  psim_print_info (simulator, verbose);
228
}
229
 
230
 
231
SIM_RC
232
sim_create_inferior (SIM_DESC sd,
233
                     struct _bfd *abfd,
234
                     char **argv,
235
                     char **envp)
236
{
237
  unsigned_word entry_point;
238
  TRACE(trace_gdb, ("sim_create_inferior(start_address=0x%x, ...)\n",
239
                    entry_point));
240
 
241
  if (simulator == NULL)
242
    error ("No program loaded");
243
 
244
  if (abfd != NULL)
245
    entry_point = bfd_get_start_address (abfd);
246
  else
247
    entry_point = 0xfff00000; /* ??? */
248
 
249
  psim_init(simulator);
250
  psim_stack(simulator, argv, envp);
251
 
252
  psim_write_register(simulator, -1 /* all start at same PC */,
253
                      &entry_point, "pc", cooked_transfer);
254
  return SIM_RC_OK;
255
}
256
 
257
 
258
void
259
sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc)
260
{
261
  psim_status status = psim_get_status(simulator);
262
 
263
  switch (status.reason) {
264
  case was_continuing:
265
    *reason = sim_stopped;
266
    if (status.signal == 0)
267
      *sigrc = SIGTRAP;
268
    else
269
      *sigrc = status.signal;
270
    break;
271
  case was_trap:
272
    *reason = sim_stopped;
273
    *sigrc = SIGTRAP;
274
    break;
275
  case was_exited:
276
    *reason = sim_exited;
277
    *sigrc = status.signal;
278
    break;
279
  case was_signalled:
280
    *reason = sim_signalled;
281
    *sigrc = status.signal;
282
    break;
283
  }
284
 
285
  TRACE(trace_gdb, ("sim_stop_reason(reason=0x%lx(%ld), sigrc=0x%lx(%ld))\n",
286
                    (long)reason, (long)*reason, (long)sigrc, (long)*sigrc));
287
}
288
 
289
 
290
 
291
/* Run (or resume) the program.  */
292
 
293
int
294
sim_stop (SIM_DESC sd)
295
{
296
  psim_stop (simulator);
297
  return 1;
298
}
299
 
300
void
301
sim_resume (SIM_DESC sd, int step, int siggnal)
302
{
303
  TRACE(trace_gdb, ("sim_resume(step=%d, siggnal=%d)\n",
304
                    step, siggnal));
305
 
306
  if (step)
307
    {
308
      psim_step (simulator);
309
    }
310
  else
311
    {
312
      psim_run (simulator);
313
    }
314
}
315
 
316
void
317
sim_do_command (SIM_DESC sd, char *cmd)
318
{
319
  TRACE(trace_gdb, ("sim_do_commands(cmd=%s) called\n",
320
                    cmd ? cmd : "(null)"));
321
  if (cmd != NULL) {
322
    char **argv = buildargv(cmd);
323
    psim_command(root_device, argv);
324
    freeargv(argv);
325
  }
326
}
327
 
328
 
329
/* Polling, if required */
330
 
331
void
332
sim_io_poll_quit (void)
333
{
334
  if (callbacks->poll_quit != NULL && poll_quit_count-- < 0)
335
    {
336
      poll_quit_count = POLL_QUIT_INTERVAL;
337
      if (callbacks->poll_quit (callbacks))
338
        psim_stop (simulator);
339
    }
340
}
341
 
342
 
343
 
344
/* Map simulator IO operations onto the corresponding GDB I/O
345
   functions.
346
 
347
   NB: Only a limited subset of operations are mapped across.  More
348
   advanced operations (such as dup or write) must either be mapped to
349
   one of the below calls or handled internally */
350
 
351
int
352
sim_io_read_stdin(char *buf,
353
                  int sizeof_buf)
354
{
355
  switch (CURRENT_STDIO) {
356
  case DO_USE_STDIO:
357
    return callbacks->read_stdin(callbacks, buf, sizeof_buf);
358
    break;
359
  case DONT_USE_STDIO:
360
    return callbacks->read(callbacks, 0, buf, sizeof_buf);
361
    break;
362
  default:
363
    error("sim_io_read_stdin: unaccounted switch\n");
364
    break;
365
  }
366
  return 0;
367
}
368
 
369
int
370
sim_io_write_stdout(const char *buf,
371
                    int sizeof_buf)
372
{
373
  switch (CURRENT_STDIO) {
374
  case DO_USE_STDIO:
375
    return callbacks->write_stdout(callbacks, buf, sizeof_buf);
376
    break;
377
  case DONT_USE_STDIO:
378
    return callbacks->write(callbacks, 1, buf, sizeof_buf);
379
    break;
380
  default:
381
    error("sim_io_write_stdout: unaccounted switch\n");
382
    break;
383
  }
384
  return 0;
385
}
386
 
387
int
388
sim_io_write_stderr(const char *buf,
389
                    int sizeof_buf)
390
{
391
  switch (CURRENT_STDIO) {
392
  case DO_USE_STDIO:
393
    /* NB: I think there should be an explicit write_stderr callback */
394
    return callbacks->write(callbacks, 3, buf, sizeof_buf);
395
    break;
396
  case DONT_USE_STDIO:
397
    return callbacks->write(callbacks, 3, buf, sizeof_buf);
398
    break;
399
  default:
400
    error("sim_io_write_stderr: unaccounted switch\n");
401
    break;
402
  }
403
  return 0;
404
}
405
 
406
 
407
void
408
sim_io_printf_filtered(const char *fmt,
409
                       ...)
410
{
411
  char message[1024];
412
  va_list ap;
413
  /* format the message */
414
  va_start(ap, fmt);
415
  vsprintf(message, fmt, ap);
416
  va_end(ap);
417
  /* sanity check */
418
  if (strlen(message) >= sizeof(message))
419
    error("sim_io_printf_filtered: buffer overflow\n");
420
  callbacks->printf_filtered(callbacks, "%s", message);
421
}
422
 
423
void
424
sim_io_flush_stdoutput(void)
425
{
426
  switch (CURRENT_STDIO) {
427
  case DO_USE_STDIO:
428
    callbacks->flush_stdout (callbacks);
429
    break;
430
  case DONT_USE_STDIO:
431
    break;
432
  default:
433
    error("sim_io_read_stdin: unaccounted switch\n");
434
    break;
435
  }
436
}
437
 
438
/****/
439
 
440
void *
441
zalloc(long size)
442
{
443
  void *memory = (void*)xmalloc(size);
444
  if (memory == NULL)
445
    error("xmalloc failed\n");
446
  memset(memory, 0, size);
447
  return memory;
448
}
449
 
450
void zfree(void *data)
451
{
452
  free(data);
453
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.