Go forward to Native Conditionals.
Go backward to Host Conditionals.
Go up to Top.

Target Conditionals
*******************

   When GDB is configured and compiled, various macros are defined or
left undefined, to control compilation based on the attributes of the
target system.  These macros and their meanings are:

   *NOTE:  For now, both host and target conditionals are here.
Eliminate host conditionals from this list as they are identified.*

`PUSH_DUMMY_FRAME'
     Used in `call_function_by_hand' to create an artificial stack
     frame.

`POP_FRAME'
     Used in `call_function_by_hand' to remove an artificial stack
     frame.

`BLOCK_ADDRESS_FUNCTION_RELATIVE'
     dbxread.c

`PYRAMID_CONTROL_FRAME_DEBUGGING'
     pyr-xdep.c

`ADDITIONAL_OPTIONS'
     main.c

`ADDITIONAL_OPTION_CASES'
     main.c

`ADDITIONAL_OPTION_HANDLER'
     main.c

`ADDITIONAL_OPTION_HELP'
     main.c

`ADDR_BITS_REMOVE (addr)'
     If a raw machine address includes any bits that are not really part
     of the address, then define this macro to expand into an expression
     that zeros those bits in ADDR.  For example, the two low-order
     bits of a Motorola 88K address may be used by some kernels for
     their own purposes, since addresses must always be 4-byte aligned,
     and so are of no use for addressing.  Those bits should be
     filtered out with an expression such as `((addr) & ~3)'.

`ALIGN_STACK_ON_STARTUP'
     main.c

`ALTOS'
     altos-xdep.c

`ALTOS_AS'
     xm-altos.h

`BCS'
     tm-delta88.h

`BEFORE_MAIN_LOOP_HOOK'
     Define this to expand into any code that you want to execute before
     the main loop starts.  Although this is not, strictly speaking, a
     target conditional, that is how it is currently being used.  Note
     that if a configuration were to define it one way for a host and a
     different way for the target, GDB will probably not compile, let
     alone run correctly.

`BELIEVE_PCC_PROMOTION'
     coffread.c

`BELIEVE_PCC_PROMOTION_TYPE'
     stabsread.c

`BITS_BIG_ENDIAN'
     Define this if the numbering of bits in the targets does *not*
     match the endianness of the target byte order.  A value of 1 means
     that the bits are numbered in a big-endian order, 0 means
     little-endian.

`BLOCK_ADDRESS_ABSOLUTE'
     dbxread.c

`BREAKPOINT'
     tm-m68k.h

`CALL_DUMMY'
     valops.c

`CALL_DUMMY_LOCATION'
     inferior.h

`CALL_DUMMY_STACK_ADJUST'
     valops.c

`CANNOT_FETCH_REGISTER (regno)'
     A C expression that should be nonzero if REGNO cannot be fetched
     from an inferior process.  This is only relevant if
     `FETCH_INFERIOR_REGISTERS' is not defined.

`CANNOT_STORE_REGISTER (regno)'
     A C expression that should be nonzero if REGNO should not be
     written to the target.  This is often the case for program
     counters, status words, and other special registers.  If this is
     not defined, GDB will assume that all registers may be written.

`CFRONT_PRODUCER'
     dwarfread.c

`DO_DEFERRED_STORES'
`CLEAR_DEFERRED_STORES'
     Define this to execute any deferred stores of registers into the
     inferior, and to cancel any deferred stores.

     Currently only implemented correctly for native Sparc
     configurations?

`CPLUS_MARKER'
     Define this to expand into the character that G++ uses to
     distinguish compiler-generated identifiers from
     programmer-specified identifiers.  By default, this expands into
     `'$''.  Most System V targets should define this to `'.''.

`DBX_PARM_SYMBOL_CLASS'
     stabsread.c

`DECR_PC_AFTER_BREAK'
     Define this to be the amount by which to decrement the PC after
     the program encounters a breakpoint.  This is often the number of
     bytes in BREAKPOINT, though not always.  For most targets this
     value will be 0.

`DECR_PC_AFTER_HW_BREAK'
     Similarly, for hardware breakpoints.

`DELTA88'
     m88k-xdep.c

`DEV_TTY'
     symmisc.c

`DGUX'
     m88k-xdep.c

`DISABLE_UNSETTABLE_BREAK addr'
     If defined, this should evaluate to 1 if ADDR is in a shared
     library in which breakpoints cannot be set and so should be
     disabled.

`DO_REGISTERS_INFO'
     infcmd.c

