Commit | Line | Data |
---|---|---|
bd5635a1 | 1 | /* Interface between GDB and target environments, including files and processes |
fcbc95a7 | 2 | Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. |
bd5635a1 RP |
3 | Contributed by Cygnus Support. Written by John Gilmore. |
4 | ||
5 | This file is part of GDB. | |
6 | ||
75af490b | 7 | This program is free software; you can redistribute it and/or modify |
bd5635a1 | 8 | it under the terms of the GNU General Public License as published by |
75af490b JG |
9 | the Free Software Foundation; either version 2 of the License, or |
10 | (at your option) any later version. | |
bd5635a1 | 11 | |
75af490b | 12 | This program is distributed in the hope that it will be useful, |
bd5635a1 RP |
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 | |
75af490b JG |
18 | along with this program; if not, write to the Free Software |
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
20 | ||
21 | #if !defined (TARGET_H) | |
22 | #define TARGET_H | |
bd5635a1 RP |
23 | |
24 | /* This include file defines the interface between the main part | |
25 | of the debugger, and the part which is target-specific, or | |
26 | specific to the communications interface between us and the | |
27 | target. | |
28 | ||
29 | A TARGET is an interface between the debugger and a particular | |
30 | kind of file or process. Targets can be STACKED in STRATA, | |
31 | so that more than one target can potentially respond to a request. | |
32 | In particular, memory accesses will walk down the stack of targets | |
33 | until they find a target that is interested in handling that particular | |
34 | address. STRATA are artificial boundaries on the stack, within | |
35 | which particular kinds of targets live. Strata exist so that | |
36 | people don't get confused by pushing e.g. a process target and then | |
37 | a file target, and wondering why they can't see the current values | |
38 | of variables any more (the file target is handling them and they | |
39 | never get to the process target). So when you push a file target, | |
40 | it goes into the file stratum, which is always below the process | |
41 | stratum. */ | |
42 | ||
75af490b JG |
43 | #include "bfd.h" |
44 | ||
bd5635a1 RP |
45 | enum strata { |
46 | dummy_stratum, /* The lowest of the low */ | |
47 | file_stratum, /* Executable files, etc */ | |
48 | core_stratum, /* Core dump files */ | |
75af490b | 49 | process_stratum /* Executing processes */ |
bd5635a1 RP |
50 | }; |
51 | ||
67ac9759 JK |
52 | /* Stuff for target_wait. */ |
53 | ||
54 | /* Generally, what has the program done? */ | |
55 | enum target_waitkind { | |
56 | /* The program has exited. The exit status is in value.integer. */ | |
57 | TARGET_WAITKIND_EXITED, | |
58 | ||
59 | /* The program has stopped with a signal. Which signal is in value.sig. */ | |
60 | TARGET_WAITKIND_STOPPED, | |
61 | ||
62 | /* The program has terminated with a signal. Which signal is in | |
63 | value.sig. */ | |
fcbc95a7 JK |
64 | TARGET_WAITKIND_SIGNALLED, |
65 | ||
66 | /* The program is letting us know that it dynamically loaded something | |
67 | (e.g. it called load(2) on AIX). */ | |
68 | TARGET_WAITKIND_LOADED, | |
69 | ||
70 | /* Nothing happened, but we stopped anyway. This perhaps should be handled | |
71 | within target_wait, but I'm not sure target_wait should be resuming the | |
72 | inferior. */ | |
73 | TARGET_WAITKIND_SPURIOUS | |
67ac9759 JK |
74 | }; |
75 | ||
76 | /* The numbering of these signals is chosen to match traditional unix | |
77 | signals (insofar as various unices use the same numbers, anyway). | |
78 | It is also the numbering of the GDB remote protocol. Other remote | |
79 | protocols, if they use a different numbering, should make sure to | |
80 | translate appropriately. */ | |
81 | ||
82 | /* This is based strongly on Unix/POSIX signals for several reasons: | |
83 | (1) This set of signals represents a widely-accepted attempt to | |
84 | represent events of this sort in a portable fashion, (2) we want a | |
85 | signal to make it from wait to child_wait to the user intact, (3) many | |
86 | remote protocols use a similar encoding. However, it is | |
87 | recognized that this set of signals has limitations (such as not | |
88 | distinguishing between various kinds of SIGSEGV, or not | |
89 | distinguishing hitting a breakpoint from finishing a single step). | |
90 | So in the future we may get around this either by adding additional | |
91 | signals for breakpoint, single-step, etc., or by adding signal | |
92 | codes; the latter seems more in the spirit of what BSD, System V, | |
93 | etc. are doing to address these issues. */ | |
94 | ||
95 | /* For an explanation of what each signal means, see | |
96 | target_signal_to_string. */ | |
97 | ||
98 | enum target_signal { | |
99 | /* Used some places (e.g. stop_signal) to record the concept that | |
100 | there is no signal. */ | |
101 | TARGET_SIGNAL_0 = 0, | |
102 | TARGET_SIGNAL_HUP = 1, | |
103 | TARGET_SIGNAL_INT = 2, | |
104 | TARGET_SIGNAL_QUIT = 3, | |
105 | TARGET_SIGNAL_ILL = 4, | |
106 | TARGET_SIGNAL_TRAP = 5, | |
107 | TARGET_SIGNAL_ABRT = 6, | |
108 | TARGET_SIGNAL_EMT = 7, | |
109 | TARGET_SIGNAL_FPE = 8, | |
110 | TARGET_SIGNAL_KILL = 9, | |
111 | TARGET_SIGNAL_BUS = 10, | |
112 | TARGET_SIGNAL_SEGV = 11, | |
113 | TARGET_SIGNAL_SYS = 12, | |
114 | TARGET_SIGNAL_PIPE = 13, | |
115 | TARGET_SIGNAL_ALRM = 14, | |
116 | TARGET_SIGNAL_TERM = 15, | |
117 | TARGET_SIGNAL_URG = 16, | |
118 | TARGET_SIGNAL_STOP = 17, | |
119 | TARGET_SIGNAL_TSTP = 18, | |
120 | TARGET_SIGNAL_CONT = 19, | |
121 | TARGET_SIGNAL_CHLD = 20, | |
122 | TARGET_SIGNAL_TTIN = 21, | |
123 | TARGET_SIGNAL_TTOU = 22, | |
124 | TARGET_SIGNAL_IO = 23, | |
125 | TARGET_SIGNAL_XCPU = 24, | |
126 | TARGET_SIGNAL_XFSZ = 25, | |
127 | TARGET_SIGNAL_VTALRM = 26, | |
128 | TARGET_SIGNAL_PROF = 27, | |
129 | TARGET_SIGNAL_WINCH = 28, | |
130 | TARGET_SIGNAL_LOST = 29, | |
131 | TARGET_SIGNAL_USR1 = 30, | |
132 | TARGET_SIGNAL_USR2 = 31, | |
133 | TARGET_SIGNAL_PWR = 32, | |
134 | /* Similar to SIGIO. Perhaps they should have the same number. */ | |
135 | TARGET_SIGNAL_POLL = 33, | |
136 | TARGET_SIGNAL_WIND = 34, | |
137 | TARGET_SIGNAL_PHONE = 35, | |
138 | TARGET_SIGNAL_WAITING = 36, | |
139 | TARGET_SIGNAL_LWP = 37, | |
140 | TARGET_SIGNAL_DANGER = 38, | |
141 | TARGET_SIGNAL_GRANT = 39, | |
142 | TARGET_SIGNAL_RETRACT = 40, | |
143 | TARGET_SIGNAL_MSG = 41, | |
144 | TARGET_SIGNAL_SOUND = 42, | |
145 | TARGET_SIGNAL_SAK = 43, | |
146 | ||
147 | /* Some signal we don't know about. */ | |
148 | TARGET_SIGNAL_UNKNOWN, | |
149 | ||
fcbc95a7 JK |
150 | /* Use whatever signal we use when one is not specifically specified |
151 | (for passing to proceed and so on). */ | |
152 | TARGET_SIGNAL_DEFAULT, | |
153 | ||
67ac9759 JK |
154 | /* Last and unused enum value, for sizing arrays, etc. */ |
155 | TARGET_SIGNAL_LAST | |
156 | }; | |
157 | ||
158 | struct target_waitstatus { | |
159 | enum target_waitkind kind; | |
160 | ||
161 | /* Exit status or signal number. */ | |
162 | union { | |
163 | int integer; | |
164 | enum target_signal sig; | |
165 | } value; | |
166 | }; | |
167 | ||
168 | /* Return the string for a signal. */ | |
169 | extern char *target_signal_to_string PARAMS ((enum target_signal)); | |
170 | ||
171 | /* Return the name (SIGHUP, etc.) for a signal. */ | |
172 | extern char *target_signal_to_name PARAMS ((enum target_signal)); | |
173 | ||
174 | /* Given a name (SIGHUP, etc.), return its signal. */ | |
175 | enum target_signal target_signal_from_name PARAMS ((char *)); | |
176 | \f | |
75af490b JG |
177 | struct target_ops |
178 | { | |
179 | char *to_shortname; /* Name this target type */ | |
180 | char *to_longname; /* Name for printing */ | |
181 | char *to_doc; /* Documentation. Does not include trailing | |
182 | newline, and starts with a one-line descrip- | |
183 | tion (probably similar to to_longname). */ | |
184 | void (*to_open) PARAMS ((char *, int)); | |
185 | void (*to_close) PARAMS ((int)); | |
186 | void (*to_attach) PARAMS ((char *, int)); | |
187 | void (*to_detach) PARAMS ((char *, int)); | |
67ac9759 JK |
188 | void (*to_resume) PARAMS ((int, int, enum target_signal)); |
189 | int (*to_wait) PARAMS ((int, struct target_waitstatus *)); | |
75af490b JG |
190 | void (*to_fetch_registers) PARAMS ((int)); |
191 | void (*to_store_registers) PARAMS ((int)); | |
192 | void (*to_prepare_to_store) PARAMS ((void)); | |
f1e7bafc JK |
193 | |
194 | /* Transfer LEN bytes of memory between GDB address MYADDR and | |
195 | target address MEMADDR. If WRITE, transfer them to the target, else | |
196 | transfer them from the target. TARGET is the target from which we | |
197 | get this function. | |
198 | ||
199 | Return value, N, is one of the following: | |
200 | ||
201 | 0 means that we can't handle this. If errno has been set, it is the | |
202 | error which prevented us from doing it (FIXME: What about bfd_error?). | |
203 | ||
204 | positive (call it N) means that we have transferred N bytes | |
205 | starting at MEMADDR. We might be able to handle more bytes | |
206 | beyond this length, but no promises. | |
207 | ||
208 | negative (call its absolute value N) means that we cannot | |
209 | transfer right at MEMADDR, but we could transfer at least | |
210 | something at MEMADDR + N. */ | |
211 | ||
212 | int (*to_xfer_memory) PARAMS ((CORE_ADDR memaddr, char *myaddr, | |
213 | int len, int write, | |
214 | struct target_ops * target)); | |
215 | ||
75af490b JG |
216 | void (*to_files_info) PARAMS ((struct target_ops *)); |
217 | int (*to_insert_breakpoint) PARAMS ((CORE_ADDR, char *)); | |
218 | int (*to_remove_breakpoint) PARAMS ((CORE_ADDR, char *)); | |
219 | void (*to_terminal_init) PARAMS ((void)); | |
220 | void (*to_terminal_inferior) PARAMS ((void)); | |
221 | void (*to_terminal_ours_for_output) PARAMS ((void)); | |
222 | void (*to_terminal_ours) PARAMS ((void)); | |
223 | void (*to_terminal_info) PARAMS ((char *, int)); | |
224 | void (*to_kill) PARAMS ((void)); | |
225 | void (*to_load) PARAMS ((char *, int)); | |
226 | int (*to_lookup_symbol) PARAMS ((char *, CORE_ADDR *)); | |
227 | void (*to_create_inferior) PARAMS ((char *, char *, char **)); | |
228 | void (*to_mourn_inferior) PARAMS ((void)); | |
836e343b | 229 | int (*to_can_run) PARAMS ((void)); |
67ac9759 | 230 | void (*to_notice_signals) PARAMS ((int pid)); |
75af490b JG |
231 | enum strata to_stratum; |
232 | struct target_ops | |
233 | *to_next; | |
234 | int to_has_all_memory; | |
235 | int to_has_memory; | |
236 | int to_has_stack; | |
237 | int to_has_registers; | |
238 | int to_has_execution; | |
239 | struct section_table | |
240 | *to_sections; | |
241 | struct section_table | |
242 | *to_sections_end; | |
243 | int to_magic; | |
244 | /* Need sub-structure for target machine related rather than comm related? */ | |
bd5635a1 RP |
245 | }; |
246 | ||
247 | /* Magic number for checking ops size. If a struct doesn't end with this | |
248 | number, somebody changed the declaration but didn't change all the | |
249 | places that initialize one. */ | |
250 | ||
251 | #define OPS_MAGIC 3840 | |
252 | ||
f1e7bafc JK |
253 | /* The ops structure for our "current" target process. This should |
254 | never be NULL. If there is no target, it points to the dummy_target. */ | |
bd5635a1 RP |
255 | |
256 | extern struct target_ops *current_target; | |
257 | ||
258 | /* Define easy words for doing these operations on our current target. */ | |
259 | ||
260 | #define target_shortname (current_target->to_shortname) | |
261 | #define target_longname (current_target->to_longname) | |
262 | ||
9136fe49 JK |
263 | /* The open routine takes the rest of the parameters from the command, |
264 | and (if successful) pushes a new target onto the stack. | |
265 | Targets should supply this routine, if only to provide an error message. */ | |
bd5635a1 RP |
266 | #define target_open(name, from_tty) \ |
267 | (*current_target->to_open) (name, from_tty) | |
268 | ||
269 | /* Does whatever cleanup is required for a target that we are no longer | |
270 | going to be calling. Argument says whether we are quitting gdb and | |
271 | should not get hung in case of errors, or whether we want a clean | |
272 | termination even if it takes a while. This routine is automatically | |
273 | always called just before a routine is popped off the target stack. | |
274 | Closing file descriptors and freeing memory are typical things it should | |
275 | do. */ | |
276 | ||
277 | #define target_close(quitting) \ | |
278 | (*current_target->to_close) (quitting) | |
279 | ||
836e343b JG |
280 | /* Attaches to a process on the target side. Arguments are as passed |
281 | to the `attach' command by the user. This routine can be called | |
282 | when the target is not on the target-stack, if the target_can_run | |
283 | routine returns 1; in that case, it must push itself onto the stack. | |
284 | Upon exit, the target should be ready for normal operations, and | |
285 | should be ready to deliver the status of the process immediately | |
286 | (without waiting) to an upcoming target_wait call. */ | |
bd5635a1 RP |
287 | |
288 | #define target_attach(args, from_tty) \ | |
289 | (*current_target->to_attach) (args, from_tty) | |
290 | ||
291 | /* Takes a program previously attached to and detaches it. | |
292 | The program may resume execution (some targets do, some don't) and will | |
293 | no longer stop on signals, etc. We better not have left any breakpoints | |
294 | in the program or it'll die when it hits one. ARGS is arguments | |
295 | typed by the user (e.g. a signal to send the process). FROM_TTY | |
296 | says whether to be verbose or not. */ | |
297 | ||
f1e7bafc JK |
298 | extern void |
299 | target_detach PARAMS ((char *, int)); | |
bd5635a1 | 300 | |
f1e7bafc | 301 | /* Resume execution of the target process PID. STEP says whether to |
fcbc95a7 JK |
302 | single-step or to run free; SIGGNAL is the signal to be given to |
303 | the target, or TARGET_SIGNAL_0 for no signal. The caller may not | |
304 | pass TARGET_SIGNAL_DEFAULT. */ | |
bd5635a1 | 305 | |
f1e7bafc JK |
306 | #define target_resume(pid, step, siggnal) \ |
307 | (*current_target->to_resume) (pid, step, siggnal) | |
bd5635a1 | 308 | |
67ac9759 JK |
309 | /* Wait for process pid to do something. Pid = -1 to wait for any pid to do |
310 | something. Return pid of child, or -1 in case of error; store status | |
311 | through argument pointer STATUS. */ | |
bd5635a1 | 312 | |
67ac9759 JK |
313 | #define target_wait(pid, status) \ |
314 | (*current_target->to_wait) (pid, status) | |
bd5635a1 | 315 | |
75af490b | 316 | /* Fetch register REGNO, or all regs if regno == -1. No result. */ |
bd5635a1 RP |
317 | |
318 | #define target_fetch_registers(regno) \ | |
319 | (*current_target->to_fetch_registers) (regno) | |
320 | ||
321 | /* Store at least register REGNO, or all regs if REGNO == -1. | |
f1e7bafc JK |
322 | It can store as many registers as it wants to, so target_prepare_to_store |
323 | must have been previously called. Calls error() if there are problems. */ | |
bd5635a1 RP |
324 | |
325 | #define target_store_registers(regs) \ | |
326 | (*current_target->to_store_registers) (regs) | |
327 | ||
328 | /* Get ready to modify the registers array. On machines which store | |
329 | individual registers, this doesn't need to do anything. On machines | |
330 | which store all the registers in one fell swoop, this makes sure | |
331 | that REGISTERS contains all the registers from the program being | |
332 | debugged. */ | |
333 | ||
334 | #define target_prepare_to_store() \ | |
335 | (*current_target->to_prepare_to_store) () | |
336 | ||
75af490b JG |
337 | extern int |
338 | target_read_string PARAMS ((CORE_ADDR, char *, int)); | |
339 | ||
340 | extern int | |
341 | target_read_memory PARAMS ((CORE_ADDR, char *, int)); | |
342 | ||
f1e7bafc JK |
343 | extern int |
344 | target_read_memory_partial PARAMS ((CORE_ADDR, char *, int, int *)); | |
345 | ||
75af490b JG |
346 | extern int |
347 | target_write_memory PARAMS ((CORE_ADDR, char *, int)); | |
348 | ||
349 | extern int | |
350 | xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *)); | |
351 | ||
352 | extern int | |
353 | child_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *)); | |
354 | ||
f1e7bafc JK |
355 | /* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR. |
356 | Returns 0 for success, errno code for failure (which includes partial | |
357 | transfers--if you want a more useful response to partial transfers, try | |
358 | target_read_memory_partial). */ | |
359 | ||
360 | extern int target_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, | |
361 | int len, int write)); | |
75af490b JG |
362 | |
363 | /* From exec.c */ | |
364 | ||
365 | extern void | |
366 | print_section_info PARAMS ((struct target_ops *, bfd *)); | |
bd5635a1 RP |
367 | |
368 | /* Print a line about the current target. */ | |
369 | ||
370 | #define target_files_info() \ | |
75af490b | 371 | (*current_target->to_files_info) (current_target) |
bd5635a1 RP |
372 | |
373 | /* Insert a breakpoint at address ADDR in the target machine. | |
374 | SAVE is a pointer to memory allocated for saving the | |
375 | target contents. It is guaranteed by the caller to be long enough | |
376 | to save "sizeof BREAKPOINT" bytes. Result is 0 for success, or | |
377 | an errno value. */ | |
378 | ||
379 | #define target_insert_breakpoint(addr, save) \ | |
380 | (*current_target->to_insert_breakpoint) (addr, save) | |
381 | ||
382 | /* Remove a breakpoint at address ADDR in the target machine. | |
383 | SAVE is a pointer to the same save area | |
384 | that was previously passed to target_insert_breakpoint. | |
385 | Result is 0 for success, or an errno value. */ | |
386 | ||
387 | #define target_remove_breakpoint(addr, save) \ | |
388 | (*current_target->to_remove_breakpoint) (addr, save) | |
389 | ||
390 | /* Initialize the terminal settings we record for the inferior, | |
391 | before we actually run the inferior. */ | |
392 | ||
393 | #define target_terminal_init() \ | |
394 | (*current_target->to_terminal_init) () | |
f1e7bafc | 395 | |
bd5635a1 RP |
396 | /* Put the inferior's terminal settings into effect. |
397 | This is preparation for starting or resuming the inferior. */ | |
398 | ||
399 | #define target_terminal_inferior() \ | |
400 | (*current_target->to_terminal_inferior) () | |
401 | ||
402 | /* Put some of our terminal settings into effect, | |
403 | enough to get proper results from our output, | |
404 | but do not change into or out of RAW mode | |
405 | so that no input is discarded. | |
406 | ||
407 | After doing this, either terminal_ours or terminal_inferior | |
408 | should be called to get back to a normal state of affairs. */ | |
409 | ||
410 | #define target_terminal_ours_for_output() \ | |
411 | (*current_target->to_terminal_ours_for_output) () | |
412 | ||
413 | /* Put our terminal settings into effect. | |
414 | First record the inferior's terminal settings | |
415 | so they can be restored properly later. */ | |
416 | ||
417 | #define target_terminal_ours() \ | |
418 | (*current_target->to_terminal_ours) () | |
419 | ||
420 | /* Print useful information about our terminal status, if such a thing | |
421 | exists. */ | |
422 | ||
423 | #define target_terminal_info(arg, from_tty) \ | |
424 | (*current_target->to_terminal_info) (arg, from_tty) | |
425 | ||
426 | /* Kill the inferior process. Make it go away. */ | |
427 | ||
75af490b JG |
428 | #define target_kill() \ |
429 | (*current_target->to_kill) () | |
bd5635a1 RP |
430 | |
431 | /* Load an executable file into the target process. This is expected to | |
432 | not only bring new code into the target process, but also to update | |
433 | GDB's symbol tables to match. */ | |
434 | ||
435 | #define target_load(arg, from_tty) \ | |
436 | (*current_target->to_load) (arg, from_tty) | |
437 | ||
bd5635a1 RP |
438 | /* Look up a symbol in the target's symbol table. NAME is the symbol |
439 | name. ADDRP is a CORE_ADDR * pointing to where the value of the symbol | |
440 | should be returned. The result is 0 if successful, nonzero if the | |
441 | symbol does not exist in the target environment. This function should | |
442 | not call error() if communication with the target is interrupted, since | |
443 | it is called from symbol reading, but should return nonzero, possibly | |
444 | doing a complain(). */ | |
445 | ||
446 | #define target_lookup_symbol(name, addrp) \ | |
447 | (*current_target->to_lookup_symbol) (name, addrp) | |
448 | ||
449 | /* Start an inferior process and set inferior_pid to its pid. | |
450 | EXEC_FILE is the file to run. | |
451 | ALLARGS is a string containing the arguments to the program. | |
452 | ENV is the environment vector to pass. Errors reported with error(). | |
453 | On VxWorks and various standalone systems, we ignore exec_file. */ | |
454 | ||
455 | #define target_create_inferior(exec_file, args, env) \ | |
456 | (*current_target->to_create_inferior) (exec_file, args, env) | |
457 | ||
458 | /* The inferior process has died. Do what is right. */ | |
459 | ||
460 | #define target_mourn_inferior() \ | |
461 | (*current_target->to_mourn_inferior) () | |
462 | ||
836e343b JG |
463 | /* Does target have enough data to do a run or attach command? */ |
464 | ||
465 | #define target_can_run(t) \ | |
466 | ((t)->to_can_run) () | |
467 | ||
f1e7bafc JK |
468 | /* post process changes to signal handling in the inferior. */ |
469 | ||
67ac9759 JK |
470 | #define target_notice_signals(pid) \ |
471 | (*current_target->to_notice_signals) (pid) | |
f1e7bafc | 472 | |
bd5635a1 RP |
473 | /* Pointer to next target in the chain, e.g. a core file and an exec file. */ |
474 | ||
475 | #define target_next \ | |
476 | (current_target->to_next) | |
477 | ||
478 | /* Does the target include all of memory, or only part of it? This | |
479 | determines whether we look up the target chain for other parts of | |
480 | memory if this target can't satisfy a request. */ | |
481 | ||
482 | #define target_has_all_memory \ | |
483 | (current_target->to_has_all_memory) | |
484 | ||
485 | /* Does the target include memory? (Dummy targets don't.) */ | |
486 | ||
487 | #define target_has_memory \ | |
488 | (current_target->to_has_memory) | |
489 | ||
490 | /* Does the target have a stack? (Exec files don't, VxWorks doesn't, until | |
491 | we start a process.) */ | |
492 | ||
493 | #define target_has_stack \ | |
494 | (current_target->to_has_stack) | |
495 | ||
496 | /* Does the target have registers? (Exec files don't.) */ | |
497 | ||
498 | #define target_has_registers \ | |
499 | (current_target->to_has_registers) | |
500 | ||
f1e7bafc JK |
501 | /* Does the target have execution? Can we make it jump (through |
502 | hoops), or pop its stack a few times? FIXME: If this is to work that | |
503 | way, it needs to check whether an inferior actually exists. | |
504 | remote-udi.c and probably other targets can be the current target | |
505 | when the inferior doesn't actually exist at the moment. Right now | |
506 | this just tells us whether this target is *capable* of execution. */ | |
bd5635a1 RP |
507 | |
508 | #define target_has_execution \ | |
509 | (current_target->to_has_execution) | |
510 | ||
f1e7bafc JK |
511 | /* Converts a process id to a string. Usually, the string just contains |
512 | `process xyz', but on some systems it may contain | |
513 | `process xyz thread abc'. */ | |
514 | ||
515 | #ifndef target_pid_to_str | |
516 | #define target_pid_to_str(PID) \ | |
517 | normal_pid_to_str (PID) | |
518 | extern char *normal_pid_to_str PARAMS ((int pid)); | |
519 | #endif | |
520 | ||
bd5635a1 RP |
521 | /* Routines for maintenance of the target structures... |
522 | ||
523 | add_target: Add a target to the list of all possible targets. | |
524 | ||
525 | push_target: Make this target the top of the stack of currently used | |
526 | targets, within its particular stratum of the stack. Result | |
527 | is 0 if now atop the stack, nonzero if not on top (maybe | |
528 | should warn user). | |
529 | ||
530 | unpush_target: Remove this from the stack of currently used targets, | |
531 | no matter where it is on the list. Returns 0 if no | |
532 | change, 1 if removed from stack. | |
533 | ||
534 | pop_target: Remove the top thing on the stack of current targets. */ | |
535 | ||
75af490b JG |
536 | extern void |
537 | add_target PARAMS ((struct target_ops *)); | |
538 | ||
539 | extern int | |
540 | push_target PARAMS ((struct target_ops *)); | |
541 | ||
542 | extern int | |
543 | unpush_target PARAMS ((struct target_ops *)); | |
544 | ||
545 | extern void | |
546 | target_preopen PARAMS ((int)); | |
547 | ||
548 | extern void | |
549 | pop_target PARAMS ((void)); | |
550 | ||
551 | /* Struct section_table maps address ranges to file sections. It is | |
552 | mostly used with BFD files, but can be used without (e.g. for handling | |
553 | raw disks, or files not in formats handled by BFD). */ | |
554 | ||
555 | struct section_table { | |
556 | CORE_ADDR addr; /* Lowest address in section */ | |
557 | CORE_ADDR endaddr; /* 1+highest address in section */ | |
558 | sec_ptr sec_ptr; /* BFD section pointer */ | |
559 | bfd *bfd; /* BFD file pointer */ | |
560 | }; | |
561 | ||
562 | /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR. | |
563 | Returns 0 if OK, 1 on error. */ | |
564 | ||
565 | extern int | |
566 | build_section_table PARAMS ((bfd *, struct section_table **, | |
567 | struct section_table **)); | |
568 | ||
75af490b JG |
569 | /* From mem-break.c */ |
570 | ||
571 | extern int | |
572 | memory_remove_breakpoint PARAMS ((CORE_ADDR, char *)); | |
573 | ||
574 | extern int | |
575 | memory_insert_breakpoint PARAMS ((CORE_ADDR, char *)); | |
576 | ||
dcc8abce JG |
577 | /* From target.c */ |
578 | ||
579 | void | |
580 | noprocess PARAMS ((void)); | |
581 | ||
836e343b JG |
582 | void |
583 | find_default_attach PARAMS ((char *, int)); | |
584 | ||
585 | void | |
586 | find_default_create_inferior PARAMS ((char *, char *, char **)); | |
587 | ||
f1e7bafc JK |
588 | struct target_ops * |
589 | find_core_target PARAMS ((void)); | |
590 | \f | |
67ac9759 JK |
591 | /* Stuff that should be shared among the various remote targets. */ |
592 | ||
593 | /* Debugging level. 0 is off, and non-zero values mean to print some debug | |
594 | information (higher values, more information). */ | |
595 | extern int remote_debug; | |
596 | ||
597 | /* Speed in bits per second. */ | |
598 | extern int baud_rate; | |
599 | \f | |
600 | /* Functions for helping to write a native target. */ | |
601 | ||
602 | /* This is for native targets which use a unix/POSIX-style waitstatus. */ | |
603 | extern void store_waitstatus PARAMS ((struct target_waitstatus *, int)); | |
604 | ||
605 | /* Convert between host signal numbers and enum target_signal's. */ | |
606 | extern enum target_signal target_signal_from_host PARAMS ((int)); | |
607 | extern int target_signal_to_host PARAMS ((enum target_signal)); | |
608 | ||
75af490b | 609 | #endif /* !defined (TARGET_H) */ |