Results of first-pass at looking for problems with making the target

architecture a vector.

1 files changed, 1064 insertions, 0 deletions

diff --git a/gdb/carp-tdep.c b/gdb/carp-tdep.c
new file mode 100644
index 0000000..464aa50
--- /dev/null
+++ b/gdb/carp-tdep.c
@@ -0,0 +1,1064 @@
+#include "defs.h"
+#include "tm.h"
+#include "target.h"
+
+/* #define CARP */
+
+/* BAD HACKS */
+
+int carp_sizeof_struct_frame_saved_regs;
+/* #define SIZEOF_STRUCT_FRAME_SAVED_REGS carp_sizeof_struct_frame_saved_regs */
+
+
+
+
+#if 0
+@item ADDITIONAL_OPTIONS
+@item ADDITIONAL_OPTION_CASES
+@item ADDITIONAL_OPTION_HANDLER
+@item ADDITIONAL_OPTION_HELP
+These are a set of macros that allow the addition of additional command
+line options to GDB.  They are currently used only for the unsupported
+i960 Nindy target, and should not be used in any other configuration.
+#endif
+
+
+#if 0
+@item 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 @var{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 @code{((addr) & ~3)}.
+#endif
+CORE_ADDR carp_addr_bits_remove (CORE_ADDR addr) { return 0; }
+/* #define ADDR_BITS_REMOVE(addr) carp_addr_bits_remove (addr) */
+
+
+#if 0
+@item 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.
+This is currently used only for the unsupported i960 Nindy target, and
+should not be used in any other configuration.
+#endif
+
+
+#if 0
+@item BELIEVE_PCC_PROMOTION
+Define if the compiler promotes a short or char parameter to an int, but
+still reports the parameter as its original type, rather than the
+promoted type.
+#endif
+int carp_believe_pcc_promotion;
+/* #define BELIEVE_PCC_PROMOTION carp_believe_pcc_promotion */
+
+
+#if 0
+@item BELIEVE_PCC_PROMOTION_TYPE
+Define this if GDB should believe the type of a short argument when
+compiled by pcc, but look within a full int space to get its value.
+Only defined for Sun-3 at present.
+#endif
+int carp_believe_pcc_promotion_type;
+/* #define BELIEVE_PCC_PROMOTION_TYPE carp_believe_pcc_promotion_type */
+
+
+#if 0
+@item 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.
+#endif
+int carp_bits_big_endian;
+/* #define BITS_BIG_ENDIAN carp_bits_big_endian */
+
+
+#if 0
+@item BREAKPOINT
+This is the character array initializer for the bit pattern to put into
+memory where a breakpoint is set.  Although it is common to use a trap
+instruction for a breakpoint, it is not required; for instance, the bit
+pattern could be an invalid instruction.  The breakpoint must be no
+longer than the shortest instruction of the architecture.
+#endif
+char *carp_breakpoint;
+/* #define BREAKPOINT carp_breakpoint */
+
+
+#if 0
+@item BIG_BREAKPOINT
+@item LITTLE_BREAKPOINT
+Similar to BREAKPOINT, but used for bi-endian targets.
+#endif
+char *carp_big_breakpoint;
+char *carp_little_breakpoint;
+/* #define BIG_BREAKPOINT carp_big_breakpoint */
+/* #define LITTLE_BREAKPOINT carp_little_breakpoint */
+
+
+#if 0
+@item CALL_DUMMY
+valops.c
+@item CALL_DUMMY_LOCATION
+inferior.h
+@item CALL_DUMMY_STACK_ADJUST
+valops.c
+@item CALL_DUMMY_START_OFFSET
+#endif
+char *carp_call_dummy (void) { return 0; }
+/* #define CALL_DUMMY carp_call_dummy () */
+int carp_sizeof_call_dummy;
+/* #define SIZEOF_CALL_DUMMY carp_sizeof_call_dummy */
+int carp_call_dummy_location;
+/* #define CALL_DUMMY_LOCATION carp_call_dummy_location */
+int carp_call_stack_adjust;
+/* #define CALL_DUMMY_STACK_ADJUST carp_call_stack_adjust */
+int carp_call_start_offset;
+/* #define CALL_DUMMY_START_OFFSET carp_call_start_offset */
+
+
+#if 0
+@item CANNOT_FETCH_REGISTER (regno)
+A C expression that should be nonzero if @var{regno} cannot be fetched
+from an inferior process.  This is only relevant if
+@code{FETCH_INFERIOR_REGISTERS} is not defined.
+#endif
+int carp_cannot_fetch_register;
+/* #define CANNOT_FETCH_REGISTER(regno) carp_cannot_fetch_register(regno) */
+
+
+#if 0
+@item CANNOT_STORE_REGISTER (regno)
+A C expression that should be nonzero if @var{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.
+#endif
+int carp_cannot_store_register (int regno) { return 0; }
+/* #define CANNOT_STORE_REGISTER(regno) carp_cannot_store_register(regno) */
+
+
+#if 0
+@item CHILL_PRODUCER
+@item GCC_PRODUCER
+@item GPLUS_PRODUCER
+@item LCC_PRODUCER
+If defined, these are the producer strings in a DWARF 1 file.  All of
+these have reasonable defaults already.
+#endif
+
+
+#if 0
+@item DO_DEFERRED_STORES
+@item 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?
+#endif
+void carp_do_deferred_stores (void) { return; }
+void carp_clear_deferred_stores (void) { return; }
+/* #define DO_DEFERRED_STORES carp_do_deferred_stores () */
+/* #define CLEAR_DEFERRED_STORES carp_clear_deferred_stores () */
+
+
+#if 0
+@item 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 @code{'$'}.  Most System V targets should
+define this to @code{'.'}.
+#endif
+
+
+#if 0
+@item DBX_PARM_SYMBOL_CLASS
+Hook for the @code{SYMBOL_CLASS} of a parameter when decoding DBX symbol
+information.  In the i960, parameters can be stored as locals or as
+args, depending on the type of the debug record.
+#endif
+
+
+#if 0
+@item 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.
+#endif
+int carp_decr_pc_after_break;
+/* #define DECR_PC_AFTER_BREAK carp_decr_pc_after_break */
+
+
+#if 0
+@item DECR_PC_AFTER_HW_BREAK
+Similarly, for hardware breakpoints.
+#endif
+int carp_decr_pc_after_hw_break;
+/* #define DECR_PC_AFTER_HW_BREAK carp_decr_pc_after_hw_break */
+
+
+#if 0
+@item DISABLE_UNSETTABLE_BREAK addr
+If defined, this should evaluate to 1 if @var{addr} is in a shared
+library in which breakpoints cannot be set and so should be disabled.
+#endif
+
+
+#if 0
+@item DO_REGISTERS_INFO
+If defined, use this to print the value of a register or all registers.
+#endif
+void carp_do_registers_info (int regnum, int fpregs) { return; }
+/* #define DO_REGISTERS_INFO(r, f) carp_do_registers_info (r, f) */
+
+
+#if 0
+@item END_OF_TEXT_DEFAULT
+This is an expression that should designate the end of the text section
+(? FIXME ?)
+#endif
+
+
+#if 0
+@item EXTRACT_RETURN_VALUE(type,regbuf,valbuf)
+Define this to extract a functions return value of type @var{type} from
+the raw register state @var{regbuf} and copy that, in virtual format,
+into @var{valbuf}.
+#endif
+void carp_extract_return_value (struct type *type, char *regbuf, char *valbuf) { return; }
+/* #define EXTRACT_RETURN_VALUE(type,regbuf,valbuf) carp_extract_return_value(type,regbuf,valbuf) */
+
+ 
+#if 0
+@item EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)
+Define this to extract from an array @var{regbuf} containing the (raw)
+register state, the address in which a function should return its
+structure value, as a CORE_ADDR (or an expression that can be used as
+one).
+#endif
+CORE_ADDR carp_extract_struct_value_address (char *regbuf) { return 0; }
+/* #define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) carp_extract_struct_value_address(regbuf) */
+
+
+#if 0
+@item EXTRA_FRAME_INFO
+If defined, this must be a list of slots that may be inserted into the
+@code{frame_info} structure defined in @code{frame.h}.
+#endif
+
+
+#if 0
+@item FIX_CALL_DUMMY
+#endif
+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; }
+/* #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) */
+
+
+#if 0
+@item FLOAT_INFO
+If defined, then the info float command will print information about
+the processors floating point unit.
+#endif
+void carp_float_info (void) { return; }
+/* #define FLOAT_INFO carp_float_info () */
+
+
+#if 0
+@item FP_REGNUM
+The number of the frame pointer register.
+#endif
+int carp_fp_regnum;
+/* #define FP_REGNUM carp_fp_regnum */
+
+
+#if 0
+@item FRAMELESS_FUNCTION_INVOCATION(fi, frameless)
+Define this to set the variable @var{frameless} to 1 if the function
+invocation represented by @var{fi} does not have a stack frame
+associated with it.  Otherwise set it to 0.
+#endif
+int carp_frameless_function_invocation (struct frame_info *fi) { return 0; }
+/* #define FRAMELESS_FUNCTION_INVOCATION(fi,frameless) (frameless) = carp_frameless_function_invocation (fi) */
+
+
+#if 0
+@item FRAME_ARGS_ADDRESS
+stack.c
+#endif
+CORE_ADDR carp_frame_args_address (struct frame_info *fi) { return 0; };
+/* #define FRAME_ARGS_ADDRESS(FI) carp_frame_args_address (FI) */
+
+
+#if 0
+@item FRAME_ARGS_ADDRESS_CORRECT
+stack.c
+#endif
+CORE_ADDR carp_frame_args_address_correct (struct frame_info *fi) { return 0; }
+/* #define FRAME_ARGS_ADDRESS_CORRECT(FI) carp_frame_args_address_correct(FI) */
+
+
+#if 0
+@item FRAME_ARGS_SKIP
+#endif
+int carp_frame_args_skip;
+/* #define FRAME_ARGS_SKIP carp_frame_args_skip */
+
+
+#if 0
+@item FRAME_CHAIN(frame)
+Given @var{frame}, return a pointer to the calling frame.
+#endif
+CORE_ADDR carp_frame_chain (struct frame_info *fi) { return 0; }
+/* #define FRAME_CHAIN(frame) carp_frame_chain (frame) */
+
+
+#if 0
+@item FRAME_CHAIN_COMBINE(chain,frame)
+Define this to take the frame chain pointer and the frames nominal
+address and produce the nominal address of the callers frame.
+Presently only defined for HP PA.
+#endif
+CORE_ADDR carp_frame_chain_combine (CORE_ADDR address, struct frame_info *fi) { return 0; }
+/* #define FRAME_CHAIN_COMBINE(address, frame) carp_frame_chain_combine (address, frame) */
+
+
+
+#if 0
+@item FRAME_CHAIN_VALID(chain,thisframe)
+Define this to be an expression that returns zero if the given frame is
+an outermost frame, with no caller, and nonzero otherwise.  The default
+definition is nonzero if the chain pointer is nonzero and given frames
+PC is not inside the startup file (such as @file{crt0.o}).  The
+alternate default definition (which is used if
+FRAME_CHAIN_VALID_ALTERNATE is defined) is nonzero if the chain pointer
+is nonzero and the given frames PC is not in @code{main()} or a known
+entry point function (such as @code{_start()}).
+#endif
+int carp_frame_chain_valid (CORE_ADDR address, struct frame_info *fi) { return 0; }
+/* #define FRAME_CHAIN_VALID(address, frame) carp_frame_chain_valid (address, frame) */
+
+
+#if 0
+@item FRAME_CHAIN_VALID_ALTERNATE
+Define this in order to use the alternate default definition of
+@code{FRAME_CHAIN_VALID}.
+#endif
+
+
+#if 0
+@item FRAME_FIND_SAVED_REGS
+stack.c
+#endif
+void carp_frame_find_saved_regs (struct frame_info *frame, struct frame_saved_regs *saved_regs_addr) { return; }
+/* #define FRAME_FIND_SAVED_REGS(frame, saved_regs_addr) carp_frame_find_saved_regs (frame, &(saved_regs_addr)) */
+
+
+#if 0
+@item FRAME_LOCALS_ADDRESS
+stack.c
+#endif
+CORE_ADDR carp_frame_locals_address (struct frame_info *fi) { return 0; };
+/* #define FRAME_LOCALS_ADDRESS(FI) carp_frame_locals_address (FI) */
+
+
+#if 0
+@item FRAME_NUM_ARGS (val, fi)
+For the frame described by fi, set val to the number of arguments
+that are being passed.
+#endif
+int carp_frame_num_args (struct frame_info *fi) { return 0; }
+/* #define FRAME_NUM_ARGS(val, fi) (val) = carp_frame_num_args (fi) */
+
+
+#if 0
+@item FRAME_SAVED_PC(frame)
+Given @var{frame}, return the pc saved there.  That is, the return
+address.
+#endif
+CORE_ADDR carp_frame_saved_pc (struct frame_info *fi) { return 0; }
+/* #define FRAME_SAVED_PC(fi) carp_frame_saved_pc (fi) */
+
+
+#if 0
+@item FUNCTION_EPILOGUE_SIZE
+For some COFF targets, the @code{x_sym.x_misc.x_fsize} field of the
+function end symbol is 0.  For such targets, you must define
+@code{FUNCTION_EPILOGUE_SIZE} to expand into the standard size of a
+functions epilogue.
+#endif
+int carp_function_epilogue_size;
+/* #define FUNCTION_EPILOGUE_SIZE carp_function_epilogue_size */
+
+
+#if 0
+@item FUNCTION_START_OFFSET
+#endif
+int carp_function_start_offset;
+/* #define FUNCTION_START_OFFSET carp_function_start_offset */
+
+
+#if 0
+@item GCC_COMPILED_FLAG_SYMBOL
+@item GCC2_COMPILED_FLAG_SYMBOL
+If defined, these are the names of the symbols that GDB will look for to
+detect that GCC compiled the file.  The default symbols are
+@code{gcc_compiled.} and @code{gcc2_compiled.}, respectively. (Currently
+only defined for the Delta 68.)
+#endif
+
+
+#if 0
+@item 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
+HPPAs.  This should all be ripped out, and a scheme like elfread.c
+used.
+#endif
+
+
+#if 0
+@item GDB_TARGET_IS_MACH386
+@item GDB_TARGET_IS_SUN3
+@item GDB_TARGET_IS_SUN386
+Kludges that should go away.
+#endif
+
+
+#if 0
+@item 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.
+#endif
+
+
+#if 0
+@item GET_SAVED_REGISTER
+Define this if you need to supply your own definition for the function
+@code{get_saved_register}.  Currently this is only done for the a29k.
+#endif
+void get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval) { return; }
+/* #define GET_SAVED_REGISTER */
+
+
+#if 0
+@item HAVE_REGISTER_WINDOWS
+Define this if the target has register windows.
+@item REGISTER_IN_WINDOW_P (regnum)
+Define this to be an expression that is 1 is the given register is in
+the window.
+#endif
+int carp_have_register_windows;
+int carp_register_in_window_p (int regnum) { return 0; }
+/* #define HAVE_REGISTER_WINDOWS carp_have_register_windows */
+/* #define REGISTER_IN_WINDOW_P(regnum) carp_register_in_window_p (regnum) */
+
+
+#if 0
+@item REGISTER_VIRTUAL_TYPE
+#endif
+struct type *carp_register_virtual_type (int regno) { return 0; }
+/* #define REGISTER_VIRTUAL_TYPE(regno) carp_register_virtual_type (regno) */
+
+
+
+#if 0
+@item 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.
+#endif
+
+
+#if 0
+@item IEEE_FLOAT
+Define this if the target system uses IEEE-format floating point numbers.
+#endif
+int carp_ieee_float;
+/* #define IEEE_FLOAT carp_ieee_float */
+
+
+#if 0
+@item INIT_EXTRA_FRAME_INFO (fromleaf, fci)
+If defined, this should be a C expression or statement that fills in the
+@code{EXTRA_FRAME_INFO} slots of the given frame @var{fci}.
+#endif
+void carp_init_extra_frame_info (CORE_ADDR fromleaf, struct frame_info *fci) { return; }
+/* #define INIT_EXTRA_FRAME_INFO(fromleaf, fci) carp_init_extra_frame_info (fromleaf, fci) */
+
+
+
+#if 0
+@item INIT_FRAME_PC (fromleaf, prev)
+This is a C statement that sets the pc of the frame pointed to by
+@var{prev}.  [By default...]
+#endif
+void carp_init_frame_pc (CORE_ADDR fromleaf, struct frame_info *fci) { return; }
+/* #define INIT_FRAME_PC(fromleaf, fci) carp_init_frame_pc (fromleaf, fci) */
+
+
+#if 0
+@item INNER_THAN
+Define this to be either @code{<} if the targets stack grows downward
+in memory, or @code{>} is the stack grows upwards.
+#endif
+/* #define INNER_THAN < */
+
+
+#if 0
+@item IN_SIGTRAMP (pc, name)
+Define this to return true if the given pc and/or name indicates that
+the current function is a sigtramp.
+#endif
+int carp_in_sigtramp (CORE_ADDR pc, char *name) { return 0; }
+/* #define IN_SIGTRAMP(pc, name) carp_in_sigtramp (pc, name) */
+
+
+#if 0
+@item SIGTRAMP_START (pc)
+@item SIGTRAMP_END (pc)
+Define these to be the start and end address of the sigtramp for the
+given pc.  On machines where the address is just a compile time
+constant, the macro expansion will typically just ignore the supplied
+pc.
+#endif
+CORE_ADDR carp_sigtramp_start (CORE_ADDR pc) { return 0; }
+CORE_ADDR carp_sigtramp_end (CORE_ADDR pc) { return 0; }
+/* #define SIGTRAMP_START(pc) carp_sigtramp_start (pc) */
+/* #define SIGTRAMP_END(pc) carp_sigtramp_end (pc) */
+
+
+#if 0
+@item 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.
+#endif
+
+
+#if 0
+@item 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.
+#endif
+int carp_is_trapped_internalvar (char *name) { return 0; }
+/* #define IS_TRAPPED_INTERNALVAR(name) carp_is_trapped_internalvar (name) */
+
+
+#if 0
+@item KERNEL_DEBUGGING
+tm-ultra3.h
+#endif
+
+
+#if 0
+@item MAX_REGISTER_RAW_SIZE
+#endif
+int carp_max_register_raw_size;
+/* #define MAX_REGISTER_RAW_SIZE carp_max_register_raw_size */
+
+
+#if 0
+@item MAX_REGISTER_VIRTUAL_SIZE
+#endif
+int carp_max_register_virtual_size;
+/* #define MAX_REGISTER_VIRTUAL_SIZE carp_max_register_virtual_size */
+
+
+#if 0
+@item MIPSEL
+mips-tdep.c
+#endif
+
+
+#if 0
+@item NEED_TEXT_START_END
+Define this if GDB should determine the start and end addresses of the
+text section.  (Seems dubious.)
+#endif
+int carp_need_text_start_end;
+/* #define NEED_TEXT_START_END carp_need_text_start_end */
+
+
+#if 0
+@item NO_HIF_SUPPORT
+(Specific to the a29k.)
+#endif
+
+
+#if 0
+@item NO_SINGLE_STEP
+Define this if the target does not support single-stepping.  If this is
+defined, you must supply, in @code{*-tdep.c}, the function
+@code{single_step}, which takes a target_signal as argument and returns
+nothing.  It must insert breakpoints at each possible destinations of
+the next instruction.  See @code{sparc-tdep.c} and @code{rs6000-tdep.c}
+for examples.
+#endif
+int one_stepped;
+void single_step (enum target_signal signal) { return; }
+/* #define NO_SINGLE_STEP */
+
+
+#if 0
+@item NUM_REGS
+#endif
+int carp_num_regs;
+/* #define NUM_REGS carp_num_regs */
+
+
+#if 0
+@item PCC_SOL_BROKEN
+(Used only in the Convex target.)
+#endif
+
+
+#if 0
+@item PC_IN_CALL_DUMMY
+inferior.h
+#endif
+int carp_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp) { return 0; }
+/* #define PC_IN_CALL_DUMMY(pc, sp, fp) carp_pc_in_call_dummy (pc, sp, fp) */
+
+
+#if 0
+@item PC_LOAD_SEGMENT
+If defined, print information about the load segment for the program
+counter.  (Defined only for the RS/6000.)
+#endif
+
+
+#if 0
+@item 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
+@code{TARGET_WRITE_PC} is not defined.
+#endif
+int carp_pc_regnum;
+/* #define PC_REGNUM carp_pc_regnum */
+
+
+#if 0
+@item NPC_REGNUM
+The number of the next program counter register, if defined.
+#endif
+
+
+#if 0
+@item NNPC_REGNUM
+The number of the next next program counter register, if defined.
+Currently, this is only defined for the Motorola 88K.
+#endif
+
+
+#if 0
+@item PRINT_REGISTER_HOOK (regno)
+If defined, this must be a function that prints the contents of the
+given register to standard output.
+#endif
+
+
+#if 0
+@item PRINT_TYPELESS_INTEGER
+This is an obscure substitute for @code{print_longest} that seems to
+have been defined for the Convex target.
+#endif
+
+
+#if 0
+@item PROCESS_LINENUMBER_HOOK
+A hook defined for XCOFF reading.
+#endif
+
+
+#if 0
+@item PROLOGUE_FIRSTLINE_OVERLAP
+(Only used in unsupported Convex configuration.)
+#endif
+
+
+#if 0
+@item PS_REGNUM
+If defined, this is the number of the processor status register.  (This
+definition is only used in generic code when parsing "$ps".)
+#endif
+
+
+#if 0
+@item POP_FRAME
+Used in @samp{call_function_by_hand} to remove an artificial stack
+frame.
+#endif
+void carp_pop_frame (void) { return; }
+/* #define POP_FRAME carp_pop_frame () */
+
+
+#if 0
+@item PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)
+Define this to push arguments onto the stack for inferior function call.
+#endif
+CORE_ADDR carp_push_arguments (int nargs, struct value **args, CORE_ADDR sp, unsigned char struct_return, CORE_ADDR struct_addr) { return 0; }
+/* #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) (SP) = carp_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) */
+
+
+#if 0
+@item PUSH_DUMMY_FRAME
+Used in @samp{call_function_by_hand} to create an artificial stack frame.
+#endif
+void carp_push_dummy_frame (void) { return; }
+/* #define PUSH_DUMMY_FRAME carp_push_dummy_frame () */
+
+
+#if 0
+@item REGISTER_BYTE
+#endif
+int carp_register_byte (int regnum) { return 0; }
+#define REGISTER_BYTE(regnum) carp_register_byte (regnum)
+
+
+#if 0
+@item REGISTER_BYTES
+The total amount of space needed to store GDBs copy of the machines
+register state.
+#endif
+int carp_register_bytes;
+/* #define REGISTER_BYTES carp_register_bytes */
+
+
+#if 0
+@item REGISTER_NAMES
+Define this to expand into an initializer of an array of strings.  Each
+string is the name of a register.
+#endif
+char **carp_register_names;
+/* #define REGISTER_NAMES carp_register_names */
+
+
+#if 0
+@item REGISTER_RAW_SIZE
+#endif
+int carp_register_raw_size (int regnum) { return 0; }
+/* #define REGISTER_RAW_SIZE(regnum) carp_register_raw_size (regnum) */
+
+
+#if 0
+@item REGISTER_SIZE
+Size of a general purpose register?
+#endif
+int carp_register_size;
+/* #define REGISTER_SIZE carp_register_size */
+
+
+#if 0
+@item REGISTER_VIRTUAL_SIZE
+#endif
+int carp_register_virtual_size (int regnum) { return 0; }
+/* #define REGISTER_VIRTUAL_SIZE(regnum) carp_register_virtual_size (regnum) */
+
+
+#if 0
+@item REG_STRUCT_HAS_ADDR (gcc_p, type)
+Define this to return 1 if the given type will be passed by pointer
+rather than directly.
+#endif
+int carp_reg_struct_has_addr (int gcc_p, struct type *type) { return 0; }
+/* #define REG_STRUCT_HAS_ADDR(gcc_p, type) carp_reg_struct_has_addr (gcc_p, type) */
+
+
+#if 0
+@item SAVED_PC_AFTER_CALL (frame)
+#endif
+CORE_ADDR carp_saved_pc_after_call (struct frame_info *frame) { return 0; }
+/* #define SAVED_PC_AFTER_CALL(frame) carp_saved_pc_after_call (frame) */
+
+
+#if 0
+@item SDB_REG_TO_REGNUM (regnum)
+Define this to convert sdb register numbers into GDB regnums.  If not
+defined, no conversion will be done.
+#endif
+int carp_sdb_reg_to_regnum (int regnum) { return 0; }
+/* #define SDB_REG_TO_REGNUM(regnum) carp_sdb_reg_to_regnum (regnum) */
+
+
+#if 0
+@item SET_TRAPPED_INTERNALVAR
+#endif
+void carp_set_trapped_internalvar (struct internalvar *var, struct value *newval, int bitpos, int bitsize, int offset) { return; }
+/* #dfine SET_TRAPPED_INTERNALVAR(var, newval, bitpos, bitsize, offset) carp_set_trapped_internalvar (var, newval, bitpos, bitsize, offset) */
+
+
+#if 0
+@item SHIFT_INST_REGS
+(Only used for m88k targets.)
+#endif
+
+
+#if 0
+@item SKIP_PROLOGUE
+A C statement that advances the PC across any function entry prologue
+instructions so as to reach real code.
+#endif
+CORE_ADDR carp_skip_prologue (CORE_ADDR pc) { return 0; }
+/* #define SKIP_PROLOGUE(pc) (pc) = carp_skip_prologue (pc) */
+
+
+#if 0
+@item 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,
+@code{SKIP_PROLOGUE} will be used instead.
+#endif
+CORE_ADDR carp_skip_prologue_frameless_p (CORE_ADDR pc) { return 0; }
+/* #define SKIP_PROLOGUE_FRAMELESS_P(pc) (pc) = carp_skip_prologue_frameless_p (pc) */
+
+
+#if 0
+@item 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.
+#endif
+CORE_ADDR carp_skip_trampoline_code (CORE_ADDR pc) { return 0; }
+/* #define SKIP_TRAMPOLINE_CODE(pc) (pc) = carp_skip_trampoline_code (pc) */
+
+
+#if 0
+@item SP_REGNUM
+Define this to be the number of the register that serves as the stack
+pointer.
+#endif
+int carp_sp_regnum;
+/* #define SP_REGNUM carp_sp_regnum */
+
+
+#if 0
+@item 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.
+#endif
+int carp_stab_reg_to_regnum (int regnum) { return 0; }
+/* #define STAB_REG_TO_REGNUM(regnum) carp_stab_reg_to_regnum (regnum) */
+
+
+#if 0
+@item STACK_ALIGN (addr)
+Define this to adjust the address to the alignment required for the
+processors stack.
+#endif
+CORE_ADDR carp_stack_align (CORE_ADDR pc) { return 0; }
+/* #define STACK_ALIGN(pc) carp_stack_align (pc) */
+
+
+#if 0
+@item STEP_SKIPS_DELAY (addr)
+Define this to return true if the address is of an instruction with a
+delay slot.  If a breakpoint has been placed in the instructions delay
+slot, GDB will single-step over that instruction before resuming
+normally.  Currently only defined for the Mips.
+#endif
+
+
+#if 0
+@item STORE_STRUCT_RETURN (type, valbuf)
+A C expression that stores a function return value of type @var{type},
+where @var{valbuf} is the address of the value to be stored.
+#endif
+void carp_store_struct_return (CORE_ADDR addr, CORE_ADDR sp) { return; }
+/* #define STORE_STRUCT_RETURN(addr,sp) carp_store_struct_return (addr, sp) */
+
+
+#if 0
+@item STORE_RETURN_VALUE (type, valbuf)
+A C expression that stores a function return value of type @var{type},
+where @var{valbuf} is the address of the value to be stored.
+#endif
+void carp_store_return_value (struct type *type, char *valbuf) { return; }
+/* #define STORE_RETURN_VALUE(type,valbuf) carp_store_return_value (type, valbuf) */
+
+
+#if 0
+@item SUN_FIXED_LBRAC_BUG
+(Used only for Sun-3 and Sun-4 targets.)
+#endif
+
+
+#if 0
+@item SYMBOL_RELOADING_DEFAULT
+The default value of the symbol-reloading variable.  (Never defined in
+current sources.)
+#endif
+
+
+#if 0
+@item TARGET_BYTE_ORDER
+The ordering of bytes in the target.  This must be defined to be either
+@code{BIG_ENDIAN} or @code{LITTLE_ENDIAN}.
+#endif
+int carp_target_byte_order;
+/* #define TARGET_BYTE_ORDER carp_target_byte_order */
+
+
+#if 0
+@item TARGET_CHAR_BIT
+Number of bits in a char; defaults to 8.
+#endif
+
+
+#if 0
+@item TARGET_COMPLEX_BIT
+Number of bits in a complex number; defaults to @code{2 * TARGET_FLOAT_BIT}.
+#endif
+int carp_target_complex_bit;
+/* #define TARGET_COMPLEX_BIT carp_target_complex_bit */
+
+
+#if 0
+@item TARGET_DOUBLE_BIT
+Number of bits in a double float; defaults to @code{8 * TARGET_CHAR_BIT}.
+#endif
+int carp_target_double_bit;
+/* #define TARGET_DOUBLE_BIT carp_target_double_bit */
+
+
+#if 0
+@item TARGET_DOUBLE_COMPLEX_BIT
+Number of bits in a double complex; defaults to @code{2 * TARGET_DOUBLE_BIT}.
+#endif
+int carp_target_double_complex_bit;
+/* #define TARGET_DOUBLE_COMPLEX_BIT carp_target_double_complex_bit */
+
+
+#if 0
+@item TARGET_FLOAT_BIT
+Number of bits in a float; defaults to @code{4 * TARGET_CHAR_BIT}.
+#endif
+int carp_target_float_bit;
+/* #define TARGET_FLOAT_BIT carp_target_float_bit */
+
+
+#if 0
+@item TARGET_INT_BIT
+Number of bits in an integer; defaults to @code{4 * TARGET_CHAR_BIT}.
+#endif
+int carp_target_int_bit;
+/* #define TARGET_INT_BIT carp_target_int_bit */
+
+
+#if 0
+@item TARGET_LONG_BIT
+Number of bits in a long integer; defaults to @code{4 * TARGET_CHAR_BIT}.
+#endif
+int carp_target_long_bit;
+/* #define TARGET_LONG_BIT carp_target_long_bit */
+
+
+#if 0
+@item TARGET_LONG_DOUBLE_BIT
+Number of bits in a long double float;
+defaults to @code{2 * TARGET_DOUBLE_BIT}.
+#endif
+int carp_target_long_double_bit;
+/* #define TARGET_LONG_DOUBLE_BIT carp_target_long_double_bit */
+
+
+#if 0
+@item TARGET_LONG_LONG_BIT
+Number of bits in a long long integer; defaults to @code{2 * TARGET_LONG_BIT}.
+#endif
+int carp_target_long_long_bit;
+/* #define TARGET_LONG_LONG_BIT carp_target_long_long_bit */
+
+
+#if 0
+@item TARGET_PTR_BIT
+Number of bits in a pointer; defaults to @code{TARGET_INT_BIT}.
+#endif
+int carp_target_ptr_bit;
+/* #define TARGET_PTR_BIT carp_target_ptr_bit */
+
+
+#if 0
+@item TARGET_SHORT_BIT
+Number of bits in a short integer; defaults to @code{2 * TARGET_CHAR_BIT}.
+#endif
+int carp_target_short_bit;
+/* #define TARGET_SHORT_BIT carp_target_short_bit */
+
+
+#if 0
+@item TARGET_READ_PC
+@item TARGET_WRITE_PC (val, pid)
+@item TARGET_READ_SP
+@item TARGET_WRITE_SP
+@item TARGET_READ_FP
+@item TARGET_WRITE_FP
+These change the behavior of @code{read_pc}, @code{write_pc},
+@code{read_sp}, @code{write_sp}, @code{read_fp} and @code{write_fp}.
+For most targets, these may be left undefined.  GDB will call the read
+and write register functions with the relevant @code{_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.
+#endif
+CORE_ADDR carp_target_read_pc (int pid) { return 0; }
+CORE_ADDR carp_target_read_sp (void) { return 0; }
+CORE_ADDR carp_target_read_fp (void) { return 0; }
+void carp_target_write_pc (CORE_ADDR pc, int pid) { return; }
+void carp_target_write_sp (CORE_ADDR sp) { return; }
+void carp_target_write_fp (CORE_ADDR fp) { return; }
+/* #define TARGET_READ_PC(pid) carp_target_read_pc (pid) */
+/* #define TARGET_WRITE_PC(val,pid) carp_target_write_pc (val, pid) */
+/* #define TARGET_READ_SP() carp_target_read_sp () */
+/* #define TARGET_WRITE_SP(val) carp_target_write_sp (val) */
+/* #define TARGET_READ_FP() carp_target_read_fp () */
+/* #define TARGET_WRITE_FP(val) carp_target_write_fp (val) */
+
+
+#if 0
+@item USE_STRUCT_CONVENTION (gcc_p, type)
+If defined, this must be an expression that is nonzero if a value of the
+given @var{type} being returned from a function must have space
+allocated for it on the stack.  @var{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.
+#endif
+
+
+#if 0
+@item VALUE_OF_TRAPPED_INTERNALVAR
+#endif
+struct value *carp_value_of_trapped_internalvar (struct internalvar *var) { return 0; }
+/* #define VALUE_OF_TRAPPED_INTERNALVAR(var) carp_value_of_trapped_internalvar (var) */
+
+
+#if 0
+@item 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.  @var{desc} is the value of @code{n_desc} from the
+@code{N_RBRAC} symbol, and @var{gcc_p} is true if GDB has noticed the
+presence of either the @code{GCC_COMPILED_SYMBOL} or the
+@code{GCC2_COMPILED_SYMBOL}.  By default, this is 0.
+#endif
+
+
+#if 0
+@item OS9K_VARIABLES_INSIDE_BLOCK (desc, gcc_p)
+Similarly, for OS/9000.  Defaults to 1.
+#endif