`END_OF_TEXT_DEFAULT'
     This is an expression that should designate the end of the text
     section (? FIXME ?)

`EXTRACT_RETURN_VALUE'
     tm-m68k.h

`EXTRACT_STRUCT_VALUE_ADDRESS'
     values.c

`EXTRA_FRAME_INFO'
     If defined, this must be a list of slots that may be inserted into
     the `frame_info' structure defined in `frame.h'.

`EXTRA_SYMTAB_INFO'
     If defined, this must be a list of slots that may be inserted into
     the `symtab' structure defined in `symtab.h'.

`FILES_INFO_HOOK'
     target.c

`FLOAT_INFO'
     infcmd.c

`FP0_REGNUM'
     a68v-xdep.c

`FPC_REGNUM'
     mach386-xdep.c

`FP_REGNUM'
     parse.c

`FRAMELESS_FUNCTION_INVOCATION'
     blockframe.c

`FRAME_ARGS_ADDRESS_CORRECT'
     stack.c

`FRAME_CHAIN'
     Given FRAME, return a pointer to the calling frame.

`FRAME_CHAIN_COMBINE'
     blockframe.c

`FRAME_CHAIN_VALID'
     frame.h

`FRAME_CHAIN_VALID_ALTERNATE'
     frame.h

`FRAME_FIND_SAVED_REGS'
     stack.c

`FRAME_GET_BASEREG_VALUE'
     frame.h

`FRAME_NUM_ARGS (val, fi)'
     For the frame described by fi, set val to the number of arguments
     that are being passed.

`FRAME_SPECIFICATION_DYADIC'
     stack.c

`FRAME_SAVED_PC'
     Given FRAME, return the pc saved there.  That is, the return
     address.

`FUNCTION_EPILOGUE_SIZE'
     For some COFF targets, the `x_sym.x_misc.x_fsize' field of the
     function end symbol is 0.  For such targets, you must define
     `FUNCTION_EPILOGUE_SIZE' to expand into the standard size of a
     function's epilogue.

`GCC2_COMPILED_FLAG_SYMBOL'
     dbxread.c

`GCC_COMPILED_FLAG_SYMBOL'
     dbxread.c

`GCC_MANGLE_BUG'
     symtab.c

`GCC_PRODUCER'
     dwarfread.c

`GDB_TARGET_IS_HPPA'
     This determines whether horrible kludge code in dbxread.c and
     partial-stab.h is used to mangle multiple-symbol-table files from
     HPPA's.  This should all be ripped out, and a scheme like
     elfread.c used.

`GDB_TARGET_IS_MACH386'
     mach386-xdep.c

`GDB_TARGET_IS_SUN3'
     a68v-xdep.c

`GDB_TARGET_IS_SUN386'
     sun386-xdep.c

`GET_LONGJMP_TARGET'
     For most machines, this is a target-dependent parameter.  On the
     DECstation and the Iris, this is a native-dependent parameter,
     since <setjmp.h> is needed to define it.

     This macro determines the target PC address that longjmp() will
     jump to, assuming that we have just stopped at a longjmp
     breakpoint.  It takes a CORE_ADDR * as argument, and stores the
     target PC value through this pointer.  It examines the current
     state of the machine as needed.

`GET_SAVED_REGISTER'
     Define this if you need to supply your own definition for the
     function `get_saved_register'.  Currently this is only done for
     the a29k.

`GPLUS_PRODUCER'
     dwarfread.c

`GR64_REGNUM'
     Very a29k-specific.

`HAVE_REGISTER_WINDOWS'
     Define this if the target has register windows.

`REGISTER_IN_WINDOW_P regnum'
     Define this to be an expression that is 1 is the given register is
     in the window.

`IBM6000_TARGET'
     Shows that we are configured for an IBM RS/6000 target.  This
     conditional should be eliminated (FIXME) and replaced by
     feature-specific macros.  It was introduced in haste and we are
     repenting at leisure.

`IEEE_FLOAT'
     Define this if the target system uses IEEE-format floating point
     numbers.

`IGNORE_SYMBOL type'
     This seems to be no longer used.

`INIT_EXTRA_FRAME_INFO (fromleaf, fci)'
     If defined, this should be a C expression or statement that fills
     in the `EXTRA_FRAME_INFO' slots of the given frame FCI.

`INIT_EXTRA_SYMTAB_INFO'
     symfile.c

`INIT_FRAME_PC (fromleaf, prev)'
     This is a C statement that sets the pc of the frame pointed to by
     PREV.  [By default...]

`INNER_THAN'
     Define this to be either `<' if the target's stack grows downward
     in memory, or `>' is the stack grows upwards.

