9 int carp_sizeof_struct_frame_saved_regs
;
10 /* #define SIZEOF_STRUCT_FRAME_SAVED_REGS carp_sizeof_struct_frame_saved_regs */
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
.
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)}.
36 CORE_ADDR
carp_addr_bits_remove (CORE_ADDR addr
) { return 0; }
37 /* #define ADDR_BITS_REMOVE(addr) carp_addr_bits_remove (addr) */
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
.
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
58 int carp_believe_pcc_promotion
;
59 /* #define BELIEVE_PCC_PROMOTION carp_believe_pcc_promotion */
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
.
68 int carp_believe_pcc_promotion_type
;
69 /* #define BELIEVE_PCC_PROMOTION_TYPE carp_believe_pcc_promotion_type */
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
.
78 int carp_bits_big_endian
;
79 /* #define BITS_BIG_ENDIAN carp_bits_big_endian */
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
.
90 char *carp_breakpoint
;
91 /* #define BREAKPOINT carp_breakpoint */
96 @item LITTLE_BREAKPOINT
97 Similar to BREAKPOINT
, but used
for bi
-endian targets
.
99 char *carp_big_breakpoint
;
100 char *carp_little_breakpoint
;
101 /* #define BIG_BREAKPOINT carp_big_breakpoint */
102 /* #define LITTLE_BREAKPOINT carp_little_breakpoint */
108 @item CALL_DUMMY_LOCATION
110 @item CALL_DUMMY_STACK_ADJUST
112 @item CALL_DUMMY_START_OFFSET
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 */
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
.
132 int carp_cannot_fetch_register
;
133 /* #define CANNOT_FETCH_REGISTER(regno) carp_cannot_fetch_register(regno) */
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
.
143 int carp_cannot_store_register (int regno
) { return 0; }
144 /* #define CANNOT_STORE_REGISTER(regno) carp_cannot_store_register(regno) */
152 If defined
, these are the producer strings in a DWARF
1 file
. All of
153 these have reasonable defaults already
.
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
?
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 () */
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
{'.'}.
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
.
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.
193 int carp_decr_pc_after_break
;
194 /* #define DECR_PC_AFTER_BREAK carp_decr_pc_after_break */
198 @item DECR_PC_AFTER_HW_BREAK
199 Similarly
, for hardware breakpoints
.
201 int carp_decr_pc_after_hw_break
;
202 /* #define DECR_PC_AFTER_HW_BREAK carp_decr_pc_after_hw_break */
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
.
213 @item DO_REGISTERS_INFO
214 If defined
, use
this to print the value of a
register or all registers
.
216 void carp_do_registers_info (int regnum
, int fpregs
) { return; }
217 /* #define DO_REGISTERS_INFO(r, f) carp_do_registers_info (r, f) */
221 @item END_OF_TEXT_DEFAULT
222 This is an expression that should designate the end of the text section
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
,
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) */
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
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) */
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
}.
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) */
264 If defined
, then the info
float command will print information about
265 the processors floating point unit
.
267 void carp_float_info (void) { return; }
268 /* #define FLOAT_INFO carp_float_info () */
273 The number of the frame pointer
register.
276 /* #define FP_REGNUM carp_fp_regnum */
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.
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) */
290 @item FRAME_ARGS_ADDRESS
293 CORE_ADDR
carp_frame_args_address (struct frame_info
*fi
) { return 0; };
294 /* #define FRAME_ARGS_ADDRESS(FI) carp_frame_args_address (FI) */
298 @item FRAME_ARGS_ADDRESS_CORRECT
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) */
306 @item FRAME_ARGS_SKIP
308 int carp_frame_args_skip
;
309 /* #define FRAME_ARGS_SKIP carp_frame_args_skip */
313 @item
FRAME_CHAIN(frame
)
314 Given @var
{frame
}, return a pointer to the calling frame
.
316 CORE_ADDR
carp_frame_chain (struct frame_info
*fi
) { return 0; }
317 /* #define FRAME_CHAIN(frame) carp_frame_chain (frame) */
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
.
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) */
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()}).
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) */
347 @item FRAME_CHAIN_VALID_ALTERNATE
348 Define
this in order to use the alternate
default definition of
349 @code
{FRAME_CHAIN_VALID
}.
354 @item FRAME_FIND_SAVED_REGS
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)) */
362 @item FRAME_LOCALS_ADDRESS
365 CORE_ADDR
carp_frame_locals_address (struct frame_info
*fi
) { return 0; };
366 /* #define FRAME_LOCALS_ADDRESS(FI) carp_frame_locals_address (FI) */
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
.
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) */
379 @item
FRAME_SAVED_PC(frame
)
380 Given @var
{frame
}, return the pc saved there
. That is
, the
return
383 CORE_ADDR
carp_frame_saved_pc (struct frame_info
*fi
) { return 0; }
384 /* #define FRAME_SAVED_PC(fi) carp_frame_saved_pc (fi) */
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
394 int carp_function_epilogue_size
;
395 /* #define FUNCTION_EPILOGUE_SIZE carp_function_epilogue_size */
399 @item FUNCTION_START_OFFSET
401 int carp_function_start_offset
;
402 /* #define FUNCTION_START_OFFSET carp_function_start_offset */
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.)
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
425 @item GDB_TARGET_IS_MACH386
426 @item GDB_TARGET_IS_SUN3
427 @item GDB_TARGET_IS_SUN386
428 Kludges that should go away
.
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
.
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
.
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
.
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 */
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
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) */
468 @item REGISTER_VIRTUAL_TYPE
470 struct type
*carp_register_virtual_type (int regno
) { return 0; }
471 /* #define REGISTER_VIRTUAL_TYPE(regno) carp_register_virtual_type (regno) */
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
.
486 Define
this if the target system uses IEEE
-format floating point numbers
.
489 /* #define IEEE_FLOAT carp_ieee_float */
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
}.
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) */
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...]
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) */
513 Define
this to be either @code
{<} if the targets stack grows downward
514 in memory
, or @code
{>} is the stack grows upwards
.
516 /* #define INNER_THAN < */
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
.
524 int carp_in_sigtramp (CORE_ADDR pc
, char *name
) { return 0; }
525 /* #define IN_SIGTRAMP(pc, name) carp_in_sigtramp (pc, name) */
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
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) */
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
.
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
.
556 int carp_is_trapped_internalvar (char *name
) { return 0; }
557 /* #define IS_TRAPPED_INTERNALVAR(name) carp_is_trapped_internalvar (name) */
561 @item KERNEL_DEBUGGING
567 @item MAX_REGISTER_RAW_SIZE
569 int carp_max_register_raw_size
;
570 /* #define MAX_REGISTER_RAW_SIZE carp_max_register_raw_size */
574 @item MAX_REGISTER_VIRTUAL_SIZE
576 int carp_max_register_virtual_size
;
577 /* #define MAX_REGISTER_VIRTUAL_SIZE carp_max_register_virtual_size */
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
.)
591 int carp_need_text_start_end
;
592 /* #define NEED_TEXT_START_END carp_need_text_start_end */
597 (Specific to the a29k
.)
602 @item SOFTWARE_SINGLE_STEP_P
603 @ttem SOFTWARE_SINGLE_STEP
605 int carp_software_single_step_p
;
606 void carp_software_single_step (int signal
, int bp_p
) { return; }
612 /* #define NUM_REGS carp_num_regs */
617 (Used only in the Convex target
.)
622 @item PC_IN_CALL_DUMMY
625 int carp_pc_in_call_dummy (CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR fp
) { return 0; }
626 /* #define PC_IN_CALL_DUMMY(pc, sp, fp) carp_pc_in_call_dummy (pc, sp, fp) */
630 @item PC_LOAD_SEGMENT
631 If defined
, print information about the load segment
for the program
632 counter
. (Defined only
for the RS
/6000.)
638 If the program counter is kept in a
register, then define
this macro to
639 be the number of that
register. This need be defined only
if
640 @code
{TARGET_WRITE_PC
} is
not defined
.
643 /* #define PC_REGNUM carp_pc_regnum */
648 The number of the next program counter
register, if defined
.
654 The number of the next next program counter
register, if defined
.
655 Currently
, this is only defined
for the Motorola
88K
.
660 @item
PRINT_REGISTER_HOOK (regno
)
661 If defined
, this must be a function that prints the contents of the
662 given
register to standard output
.
667 @item PRINT_TYPELESS_INTEGER
668 This is an obscure substitute
for @code
{print_longest
} that seems to
669 have been defined
for the Convex target
.
674 @item PROCESS_LINENUMBER_HOOK
675 A hook defined
for XCOFF reading
.
680 @item PROLOGUE_FIRSTLINE_OVERLAP
681 (Only used in unsupported Convex configuration
.)
687 If defined
, this is the number of the processor status
register. (This
688 definition is only used in generic code when parsing
"$ps".)
694 Used in @samp
{call_function_by_hand
} to remove an artificial stack
697 void carp_pop_frame (void) { return; }
698 /* #define POP_FRAME carp_pop_frame () */
702 @item
PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
)
703 Define
this to push arguments onto the stack
for inferior function call
.
705 CORE_ADDR
carp_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
, unsigned char struct_return
, CORE_ADDR struct_addr
) { return 0; }
706 /* #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) (SP) = carp_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) */
710 @item PUSH_DUMMY_FRAME
711 Used in @samp
{call_function_by_hand
} to create an artificial stack frame
.
713 void carp_push_dummy_frame (void) { return; }
714 /* #define PUSH_DUMMY_FRAME carp_push_dummy_frame () */
720 int carp_register_byte (int regnum
) { return 0; }
721 #define REGISTER_BYTE(regnum) carp_register_byte (regnum)
726 The total amount of space needed to store GDBs copy of the machines
729 int carp_register_bytes
;
730 /* #define REGISTER_BYTES carp_register_bytes */
735 Define
this to expand into an initializer of an array of strings
. Each
736 string is the name of a
register.
738 char **carp_register_names
;
739 /* #define REGISTER_NAMES carp_register_names */
743 @item REGISTER_RAW_SIZE
745 int carp_register_raw_size (int regnum
) { return 0; }
746 /* #define REGISTER_RAW_SIZE(regnum) carp_register_raw_size (regnum) */
751 Size of a general purpose
register?
753 int carp_register_size
;
754 /* #define REGISTER_SIZE carp_register_size */
758 @item REGISTER_VIRTUAL_SIZE
760 int carp_register_virtual_size (int regnum
) { return 0; }
761 /* #define REGISTER_VIRTUAL_SIZE(regnum) carp_register_virtual_size (regnum) */
765 @item
REG_STRUCT_HAS_ADDR (gcc_p
, type
)
766 Define
this to
return 1 if the given type will be passed by pointer
767 rather than directly
.
769 int carp_reg_struct_has_addr (int gcc_p
, struct type
*type
) { return 0; }
770 /* #define REG_STRUCT_HAS_ADDR(gcc_p, type) carp_reg_struct_has_addr (gcc_p, type) */
774 @item
SAVED_PC_AFTER_CALL (frame
)
776 CORE_ADDR
carp_saved_pc_after_call (struct frame_info
*frame
) { return 0; }
777 /* #define SAVED_PC_AFTER_CALL(frame) carp_saved_pc_after_call (frame) */
781 @item
SDB_REG_TO_REGNUM (regnum
)
782 Define
this to convert sdb
register numbers into GDB regnums
. If
not
783 defined
, no conversion will be done
.
785 int carp_sdb_reg_to_regnum (int regnum
) { return 0; }
786 /* #define SDB_REG_TO_REGNUM(regnum) carp_sdb_reg_to_regnum (regnum) */
790 @item SET_TRAPPED_INTERNALVAR
792 void carp_set_trapped_internalvar (struct internalvar
*var
, struct value
*newval
, int bitpos
, int bitsize
, int offset
) { return; }
793 /* #dfine SET_TRAPPED_INTERNALVAR(var, newval, bitpos, bitsize, offset) carp_set_trapped_internalvar (var, newval, bitpos, bitsize, offset) */
797 @item SHIFT_INST_REGS
798 (Only used
for m88k targets
.)
804 A C statement that advances the PC across any function entry prologue
805 instructions so as to reach real code
.
807 CORE_ADDR
carp_skip_prologue (CORE_ADDR pc
) { return 0; }
808 /* #define SKIP_PROLOGUE(pc) (pc) = carp_skip_prologue (pc) */
812 @item SKIP_PROLOGUE_FRAMELESS_P
813 A C statement that should behave similarly
, but that can stop as soon as
814 the function is known to have a frame
. If
not defined
,
815 @code
{SKIP_PROLOGUE
} will be used instead
.
817 CORE_ADDR
carp_skip_prologue_frameless_p (CORE_ADDR pc
) { return 0; }
818 /* #define SKIP_PROLOGUE_FRAMELESS_P(pc) (pc) = carp_skip_prologue_frameless_p (pc) */
822 @item
SKIP_TRAMPOLINE_CODE (pc
)
823 If the target machine has trampoline code that sits between callers
and
824 the functions being called
, then define
this macro to
return a
new PC
825 that is at the start of the real function
.
827 CORE_ADDR
carp_skip_trampoline_code (CORE_ADDR pc
) { return 0; }
828 /* #define SKIP_TRAMPOLINE_CODE(pc) (pc) = carp_skip_trampoline_code (pc) */
833 Define
this to be the number of the
register that serves as the stack
837 /* #define SP_REGNUM carp_sp_regnum */
841 @item STAB_REG_TO_REGNUM
842 Define
this to convert stab
register numbers (as gotten from r
843 declarations
) into GDB regnums
. If
not defined
, no conversion will be
846 int carp_stab_reg_to_regnum (int regnum
) { return 0; }
847 /* #define STAB_REG_TO_REGNUM(regnum) carp_stab_reg_to_regnum (regnum) */
851 @item
STACK_ALIGN (addr
)
852 Define
this to adjust the address to the alignment required
for the
855 CORE_ADDR
carp_stack_align (CORE_ADDR pc
) { return 0; }
856 /* #define STACK_ALIGN(pc) carp_stack_align (pc) */
860 @item
STEP_SKIPS_DELAY (addr
)
861 Define
this to
return true if the address is of an instruction with a
862 delay slot
. If a breakpoint has been placed in the instructions delay
863 slot
, GDB will single
-step over that instruction before resuming
864 normally
. Currently only defined
for the Mips
.
869 @item
STORE_STRUCT_RETURN (type
, valbuf
)
870 A C expression that stores a function
return value of type @var
{type
},
871 where @var
{valbuf
} is the address of the value to be stored
.
873 void carp_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
) { return; }
874 /* #define STORE_STRUCT_RETURN(addr,sp) carp_store_struct_return (addr, sp) */
878 @item
STORE_RETURN_VALUE (type
, valbuf
)
879 A C expression that stores a function
return value of type @var
{type
},
880 where @var
{valbuf
} is the address of the value to be stored
.
882 void carp_store_return_value (struct type
*type
, char *valbuf
) { return; }
883 /* #define STORE_RETURN_VALUE(type,valbuf) carp_store_return_value (type, valbuf) */
887 @item SUN_FIXED_LBRAC_BUG
888 (Used only
for Sun
-3 and Sun
-4 targets
.)
893 @item SYMBOL_RELOADING_DEFAULT
894 The
default value of the symbol
-reloading variable
. (Never defined in
900 @item TARGET_BYTE_ORDER
901 The ordering of bytes in the target
. This must be defined to be either
902 @code
{BIG_ENDIAN
} or @code
{LITTLE_ENDIAN
}.
904 int carp_target_byte_order
;
905 /* #define TARGET_BYTE_ORDER carp_target_byte_order */
909 @item TARGET_CHAR_BIT
910 Number of bits in a
char; defaults to
8.
915 @item TARGET_COMPLEX_BIT
916 Number of bits in a
complex number
; defaults to @code
{2 * TARGET_FLOAT_BIT
}.
918 int carp_target_complex_bit
;
919 /* #define TARGET_COMPLEX_BIT carp_target_complex_bit */
923 @item TARGET_DOUBLE_BIT
924 Number of bits in a
double float; defaults to @code
{8 * TARGET_CHAR_BIT
}.
926 int carp_target_double_bit
;
927 /* #define TARGET_DOUBLE_BIT carp_target_double_bit */
931 @item TARGET_DOUBLE_COMPLEX_BIT
932 Number of bits in a
double complex; defaults to @code
{2 * TARGET_DOUBLE_BIT
}.
934 int carp_target_double_complex_bit
;
935 /* #define TARGET_DOUBLE_COMPLEX_BIT carp_target_double_complex_bit */
939 @item TARGET_FLOAT_BIT
940 Number of bits in a
float; defaults to @code
{4 * TARGET_CHAR_BIT
}.
942 int carp_target_float_bit
;
943 /* #define TARGET_FLOAT_BIT carp_target_float_bit */
948 Number of bits in an integer
; defaults to @code
{4 * TARGET_CHAR_BIT
}.
950 int carp_target_int_bit
;
951 /* #define TARGET_INT_BIT carp_target_int_bit */
955 @item TARGET_LONG_BIT
956 Number of bits in a
long integer
; defaults to @code
{4 * TARGET_CHAR_BIT
}.
958 int carp_target_long_bit
;
959 /* #define TARGET_LONG_BIT carp_target_long_bit */
963 @item TARGET_LONG_DOUBLE_BIT
964 Number of bits in a
long double float;
965 defaults to @code
{2 * TARGET_DOUBLE_BIT
}.
967 int carp_target_long_double_bit
;
968 /* #define TARGET_LONG_DOUBLE_BIT carp_target_long_double_bit */
972 @item TARGET_LONG_LONG_BIT
973 Number of bits in a
long long integer
; defaults to @code
{2 * TARGET_LONG_BIT
}.
975 int carp_target_long_long_bit
;
976 /* #define TARGET_LONG_LONG_BIT carp_target_long_long_bit */
981 Number of bits in a pointer
; defaults to @code
{TARGET_INT_BIT
}.
983 int carp_target_ptr_bit
;
984 /* #define TARGET_PTR_BIT carp_target_ptr_bit */
988 @item TARGET_SHORT_BIT
989 Number of bits in a
short integer
; defaults to @code
{2 * TARGET_CHAR_BIT
}.
991 int carp_target_short_bit
;
992 /* #define TARGET_SHORT_BIT carp_target_short_bit */
997 @item
TARGET_WRITE_PC (val
, pid
)
999 @item TARGET_WRITE_SP
1000 @item TARGET_READ_FP
1001 @item TARGET_WRITE_FP
1002 These change the behavior of @code
{read_pc
}, @code
{write_pc
},
1003 @code
{read_sp
}, @code
{write_sp
}, @code
{read_fp
} and @code
{write_fp
}.
1004 For most targets
, these may be left undefined
. GDB will call the read
1005 and write
register functions with the relevant @code
{_REGNUM
} argument
.
1007 These macros are useful when a target keeps one of these registers in a
1008 hard to get at place
; for example
, part in a segment
register and part
1009 in an ordinary
register.
1011 CORE_ADDR
carp_target_read_pc (int pid
) { return 0; }
1012 CORE_ADDR
carp_target_read_sp (void) { return 0; }
1013 CORE_ADDR
carp_target_read_fp (void) { return 0; }
1014 void carp_target_write_pc (CORE_ADDR pc
, int pid
) { return; }
1015 void carp_target_write_sp (CORE_ADDR sp
) { return; }
1016 void carp_target_write_fp (CORE_ADDR fp
) { return; }
1017 /* #define TARGET_READ_PC(pid) carp_target_read_pc (pid) */
1018 /* #define TARGET_WRITE_PC(val,pid) carp_target_write_pc (val, pid) */
1019 /* #define TARGET_READ_SP() carp_target_read_sp () */
1020 /* #define TARGET_WRITE_SP(val) carp_target_write_sp (val) */
1021 /* #define TARGET_READ_FP() carp_target_read_fp () */
1022 /* #define TARGET_WRITE_FP(val) carp_target_write_fp (val) */
1026 @item
USE_STRUCT_CONVENTION (gcc_p
, type
)
1027 If defined
, this must be an expression that is nonzero
if a value of the
1028 given @var
{type
} being returned from a function must have space
1029 allocated
for it on the stack
. @var
{gcc_p
} is
true if the function
1030 being considered is known to have been compiled by GCC
; this is helpful
1031 for systems where GCC is known to use different calling convention than
1037 @item VALUE_OF_TRAPPED_INTERNALVAR
1039 struct value
*carp_value_of_trapped_internalvar (struct internalvar
*var
) { return 0; }
1040 /* #define VALUE_OF_TRAPPED_INTERNALVAR(var) carp_value_of_trapped_internalvar (var) */
1044 @item
VARIABLES_INSIDE_BLOCK (desc
, gcc_p
)
1045 For dbx
-style debugging information
, if the compiler puts variable
1046 declarations inside LBRAC
/RBRAC blocks
, this should be defined to be
1047 nonzero
. @var
{desc
} is the value of @code
{n_desc
} from the
1048 @code
{N_RBRAC
} symbol
, and @var
{gcc_p
} is
true if GDB has noticed the
1049 presence of either the @code
{GCC_COMPILED_SYMBOL
} or the
1050 @code
{GCC2_COMPILED_SYMBOL
}. By
default, this is
0.
1055 @item
OS9K_VARIABLES_INSIDE_BLOCK (desc
, gcc_p
)
1056 Similarly
, for OS
/9000. Defaults to
1.