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

Subversion Repositories or1k

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

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-1997, 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 <stdarg.h>
23
#include <stdio.h>
24
#include <fcntl.h>
25
 
26
#include <signal.h>
27
 
28
#include "psim.h"
29
#include "options.h"
30
#include "device.h" /* FIXME: psim should provide the interface */
31
#include "events.h" /* FIXME: psim should provide the interface */
32
 
33
#ifdef HAVE_STDLIB_H
34
#include <stdlib.h>
35
#endif
36
 
37
#ifdef HAVE_UNISTD_H
38
#include <unistd.h>
39
#endif
40
 
41
#ifdef HAVE_STRING_H
42
#include <string.h>
43
#else
44
#ifdef HAVE_STRINGS_H
45
#include <strings.h>
46
#endif
47
#endif
48
 
49
#include <errno.h>
50
 
51
#if !defined(O_NDELAY) || !defined(F_GETFL) || !defined(F_SETFL)
52
#undef WITH_STDIO
53
#define WITH_STDIO DO_USE_STDIO
54
#endif
55
 
56
 
57
extern char **environ;
58
 
59
static psim *simulation = NULL;
60
 
61
 
62
void
63
sim_io_poll_quit (void)
64
{
65
  /* nothing to do */
66
}
67
 
68
void
69
sim_io_printf_filtered(const char *msg, ...)
70
{
71
  va_list ap;
72
  va_start(ap, msg);
73
  vprintf(msg, ap);
74
  va_end(ap);
75
}
76
 
77
void
78
error (const char *msg, ...)
79
{
80
  va_list ap;
81
  va_start(ap, msg);
82
  vprintf(msg, ap);
83
  printf("\n");
84
  va_end(ap);
85
 
86
  /* any final clean up */
87
  if (ppc_trace[trace_print_info] && simulation != NULL)
88
    psim_print_info (simulation, ppc_trace[trace_print_info]);
89
 
90
  exit (1);
91
}
92
 
93
int
94
sim_io_write_stdout(const char *buf,
95
                    int sizeof_buf)
96
{
97
  switch (CURRENT_STDIO) {
98
  case DO_USE_STDIO:
99
    {
100
      int i;
101
      for (i = 0; i < sizeof_buf; i++) {
102
        putchar(buf[i]);
103
      }
104
      return i;
105
    }
106
    break;
107
  case DONT_USE_STDIO:
108
    return write(1, buf, sizeof_buf);
109
    break;
110
  default:
111
    error("sim_io_write_stdout: invalid switch\n");
112
  }
113
  return 0;
114
}
115
 
116
int
117
sim_io_write_stderr(const char *buf,
118
                    int sizeof_buf)
119
{
120
  switch (CURRENT_STDIO) {
121
  case DO_USE_STDIO:
122
    {
123
      int i;
124
      for (i = 0; i < sizeof_buf; i++) {
125
        fputc(buf[i], stderr);
126
      }
127
      return i;
128
    }
129
    break;
130
  case DONT_USE_STDIO:
131
    return write(2, buf, sizeof_buf);
132
    break;
133
  default:
134
    error("sim_io_write_stdout: invalid switch\n");
135
  }
136
  return 0;
137
}
138
 
139
int
140
sim_io_read_stdin(char *buf,
141
                  int sizeof_buf)