`IN_SIGTRAMP pc name'
     Define this to return true if the given pc and/or name indicates
     that the current function is a sigtramp.

`SIGTRAMP_START'
`SIGTRAMP_END'
     Define these to be the start and end address of the sigtramp.
     These will be used if defined, and `IN_SIGTRAMP' is not; otherwise
     the name of the sigtramp will be assumed to be `_sigtramp'.

`IN_SOLIB_TRAMPOLINE pc name'
     Define this to evaluate to nonzero if the program is stopped in
     the trampoline that connects to a shared library.

`IS_TRAPPED_INTERNALVAR name'
     This is an ugly hook to allow the specification of special actions
     that should occur as a side-effect of setting the value of a
     variable internal to GDB.  Currently only used by the h8500.  Note
     that this could be either a host or target conditional.

`KERNEL_DEBUGGING'
     tm-ultra3.h

`LCC_PRODUCER'
     dwarfread.c

`L_LNNO32'
     coffread.c

`MIPSEL'
     mips-tdep.c

`MOTOROLA'
     xm-altos.h

`NBPG'
     altos-xdep.c

`NEED_TEXT_START_END'
     Define this if GDB should determine the start and end addresses of
     the text section.  (Seems dubious.)

`NOTICE_SIGNAL_HANDLING_CHANGE'
     infrun.c

`NO_HIF_SUPPORT'
     remote-mm.c

`NO_SIGINTERRUPT'
     remote-adapt.c

`NO_SINGLE_STEP'
     Define this if the target does not support single-stepping.  If
     this is defined, you must supply, in `*-tdep.c', the function
     `single_step', which takes a pid as argument and returns nothing.
     It must insert breakpoints at each possible destinations of the
     next instruction.  See `sparc-tdep.c' and `rs6000-tdep.c' for
     examples.

`NUMERIC_REG_NAMES'
     mips-tdep.c

`N_SETV'
     dbxread.c

`N_SET_MAGIC'
     hppabsd-tdep.c

`ONE_PROCESS_WRITETEXT'
     breakpoint.c

`PCC_SOL_BROKEN'
     dbxread.c

`PC_IN_CALL_DUMMY'
     inferior.h

`PC_LOAD_SEGMENT'
     stack.c

`PC_REGNUM'
     If the program counter is kept in a register, then define this
     macro to be the number of that register.  This need be defined
     only if `TARGET_WRITE_PC' is not defined.

`NPC_REGNUM'
     The number of the "next program counter" register, if defined.

`NNPC_REGNUM'
     The number of the "next next program counter" register, if defined.
     Currently, this is only defined for the Motorola 88K.

`PRINT_RANDOM_SIGNAL'
     infcmd.c

`PRINT_REGISTER_HOOK'
     infcmd.c

`PRINT_TYPELESS_INTEGER'
     This is an obscure substitute for `print_longest' that seems to
     have been defined for the Convex target.

`PROCESS_LINENUMBER_HOOK'
     buildsym.c

`PROLOGUE_FIRSTLINE_OVERLAP'
     infrun.c

`PS_REGNUM'
     parse.c

`PUSH_ARGUMENTS'
     valops.c

`REGISTER_BYTES'
     remote.c

`REGISTER_NAMES'
     Define this to expand into an initializer of an array of strings.
     Each string is the name of a register.  [more detail]

`REG_STACK_SEGMENT'
     exec.c

`REG_STRUCT_HAS_ADDR'
     findvar.c

`R_FP'
     dwarfread.c

`R_OK'
     xm-altos.h

`SDB_REG_TO_REGNUM'
     Define this to convert sdb register numbers into GDB regnums.  If
     not defined, no conversion will be done.

`SEEK_END'
     state.c

`SEEK_SET'
     state.c

`SEM'
     coffread.c

`SHELL_COMMAND_CONCAT'
     infrun.c

`SHELL_FILE'
     infrun.c

`SHIFT_INST_REGS'
     breakpoint.c

`SIGTRAP_STOP_AFTER_LOAD'
     infrun.c

`SKIP_PROLOGUE'
     A C statement that advances the PC across any function entry
     prologue instructions so as to reach "real" code.

`SKIP_PROLOGUE_FRAMELESS_P'
     A C statement that should behave similarly, but that can stop as
     soon as the function is known to have a frame.  If not defined,
     `SKIP_PROLOGUE' will be used instead.

