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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [standalone.c] - Blame information for rev 1774

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

Line No. Rev Author Line
1 578 markom
/* Interface to bare machine for GDB running as kernel debugger.
2
   Copyright 1986, 1989, 1991, 1992, 1993, 1995, 1996, 2000, 2001
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include <stdio.h>
23
#include <sys/ioctl.h>
24
#include <errno.h>
25
#include <sys/types.h>
26
#include "gdb_stat.h"
27
 
28
#if defined (SIGTSTP) && defined (SIGIO)
29
#include <sys/time.h>
30
#include <sys/resource.h>
31
#endif /* SIGTSTP and SIGIO defined (must be 4.2) */
32
 
33
#include "defs.h"
34
#include <signal.h>
35
#include "symtab.h"
36
#include "frame.h"
37
#include "inferior.h"
38
#include "gdb_wait.h"
39
 
40
 
41
/* Random system calls, mostly no-ops to prevent link problems  */
42
 
43
ioctl (int desc, int code, int arg)
44
{
45
}
46
 
47
int (*signal ()) ()
48
{
49
}
50
 
51
kill (void)
52
{
53
}
54
 
55
getpid (void)
56
{
57
  return 0;
58
}
59
 
60
sigsetmask (void)
61
{
62
}
63
 
64
chdir (void)
65
{
66
}
67
 
68
char *
69
getcwd (char *buf, unsigned int len)
70
{
71
  buf[0] = '/';
72
  buf[1] = 0;
73
  return buf;
74
}
75
 
76
/* Used to check for existence of .gdbinit.  Say no.  */
77
 
78
access (void)
79
{
80
  return -1;
81
}
82
 
83
exit (void)
84
{
85
  error ("Fatal error; restarting.");
86
}
87
 
88
/* Reading "files".  The contents of some files are written into kdb's
89
   data area before it is run.  These files are used to contain the
90
   symbol table for kdb to load, and the source files (in case the
91
   kdb user wants to print them).  The symbols are stored in a file
92
   named "kdb-symbols" in a.out format (except that all the text and
93
   data have been stripped to save room).
94
 
95
   The files are stored in the following format:
96
   int     number of bytes of data for this file, including these four.
97
   char[]  name of the file, ending with a null.
98
   padding to multiple of 4 boundary.
99
   char[]  file contents.  The length can be deduced from what was
100
   specified before.  There is no terminating null here.
101
 
102
   If the int at the front is zero, it means there are no more files.
103
 
104
   Opening a file in kdb returns a nonzero value to indicate success,
105
   but the value does not matter.  Only one file can be open, and only
106
   for reading.  All the primitives for input from the file know
107
   which file is open and ignore what is specified for the descriptor
108
   or for the stdio stream.
109
 
110
   Input with fgetc can be done either on the file that is open
111
   or on stdin (which reads from the terminal through tty_input ()  */
112
 
113
/* Address of data for the files stored in format described above.  */
114
char *files_start;
115
 
116
/* The file stream currently open:  */
117
 
118
char *sourcebeg;                /* beginning of contents */
119
int sourcesize;                 /* size of contents */
120
char *sourceptr;                /* current read pointer */
121
int sourceleft;                 /* number of bytes to eof */
122
 
123
/* "descriptor" for the file now open.
124
   Incremented at each close.
125
   If specified descriptor does not match this,
126
   it means the program is trying to use a closed descriptor.
127
   We report an error for that.  */
128
 
129
int sourcedesc;
130
 
131
open (char *filename, int modes)
132
{
133
  register char *next;
134
 
135
  if (modes)
136
    {
137
      errno = EROFS;
138
      return -1;
139
    }
140
 
141
  if (sourceptr)
142
    {
143
      errno = EMFILE;
144
      return -1;
145
    }
146
 
147
  for (next = files_start; *(int *) next; next += *(int *) next)
148
    {
149
      if (!strcmp (next + 4, filename))
150
        {
151
          sourcebeg = next + 4 + strlen (next + 4) + 1;
152
          sourcebeg = (char *) (((int) sourcebeg + 3) & (-4));
153
          sourceptr = sourcebeg;
154
          sourcesize = next + *(int *) next - sourceptr;
155
          sourceleft = sourcesize;
156
          return sourcedesc;
157
        }
158
    }
159
  return 0;
160
}
161
 
162
close (int desc)
163
{
164
  sourceptr = 0;
165
  sourcedesc++;
166
  /* Don't let sourcedesc get big enough to be confused with stdin.  */
167
  if (sourcedesc == 100)
168
    sourcedesc = 5;
169
}
170
 
171
FILE *
172
fopen (char *filename, char *modes)
173
{
174
  return (FILE *) open (filename, *modes == 'w');
175
}
176
 
177
FILE *
178
fdopen (int desc)
179
{
180
  return (FILE *) desc;
181
}
182
 
183
fclose (int desc)
184
{
185
  close (desc);
186
}
187
 
188
fstat (int desc, struct stat *statbuf)
189
{
190
  if (desc != sourcedesc)
191
    {
192
      errno = EBADF;
193
      return -1;
194
    }
195
  statbuf->st_size = sourcesize;
196
}
197
 
