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 SOFTWARE_SINGLE_STEP_P
 603 @ttem SOFTWARE_SINGLE_STEP
 604 #endif
 605 int carp_software_single_step_p;
 606 void carp_software_single_step (int signal, int bp_p) { return; }
 607
 608 #if 0
 609 @item NUM_REGS
 610 #endif
 611 int carp_num_regs;
 612 /* #define NUM_REGS carp_num_regs */
 613
 614
 615 #if 0
 616 @item PCC_SOL_BROKEN
 617 (Used only in the Convex target.)
 618 #endif
 619
 620
 621 #if 0
 622 @item PC_IN_CALL_DUMMY
 623 inferior.h
 624 #endif
 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) */
 627
 628
 629 #if 0
 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.)
 633 #endif
 634
 635
 636 #if 0
 637 @item PC_REGNUM
 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.
 641 #endif
 642 int carp_pc_regnum;
 643 /* #define PC_REGNUM carp_pc_regnum */
 644
 645
 646 #if 0
 647 @item NPC_REGNUM
 648 The number of the next program counter register, if defined.
 649 #endif
 650
 651
 652 #if 0
 653 @item NNPC_REGNUM
 654 The number of the next next program counter register, if defined.
 655 Currently, this is only defined for the Motorola 88K.
 656 #endif
 657
 658
 659 #if 0
 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.
 663 #endif
 664
 665
 666 #if 0
 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.
 670 #endif
 671
 672
 673 #if 0
 674 @item PROCESS_LINENUMBER_HOOK
 675 A hook defined for XCOFF reading.
 676 #endif
 677
 678
 679 #if 0
 680 @item PROLOGUE_FIRSTLINE_OVERLAP
 681 (Only used in unsupported Convex configuration.)
 682 #endif
 683
 684
 685 #if 0
 686 @item PS_REGNUM
 687 If defined, this is the number of the processor status register.  (This
 688 definition is only used in generic code when parsing "$ps".)
 689 #endif
 690
 691
 692 #if 0
 693 @item POP_FRAME
 694 Used in @samp{call_function_by_hand} to remove an artificial stack
 695 frame.
 696 #endif
 697 void carp_pop_frame (void) { return; }
 698 /* #define POP_FRAME carp_pop_frame () */
 699
 700
 701 #if 0
 702 @item PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)
 703 Define this to push arguments onto the stack for inferior function call.
 704 #endif
 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) */
 707
 708
 709 #if 0
 710 @item PUSH_DUMMY_FRAME
 711 Used in @samp{call_function_by_hand} to create an artificial stack frame.
 712 #endif
 713 void carp_push_dummy_frame (void) { return; }
 714 /* #define PUSH_DUMMY_FRAME carp_push_dummy_frame () */
 715
 716
 717 #if 0
 718 @item REGISTER_BYTE
 719 #endif
 720 int carp_register_byte (int regnum) { return 0; }
 721 #define REGISTER_BYTE(regnum) carp_register_byte (regnum)
 722
 723
 724 #if 0
 725 @item REGISTER_BYTES
 726 The total amount of space needed to store GDBs copy of the machines
 727 register state.
 728 #endif
 729 int carp_register_bytes;
 730 /* #define REGISTER_BYTES carp_register_bytes */
 731
 732
 733 #if 0
 734 @item REGISTER_NAMES
 735 Define this to expand into an initializer of an array of strings.  Each
 736 string is the name of a register.
 737 #endif
 738 char **carp_register_names;
 739 /* #define REGISTER_NAMES carp_register_names */
 740
 741
 742 #if 0
 743 @item REGISTER_RAW_SIZE
 744 #endif
 745 int carp_register_raw_size (int regnum) { return 0; }
 746 /* #define REGISTER_RAW_SIZE(regnum) carp_register_raw_size (regnum) */
 747
 748
 749 #if 0
 750 @item REGISTER_SIZE
 751 Size of a general purpose register?
 752 #endif
 753 int carp_register_size;
 754 /* #define REGISTER_SIZE carp_register_size */
 755
 756
 757 #if 0
 758 @item REGISTER_VIRTUAL_SIZE
 759 #endif
 760 int carp_register_virtual_size (int regnum) { return 0; }
 761 /* #define REGISTER_VIRTUAL_SIZE(regnum) carp_register_virtual_size (regnum) */
 762
 763
 764 #if 0
 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.
 768 #endif
 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) */
 771
 772
 773 #if 0
 774 @item SAVED_PC_AFTER_CALL (frame)
 775 #endif
 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) */
 778
 779
 780 #if 0
 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.
 784 #endif
 785 int carp_sdb_reg_to_regnum (int regnum) { return 0; }
 786 /* #define SDB_REG_TO_REGNUM(regnum) carp_sdb_reg_to_regnum (regnum) */
 787
 788
 789 #if 0
 790 @item SET_TRAPPED_INTERNALVAR
 791 #endif
 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) */
 794
 795
 796 #if 0
 797 @item SHIFT_INST_REGS
 798 (Only used for m88k targets.)
 799 #endif
 800
 801
 802 #if 0
 803 @item SKIP_PROLOGUE
 804 A C statement that advances the PC across any function entry prologue
 805 instructions so as to reach real code.
 806 #endif
 807 CORE_ADDR carp_skip_prologue (CORE_ADDR pc) { return 0; }
 808 /* #define SKIP_PROLOGUE(pc) (pc) = carp_skip_prologue (pc) */
 809
 810
 811 #if 0
 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.
 816 #endif
 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) */
 819
 820
 821 #if 0
 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.
 826 #endif
 827 CORE_ADDR carp_skip_trampoline_code (CORE_ADDR pc) { return 0; }
 828 /* #define SKIP_TRAMPOLINE_CODE(pc) (pc) = carp_skip_trampoline_code (pc) */
 829
 830
 831 #if 0
 832 @item SP_REGNUM
 833 Define this to be the number of the register that serves as the stack
 834 pointer.
 835 #endif
 836 int carp_sp_regnum;
 837 /* #define SP_REGNUM carp_sp_regnum */
 838
 839
 840 #if 0
 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
 844 done.
 845 #endif
 846 int carp_stab_reg_to_regnum (int regnum) { return 0; }
 847 /* #define STAB_REG_TO_REGNUM(regnum) carp_stab_reg_to_regnum (regnum) */
 848
 849
 850 #if 0
 851 @item STACK_ALIGN (addr)
 852 Define this to adjust the address to the alignment required for the
 853 processors stack.
 854 #endif
 855 CORE_ADDR carp_stack_align (CORE_ADDR pc) { return 0; }
 856 /* #define STACK_ALIGN(pc) carp_stack_align (pc) */
 857
 858
 859 #if 0
 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.
 865 #endif
 866
 867
 868 #if 0
 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.
 872 #endif
 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) */
 875
 876
 877 #if 0
 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.
 881 #endif
 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) */
 884
 885
 886 #if 0
 887 @item SUN_FIXED_LBRAC_BUG
 888 (Used only for Sun-3 and Sun-4 targets.)
 889 #endif
 890
 891
 892 #if 0
 893 @item SYMBOL_RELOADING_DEFAULT
 894 The default value of the symbol-reloading variable.  (Never defined in
 895 current sources.)
 896 #endif
 897
 898
 899 #if 0
 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}.
 903 #endif
 904 int carp_target_byte_order;
 905 /* #define TARGET_BYTE_ORDER carp_target_byte_order */
 906
 907
 908 #if 0
 909 @item TARGET_CHAR_BIT
 910 Number of bits in a char; defaults to 8.
 911 #endif
 912
 913
 914 #if 0
 915 @item TARGET_COMPLEX_BIT
 916 Number of bits in a complex number; defaults to @code{2 * TARGET_FLOAT_BIT}.
 917 #endif
 918 int carp_target_complex_bit;
 919 /* #define TARGET_COMPLEX_BIT carp_target_complex_bit */
 920
 921
 922 #if 0
 923 @item TARGET_DOUBLE_BIT
 924 Number of bits in a double float; defaults to @code{8 * TARGET_CHAR_BIT}.
 925 #endif
 926 int carp_target_double_bit;
 927 /* #define TARGET_DOUBLE_BIT carp_target_double_bit */
 928
 929
 930 #if 0
 931 @item TARGET_DOUBLE_COMPLEX_BIT
 932 Number of bits in a double complex; defaults to @code{2 * TARGET_DOUBLE_BIT}.
 933 #endif
 934 int carp_target_double_complex_bit;
 935 /* #define TARGET_DOUBLE_COMPLEX_BIT carp_target_double_complex_bit */
 936
 937
 938 #if 0
 939 @item TARGET_FLOAT_BIT
 940 Number of bits in a float; defaults to @code{4 * TARGET_CHAR_BIT}.
 941 #endif
 942 int carp_target_float_bit;
 943 /* #define TARGET_FLOAT_BIT carp_target_float_bit */
 944
 945
 946 #if 0
 947 @item TARGET_INT_BIT
 948 Number of bits in an integer; defaults to @code{4 * TARGET_CHAR_BIT}.
 949 #endif
 950 int carp_target_int_bit;
 951 /* #define TARGET_INT_BIT carp_target_int_bit */
 952
 953
 954 #if 0
 955 @item TARGET_LONG_BIT
 956 Number of bits in a long integer; defaults to @code{4 * TARGET_CHAR_BIT}.
 957 #endif
 958 int carp_target_long_bit;
 959 /* #define TARGET_LONG_BIT carp_target_long_bit */
 960
 961
 962 #if 0
 963 @item TARGET_LONG_DOUBLE_BIT
 964 Number of bits in a long double float;
 965 defaults to @code{2 * TARGET_DOUBLE_BIT}.
 966 #endif
 967 int carp_target_long_double_bit;
 968 /* #define TARGET_LONG_DOUBLE_BIT carp_target_long_double_bit */
 969
 970
 971 #if 0
 972 @item TARGET_LONG_LONG_BIT
 973 Number of bits in a long long integer; defaults to @code{2 * TARGET_LONG_BIT}.
 974 #endif
 975 int carp_target_long_long_bit;
 976 /* #define TARGET_LONG_LONG_BIT carp_target_long_long_bit */
 977
 978
 979 #if 0
 980 @item TARGET_PTR_BIT
 981 Number of bits in a pointer; defaults to @code{TARGET_INT_BIT}.
 982 #endif
 983 int carp_target_ptr_bit;
 984 /* #define TARGET_PTR_BIT carp_target_ptr_bit */
 985
 986
 987 #if 0
 988 @item TARGET_SHORT_BIT
 989 Number of bits in a short integer; defaults to @code{2 * TARGET_CHAR_BIT}.
 990 #endif
 991 int carp_target_short_bit;
 992 /* #define TARGET_SHORT_BIT carp_target_short_bit */
 993
 994
 995 #if 0
 996 @item TARGET_READ_PC
 997 @item TARGET_WRITE_PC (val, pid)
 998 @item TARGET_READ_SP
 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.
1006
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.
1010 #endif
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) */
1023
1024
1025 #if 0
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
1032 other compilers.
1033 #endif
1034
1035
1036 #if 0
1037 @item VALUE_OF_TRAPPED_INTERNALVAR
1038 #endif
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) */
1041
1042
1043 #if 0
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.
1051 #endif
1052
1053
1054 #if 0
1055 @item OS9K_VARIABLES_INSIDE_BLOCK (desc, gcc_p)
1056 Similarly, for OS/9000.  Defaults to 1.
1057 #endif