Commit | Line | Data |
---|---|---|
24615880 AC |
1 | #include "defs.h" |
2 | #include "tm.h" | |
3 | #include "target.h" | |
4 | ||
5 | /* #define CARP */ | |
6 | ||
7 | /* BAD HACKS */ | |
8 | ||
9 | int carp_sizeof_struct_frame_saved_regs; | |
10 | /* #define SIZEOF_STRUCT_FRAME_SAVED_REGS carp_sizeof_struct_frame_saved_regs */ | |
11 | ||
12 | ||
13 | ||
14 | ||
15 | #if 0 | |
16 | @item ADDITIONAL_OPTIONS | |
17 | @item ADDITIONAL_OPTION_CASES | |
18 | @item ADDITIONAL_OPTION_HANDLER | |
19 | @item ADDITIONAL_OPTION_HELP | |
20 | These are a set of macros that allow the addition of additional command | |
21 | line options to GDB. They are currently used only for the unsupported | |
22 | i960 Nindy target, and should not be used in any other configuration. | |
23 | #endif | |
24 | ||
25 | ||
26 | #if 0 | |
27 | @item ADDR_BITS_REMOVE (addr) | |
28 | If a raw machine address includes any bits that are not really part of | |
29 | the address, then define this macro to expand into an expression that | |
30 | zeros those bits in @var{addr}. For example, the two low-order bits of | |
31 | a Motorola 88K address may be used by some kernels for their own | |
32 | purposes, since addresses must always be 4-byte aligned, and so are of | |
33 | no use for addressing. Those bits should be filtered out with an | |
34 | expression such as @code{((addr) & ~3)}. | |
35 | #endif | |
36 | CORE_ADDR carp_addr_bits_remove (CORE_ADDR addr) { return 0; } | |
37 | /* #define ADDR_BITS_REMOVE(addr) carp_addr_bits_remove (addr) */ | |
38 | ||
39 | ||
40 | #if 0 | |
41 | @item BEFORE_MAIN_LOOP_HOOK | |
42 | Define this to expand into any code that you want to execute before the | |
43 | main loop starts. Although this is not, strictly speaking, a target | |
44 | conditional, that is how it is currently being used. Note that if a | |
45 | configuration were to define it one way for a host and a different way | |
46 | for the target, GDB will probably not compile, let alone run correctly. | |
47 | This is currently used only for the unsupported i960 Nindy target, and | |
48 | should not be used in any other configuration. | |
49 | #endif | |
50 | ||
51 | ||
52 | #if 0 | |
53 | @item BELIEVE_PCC_PROMOTION | |
54 | Define if the compiler promotes a short or char parameter to an int, but | |
55 | still reports the parameter as its original type, rather than the | |
56 | promoted type. | |
57 | #endif | |
58 | int carp_believe_pcc_promotion; | |
59 | /* #define BELIEVE_PCC_PROMOTION carp_believe_pcc_promotion */ | |
60 | ||
61 | ||
62 | #if 0 | |
63 | @item BELIEVE_PCC_PROMOTION_TYPE | |
64 | Define this if GDB should believe the type of a short argument when | |
65 | compiled by pcc, but look within a full int space to get its value. | |
66 | Only defined for Sun-3 at present. | |
67 | #endif | |
68 | int carp_believe_pcc_promotion_type; | |
69 | /* #define BELIEVE_PCC_PROMOTION_TYPE carp_believe_pcc_promotion_type */ | |
70 | ||
71 | ||
72 | #if 0 | |
73 | @item BITS_BIG_ENDIAN | |
74 | Define this if the numbering of bits in the targets does *not* match the | |
75 | endianness of the target byte order. A value of 1 means that the bits | |
76 | are numbered in a big-endian order, 0 means little-endian. | |
77 | #endif | |
78 | int carp_bits_big_endian; | |
79 | /* #define BITS_BIG_ENDIAN carp_bits_big_endian */ | |
80 | ||
81 | ||
82 | #if 0 | |
83 | @item BREAKPOINT | |
84 | This is the character array initializer for the bit pattern to put into | |
85 | memory where a breakpoint is set. Although it is common to use a trap | |
86 | instruction for a breakpoint, it is not required; for instance, the bit | |
87 | pattern could be an invalid instruction. The breakpoint must be no | |
88 | longer than the shortest instruction of the architecture. | |
89 | #endif | |
90 | char *carp_breakpoint; | |
91 | /* #define BREAKPOINT carp_breakpoint */ | |
92 | ||
93 | ||
94 | #if 0 | |
95 | @item BIG_BREAKPOINT | |
96 | @item LITTLE_BREAKPOINT | |
97 | Similar to BREAKPOINT, but used for bi-endian targets. | |
98 | #endif | |
99 | char *carp_big_breakpoint; | |
100 | char *carp_little_breakpoint; | |
101 | /* #define BIG_BREAKPOINT carp_big_breakpoint */ | |
102 | /* #define LITTLE_BREAKPOINT carp_little_breakpoint */ | |
103 | ||
104 | ||
105 | #if 0 | |
106 | @item CALL_DUMMY | |
107 | valops.c | |
108 | @item CALL_DUMMY_LOCATION | |
109 | inferior.h | |
110 | @item CALL_DUMMY_STACK_ADJUST | |
111 | valops.c | |
112 | @item CALL_DUMMY_START_OFFSET | |
113 | #endif | |
114 | char *carp_call_dummy (void) { return 0; } | |
115 | /* #define CALL_DUMMY carp_call_dummy () */ | |
116 | int carp_sizeof_call_dummy; | |
117 | /* #define SIZEOF_CALL_DUMMY carp_sizeof_call_dummy */ | |
118 | int carp_call_dummy_location; | |
119 | /* #define CALL_DUMMY_LOCATION carp_call_dummy_location */ | |
120 | int carp_call_stack_adjust; | |
121 | /* #define CALL_DUMMY_STACK_ADJUST carp_call_stack_adjust */ | |
122 | int carp_call_start_offset; | |
123 | /* #define CALL_DUMMY_START_OFFSET carp_call_start_offset */ | |
124 | ||
125 | ||
126 | #if 0 | |
127 | @item CANNOT_FETCH_REGISTER (regno) | |
128 | A C expression that should be nonzero if @var{regno} cannot be fetched | |
129 | from an inferior process. This is only relevant if | |
130 | @code{FETCH_INFERIOR_REGISTERS} is not defined. | |
131 | #endif | |
132 | int carp_cannot_fetch_register; | |
133 | /* #define CANNOT_FETCH_REGISTER(regno) carp_cannot_fetch_register(regno) */ | |
134 | ||
135 | ||
136 | #if 0 | |
137 | @item CANNOT_STORE_REGISTER (regno) | |
138 | A C expression that should be nonzero if @var{regno} should not be | |
139 | written to the target. This is often the case for program counters, | |
140 | status words, and other special registers. If this is not defined, GDB | |
141 | will assume that all registers may be written. | |
142 | #endif | |
143 | int carp_cannot_store_register (int regno) { return 0; } | |
144 | /* #define CANNOT_STORE_REGISTER(regno) carp_cannot_store_register(regno) */ | |
145 | ||
146 | ||
147 | #if 0 | |
148 | @item CHILL_PRODUCER | |
149 | @item GCC_PRODUCER | |
150 | @item GPLUS_PRODUCER | |
151 | @item LCC_PRODUCER | |
152 | If defined, these are the producer strings in a DWARF 1 file. All of | |
153 | these have reasonable defaults already. | |
154 | #endif | |
155 | ||
156 | ||
157 | #if 0 | |
158 | @item DO_DEFERRED_STORES | |
159 | @item CLEAR_DEFERRED_STORES | |
160 | Define this to execute any deferred stores of registers into the inferior, | |
161 | and to cancel any deferred stores. | |
162 | Currently only implemented correctly for native Sparc configurations? | |
163 | #endif | |
164 | void carp_do_deferred_stores (void) { return; } | |
165 | void carp_clear_deferred_stores (void) { return; } | |
166 | /* #define DO_DEFERRED_STORES carp_do_deferred_stores () */ | |
167 | /* #define CLEAR_DEFERRED_STORES carp_clear_deferred_stores () */ | |
168 | ||
169 | ||
170 | #if 0 | |
171 | @item CPLUS_MARKER | |
172 | Define this to expand into the character that G++ uses to distinguish | |
173 | compiler-generated identifiers from programmer-specified identifiers. | |
174 | By default, this expands into @code{'$'}. Most System V targets should | |
175 | define this to @code{'.'}. | |
176 | #endif | |
177 | ||
178 | ||
179 | #if 0 | |
180 | @item DBX_PARM_SYMBOL_CLASS | |
181 | Hook for the @code{SYMBOL_CLASS} of a parameter when decoding DBX symbol | |
182 | information. In the i960, parameters can be stored as locals or as | |
183 | args, depending on the type of the debug record. | |
184 | #endif | |
185 | ||
186 | ||
187 | #if 0 | |
188 | @item DECR_PC_AFTER_BREAK | |
189 | Define this to be the amount by which to decrement the PC after the | |
190 | program encounters a breakpoint. This is often the number of bytes in | |
191 | BREAKPOINT, though not always. For most targets this value will be 0. | |
192 | #endif | |
193 | int carp_decr_pc_after_break; | |
194 | /* #define DECR_PC_AFTER_BREAK carp_decr_pc_after_break */ | |
195 | ||
196 | ||
197 | #if 0 | |
198 | @item DECR_PC_AFTER_HW_BREAK | |
199 | Similarly, for hardware breakpoints. | |
200 | #endif | |
201 | int carp_decr_pc_after_hw_break; | |
202 | /* #define DECR_PC_AFTER_HW_BREAK carp_decr_pc_after_hw_break */ | |
203 | ||
204 | ||
205 | #if 0 | |
206 | @item DISABLE_UNSETTABLE_BREAK addr | |
207 | If defined, this should evaluate to 1 if @var{addr} is in a shared | |
208 | library in which breakpoints cannot be set and so should be disabled. | |
209 | #endif | |
210 | ||
211 | ||
212 | #if 0 | |
213 | @item DO_REGISTERS_INFO | |
214 | If defined, use this to print the value of a register or all registers. | |
215 | #endif | |
216 | void carp_do_registers_info (int regnum, int fpregs) { return; } | |
217 | /* #define DO_REGISTERS_INFO(r, f) carp_do_registers_info (r, f) */ | |
218 | ||
219 | ||
220 | #if 0 | |
221 | @item END_OF_TEXT_DEFAULT | |
222 | This is an expression that should designate the end of the text section | |
223 | (? FIXME ?) | |
224 | #endif | |
225 | ||
226 | ||
227 | #if 0 | |
228 | @item EXTRACT_RETURN_VALUE(type,regbuf,valbuf) | |
229 | Define this to extract a functions return value of type @var{type} from | |
230 | the raw register state @var{regbuf} and copy that, in virtual format, | |
231 | into @var{valbuf}. | |
232 | #endif | |
233 | void carp_extract_return_value (struct type *type, char *regbuf, char *valbuf) { return; } | |
234 | /* #define EXTRACT_RETURN_VALUE(type,regbuf,valbuf) carp_extract_return_value(type,regbuf,valbuf) */ | |
235 | ||
236 | ||
237 | #if 0 | |
238 | @item EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) | |
239 | Define this to extract from an array @var{regbuf} containing the (raw) | |
240 | register state, the address in which a function should return its | |
241 | structure value, as a CORE_ADDR (or an expression that can be used as | |
242 | one). | |
243 | #endif | |
244 | CORE_ADDR carp_extract_struct_value_address (char *regbuf) { return 0; } | |
245 | /* #define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) carp_extract_struct_value_address(regbuf) */ | |
246 | ||
247 | ||
248 | #if 0 | |
249 | @item EXTRA_FRAME_INFO | |
250 | If defined, this must be a list of slots that may be inserted into the | |
251 | @code{frame_info} structure defined in @code{frame.h}. | |
252 | #endif | |
253 | ||
254 | ||
255 | #if 0 | |
256 | @item FIX_CALL_DUMMY | |
257 | #endif | |
258 | CORE_ADDR carp_fix_call_dummy (char *dummyname, CORE_ADDR start_sp, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p) { return 0; } | |
259 | /* #define FIX_CALL_DUMMY(dummy1, start_sp, funaddr, nargs, args, value_type, using_gcc) carp_fix_call_dummy (dummy1, start_sp, funaddr, nargs, args, value_type, using_gcc) */ | |
260 | ||
261 | ||
262 | #if 0 | |
263 | @item FLOAT_INFO | |
264 | If defined, then the info float command will print information about | |
265 | the processors floating point unit. | |
266 | #endif | |
267 | void carp_float_info (void) { return; } | |
268 | /* #define FLOAT_INFO carp_float_info () */ | |
269 | ||
270 | ||
271 | #if 0 | |
272 | @item FP_REGNUM | |
273 | The number of the frame pointer register. | |
274 | #endif | |
275 | int carp_fp_regnum; | |
276 | /* #define FP_REGNUM carp_fp_regnum */ | |
277 | ||
278 | ||
279 | #if 0 | |
280 | @item FRAMELESS_FUNCTION_INVOCATION(fi, frameless) | |
281 | Define this to set the variable @var{frameless} to 1 if the function | |
282 | invocation represented by @var{fi} does not have a stack frame | |
283 | associated with it. Otherwise set it to 0. | |
284 | #endif | |
285 | int carp_frameless_function_invocation (struct frame_info *fi) { return 0; } | |
286 | /* #define FRAMELESS_FUNCTION_INVOCATION(fi,frameless) (frameless) = carp_frameless_function_invocation (fi) */ | |
287 | ||
288 | ||
289 | #if 0 | |
290 | @item FRAME_ARGS_ADDRESS | |
291 | stack.c | |
292 | #endif | |
293 | CORE_ADDR carp_frame_args_address (struct frame_info *fi) { return 0; }; | |
294 | /* #define FRAME_ARGS_ADDRESS(FI) carp_frame_args_address (FI) */ | |
295 | ||
296 | ||
297 | #if 0 | |
298 | @item FRAME_ARGS_ADDRESS_CORRECT | |
299 | stack.c | |
300 | #endif | |
301 | CORE_ADDR carp_frame_args_address_correct (struct frame_info *fi) { return 0; } | |
302 | /* #define FRAME_ARGS_ADDRESS_CORRECT(FI) carp_frame_args_address_correct(FI) */ | |
303 | ||
304 | ||
305 | #if 0 | |
306 | @item FRAME_ARGS_SKIP | |
307 | #endif | |
308 | int carp_frame_args_skip; | |
309 | /* #define FRAME_ARGS_SKIP carp_frame_args_skip */ | |
310 | ||
311 | ||
312 | #if 0 | |
313 | @item FRAME_CHAIN(frame) | |
314 | Given @var{frame}, return a pointer to the calling frame. | |
315 | #endif | |
316 | CORE_ADDR carp_frame_chain (struct frame_info *fi) { return 0; } | |
317 | /* #define FRAME_CHAIN(frame) carp_frame_chain (frame) */ | |
318 | ||
319 | ||
320 | #if 0 | |
321 | @item FRAME_CHAIN_COMBINE(chain,frame) | |
322 | Define this to take the frame chain pointer and the frames nominal | |
323 | address and produce the nominal address of the callers frame. | |
324 | Presently only defined for HP PA. | |
325 | #endif | |
326 | CORE_ADDR carp_frame_chain_combine (CORE_ADDR address, struct frame_info *fi) { return 0; } | |
327 | /* #define FRAME_CHAIN_COMBINE(address, frame) carp_frame_chain_combine (address, frame) */ | |
328 | ||
329 | ||
330 | ||
331 | #if 0 | |
332 | @item FRAME_CHAIN_VALID(chain,thisframe) | |
333 | Define this to be an expression that returns zero if the given frame is | |
334 | an outermost frame, with no caller, and nonzero otherwise. The default | |
335 | definition is nonzero if the chain pointer is nonzero and given frames | |
336 | PC is not inside the startup file (such as @file{crt0.o}). The | |
337 | alternate default definition (which is used if | |
338 | FRAME_CHAIN_VALID_ALTERNATE is defined) is nonzero if the chain pointer | |
339 | is nonzero and the given frames PC is not in @code{main()} or a known | |
340 | entry point function (such as @code{_start()}). | |
341 | #endif | |
342 | int carp_frame_chain_valid (CORE_ADDR address, struct frame_info *fi) { return 0; } | |
343 | /* #define FRAME_CHAIN_VALID(address, frame) carp_frame_chain_valid (address, frame) */ | |
344 | ||
345 | ||
346 | #if 0 | |
347 | @item FRAME_CHAIN_VALID_ALTERNATE | |
348 | Define this in order to use the alternate default definition of | |
349 | @code{FRAME_CHAIN_VALID}. | |
350 | #endif | |
351 | ||
352 | ||
353 | #if 0 | |
354 | @item FRAME_FIND_SAVED_REGS | |
355 | stack.c | |
356 | #endif | |
357 | void carp_frame_find_saved_regs (struct frame_info *frame, struct frame_saved_regs *saved_regs_addr) { return; } | |
358 | /* #define FRAME_FIND_SAVED_REGS(frame, saved_regs_addr) carp_frame_find_saved_regs (frame, &(saved_regs_addr)) */ | |
359 | ||
360 | ||
361 | #if 0 | |
362 | @item FRAME_LOCALS_ADDRESS | |
363 | stack.c | |
364 | #endif | |
365 | CORE_ADDR carp_frame_locals_address (struct frame_info *fi) { return 0; }; | |
366 | /* #define FRAME_LOCALS_ADDRESS(FI) carp_frame_locals_address (FI) */ | |
367 | ||
368 | ||
369 | #if 0 | |
370 | @item FRAME_NUM_ARGS (val, fi) | |
371 | For the frame described by fi, set val to the number of arguments | |
372 | that are being passed. | |
373 | #endif | |
374 | int carp_frame_num_args (struct frame_info *fi) { return 0; } | |
375 | /* #define FRAME_NUM_ARGS(val, fi) (val) = carp_frame_num_args (fi) */ | |
376 | ||
377 | ||
378 | #if 0 | |
379 | @item FRAME_SAVED_PC(frame) | |
380 | Given @var{frame}, return the pc saved there. That is, the return | |
381 | address. | |
382 | #endif | |
383 | CORE_ADDR carp_frame_saved_pc (struct frame_info *fi) { return 0; } | |
384 | /* #define FRAME_SAVED_PC(fi) carp_frame_saved_pc (fi) */ | |
385 | ||
386 | ||
387 | #if 0 | |
388 | @item FUNCTION_EPILOGUE_SIZE | |
389 | For some COFF targets, the @code{x_sym.x_misc.x_fsize} field of the | |
390 | function end symbol is 0. For such targets, you must define | |
391 | @code{FUNCTION_EPILOGUE_SIZE} to expand into the standard size of a | |
392 | functions epilogue. | |
393 | #endif | |
394 | int carp_function_epilogue_size; | |
395 | /* #define FUNCTION_EPILOGUE_SIZE carp_function_epilogue_size */ | |
396 | ||
397 | ||
398 | #if 0 | |
399 | @item FUNCTION_START_OFFSET | |
400 | #endif | |
401 | int carp_function_start_offset; | |
402 | /* #define FUNCTION_START_OFFSET carp_function_start_offset */ | |
403 | ||
404 | ||
405 | #if 0 | |
406 | @item GCC_COMPILED_FLAG_SYMBOL | |
407 | @item GCC2_COMPILED_FLAG_SYMBOL | |
408 | If defined, these are the names of the symbols that GDB will look for to | |
409 | detect that GCC compiled the file. The default symbols are | |
410 | @code{gcc_compiled.} and @code{gcc2_compiled.}, respectively. (Currently | |
411 | only defined for the Delta 68.) | |
412 | #endif | |
413 | ||
414 | ||
415 | #if 0 | |
416 | @item GDB_TARGET_IS_HPPA | |
417 | This determines whether horrible kludge code in dbxread.c and | |
418 | partial-stab.h is used to mangle multiple-symbol-table files from | |
419 | HPPAs. This should all be ripped out, and a scheme like elfread.c | |
420 | used. | |
421 | #endif | |
422 | ||
423 | ||
424 | #if 0 | |
425 | @item GDB_TARGET_IS_MACH386 | |
426 | @item GDB_TARGET_IS_SUN3 | |
427 | @item GDB_TARGET_IS_SUN386 | |
428 | Kludges that should go away. | |
429 | #endif | |
430 | ||
431 | ||
432 | #if 0 | |
433 | @item GET_LONGJMP_TARGET | |
434 | For most machines, this is a target-dependent parameter. On the | |
435 | DECstation and the Iris, this is a native-dependent parameter, since | |
436 | <setjmp.h> is needed to define it. | |
437 | ||
438 | This macro determines the target PC address that longjmp() will jump to, | |
439 | assuming that we have just stopped at a longjmp breakpoint. It takes a | |
440 | CORE_ADDR * as argument, and stores the target PC value through this | |
441 | pointer. It examines the current state of the machine as needed. | |
442 | #endif | |
443 | ||
444 | ||
445 | #if 0 | |
446 | @item GET_SAVED_REGISTER | |
447 | Define this if you need to supply your own definition for the function | |
448 | @code{get_saved_register}. Currently this is only done for the a29k. | |
449 | #endif | |
450 | void get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval) { return; } | |
451 | /* #define GET_SAVED_REGISTER */ | |
452 | ||
453 | ||
454 | #if 0 | |
455 | @item HAVE_REGISTER_WINDOWS | |
456 | Define this if the target has register windows. | |
457 | @item REGISTER_IN_WINDOW_P (regnum) | |
458 | Define this to be an expression that is 1 is the given register is in | |
459 | the window. | |
460 | #endif | |
461 | int carp_have_register_windows; | |
462 | int carp_register_in_window_p (int regnum) { return 0; } | |
463 | /* #define HAVE_REGISTER_WINDOWS carp_have_register_windows */ | |
464 | /* #define REGISTER_IN_WINDOW_P(regnum) carp_register_in_window_p (regnum) */ | |
465 | ||
466 | ||
467 | #if 0 | |
468 | @item REGISTER_VIRTUAL_TYPE | |
469 | #endif | |
470 | struct type *carp_register_virtual_type (int regno) { return 0; } | |
471 | /* #define REGISTER_VIRTUAL_TYPE(regno) carp_register_virtual_type (regno) */ | |
472 | ||
473 | ||
474 | ||
475 | #if 0 | |
476 | @item IBM6000_TARGET | |
477 | Shows that we are configured for an IBM RS/6000 target. This | |
478 | conditional should be eliminated (FIXME) and replaced by | |
479 | feature-specific macros. It was introduced in haste and we are | |
480 | repenting at leisure. | |
481 | #endif | |
482 | ||
483 | ||
484 | #if 0 | |
485 | @item IEEE_FLOAT | |
486 | Define this if the target system uses IEEE-format floating point numbers. | |
487 | #endif | |
488 | int carp_ieee_float; | |
489 | /* #define IEEE_FLOAT carp_ieee_float */ | |
490 | ||
491 | ||
492 | #if 0 | |
493 | @item INIT_EXTRA_FRAME_INFO (fromleaf, fci) | |
494 | If defined, this should be a C expression or statement that fills in the | |
495 | @code{EXTRA_FRAME_INFO} slots of the given frame @var{fci}. | |
496 | #endif | |
497 | void carp_init_extra_frame_info (CORE_ADDR fromleaf, struct frame_info *fci) { return; } | |
498 | /* #define INIT_EXTRA_FRAME_INFO(fromleaf, fci) carp_init_extra_frame_info (fromleaf, fci) */ | |
499 | ||
500 | ||
501 | ||
502 | #if 0 | |
503 | @item INIT_FRAME_PC (fromleaf, prev) | |
504 | This is a C statement that sets the pc of the frame pointed to by | |
505 | @var{prev}. [By default...] | |
506 | #endif | |
507 | void carp_init_frame_pc (CORE_ADDR fromleaf, struct frame_info *fci) { return; } | |
508 | /* #define INIT_FRAME_PC(fromleaf, fci) carp_init_frame_pc (fromleaf, fci) */ | |
509 | ||
510 | ||
511 | #if 0 | |
512 | @item INNER_THAN | |
513 | Define this to be either @code{<} if the targets stack grows downward | |
514 | in memory, or @code{>} is the stack grows upwards. | |
515 | #endif | |
516 | /* #define INNER_THAN < */ | |
517 | ||
518 | ||
519 | #if 0 | |
520 | @item IN_SIGTRAMP (pc, name) | |
521 | Define this to return true if the given pc and/or name indicates that | |
522 | the current function is a sigtramp. | |
523 | #endif | |
524 | int carp_in_sigtramp (CORE_ADDR pc, char *name) { return 0; } | |
525 | /* #define IN_SIGTRAMP(pc, name) carp_in_sigtramp (pc, name) */ | |
526 | ||
527 | ||
528 | #if 0 | |
529 | @item SIGTRAMP_START (pc) | |
530 | @item SIGTRAMP_END (pc) | |
531 | Define these to be the start and end address of the sigtramp for the | |
532 | given pc. On machines where the address is just a compile time | |
533 | constant, the macro expansion will typically just ignore the supplied | |
534 | pc. | |
535 | #endif | |
536 | CORE_ADDR carp_sigtramp_start (CORE_ADDR pc) { return 0; } | |
537 | CORE_ADDR carp_sigtramp_end (CORE_ADDR pc) { return 0; } | |
538 | /* #define SIGTRAMP_START(pc) carp_sigtramp_start (pc) */ | |
539 | /* #define SIGTRAMP_END(pc) carp_sigtramp_end (pc) */ | |
540 | ||
541 | ||
542 | #if 0 | |
543 | @item IN_SOLIB_TRAMPOLINE pc name | |
544 | Define this to evaluate to nonzero if the program is stopped in the | |
545 | trampoline that connects to a shared library. | |
546 | #endif | |
547 | ||
548 | ||
549 | #if 0 | |
550 | @item IS_TRAPPED_INTERNALVAR name | |
551 | This is an ugly hook to allow the specification of special actions that | |
552 | should occur as a side-effect of setting the value of a variable | |
553 | internal to GDB. Currently only used by the h8500. Note that this | |
554 | could be either a host or target conditional. | |
555 | #endif | |
556 | int carp_is_trapped_internalvar (char *name) { return 0; } | |
557 | /* #define IS_TRAPPED_INTERNALVAR(name) carp_is_trapped_internalvar (name) */ | |
558 | ||
559 | ||
560 | #if 0 | |
561 | @item KERNEL_DEBUGGING | |
562 | tm-ultra3.h | |
563 | #endif | |
564 | ||
565 | ||
566 | #if 0 | |
567 | @item MAX_REGISTER_RAW_SIZE | |
568 | #endif | |
569 | int carp_max_register_raw_size; | |
570 | /* #define MAX_REGISTER_RAW_SIZE carp_max_register_raw_size */ | |
571 | ||
572 | ||
573 | #if 0 | |
574 | @item MAX_REGISTER_VIRTUAL_SIZE | |
575 | #endif | |
576 | int carp_max_register_virtual_size; | |
577 | /* #define MAX_REGISTER_VIRTUAL_SIZE carp_max_register_virtual_size */ | |
578 | ||
579 | ||
580 | #if 0 | |
581 | @item MIPSEL | |
582 | mips-tdep.c | |
583 | #endif | |
584 | ||
585 | ||
586 | #if 0 | |
587 | @item NEED_TEXT_START_END | |
588 | Define this if GDB should determine the start and end addresses of the | |
589 | text section. (Seems dubious.) | |
590 | #endif | |
591 | int carp_need_text_start_end; | |
592 | /* #define NEED_TEXT_START_END carp_need_text_start_end */ | |
593 | ||
594 | ||
595 | #if 0 | |
596 | @item NO_HIF_SUPPORT | |
597 | (Specific to the a29k.) | |
598 | #endif | |
599 | ||
600 | ||
601 | #if 0 | |
602 | @item NO_SINGLE_STEP | |
603 | Define this if the target does not support single-stepping. If this is | |
604 | defined, you must supply, in @code{*-tdep.c}, the function | |
605 | @code{single_step}, which takes a target_signal as argument and returns | |
606 | nothing. It must insert breakpoints at each possible destinations of | |
607 | the next instruction. See @code{sparc-tdep.c} and @code{rs6000-tdep.c} | |
608 | for examples. | |
609 | #endif | |
610 | int one_stepped; | |
611 | void single_step (enum target_signal signal) { return; } | |
612 | /* #define NO_SINGLE_STEP */ | |
613 | ||
614 | ||
615 | #if 0 | |
616 | @item NUM_REGS | |
617 | #endif | |
618 | int carp_num_regs; | |
619 | /* #define NUM_REGS carp_num_regs */ | |
620 | ||
621 | ||
622 | #if 0 | |
623 | @item PCC_SOL_BROKEN | |
624 | (Used only in the Convex target.) | |
625 | #endif | |
626 | ||
627 | ||
628 | #if 0 | |
629 | @item PC_IN_CALL_DUMMY | |
630 | inferior.h | |
631 | #endif | |
632 | int carp_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp) { return 0; } | |
633 | /* #define PC_IN_CALL_DUMMY(pc, sp, fp) carp_pc_in_call_dummy (pc, sp, fp) */ | |
634 | ||
635 | ||
636 | #if 0 | |
637 | @item PC_LOAD_SEGMENT | |
638 | If defined, print information about the load segment for the program | |
639 | counter. (Defined only for the RS/6000.) | |
640 | #endif | |
641 | ||
642 | ||
643 | #if 0 | |
644 | @item PC_REGNUM | |
645 | If the program counter is kept in a register, then define this macro to | |
646 | be the number of that register. This need be defined only if | |
647 | @code{TARGET_WRITE_PC} is not defined. | |
648 | #endif | |
649 | int carp_pc_regnum; | |
650 | /* #define PC_REGNUM carp_pc_regnum */ | |
651 | ||
652 | ||
653 | #if 0 | |
654 | @item NPC_REGNUM | |
655 | The number of the next program counter register, if defined. | |
656 | #endif | |
657 | ||
658 | ||
659 | #if 0 | |
660 | @item NNPC_REGNUM | |
661 | The number of the next next program counter register, if defined. | |
662 | Currently, this is only defined for the Motorola 88K. | |
663 | #endif | |
664 | ||
665 | ||
666 | #if 0 | |
667 | @item PRINT_REGISTER_HOOK (regno) | |
668 | If defined, this must be a function that prints the contents of the | |
669 | given register to standard output. | |
670 | #endif | |
671 | ||
672 | ||
673 | #if 0 | |
674 | @item PRINT_TYPELESS_INTEGER | |
675 | This is an obscure substitute for @code{print_longest} that seems to | |
676 | have been defined for the Convex target. | |
677 | #endif | |
678 | ||
679 | ||
680 | #if 0 | |
681 | @item PROCESS_LINENUMBER_HOOK | |
682 | A hook defined for XCOFF reading. | |
683 | #endif | |
684 | ||
685 | ||
686 | #if 0 | |
687 | @item PROLOGUE_FIRSTLINE_OVERLAP | |
688 | (Only used in unsupported Convex configuration.) | |
689 | #endif | |
690 | ||
691 | ||
692 | #if 0 | |
693 | @item PS_REGNUM | |
694 | If defined, this is the number of the processor status register. (This | |
695 | definition is only used in generic code when parsing "$ps".) | |
696 | #endif | |
697 | ||
698 | ||
699 | #if 0 | |
700 | @item POP_FRAME | |
701 | Used in @samp{call_function_by_hand} to remove an artificial stack | |
702 | frame. | |
703 | #endif | |
704 | void carp_pop_frame (void) { return; } | |
705 | /* #define POP_FRAME carp_pop_frame () */ | |
706 | ||
707 | ||
708 | #if 0 | |
709 | @item PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr) | |
710 | Define this to push arguments onto the stack for inferior function call. | |
711 | #endif | |
712 | CORE_ADDR carp_push_arguments (int nargs, struct value **args, CORE_ADDR sp, unsigned char struct_return, CORE_ADDR struct_addr) { return 0; } | |
713 | /* #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) (SP) = carp_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) */ | |
714 | ||
715 | ||
716 | #if 0 | |
717 | @item PUSH_DUMMY_FRAME | |
718 | Used in @samp{call_function_by_hand} to create an artificial stack frame. | |
719 | #endif | |
720 | void carp_push_dummy_frame (void) { return; } | |
721 | /* #define PUSH_DUMMY_FRAME carp_push_dummy_frame () */ | |
722 | ||
723 | ||
724 | #if 0 | |
725 | @item REGISTER_BYTE | |
726 | #endif | |
727 | int carp_register_byte (int regnum) { return 0; } | |
728 | #define REGISTER_BYTE(regnum) carp_register_byte (regnum) | |
729 | ||
730 | ||
731 | #if 0 | |
732 | @item REGISTER_BYTES | |
733 | The total amount of space needed to store GDBs copy of the machines | |
734 | register state. | |
735 | #endif | |
736 | int carp_register_bytes; | |
737 | /* #define REGISTER_BYTES carp_register_bytes */ | |
738 | ||
739 | ||
740 | #if 0 | |
741 | @item REGISTER_NAMES | |
742 | Define this to expand into an initializer of an array of strings. Each | |
743 | string is the name of a register. | |
744 | #endif | |
745 | char **carp_register_names; | |
746 | /* #define REGISTER_NAMES carp_register_names */ | |
747 | ||
748 | ||
749 | #if 0 | |
750 | @item REGISTER_RAW_SIZE | |
751 | #endif | |
752 | int carp_register_raw_size (int regnum) { return 0; } | |
753 | /* #define REGISTER_RAW_SIZE(regnum) carp_register_raw_size (regnum) */ | |
754 | ||
755 | ||
756 | #if 0 | |
757 | @item REGISTER_SIZE | |
758 | Size of a general purpose register? | |
759 | #endif | |
760 | int carp_register_size; | |
761 | /* #define REGISTER_SIZE carp_register_size */ | |
762 | ||
763 | ||
764 | #if 0 | |
765 | @item REGISTER_VIRTUAL_SIZE | |
766 | #endif | |
767 | int carp_register_virtual_size (int regnum) { return 0; } | |
768 | /* #define REGISTER_VIRTUAL_SIZE(regnum) carp_register_virtual_size (regnum) */ | |
769 | ||
770 | ||
771 | #if 0 | |
772 | @item REG_STRUCT_HAS_ADDR (gcc_p, type) | |
773 | Define this to return 1 if the given type will be passed by pointer | |
774 | rather than directly. | |
775 | #endif | |
776 | int carp_reg_struct_has_addr (int gcc_p, struct type *type) { return 0; } | |
777 | /* #define REG_STRUCT_HAS_ADDR(gcc_p, type) carp_reg_struct_has_addr (gcc_p, type) */ | |
778 | ||
779 | ||
780 | #if 0 | |
781 | @item SAVED_PC_AFTER_CALL (frame) | |
782 | #endif | |
783 | CORE_ADDR carp_saved_pc_after_call (struct frame_info *frame) { return 0; } | |
784 | /* #define SAVED_PC_AFTER_CALL(frame) carp_saved_pc_after_call (frame) */ | |
785 | ||
786 | ||
787 | #if 0 | |
788 | @item SDB_REG_TO_REGNUM (regnum) | |
789 | Define this to convert sdb register numbers into GDB regnums. If not | |
790 | defined, no conversion will be done. | |
791 | #endif | |
792 | int carp_sdb_reg_to_regnum (int regnum) { return 0; } | |
793 | /* #define SDB_REG_TO_REGNUM(regnum) carp_sdb_reg_to_regnum (regnum) */ | |
794 | ||
795 | ||
796 | #if 0 | |
797 | @item SET_TRAPPED_INTERNALVAR | |
798 | #endif | |
799 | void carp_set_trapped_internalvar (struct internalvar *var, struct value *newval, int bitpos, int bitsize, int offset) { return; } | |
800 | /* #dfine SET_TRAPPED_INTERNALVAR(var, newval, bitpos, bitsize, offset) carp_set_trapped_internalvar (var, newval, bitpos, bitsize, offset) */ | |
801 | ||
802 | ||
803 | #if 0 | |
804 | @item SHIFT_INST_REGS | |
805 | (Only used for m88k targets.) | |
806 | #endif | |
807 | ||
808 | ||
809 | #if 0 | |
810 | @item SKIP_PROLOGUE | |
811 | A C statement that advances the PC across any function entry prologue | |
812 | instructions so as to reach real code. | |
813 | #endif | |
814 | CORE_ADDR carp_skip_prologue (CORE_ADDR pc) { return 0; } | |
815 | /* #define SKIP_PROLOGUE(pc) (pc) = carp_skip_prologue (pc) */ | |
816 | ||
817 | ||
818 | #if 0 | |
819 | @item SKIP_PROLOGUE_FRAMELESS_P | |
820 | A C statement that should behave similarly, but that can stop as soon as | |
821 | the function is known to have a frame. If not defined, | |
822 | @code{SKIP_PROLOGUE} will be used instead. | |
823 | #endif | |
824 | CORE_ADDR carp_skip_prologue_frameless_p (CORE_ADDR pc) { return 0; } | |
825 | /* #define SKIP_PROLOGUE_FRAMELESS_P(pc) (pc) = carp_skip_prologue_frameless_p (pc) */ | |
826 | ||
827 | ||
828 | #if 0 | |
829 | @item SKIP_TRAMPOLINE_CODE (pc) | |
830 | If the target machine has trampoline code that sits between callers and | |
831 | the functions being called, then define this macro to return a new PC | |
832 | that is at the start of the real function. | |
833 | #endif | |
834 | CORE_ADDR carp_skip_trampoline_code (CORE_ADDR pc) { return 0; } | |
835 | /* #define SKIP_TRAMPOLINE_CODE(pc) (pc) = carp_skip_trampoline_code (pc) */ | |
836 | ||
837 | ||
838 | #if 0 | |
839 | @item SP_REGNUM | |
840 | Define this to be the number of the register that serves as the stack | |
841 | pointer. | |
842 | #endif | |
843 | int carp_sp_regnum; | |
844 | /* #define SP_REGNUM carp_sp_regnum */ | |
845 | ||
846 | ||
847 | #if 0 | |
848 | @item STAB_REG_TO_REGNUM | |
849 | Define this to convert stab register numbers (as gotten from r | |
850 | declarations) into GDB regnums. If not defined, no conversion will be | |
851 | done. | |
852 | #endif | |
853 | int carp_stab_reg_to_regnum (int regnum) { return 0; } | |
854 | /* #define STAB_REG_TO_REGNUM(regnum) carp_stab_reg_to_regnum (regnum) */ | |
855 | ||
856 | ||
857 | #if 0 | |
858 | @item STACK_ALIGN (addr) | |
859 | Define this to adjust the address to the alignment required for the | |
860 | processors stack. | |
861 | #endif | |
862 | CORE_ADDR carp_stack_align (CORE_ADDR pc) { return 0; } | |
863 | /* #define STACK_ALIGN(pc) carp_stack_align (pc) */ | |
864 | ||
865 | ||
866 | #if 0 | |
867 | @item STEP_SKIPS_DELAY (addr) | |
868 | Define this to return true if the address is of an instruction with a | |
869 | delay slot. If a breakpoint has been placed in the instructions delay | |
870 | slot, GDB will single-step over that instruction before resuming | |
871 | normally. Currently only defined for the Mips. | |
872 | #endif | |
873 | ||
874 | ||
875 | #if 0 | |
876 | @item STORE_STRUCT_RETURN (type, valbuf) | |
877 | A C expression that stores a function return value of type @var{type}, | |
878 | where @var{valbuf} is the address of the value to be stored. | |
879 | #endif | |
880 | void carp_store_struct_return (CORE_ADDR addr, CORE_ADDR sp) { return; } | |
881 | /* #define STORE_STRUCT_RETURN(addr,sp) carp_store_struct_return (addr, sp) */ | |
882 | ||
883 | ||
884 | #if 0 | |
885 | @item STORE_RETURN_VALUE (type, valbuf) | |
886 | A C expression that stores a function return value of type @var{type}, | |
887 | where @var{valbuf} is the address of the value to be stored. | |
888 | #endif | |
889 | void carp_store_return_value (struct type *type, char *valbuf) { return; } | |
890 | /* #define STORE_RETURN_VALUE(type,valbuf) carp_store_return_value (type, valbuf) */ | |
891 | ||
892 | ||
893 | #if 0 | |
894 | @item SUN_FIXED_LBRAC_BUG | |
895 | (Used only for Sun-3 and Sun-4 targets.) | |
896 | #endif | |
897 | ||
898 | ||
899 | #if 0 | |
900 | @item SYMBOL_RELOADING_DEFAULT | |
901 | The default value of the symbol-reloading variable. (Never defined in | |
902 | current sources.) | |
903 | #endif | |
904 | ||
905 | ||
906 | #if 0 | |
907 | @item TARGET_BYTE_ORDER | |
908 | The ordering of bytes in the target. This must be defined to be either | |
909 | @code{BIG_ENDIAN} or @code{LITTLE_ENDIAN}. | |
910 | #endif | |
911 | int carp_target_byte_order; | |
912 | /* #define TARGET_BYTE_ORDER carp_target_byte_order */ | |
913 | ||
914 | ||
915 | #if 0 | |
916 | @item TARGET_CHAR_BIT | |
917 | Number of bits in a char; defaults to 8. | |
918 | #endif | |
919 | ||
920 | ||
921 | #if 0 | |
922 | @item TARGET_COMPLEX_BIT | |
923 | Number of bits in a complex number; defaults to @code{2 * TARGET_FLOAT_BIT}. | |
924 | #endif | |
925 | int carp_target_complex_bit; | |
926 | /* #define TARGET_COMPLEX_BIT carp_target_complex_bit */ | |
927 | ||
928 | ||
929 | #if 0 | |
930 | @item TARGET_DOUBLE_BIT | |
931 | Number of bits in a double float; defaults to @code{8 * TARGET_CHAR_BIT}. | |
932 | #endif | |
933 | int carp_target_double_bit; | |
934 | /* #define TARGET_DOUBLE_BIT carp_target_double_bit */ | |
935 | ||
936 | ||
937 | #if 0 | |
938 | @item TARGET_DOUBLE_COMPLEX_BIT | |
939 | Number of bits in a double complex; defaults to @code{2 * TARGET_DOUBLE_BIT}. | |
940 | #endif | |
941 | int carp_target_double_complex_bit; | |
942 | /* #define TARGET_DOUBLE_COMPLEX_BIT carp_target_double_complex_bit */ | |
943 | ||
944 | ||
945 | #if 0 | |
946 | @item TARGET_FLOAT_BIT | |
947 | Number of bits in a float; defaults to @code{4 * TARGET_CHAR_BIT}. | |
948 | #endif | |
949 | int carp_target_float_bit; | |
950 | /* #define TARGET_FLOAT_BIT carp_target_float_bit */ | |
951 | ||
952 | ||
953 | #if 0 | |
954 | @item TARGET_INT_BIT | |
955 | Number of bits in an integer; defaults to @code{4 * TARGET_CHAR_BIT}. | |
956 | #endif | |
957 | int carp_target_int_bit; | |
958 | /* #define TARGET_INT_BIT carp_target_int_bit */ | |
959 | ||
960 | ||
961 | #if 0 | |
962 | @item TARGET_LONG_BIT | |
963 | Number of bits in a long integer; defaults to @code{4 * TARGET_CHAR_BIT}. | |
964 | #endif | |
965 | int carp_target_long_bit; | |
966 | /* #define TARGET_LONG_BIT carp_target_long_bit */ | |
967 | ||
968 | ||
969 | #if 0 | |
970 | @item TARGET_LONG_DOUBLE_BIT | |
971 | Number of bits in a long double float; | |
972 | defaults to @code{2 * TARGET_DOUBLE_BIT}. | |
973 | #endif | |
974 | int carp_target_long_double_bit; | |
975 | /* #define TARGET_LONG_DOUBLE_BIT carp_target_long_double_bit */ | |
976 | ||
977 | ||
978 | #if 0 | |
979 | @item TARGET_LONG_LONG_BIT | |
980 | Number of bits in a long long integer; defaults to @code{2 * TARGET_LONG_BIT}. | |
981 | #endif | |
982 | int carp_target_long_long_bit; | |
983 | /* #define TARGET_LONG_LONG_BIT carp_target_long_long_bit */ | |
984 | ||
985 | ||
986 | #if 0 | |
987 | @item TARGET_PTR_BIT | |
988 | Number of bits in a pointer; defaults to @code{TARGET_INT_BIT}. | |
989 | #endif | |
990 | int carp_target_ptr_bit; | |
991 | /* #define TARGET_PTR_BIT carp_target_ptr_bit */ | |
992 | ||
993 | ||
994 | #if 0 | |
995 | @item TARGET_SHORT_BIT | |
996 | Number of bits in a short integer; defaults to @code{2 * TARGET_CHAR_BIT}. | |
997 | #endif | |
998 | int carp_target_short_bit; | |
999 | /* #define TARGET_SHORT_BIT carp_target_short_bit */ | |
1000 | ||
1001 | ||
1002 | #if 0 | |
1003 | @item TARGET_READ_PC | |
1004 | @item TARGET_WRITE_PC (val, pid) | |
1005 | @item TARGET_READ_SP | |
1006 | @item TARGET_WRITE_SP | |
1007 | @item TARGET_READ_FP | |
1008 | @item TARGET_WRITE_FP | |
1009 | These change the behavior of @code{read_pc}, @code{write_pc}, | |
1010 | @code{read_sp}, @code{write_sp}, @code{read_fp} and @code{write_fp}. | |
1011 | For most targets, these may be left undefined. GDB will call the read | |
1012 | and write register functions with the relevant @code{_REGNUM} argument. | |
1013 | ||
1014 | These macros are useful when a target keeps one of these registers in a | |
1015 | hard to get at place; for example, part in a segment register and part | |
1016 | in an ordinary register. | |
1017 | #endif | |
1018 | CORE_ADDR carp_target_read_pc (int pid) { return 0; } | |
1019 | CORE_ADDR carp_target_read_sp (void) { return 0; } | |
1020 | CORE_ADDR carp_target_read_fp (void) { return 0; } | |
1021 | void carp_target_write_pc (CORE_ADDR pc, int pid) { return; } | |
1022 | void carp_target_write_sp (CORE_ADDR sp) { return; } | |
1023 | void carp_target_write_fp (CORE_ADDR fp) { return; } | |
1024 | /* #define TARGET_READ_PC(pid) carp_target_read_pc (pid) */ | |
1025 | /* #define TARGET_WRITE_PC(val,pid) carp_target_write_pc (val, pid) */ | |
1026 | /* #define TARGET_READ_SP() carp_target_read_sp () */ | |
1027 | /* #define TARGET_WRITE_SP(val) carp_target_write_sp (val) */ | |
1028 | /* #define TARGET_READ_FP() carp_target_read_fp () */ | |
1029 | /* #define TARGET_WRITE_FP(val) carp_target_write_fp (val) */ | |
1030 | ||
1031 | ||
1032 | #if 0 | |
1033 | @item USE_STRUCT_CONVENTION (gcc_p, type) | |
1034 | If defined, this must be an expression that is nonzero if a value of the | |
1035 | given @var{type} being returned from a function must have space | |
1036 | allocated for it on the stack. @var{gcc_p} is true if the function | |
1037 | being considered is known to have been compiled by GCC; this is helpful | |
1038 | for systems where GCC is known to use different calling convention than | |
1039 | other compilers. | |
1040 | #endif | |
1041 | ||
1042 | ||
1043 | #if 0 | |
1044 | @item VALUE_OF_TRAPPED_INTERNALVAR | |
1045 | #endif | |
1046 | struct value *carp_value_of_trapped_internalvar (struct internalvar *var) { return 0; } | |
1047 | /* #define VALUE_OF_TRAPPED_INTERNALVAR(var) carp_value_of_trapped_internalvar (var) */ | |
1048 | ||
1049 | ||
1050 | #if 0 | |
1051 | @item VARIABLES_INSIDE_BLOCK (desc, gcc_p) | |
1052 | For dbx-style debugging information, if the compiler puts variable | |
1053 | declarations inside LBRAC/RBRAC blocks, this should be defined to be | |
1054 | nonzero. @var{desc} is the value of @code{n_desc} from the | |
1055 | @code{N_RBRAC} symbol, and @var{gcc_p} is true if GDB has noticed the | |
1056 | presence of either the @code{GCC_COMPILED_SYMBOL} or the | |
1057 | @code{GCC2_COMPILED_SYMBOL}. By default, this is 0. | |
1058 | #endif | |
1059 | ||
1060 | ||
1061 | #if 0 | |
1062 | @item OS9K_VARIABLES_INSIDE_BLOCK (desc, gcc_p) | |
1063 | Similarly, for OS/9000. Defaults to 1. | |
1064 | #endif |