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 < */ | |
3a0c96a9 AC |
517 | extern int carp_inner_than (int, int); |
518 | #define INNER_THAN(x,y) carp_inner_than(x,y) | |
24615880 AC |
519 | |
520 | ||
521 | #if 0 | |
522 | @item IN_SIGTRAMP (pc, name) | |
523 | Define this to return true if the given pc and/or name indicates that | |
524 | the current function is a sigtramp. | |
525 | #endif | |
526 | int carp_in_sigtramp (CORE_ADDR pc, char *name) { return 0; } | |
527 | /* #define IN_SIGTRAMP(pc, name) carp_in_sigtramp (pc, name) */ | |
528 | ||
529 | ||
530 | #if 0 | |
531 | @item SIGTRAMP_START (pc) | |
532 | @item SIGTRAMP_END (pc) | |
533 | Define these to be the start and end address of the sigtramp for the | |
534 | given pc. On machines where the address is just a compile time | |
535 | constant, the macro expansion will typically just ignore the supplied | |
536 | pc. | |
537 | #endif | |
538 | CORE_ADDR carp_sigtramp_start (CORE_ADDR pc) { return 0; } | |
539 | CORE_ADDR carp_sigtramp_end (CORE_ADDR pc) { return 0; } | |
540 | /* #define SIGTRAMP_START(pc) carp_sigtramp_start (pc) */ | |
541 | /* #define SIGTRAMP_END(pc) carp_sigtramp_end (pc) */ | |
542 | ||
543 | ||
544 | #if 0 | |
545 | @item IN_SOLIB_TRAMPOLINE pc name | |
546 | Define this to evaluate to nonzero if the program is stopped in the | |
547 | trampoline that connects to a shared library. | |
548 | #endif | |
549 | ||
550 | ||
551 | #if 0 | |
552 | @item IS_TRAPPED_INTERNALVAR name | |
553 | This is an ugly hook to allow the specification of special actions that | |
554 | should occur as a side-effect of setting the value of a variable | |
555 | internal to GDB. Currently only used by the h8500. Note that this | |
556 | could be either a host or target conditional. | |
557 | #endif | |
558 | int carp_is_trapped_internalvar (char *name) { return 0; } | |
559 | /* #define IS_TRAPPED_INTERNALVAR(name) carp_is_trapped_internalvar (name) */ | |
560 | ||
561 | ||
562 | #if 0 | |
563 | @item KERNEL_DEBUGGING | |
564 | tm-ultra3.h | |
565 | #endif | |
566 | ||
567 | ||
568 | #if 0 | |
569 | @item MAX_REGISTER_RAW_SIZE | |
570 | #endif | |
571 | int carp_max_register_raw_size; | |
572 | /* #define MAX_REGISTER_RAW_SIZE carp_max_register_raw_size */ | |
573 | ||
574 | ||
575 | #if 0 | |
576 | @item MAX_REGISTER_VIRTUAL_SIZE | |
577 | #endif | |
578 | int carp_max_register_virtual_size; | |
579 | /* #define MAX_REGISTER_VIRTUAL_SIZE carp_max_register_virtual_size */ | |
580 | ||
581 | ||
582 | #if 0 | |
583 | @item MIPSEL | |
584 | mips-tdep.c | |
585 | #endif | |
586 | ||
587 | ||
588 | #if 0 | |
589 | @item NEED_TEXT_START_END | |
590 | Define this if GDB should determine the start and end addresses of the | |
591 | text section. (Seems dubious.) | |
592 | #endif | |
593 | int carp_need_text_start_end; | |
594 | /* #define NEED_TEXT_START_END carp_need_text_start_end */ | |
595 | ||
596 | ||
597 | #if 0 | |
598 | @item NO_HIF_SUPPORT | |
599 | (Specific to the a29k.) | |
600 | #endif | |
601 | ||
602 | ||
603 | #if 0 | |
02331869 AC |
604 | @item SOFTWARE_SINGLE_STEP_P |
605 | @ttem SOFTWARE_SINGLE_STEP | |
606 | #endif | |
607 | int carp_software_single_step_p; | |
608 | void carp_software_single_step (int signal, int bp_p) { return; } | |
24615880 AC |
609 | |
610 | #if 0 | |
611 | @item NUM_REGS | |
612 | #endif | |
613 | int carp_num_regs; | |
614 | /* #define NUM_REGS carp_num_regs */ | |
615 | ||
616 | ||
617 | #if 0 | |
618 | @item PCC_SOL_BROKEN | |
619 | (Used only in the Convex target.) | |
620 | #endif | |
621 | ||
622 | ||
623 | #if 0 | |
624 | @item PC_IN_CALL_DUMMY | |
625 | inferior.h | |
626 | #endif | |
627 | int carp_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp) { return 0; } | |
628 | /* #define PC_IN_CALL_DUMMY(pc, sp, fp) carp_pc_in_call_dummy (pc, sp, fp) */ | |
629 | ||
630 | ||
631 | #if 0 | |
632 | @item PC_LOAD_SEGMENT | |
633 | If defined, print information about the load segment for the program | |
634 | counter. (Defined only for the RS/6000.) | |
635 | #endif | |
636 | ||
637 | ||
638 | #if 0 | |
639 | @item PC_REGNUM | |
640 | If the program counter is kept in a register, then define this macro to | |
641 | be the number of that register. This need be defined only if | |
642 | @code{TARGET_WRITE_PC} is not defined. | |
643 | #endif | |
644 | int carp_pc_regnum; | |
645 | /* #define PC_REGNUM carp_pc_regnum */ | |
646 | ||
647 | ||
648 | #if 0 | |
649 | @item NPC_REGNUM | |
650 | The number of the next program counter register, if defined. | |
651 | #endif | |
652 | ||
653 | ||
654 | #if 0 | |
655 | @item NNPC_REGNUM | |
656 | The number of the next next program counter register, if defined. | |
657 | Currently, this is only defined for the Motorola 88K. | |
658 | #endif | |
659 | ||
660 | ||
661 | #if 0 | |
662 | @item PRINT_REGISTER_HOOK (regno) | |
663 | If defined, this must be a function that prints the contents of the | |
664 | given register to standard output. | |
665 | #endif | |
666 | ||
667 | ||
668 | #if 0 | |
669 | @item PRINT_TYPELESS_INTEGER | |
670 | This is an obscure substitute for @code{print_longest} that seems to | |
671 | have been defined for the Convex target. | |
672 | #endif | |
673 | ||
674 | ||
675 | #if 0 | |
676 | @item PROCESS_LINENUMBER_HOOK | |
677 | A hook defined for XCOFF reading. | |
678 | #endif | |
679 | ||
680 | ||
681 | #if 0 | |
682 | @item PROLOGUE_FIRSTLINE_OVERLAP | |
683 | (Only used in unsupported Convex configuration.) | |
684 | #endif | |
685 | ||
686 | ||
687 | #if 0 | |
688 | @item PS_REGNUM | |
689 | If defined, this is the number of the processor status register. (This | |
690 | definition is only used in generic code when parsing "$ps".) | |
691 | #endif | |
692 | ||
693 | ||
694 | #if 0 | |
695 | @item POP_FRAME | |
696 | Used in @samp{call_function_by_hand} to remove an artificial stack | |
697 | frame. | |
698 | #endif | |
699 | void carp_pop_frame (void) { return; } | |
700 | /* #define POP_FRAME carp_pop_frame () */ | |
701 | ||
702 | ||
703 | #if 0 | |
704 | @item PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr) | |
705 | Define this to push arguments onto the stack for inferior function call. | |
706 | #endif | |
707 | CORE_ADDR carp_push_arguments (int nargs, struct value **args, CORE_ADDR sp, unsigned char struct_return, CORE_ADDR struct_addr) { return 0; } | |
708 | /* #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) (SP) = carp_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) */ | |
709 | ||
710 | ||
711 | #if 0 | |
712 | @item PUSH_DUMMY_FRAME | |
713 | Used in @samp{call_function_by_hand} to create an artificial stack frame. | |
714 | #endif | |
715 | void carp_push_dummy_frame (void) { return; } | |
716 | /* #define PUSH_DUMMY_FRAME carp_push_dummy_frame () */ | |
717 | ||
718 | ||
719 | #if 0 | |
720 | @item REGISTER_BYTE | |
721 | #endif | |
722 | int carp_register_byte (int regnum) { return 0; } | |
723 | #define REGISTER_BYTE(regnum) carp_register_byte (regnum) | |
724 | ||
725 | ||
726 | #if 0 | |
727 | @item REGISTER_BYTES | |
728 | The total amount of space needed to store GDBs copy of the machines | |
729 | register state. | |
730 | #endif | |
731 | int carp_register_bytes; | |
732 | /* #define REGISTER_BYTES carp_register_bytes */ | |
733 | ||
734 | ||
735 | #if 0 | |
736 | @item REGISTER_NAMES | |
737 | Define this to expand into an initializer of an array of strings. Each | |
738 | string is the name of a register. | |
739 | #endif | |
740 | char **carp_register_names; | |
741 | /* #define REGISTER_NAMES carp_register_names */ | |
742 | ||
743 | ||
744 | #if 0 | |
745 | @item REGISTER_RAW_SIZE | |
746 | #endif | |
747 | int carp_register_raw_size (int regnum) { return 0; } | |
748 | /* #define REGISTER_RAW_SIZE(regnum) carp_register_raw_size (regnum) */ | |
749 | ||
750 | ||
751 | #if 0 | |
752 | @item REGISTER_SIZE | |
753 | Size of a general purpose register? | |
754 | #endif | |
755 | int carp_register_size; | |
756 | /* #define REGISTER_SIZE carp_register_size */ | |
757 | ||
758 | ||
759 | #if 0 | |
760 | @item REGISTER_VIRTUAL_SIZE | |
761 | #endif | |
762 | int carp_register_virtual_size (int regnum) { return 0; } | |
763 | /* #define REGISTER_VIRTUAL_SIZE(regnum) carp_register_virtual_size (regnum) */ | |
764 | ||
765 | ||
766 | #if 0 | |
767 | @item REG_STRUCT_HAS_ADDR (gcc_p, type) | |
768 | Define this to return 1 if the given type will be passed by pointer | |
769 | rather than directly. | |
770 | #endif | |
771 | int carp_reg_struct_has_addr (int gcc_p, struct type *type) { return 0; } | |
772 | /* #define REG_STRUCT_HAS_ADDR(gcc_p, type) carp_reg_struct_has_addr (gcc_p, type) */ | |
773 | ||
774 | ||
775 | #if 0 | |
776 | @item SAVED_PC_AFTER_CALL (frame) | |
777 | #endif | |
778 | CORE_ADDR carp_saved_pc_after_call (struct frame_info *frame) { return 0; } | |
779 | /* #define SAVED_PC_AFTER_CALL(frame) carp_saved_pc_after_call (frame) */ | |
780 | ||
781 | ||
782 | #if 0 | |
783 | @item SDB_REG_TO_REGNUM (regnum) | |
784 | Define this to convert sdb register numbers into GDB regnums. If not | |
785 | defined, no conversion will be done. | |
786 | #endif | |
787 | int carp_sdb_reg_to_regnum (int regnum) { return 0; } | |
788 | /* #define SDB_REG_TO_REGNUM(regnum) carp_sdb_reg_to_regnum (regnum) */ | |
789 | ||
790 | ||
791 | #if 0 | |
792 | @item SET_TRAPPED_INTERNALVAR | |
793 | #endif | |
794 | void carp_set_trapped_internalvar (struct internalvar *var, struct value *newval, int bitpos, int bitsize, int offset) { return; } | |
795 | /* #dfine SET_TRAPPED_INTERNALVAR(var, newval, bitpos, bitsize, offset) carp_set_trapped_internalvar (var, newval, bitpos, bitsize, offset) */ | |
796 | ||
797 | ||
798 | #if 0 | |
799 | @item SHIFT_INST_REGS | |
800 | (Only used for m88k targets.) | |
801 | #endif | |
802 | ||
803 | ||
804 | #if 0 | |
805 | @item SKIP_PROLOGUE | |
806 | A C statement that advances the PC across any function entry prologue | |
807 | instructions so as to reach real code. | |
808 | #endif | |
809 | CORE_ADDR carp_skip_prologue (CORE_ADDR pc) { return 0; } | |
810 | /* #define SKIP_PROLOGUE(pc) (pc) = carp_skip_prologue (pc) */ | |
811 | ||
812 | ||
813 | #if 0 | |
814 | @item SKIP_PROLOGUE_FRAMELESS_P | |
815 | A C statement that should behave similarly, but that can stop as soon as | |
816 | the function is known to have a frame. If not defined, | |
817 | @code{SKIP_PROLOGUE} will be used instead. | |
818 | #endif | |
819 | CORE_ADDR carp_skip_prologue_frameless_p (CORE_ADDR pc) { return 0; } | |
820 | /* #define SKIP_PROLOGUE_FRAMELESS_P(pc) (pc) = carp_skip_prologue_frameless_p (pc) */ | |
821 | ||
822 | ||
823 | #if 0 | |
824 | @item SKIP_TRAMPOLINE_CODE (pc) | |
825 | If the target machine has trampoline code that sits between callers and | |
826 | the functions being called, then define this macro to return a new PC | |
827 | that is at the start of the real function. | |
828 | #endif | |
829 | CORE_ADDR carp_skip_trampoline_code (CORE_ADDR pc) { return 0; } | |
830 | /* #define SKIP_TRAMPOLINE_CODE(pc) (pc) = carp_skip_trampoline_code (pc) */ | |
831 | ||
832 | ||
833 | #if 0 | |
834 | @item SP_REGNUM | |
835 | Define this to be the number of the register that serves as the stack | |
836 | pointer. | |
837 | #endif | |
838 | int carp_sp_regnum; | |
839 | /* #define SP_REGNUM carp_sp_regnum */ | |
840 | ||
841 | ||
842 | #if 0 | |
843 | @item STAB_REG_TO_REGNUM | |
844 | Define this to convert stab register numbers (as gotten from r | |
845 | declarations) into GDB regnums. If not defined, no conversion will be | |
846 | done. | |
847 | #endif | |
848 | int carp_stab_reg_to_regnum (int regnum) { return 0; } | |
849 | /* #define STAB_REG_TO_REGNUM(regnum) carp_stab_reg_to_regnum (regnum) */ | |
850 | ||
851 | ||
852 | #if 0 | |
853 | @item STACK_ALIGN (addr) | |
854 | Define this to adjust the address to the alignment required for the | |
855 | processors stack. | |
856 | #endif | |
857 | CORE_ADDR carp_stack_align (CORE_ADDR pc) { return 0; } | |
858 | /* #define STACK_ALIGN(pc) carp_stack_align (pc) */ | |
859 | ||
860 | ||
861 | #if 0 | |
862 | @item STEP_SKIPS_DELAY (addr) | |
863 | Define this to return true if the address is of an instruction with a | |
864 | delay slot. If a breakpoint has been placed in the instructions delay | |
865 | slot, GDB will single-step over that instruction before resuming | |
866 | normally. Currently only defined for the Mips. | |
867 | #endif | |
868 | ||
869 | ||
870 | #if 0 | |
871 | @item STORE_STRUCT_RETURN (type, valbuf) | |
872 | A C expression that stores a function return value of type @var{type}, | |
873 | where @var{valbuf} is the address of the value to be stored. | |
874 | #endif | |
875 | void carp_store_struct_return (CORE_ADDR addr, CORE_ADDR sp) { return; } | |
876 | /* #define STORE_STRUCT_RETURN(addr,sp) carp_store_struct_return (addr, sp) */ | |
877 | ||
878 | ||
879 | #if 0 | |
880 | @item STORE_RETURN_VALUE (type, valbuf) | |
881 | A C expression that stores a function return value of type @var{type}, | |
882 | where @var{valbuf} is the address of the value to be stored. | |
883 | #endif | |
884 | void carp_store_return_value (struct type *type, char *valbuf) { return; } | |
885 | /* #define STORE_RETURN_VALUE(type,valbuf) carp_store_return_value (type, valbuf) */ | |
886 | ||
887 | ||
888 | #if 0 | |
889 | @item SUN_FIXED_LBRAC_BUG | |
890 | (Used only for Sun-3 and Sun-4 targets.) | |
891 | #endif | |
892 | ||
893 | ||
894 | #if 0 | |
895 | @item SYMBOL_RELOADING_DEFAULT | |
896 | The default value of the symbol-reloading variable. (Never defined in | |
897 | current sources.) | |
898 | #endif | |
899 | ||
900 | ||
901 | #if 0 | |
902 | @item TARGET_BYTE_ORDER | |
903 | The ordering of bytes in the target. This must be defined to be either | |
904 | @code{BIG_ENDIAN} or @code{LITTLE_ENDIAN}. | |
905 | #endif | |
906 | int carp_target_byte_order; | |
907 | /* #define TARGET_BYTE_ORDER carp_target_byte_order */ | |
908 | ||
909 | ||
910 | #if 0 | |
911 | @item TARGET_CHAR_BIT | |
912 | Number of bits in a char; defaults to 8. | |
913 | #endif | |
914 | ||
915 | ||
916 | #if 0 | |
917 | @item TARGET_COMPLEX_BIT | |
918 | Number of bits in a complex number; defaults to @code{2 * TARGET_FLOAT_BIT}. | |
919 | #endif | |
920 | int carp_target_complex_bit; | |
921 | /* #define TARGET_COMPLEX_BIT carp_target_complex_bit */ | |
922 | ||
923 | ||
924 | #if 0 | |
925 | @item TARGET_DOUBLE_BIT | |
926 | Number of bits in a double float; defaults to @code{8 * TARGET_CHAR_BIT}. | |
927 | #endif | |
928 | int carp_target_double_bit; | |
929 | /* #define TARGET_DOUBLE_BIT carp_target_double_bit */ | |
930 | ||
931 | ||
932 | #if 0 | |
933 | @item TARGET_DOUBLE_COMPLEX_BIT | |
934 | Number of bits in a double complex; defaults to @code{2 * TARGET_DOUBLE_BIT}. | |
935 | #endif | |
936 | int carp_target_double_complex_bit; | |
937 | /* #define TARGET_DOUBLE_COMPLEX_BIT carp_target_double_complex_bit */ | |
938 | ||
939 | ||
940 | #if 0 | |
941 | @item TARGET_FLOAT_BIT | |
942 | Number of bits in a float; defaults to @code{4 * TARGET_CHAR_BIT}. | |
943 | #endif | |
944 | int carp_target_float_bit; | |
945 | /* #define TARGET_FLOAT_BIT carp_target_float_bit */ | |
946 | ||
947 | ||
948 | #if 0 | |
949 | @item TARGET_INT_BIT | |
950 | Number of bits in an integer; defaults to @code{4 * TARGET_CHAR_BIT}. | |
951 | #endif | |
952 | int carp_target_int_bit; | |
953 | /* #define TARGET_INT_BIT carp_target_int_bit */ | |
954 | ||
955 | ||
956 | #if 0 | |
957 | @item TARGET_LONG_BIT | |
958 | Number of bits in a long integer; defaults to @code{4 * TARGET_CHAR_BIT}. | |
959 | #endif | |
960 | int carp_target_long_bit; | |
961 | /* #define TARGET_LONG_BIT carp_target_long_bit */ | |
962 | ||
963 | ||
964 | #if 0 | |
965 | @item TARGET_LONG_DOUBLE_BIT | |
966 | Number of bits in a long double float; | |
967 | defaults to @code{2 * TARGET_DOUBLE_BIT}. | |
968 | #endif | |
969 | int carp_target_long_double_bit; | |
970 | /* #define TARGET_LONG_DOUBLE_BIT carp_target_long_double_bit */ | |
971 | ||
972 | ||
973 | #if 0 | |
974 | @item TARGET_LONG_LONG_BIT | |
975 | Number of bits in a long long integer; defaults to @code{2 * TARGET_LONG_BIT}. | |
976 | #endif | |
977 | int carp_target_long_long_bit; | |
978 | /* #define TARGET_LONG_LONG_BIT carp_target_long_long_bit */ | |
979 | ||
980 | ||
981 | #if 0 | |
982 | @item TARGET_PTR_BIT | |
983 | Number of bits in a pointer; defaults to @code{TARGET_INT_BIT}. | |
984 | #endif | |
985 | int carp_target_ptr_bit; | |
986 | /* #define TARGET_PTR_BIT carp_target_ptr_bit */ | |
987 | ||
988 | ||
989 | #if 0 | |
990 | @item TARGET_SHORT_BIT | |
991 | Number of bits in a short integer; defaults to @code{2 * TARGET_CHAR_BIT}. | |
992 | #endif | |
993 | int carp_target_short_bit; | |
994 | /* #define TARGET_SHORT_BIT carp_target_short_bit */ | |
995 | ||
996 | ||
997 | #if 0 | |
998 | @item TARGET_READ_PC | |
999 | @item TARGET_WRITE_PC (val, pid) | |
1000 | @item TARGET_READ_SP | |
1001 | @item TARGET_WRITE_SP | |
1002 | @item TARGET_READ_FP | |
1003 | @item TARGET_WRITE_FP | |
1004 | These change the behavior of @code{read_pc}, @code{write_pc}, | |
1005 | @code{read_sp}, @code{write_sp}, @code{read_fp} and @code{write_fp}. | |
1006 | For most targets, these may be left undefined. GDB will call the read | |
1007 | and write register functions with the relevant @code{_REGNUM} argument. | |
1008 | ||
1009 | These macros are useful when a target keeps one of these registers in a | |
1010 | hard to get at place; for example, part in a segment register and part | |
1011 | in an ordinary register. | |
1012 | #endif | |
1013 | CORE_ADDR carp_target_read_pc (int pid) { return 0; } | |
1014 | CORE_ADDR carp_target_read_sp (void) { return 0; } | |
1015 | CORE_ADDR carp_target_read_fp (void) { return 0; } | |
1016 | void carp_target_write_pc (CORE_ADDR pc, int pid) { return; } | |
1017 | void carp_target_write_sp (CORE_ADDR sp) { return; } | |
1018 | void carp_target_write_fp (CORE_ADDR fp) { return; } | |
1019 | /* #define TARGET_READ_PC(pid) carp_target_read_pc (pid) */ | |
1020 | /* #define TARGET_WRITE_PC(val,pid) carp_target_write_pc (val, pid) */ | |
1021 | /* #define TARGET_READ_SP() carp_target_read_sp () */ | |
1022 | /* #define TARGET_WRITE_SP(val) carp_target_write_sp (val) */ | |
1023 | /* #define TARGET_READ_FP() carp_target_read_fp () */ | |
1024 | /* #define TARGET_WRITE_FP(val) carp_target_write_fp (val) */ | |
1025 | ||
1026 | ||
1027 | #if 0 | |
1028 | @item USE_STRUCT_CONVENTION (gcc_p, type) | |
1029 | If defined, this must be an expression that is nonzero if a value of the | |
1030 | given @var{type} being returned from a function must have space | |
1031 | allocated for it on the stack. @var{gcc_p} is true if the function | |
1032 | being considered is known to have been compiled by GCC; this is helpful | |
1033 | for systems where GCC is known to use different calling convention than | |
1034 | other compilers. | |
1035 | #endif | |
1036 | ||
1037 | ||
1038 | #if 0 | |
1039 | @item VALUE_OF_TRAPPED_INTERNALVAR | |
1040 | #endif | |
1041 | struct value *carp_value_of_trapped_internalvar (struct internalvar *var) { return 0; } | |
1042 | /* #define VALUE_OF_TRAPPED_INTERNALVAR(var) carp_value_of_trapped_internalvar (var) */ | |
1043 | ||
1044 | ||
1045 | #if 0 | |
1046 | @item VARIABLES_INSIDE_BLOCK (desc, gcc_p) | |
1047 | For dbx-style debugging information, if the compiler puts variable | |
1048 | declarations inside LBRAC/RBRAC blocks, this should be defined to be | |
1049 | nonzero. @var{desc} is the value of @code{n_desc} from the | |
1050 | @code{N_RBRAC} symbol, and @var{gcc_p} is true if GDB has noticed the | |
1051 | presence of either the @code{GCC_COMPILED_SYMBOL} or the | |
1052 | @code{GCC2_COMPILED_SYMBOL}. By default, this is 0. | |
1053 | #endif | |
1054 | ||
1055 | ||
1056 | #if 0 | |
1057 | @item OS9K_VARIABLES_INSIDE_BLOCK (desc, gcc_p) | |
1058 | Similarly, for OS/9000. Defaults to 1. | |
1059 | #endif |