gdb/carp-tdep.c

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