198
myread (int desc, char *destptr, int size, char *filename)
199
{
200
  int len = min (sourceleft, size);
201
 
202
  if (desc != sourcedesc)
203
    {
204
      errno = EBADF;
205
      return -1;
206
    }
207
 
208
  memcpy (destptr, sourceptr, len);
209
  sourceleft -= len;
210
  return len;
211
}
212
 
213
int
214
fread (int bufp, int numelts, int eltsize, int stream)
215
{
216
  register int elts = min (numelts, sourceleft / eltsize);
217
  register int len = elts * eltsize;
218
 
219
  if (stream != sourcedesc)
220
    {
221
      errno = EBADF;
222
      return -1;
223
    }
224
 
225
  memcpy (bufp, sourceptr, len);
226
  sourceleft -= len;
227
  return elts;
228
}
229
 
230
int
231
fgetc (int desc)
232
{
233
 
234
  if (desc == (int) stdin)
235
    return tty_input ();
236
 
237
  if (desc != sourcedesc)
238
    {
239
      errno = EBADF;
240
      return -1;
241
    }
242
 
243
  if (sourceleft-- <= 0)
244
    return EOF;
245
  return *sourceptr++;
246
}
247
 
248
lseek (int desc, int pos)
249
{
250
 
251
  if (desc != sourcedesc)
252
    {
253
      errno = EBADF;
254
      return -1;
255
    }
256
 
257
  if (pos < 0 || pos > sourcesize)
258
    {
259
      errno = EINVAL;
260
      return -1;
261
    }
262
 
263
  sourceptr = sourcebeg + pos;
264
  sourceleft = sourcesize - pos;
265
}
266
 
267
/* Output in kdb can go only to the terminal, so the stream
268
   specified may be ignored.  */
269
 
270
printf (int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9)
271
{
272
  char buffer[1024];
273
  sprintf (buffer, a1, a2, a3, a4, a5, a6, a7, a8, a9);
274
  display_string (buffer);
275
}
276
 
277
fprintf (int ign, int a1, int a2, int a3, int a4, int a5, int a6, int a7,
278
         int a8, int a9)
279
{
280
  char buffer[1024];
281
  sprintf (buffer, a1, a2, a3, a4, a5, a6, a7, a8, a9);
282
  display_string (buffer);
283
}
284
 
285
fwrite (register char *buf, int numelts, int size, int stream)
286
{
287
  register int i = numelts * size;
288
  while (i-- > 0)
289
    fputc (*buf++, stream);
290
}
291
 
292
fputc (int c, int ign)
293
{
294
  char buf[2];
295
  buf[0] = c;
296
  buf[1] = 0;
297
  display_string (buf);
298
}
299
 
300
/* sprintf refers to this, but loading this from the
301
   library would cause fflush to be loaded from it too.
302
   In fact there should be no need to call this (I hope).  */
303
 
304
_flsbuf (void)
305
{
306
  error ("_flsbuf was actually called.");
307
}
308
 
309
fflush (int ign)
310
{
311
}
312
 
313
/* Entries into core and inflow, needed only to make things link ok.  */
314
 
315
exec_file_command (void)
316
{
317
}
318
 
319
core_file_command (void)
320
{
321
}
322
 
323
char *
324
get_exec_file (int err)
325
{
326
  /* Makes one printout look reasonable; value does not matter otherwise.  */
327
  return "run";
328
}
329
 
330
/* Nonzero if there is a core file.  */
331
 
332
have_core_file_p (void)
333
{
334
  return 0;
335
}
336
 
337
kill_command (void)
338
{
339
  inferior_ptid = null_ptid;
340
}
341
 
342
terminal_inferior (void)
343
{
344
}
345
 
346
terminal_ours (void)
347
{
348
}
349
 
350
terminal_init_inferior (void)
351
{
352
}
353
 
354
write_inferior_register (void)
355
{
356
}
357
 
358
read_inferior_register (void)
359
{
360
}
361
 
362
read_memory (CORE_ADDR memaddr, char *myaddr, int len)
363
{
364
  memcpy (myaddr, memaddr, len);
365
}
366
 
367
/* Always return 0 indicating success.  */
368
 
369
write_memory (CORE_ADDR memaddr, char *myaddr, int len)
370
{
371
  memcpy (memaddr, myaddr, len);
372
  return 0;
373
}
374
 
375
static REGISTER_TYPE saved_regs[NUM_REGS];
376
 
377
REGISTER_TYPE
378
read_register (int regno)
379
{
380
  if (regno < 0 || regno >= NUM_REGS)
381
    error ("Register number %d out of range.", regno);
382
  return saved_regs[regno];
383
}
384
 
385
void
386
write_register (int regno, REGISTER_TYPE value)
387
{
388
  if (regno < 0 || regno >= NUM_REGS)
389
    error ("Register number %d out of range.", regno);
390
  saved_regs[regno] = value;
391
}
392
 
393
/* System calls needed in relation to running the "inferior".  */
394
 
395
vfork (void)
396
{
397
  /* Just appear to "succeed".  Say the inferior's pid is 1.  */
398
  return 1;
399
}
400
 