142
{
143
  switch (CURRENT_STDIO) {
144
  case DO_USE_STDIO:
145
    if (sizeof_buf > 1) {
146
      if (fgets(buf, sizeof_buf, stdin) != NULL)
147
        return strlen(buf);
148
    }
149
    else if (sizeof_buf == 1) {
150
      char b[2];
151
      if (fgets(b, sizeof(b), stdin) != NULL) {
152
        memcpy(buf, b, strlen(b));
153
        return strlen(b);
154
      }
155
    }
156
    else if (sizeof_buf == 0)
157
      return 0;
158
    return sim_io_eof;
159
    break;
160
  case DONT_USE_STDIO:
161
#if defined(O_NDELAY) && defined(F_GETFL) && defined(F_SETFL)
162
    {
163
      /* check for input */
164
      int flags;
165
      int status;
166
      int nr_read;
167
      int result;
168
      /* get the old status */
169
      flags = fcntl(0, F_GETFL, 0);
170
      if (flags == -1) {
171
        perror("sim_io_read_stdin");
172
        return sim_io_eof;
173
      }
174
      /* temp, disable blocking IO */
175
      status = fcntl(0, F_SETFL, flags | O_NDELAY);
176
      if (status == -1) {
177
        perror("sim_io_read_stdin");
178
        return sim_io_eof;
179
      }
180
      /* try for input */
181
      nr_read = read(0, buf, sizeof_buf);
182
      if (nr_read > 0
183
          || (nr_read == 0 && sizeof_buf == 0))
184
        result = nr_read;
185
      else if (nr_read == 0)
186
        result = sim_io_eof;
187
      else { /* nr_read < 0 */
188
        if (errno == EAGAIN)
189
          result = sim_io_not_ready;
190
        else
191
          result = sim_io_eof;
192
      }
193
      /* return to regular vewing */
194
      status = fcntl(0, F_SETFL, flags);
195
      if (status == -1) {
196
        perror("sim_io_read_stdin");
197
        return sim_io_eof;
198
      }
199
      return result;
200
    }
201
    break;
202
#endif
203
  default:
204
    error("sim_io_read_stdin: invalid switch\n");
205
    break;
206
  }
207
  return 0;
208
}
209
 
210
void
211
sim_io_flush_stdoutput(void)
212
{
213
  switch (CURRENT_STDIO) {
214
  case DO_USE_STDIO:
215
    fflush (stdout);
216
    break;
217
  case DONT_USE_STDIO:
218
    break;
219
  default:
220
    error("sim_io_flush_stdoutput: invalid switch\n");
221
    break;
222
  }
223
}
224
 
225
 
226
void *
227
zalloc(long size)
228
{
229
  void *memory = malloc(size);
230
  if (memory == NULL)
231
    error("zmalloc failed\n");
232
  memset(memory, 0, size);
233
  return memory;
234
}
235
 
236
void
237
zfree(void *chunk)
238
{
239
  free(chunk);
240
}
241
 
242
/* When a CNTRL-C occures, queue an event to shut down the simulation */
243
 
244
static RETSIGTYPE
245
cntrl_c(int sig)
246
{
247
  psim_stop (simulation);
248
}
249
 
250
 
251
int
252
main(int argc, char **argv)
253
{
254
  const char *name_of_file;
255
  char *arg_;
256
  psim_status status;
257
  device *root = psim_tree();
258
 
259
  /* parse the arguments */
260
  argv = psim_options(root, argv + 1);
261
  if (argv[0] == NULL) {
262
    if (ppc_trace[trace_opts]) {
263
      print_options ();
264
      return 0;
265
    } else {
266
      psim_usage(0);
267
    }
268
  }
269
  name_of_file = argv[0];
270
 
271
  if (ppc_trace[trace_opts])
272
    print_options ();
273
 
274
  /* create the simulator */
275
  simulation = psim_create(name_of_file, root);
276
 
277
  /* fudge the environment so that _=prog-name */
278
  arg_ = (char*)zalloc(strlen(argv[0]) + strlen("_=") + 1);
279
  strcpy(arg_, "_=");
280
  strcat(arg_, argv[0]);
281
  putenv(arg_);
282
 
283
  /* initialize it */
284
  psim_init(simulation);
285
  psim_stack(simulation, argv, environ);
286
 
287
  {
288
    RETSIGTYPE (*prev) ();
289
    prev = signal(SIGINT, cntrl_c);
290
    psim_run(simulation);
291
    signal(SIGINT, prev);
292
  }
293
 
294
  /* any final clean up */
295
  if (ppc_trace[trace_print_info])
296
    psim_print_info (simulation, ppc_trace[trace_print_info]);
297
 
298
  /* why did we stop */
299
  status = psim_get_status(simulation);
300
  switch (status.reason) {
301
  case was_continuing:
302
    error("psim: continuing while stoped!\n");
303
    return 0;
304
  case was_trap:
305
    error("psim: no trap insn\n");
306
    return 0;
307
  case was_exited:
308
    return status.signal;
309
  case was_signalled:
310
    printf ("%s: Caught signal %d at address 0x%lx\n",
311
            name_of_file, (int)status.signal,
312
            (long)status.program_counter);
313
    return status.signal;
314
  default:
315
    error("unknown halt condition\n");
316
    return 0;
317
  }
318
}

powered by: WebSVN 2.1.0

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