1 /* Interface to bare machine for GDB running as kernel debugger.
2 Copyright (C) 1986, 1989 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GDB is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #include <sys/ioctl.h>
24 #include <sys/types.h>
27 #if defined (SIGTSTP) && defined (SIGIO)
29 #include <sys/resource.h>
30 #endif /* SIGTSTP and SIGIO defined (must be 4.2) */
40 /* Random system calls, mostly no-ops to prevent link problems */
42 ioctl (desc
, code
, arg
)
71 /* Used to check for existence of .gdbinit. Say no. */
80 error ("Fatal error; restarting.");
83 /* Reading "files". The contents of some files are written into kdb's
84 data area before it is run. These files are used to contain the
85 symbol table for kdb to load, and the source files (in case the
86 kdb user wants to print them). The symbols are stored in a file
87 named "kdb-symbols" in a.out format (except that all the text and
88 data have been stripped to save room).
90 The files are stored in the following format:
91 int number of bytes of data for this file, including these four.
92 char[] name of the file, ending with a null.
93 padding to multiple of 4 boundary.
94 char[] file contents. The length can be deduced from what was
95 specified before. There is no terminating null here.
97 If the int at the front is zero, it means there are no more files.
99 Opening a file in kdb returns a nonzero value to indicate success,
100 but the value does not matter. Only one file can be open, and only
101 for reading. All the primitives for input from the file know
102 which file is open and ignore what is specified for the descriptor
103 or for the stdio stream.
105 Input with fgetc can be done either on the file that is open
106 or on stdin (which reads from the terminal through tty_input () */
108 /* Address of data for the files stored in format described above. */
111 /* The file stream currently open: */
113 char *sourcebeg
; /* beginning of contents */
114 int sourcesize
; /* size of contents */
115 char *sourceptr
; /* current read pointer */
116 int sourceleft
; /* number of bytes to eof */
118 /* "descriptor" for the file now open.
119 Incremented at each close.
120 If specified descriptor does not match this,
121 it means the program is trying to use a closed descriptor.
122 We report an error for that. */
126 open (filename
, modes
)
145 for (next
- files_start
; * (int *) next
;
146 next
+= * (int *) next
)
148 if (!strcmp (next
+ 4, filename
))
150 sourcebeg
= next
+ 4 + strlen (next
+ 4) + 1;
151 sourcebeg
= (char *) (((int) sourcebeg
+ 3) & (-4));
152 sourceptr
= sourcebeg
;
153 sourcesize
= next
+ * (int *) next
- sourceptr
;
154 sourceleft
= sourcesize
;
166 /* Don't let sourcedesc get big enough to be confused with stdin. */
167 if (sourcedesc
== 100)
172 fopen (filename
, modes
)
176 return (FILE *) open (filename
, *modes
== 'w');
183 return (FILE *) desc
;
192 fstat (desc
, statbuf
)
193 struct stat
*statbuf
;
197 if (desc
!= sourcedesc
)
202 statbuf
->st_size
= sourcesize
;
205 myread (desc
, destptr
, size
, filename
)
211 int len
= min (sourceleft
, size
);
214 if (desc
!= sourcedesc
)
220 bcopy (sourceptr
, destptr
, len
);
226 fread (bufp
, numelts
, eltsize
, stream
)
228 register int elts
= min (numelts
, sourceleft
/ eltsize
);
229 register int len
= elts
* eltsize
;
232 if (stream
!= sourcedesc
)
238 bcopy (sourceptr
, bufp
, len
);
249 if (desc
== (int) stdin
)
252 if (desc
!= sourcedesc
)
258 if (sourceleft
-- <= 0)
269 if (desc
!= sourcedesc
)
275 if (pos
< 0 || pos
> sourcesize
)
281 sourceptr
= sourcebeg
+ pos
;
282 sourceleft
= sourcesize
- pos
;
285 /* Output in kdb can go only to the terminal, so the stream
286 specified may be ignored. */
288 printf (a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
)
291 sprintf (buffer
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
);
292 display_string (buffer
);
295 fprintf (ign
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
)
298 sprintf (buffer
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
);
299 display_string (buffer
);
302 fwrite (buf
, numelts
, size
, stream
)
306 register int i
= numelts
* size
;
308 fputc (*buf
++, stream
);
316 display_string (buf
);
319 /* sprintf refers to this, but loading this from the
320 library would cause fflush to be loaded from it too.
321 In fact there should be no need to call this (I hope). */
325 error ("_flsbuf was actually called.");
332 /* Entries into core and inflow, needed only to make things link ok. */
344 /* Makes one printout look reasonable; value does not matter otherwise. */
364 terminal_init_inferior ()
367 write_inferior_register ()
370 read_inferior_register ()
373 read_memory (memaddr
, myaddr
, len
)
378 bcopy (memaddr
, myaddr
, len
);
381 /* Always return 0 indicating success. */
383 write_memory (memaddr
, myaddr
, len
)
388 bcopy (myaddr
, memaddr
, len
);
392 static REGISTER_TYPE saved_regs
[NUM_REGS
];
395 read_register (regno
)
398 if (regno
< 0 || regno
>= NUM_REGS
)
399 error ("Register number %d out of range.", regno
);
400 return saved_regs
[regno
];
404 write_register (regno
, value
)
408 if (regno
< 0 || regno
>= NUM_REGS
)
409 error ("Register number %d out of range.", regno
);
410 saved_regs
[regno
] = value
;
413 /* System calls needed in relation to running the "inferior". */
417 /* Just appear to "succeed". Say the inferior's pid is 1. */
421 /* These are called by code that normally runs in the inferior
422 that has just been forked. That code never runs, when standalone,
423 and these definitions are so it will link without errors. */
437 /* Malloc calls these. */
442 printf ("\n%s.\n\n", str
);
452 if (next_free
+ amount
> memory_limit
)
455 return next_free
- amount
;
458 /* Various ways malloc might ask where end of memory is. */
469 return memory_limit
- next_free
;
475 addr
->rlim_cur
= memory_limit
- next_free
;
478 /* Context switching to and from program being debugged. */
480 /* GDB calls here to run the user program.
481 The frame pointer for this function is saved in
482 gdb_stack by save_frame_pointer; then we restore
483 all of the user program's registers, including PC and PS. */
485 static int fault_code
;
486 static REGISTER_TYPE gdb_stack
;
490 REGISTER_TYPE restore
[NUM_REGS
];
493 save_frame_pointer ();
495 bcopy (saved_regs
, restore
, sizeof restore
);
497 /* Control does not drop through here! */
500 save_frame_pointer (val
)
506 /* Fault handlers call here, running in the user program stack.
507 They must first push a fault code,
508 old PC, old PS, and any other info about the fault.
509 The exact format is machine-dependent and is known only
510 in the definition of PUSH_REGISTERS. */
514 /* Transfer all registers and fault code to the stack
515 in canonical order: registers in order of GDB register number,
516 followed by fault code. */
519 /* Transfer them to saved_regs and fault_code. */
523 /* Control does not reach here */
528 CORE_ADDR new_fp
= gdb_stack
;
529 /* Switch to GDB's stack */
531 /* Return from the function `resume'. */
534 /* Assuming register contents and fault code have been pushed on the stack as
535 arguments to this function, copy them into the standard place
536 for the program's registers while GDB is running. */
538 save_registers (firstreg
)
541 bcopy (&firstreg
, saved_regs
, sizeof saved_regs
);
542 fault_code
= (&firstreg
)[NUM_REGS
];
545 /* Store into the structure such as `wait' would return
546 the information on why the program faulted,
547 converted into a machine-independent signal number. */
549 static int fault_table
[] = FAULT_TABLE
;
555 WSETSTOP (*w
, fault_table
[fault_code
/ FAULT_CODE_UNITS
]);
559 /* Allocate a big space in which files for kdb to read will be stored.
560 Whatever is left is where malloc can allocate storage.
562 Initialize it, so that there will be space in the executable file
563 for it. Then the files can be put into kdb by writing them into
564 kdb's executable file. */
566 /* The default size is as much space as we expect to be available
570 #define HEAP_SIZE 400000
573 char heap
[HEAP_SIZE
] = {0};
576 #define STACK_SIZE 100000
579 int kdb_stack_beg
[STACK_SIZE
/ sizeof (int)];
582 _initialize_standalone ()
586 /* Find start of data on files. */
590 /* Find the end of the data on files. */
592 for (next
- files_start
; * (int *) next
;
593 next
+= * (int *) next
)
596 /* That is where free storage starts for sbrk to give out. */
599 memory_limit
= heap
+ sizeof heap
;
This page took 0.052419 seconds and 4 git commands to generate.