`SKIP_TRAMPOLINE_CODE (pc)'
     If the target machine has trampoline code that sits between callers
     and the functions being called, then define this macro to return a
     new PC that is at the start of the real function.

`SP_REGNUM'
     parse.c

`STAB_REG_TO_REGNUM'
     Define this to convert stab register numbers (as gotten from `r'
     declarations) into GDB regnums.  If not defined, no conversion
     will be done.

`STACK_ALIGN'
     valops.c

`STOP_SIGNAL'
     main.c

`STORE_RETURN_VALUE (type, valbuf)'
     A C expression that stores a function return value of type TYPE,
     where VALBUF is the address of the value to be stored.

`SUN4_COMPILER_FEATURE'
     infrun.c

`SUN_FIXED_LBRAC_BUG'
     dbxread.c

`SVR4_SHARED_LIBS'
     solib.c

`SYMBOL_RELOADING_DEFAULT'
     symfile.c

`TARGET_BYTE_ORDER'
     The ordering of bytes in the target.  This must be defined to be
     either `BIG_ENDIAN' or `LITTLE_ENDIAN'.

`TARGET_CHAR_BIT'
     Number of bits in a char; defaults to 8.

`TARGET_COMPLEX_BIT'
     Number of bits in a complex number; defaults to `2 *
     TARGET_FLOAT_BIT'.

`TARGET_DOUBLE_BIT'
     Number of bits in a double float; defaults to `8 *
     TARGET_CHAR_BIT'.

`TARGET_DOUBLE_COMPLEX_BIT'
     Number of bits in a double complex; defaults to `2 *
     TARGET_DOUBLE_BIT'.

`TARGET_FLOAT_BIT'
     Number of bits in a float; defaults to `4 * TARGET_CHAR_BIT'.

`TARGET_INT_BIT'
     Number of bits in an integer; defaults to `4 * TARGET_CHAR_BIT'.

`TARGET_LONG_BIT'
     Number of bits in a long integer; defaults to `4 *
     TARGET_CHAR_BIT'.

`TARGET_LONG_DOUBLE_BIT'
     Number of bits in a long double float; defaults to `2 *
     TARGET_DOUBLE_BIT'.

`TARGET_LONG_LONG_BIT'
     Number of bits in a long long integer; defaults to `2 *
     TARGET_LONG_BIT'.

`TARGET_PTR_BIT'
     Number of bits in a pointer; defaults to `TARGET_INT_BIT'.

`TARGET_SHORT_BIT'
     Number of bits in a short integer; defaults to `2 *
     TARGET_CHAR_BIT'.

`TARGET_READ_PC'
`TARGET_WRITE_PC (val, pid)'
`TARGET_READ_SP'
`TARGET_WRITE_SP'
`TARGET_READ_FP'
`TARGET_WRITE_FP'
     These change the behavior of `read_pc', `write_pc', `read_sp',
     `write_sp', `read_fp' and `write_fp'.  For most targets, these may
     be left undefined.  GDB will call the read and write register
     functions with the relevant `_REGNUM' argument.

     These macros are useful when a target keeps one of these registers
     in a hard to get at place;  for example, part in a segment
     register and part in an ordinary register.

`USE_STRUCT_CONVENTION (gcc_p, type)'
     If defined, this must be an expression that is nonzero if a value
     of the given TYPE being returned from a function must have space
     allocated for it on the stack.  GCC_P is true if the function
     being considered is known to have been compiled by GCC; this is
     helpful for systems where GCC is known to use different calling
     convention than other compilers.

`VARIABLES_INSIDE_BLOCK (desc, gcc_p)'
     For dbx-style debugging information, if the compiler puts variable
     declarations inside LBRAC/RBRAC blocks, this should be defined to
     be nonzero.  DESC is the value of `n_desc' from the `N_RBRAC'
     symbol, and GCC_P is true if GDB has noticed the presence of
     either the `GCC_COMPILED_SYMBOL' or the `GCC2_COMPILED_SYMBOL'.
     By default, this is 0.

`OS9K_VARIABLES_INSIDE_BLOCK (desc, gcc_p)'
     Similarly, for OS/9000.  Defaults to 1.

`WRS_ORIG'
     remote-vx.c

`test'
     (Define this to enable testing code in regex.c.)

   Motorola M68K target conditionals.

`BPT_VECTOR'
     Define this to be the 4-bit location of the breakpoint trap vector.
     If not defined, it will default to `0xf'.

`REMOTE_BPT_VECTOR'
     Defaults to `1'.