401
/* These are called by code that normally runs in the inferior
402
   that has just been forked.  That code never runs, when standalone,
403
   and these definitions are so it will link without errors.  */
404
 
405
ptrace (void)
406
{
407
}
408
 
409
setpgrp (void)
410
{
411
}
412
 
413
execle (void)
414
{
415
}
416
 
417
_exit (void)
418
{
419
}
420
 
421
/* Malloc calls these.  */
422
 
423
malloc_warning (char *str)
424
{
425
  printf ("\n%s.\n\n", str);
426
}
427
 
428
char *next_free;
429
char *memory_limit;
430
 
431
char *
432
sbrk (int amount)
433
{
434
  if (next_free + amount > memory_limit)
435
    return (char *) -1;
436
  next_free += amount;
437
  return next_free - amount;
438
}
439
 
440
/* Various ways malloc might ask where end of memory is.  */
441
 
442
char *
443
ulimit (void)
444
{
445
  return memory_limit;
446
}
447
 
448
int
449
vlimit (void)
450
{
451
  return memory_limit - next_free;
452
}
453
 
454
getrlimit (struct rlimit *addr)
455
{
456
  addr->rlim_cur = memory_limit - next_free;
457
}
458
 
459
/* Context switching to and from program being debugged.  */
460
 
461
/* GDB calls here to run the user program.
462
   The frame pointer for this function is saved in
463
   gdb_stack by save_frame_pointer; then we restore
464
   all of the user program's registers, including PC and PS.  */
465
 
466
static int fault_code;
467
static REGISTER_TYPE gdb_stack;
468
 
469
resume (void)
470
{
471
  REGISTER_TYPE restore[NUM_REGS];
472
 
473
  PUSH_FRAME_PTR;
474
  save_frame_pointer ();
475
 
476
  memcpy (restore, saved_regs, sizeof restore);
477
  POP_REGISTERS;
478
  /* Control does not drop through here!  */
479
}
480
 
481
save_frame_pointer (CORE_ADDR val)
482
{
483
  gdb_stack = val;
484
}
485
 
486
/* Fault handlers call here, running in the user program stack.
487
   They must first push a fault code,
488
   old PC, old PS, and any other info about the fault.
489
   The exact format is machine-dependent and is known only
490
   in the definition of PUSH_REGISTERS.  */
491
 
492
fault (void)
493
{
494
  /* Transfer all registers and fault code to the stack
495
     in canonical order: registers in order of GDB register number,
496
     followed by fault code.  */
497
  PUSH_REGISTERS;
498
 
499
  /* Transfer them to saved_regs and fault_code.  */
500
  save_registers ();
501
 
502
  restore_gdb ();
503
  /* Control does not reach here */
504
}
505
 
506
restore_gdb (void)
507
{
508
  CORE_ADDR new_fp = gdb_stack;
509
  /* Switch to GDB's stack  */
510
  POP_FRAME_PTR;
511
  /* Return from the function `resume'.  */
512
}
513
 
514
/* Assuming register contents and fault code have been pushed on the stack as
515
   arguments to this function, copy them into the standard place
516
   for the program's registers while GDB is running.  */
517
 
518
save_registers (int firstreg)
519
{
520
  memcpy (saved_regs, &firstreg, sizeof saved_regs);
521
  fault_code = (&firstreg)[NUM_REGS];
522
}
523
 
524
/* Store into the structure such as `wait' would return
525
   the information on why the program faulted,
526
   converted into a machine-independent signal number.  */
527
 
528
static int fault_table[] = FAULT_TABLE;
529
 
530
int
531
wait (WAITTYPE *w)
532
{
533
  WSETSTOP (*w, fault_table[fault_code / FAULT_CODE_UNITS]);
534
  return PIDGET (inferior_ptid);
535
}
536
 
537
/* Allocate a big space in which files for kdb to read will be stored.
538
   Whatever is left is where malloc can allocate storage.
539
 
540
   Initialize it, so that there will be space in the executable file
541
   for it.  Then the files can be put into kdb by writing them into
542
   kdb's executable file.  */
543
 
544
/* The default size is as much space as we expect to be available
545
   for kdb to use!  */
546
 
547
#ifndef HEAP_SIZE
548
#define HEAP_SIZE 400000
549
#endif
550
 
551
char heap[HEAP_SIZE] =
552
{0};
553
 
554
#ifndef STACK_SIZE
555
#define STACK_SIZE 100000
556
#endif
557
 
558
int kdb_stack_beg[STACK_SIZE / sizeof (int)];
559
int kdb_stack_end;
560
 
561
_initialize_standalone (void)
562
{
563
  register char *next;
564
 
565
  /* Find start of data on files.  */
566
 
567
  files_start = heap;
568
 
569
  /* Find the end of the data on files.  */
570
 
571
  for (next = files_start; *(int *) next; next += *(int *) next)
572
    {
573
    }
574
 
575
  /* That is where free storage starts for sbrk to give out.  */
576
  next_free = next;
577
 
578
  memory_limit = heap + sizeof heap;
579
}

powered by: WebSVN 2.1.0

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