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 extern int carp_inner_than (int, int);
 518 #define INNER_THAN(x,y) carp_inner_than(x,y)
 519
 520
 521 #if 0
 522 @item IN_SIGTRAMP (pc, name)
 523 Define this to return true if the given pc and/or name indicates that
 524 the current function is a sigtramp.
 525 #endif
 526 int carp_in_sigtramp (CORE_ADDR pc, char *name) { return 0; }
 527 /* #define IN_SIGTRAMP(pc, name) carp_in_sigtramp (pc, name) */
 528
 529
 530 #if 0
 531 @item SIGTRAMP_START (pc)
 532 @item SIGTRAMP_END (pc)
 533 Define these to be the start and end address of the sigtramp for the
 534 given pc.  On machines where the address is just a compile time
 535 constant, the macro expansion will typically just ignore the supplied
 536 pc.
 537 #endif
 538 CORE_ADDR carp_sigtramp_start (CORE_ADDR pc) { return 0; }
 539 CORE_ADDR carp_sigtramp_end (CORE_ADDR pc) { return 0; }
 540 /* #define SIGTRAMP_START(pc) carp_sigtramp_start (pc) */
 541 /* #define SIGTRAMP_END(pc) carp_sigtramp_end (pc) */
 542
 543
 544 #if 0
 545 @item IN_SOLIB_TRAMPOLINE pc name
 546 Define this to evaluate to nonzero if the program is stopped in the
 547 trampoline that connects to a shared library.
 548 #endif
 549
 550
 551 #if 0
 552 @item IS_TRAPPED_INTERNALVAR name
 553 This is an ugly hook to allow the specification of special actions that
 554 should occur as a side-effect of setting the value of a variable
 555 internal to GDB.  Currently only used by the h8500.  Note that this
 556 could be either a host or target conditional.
 557 #endif
 558 int carp_is_trapped_internalvar (char *name) { return 0; }
 559 /* #define IS_TRAPPED_INTERNALVAR(name) carp_is_trapped_internalvar (name) */
 560
 561
 562 #if 0
 563 @item KERNEL_DEBUGGING
 564 tm-ultra3.h
 565 #endif
 566
 567
 568 #if 0
 569 @item MAX_REGISTER_RAW_SIZE
 570 #endif
 571 int carp_max_register_raw_size;
 572 /* #define MAX_REGISTER_RAW_SIZE carp_max_register_raw_size */
 573
 574
 575 #if 0
 576 @item MAX_REGISTER_VIRTUAL_SIZE
 577 #endif
 578 int carp_max_register_virtual_size;
 579 /* #define MAX_REGISTER_VIRTUAL_SIZE carp_max_register_virtual_size */
 580
 581
 582 #if 0
 583 @item MIPSEL
 584 mips-tdep.c
 585 #endif
 586
 587
 588 #if 0
 589 @item NEED_TEXT_START_END
 590 Define this if GDB should determine the start and end addresses of the
 591 text section.  (Seems dubious.)
 592 #endif
 593 int carp_need_text_start_end;
 594 /* #define NEED_TEXT_START_END carp_need_text_start_end */
 595
 596
 597 #if 0
 598 @item NO_HIF_SUPPORT
 599 (Specific to the a29k.)
 600 #endif
 601
 602
 603 #if 0
 604 @item SOFTWARE_SINGLE_STEP_P
 605 @ttem SOFTWARE_SINGLE_STEP
 606 #endif
 607 int carp_software_single_step_p;
 608 void carp_software_single_step (int signal, int bp_p) { return; }
 609
 610 #if 0
 611 @item NUM_REGS
 612 #endif
 613 int carp_num_regs;
 614 /* #define NUM_REGS carp_num_regs */
 615
 616
 617 #if 0
 618 @item PCC_SOL_BROKEN
 619 (Used only in the Convex target.)
 620 #endif
 621
 622
 623 #if 0
 624 @item PC_IN_CALL_DUMMY
 625 inferior.h
 626 #endif
 627 int carp_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp) { return 0; }
 628 /* #define PC_IN_CALL_DUMMY(pc, sp, fp) carp_pc_in_call_dummy (pc, sp, fp) */
 629
 630
 631 #if 0
 632 @item PC_LOAD_SEGMENT
 633 If defined, print information about the load segment for the program
 634 counter.  (Defined only for the RS/6000.)
 635 #endif
 636
 637
 638 #if 0
 639 @item PC_REGNUM
 640 If the program counter is kept in a register, then define this macro to
 641 be the number of that register.  This need be defined only if
 642 @code{TARGET_WRITE_PC} is not defined.
 643 #endif
 644 int carp_pc_regnum;
 645 /* #define PC_REGNUM carp_pc_regnum */
 646
 647
 648 #if 0
 649 @item NPC_REGNUM
 650 The number of the next program counter register, if defined.
 651 #endif
 652
 653
 654 #if 0
 655 @item NNPC_REGNUM
 656 The number of the next next program counter register, if defined.
 657 Currently, this is only defined for the Motorola 88K.
 658 #endif
 659
 660
 661 #if 0
 662 @item PRINT_REGISTER_HOOK (regno)
 663 If defined, this must be a function that prints the contents of the
 664 given register to standard output.
 665 #endif
 666
 667
 668 #if 0
 669 @item PRINT_TYPELESS_INTEGER
 670 This is an obscure substitute for @code{print_longest} that seems to
 671 have been defined for the Convex target.
 672 #endif
 673
 674
 675 #if 0
 676 @item PROCESS_LINENUMBER_HOOK
 677 A hook defined for XCOFF reading.
 678 #endif
 679
 680
 681 #if 0
 682 @item PROLOGUE_FIRSTLINE_OVERLAP
 683 (Only used in unsupported Convex configuration.)
 684 #endif
 685
 686
 687 #if 0
 688 @item PS_REGNUM
 689 If defined, this is the number of the processor status register.  (This
 690 definition is only used in generic code when parsing "$ps".)
 691 #endif
 692
 693
 694 #if 0
 695 @item POP_FRAME
 696 Used in @samp{call_function_by_hand} to remove an artificial stack
 697 frame.
 698 #endif
 699 void carp_pop_frame (void) { return; }
 700 /* #define POP_FRAME carp_pop_frame () */
 701
 702
 703 #if 0
 704 @item PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)
 705 Define this to push arguments onto the stack for inferior function call.
 706 #endif
 707 CORE_ADDR carp_push_arguments (int nargs, struct value **args, CORE_ADDR sp, unsigned char struct_return, CORE_ADDR struct_addr) { return 0; }
 708 /* #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) (SP) = carp_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) */
 709
 710
 711 #if 0
 712 @item PUSH_DUMMY_FRAME
 713 Used in @samp{call_function_by_hand} to create an artificial stack frame.
 714 #endif
 715 void carp_push_dummy_frame (void) { return; }
 716 /* #define PUSH_DUMMY_FRAME carp_push_dummy_frame () */
 717
 718
 719 #if 0
 720 @item REGISTER_BYTE
 721 #endif
 722 int carp_register_byte (int regnum) { return 0; }
 723 #define REGISTER_BYTE(regnum) carp_register_byte (regnum)
 724
 725
 726 #if 0
 727 @item REGISTER_BYTES
 728 The total amount of space needed to store GDBs copy of the machines
 729 register state.
 730 #endif
 731 int carp_register_bytes;
 732 /* #define REGISTER_BYTES carp_register_bytes */
 733
 734
 735 #if 0
 736 @item REGISTER_NAMES
 737 Define this to expand into an initializer of an array of strings.  Each
 738 string is the name of a register.
 739 #endif
 740 char **carp_register_names;
 741 /* #define REGISTER_NAMES carp_register_names */
 742
 743
 744 #if 0
 745 @item REGISTER_RAW_SIZE
 746 #endif
 747 int carp_register_raw_size (int regnum) { return 0; }
 748 /* #define REGISTER_RAW_SIZE(regnum) carp_register_raw_size (regnum) */
 749
 750
 751 #if 0
 752 @item REGISTER_SIZE
 753 Size of a general purpose register?
 754 #endif
 755 int carp_register_size;
 756 /* #define REGISTER_SIZE carp_register_size */
 757
 758
 759 #if 0
 760 @item REGISTER_VIRTUAL_SIZE
 761 #endif
 762 int carp_register_virtual_size (int regnum) { return 0; }
 763 /* #define REGISTER_VIRTUAL_SIZE(regnum) carp_register_virtual_size (regnum) */
 764
 765
 766 #if 0
 767 @item REG_STRUCT_HAS_ADDR (gcc_p, type)
 768 Define this to return 1 if the given type will be passed by pointer
 769 rather than directly.
 770 #endif
 771 int carp_reg_struct_has_addr (int gcc_p, struct type *type) { return 0; }
 772 /* #define REG_STRUCT_HAS_ADDR(gcc_p, type) carp_reg_struct_has_addr (gcc_p, type) */
 773
 774
 775 #if 0
 776 @item SAVED_PC_AFTER_CALL (frame)
 777 #endif
 778 CORE_ADDR carp_saved_pc_after_call (struct frame_info *frame) { return 0; }
 779 /* #define SAVED_PC_AFTER_CALL(frame) carp_saved_pc_after_call (frame) */
 780
 781
 782 #if 0
 783 @item SDB_REG_TO_REGNUM (regnum)
 784 Define this to convert sdb register numbers into GDB regnums.  If not
 785 defined, no conversion will be done.
 786 #endif
 787 int carp_sdb_reg_to_regnum (int regnum) { return 0; }
 788 /* #define SDB_REG_TO_REGNUM(regnum) carp_sdb_reg_to_regnum (regnum) */
 789
 790
 791 #if 0
 792 @item SET_TRAPPED_INTERNALVAR
 793 #endif
 794 void carp_set_trapped_internalvar (struct internalvar *var, struct value *newval, int bitpos, int bitsize, int offset) { return; }
 795 /* #dfine SET_TRAPPED_INTERNALVAR(var, newval, bitpos, bitsize, offset) carp_set_trapped_internalvar (var, newval, bitpos, bitsize, offset) */
 796
 797
 798 #if 0
 799 @item SHIFT_INST_REGS
 800 (Only used for m88k targets.)
 801 #endif
 802
 803
 804 #if 0
 805 @item SKIP_PROLOGUE
 806 A C statement that advances the PC across any function entry prologue
 807 instructions so as to reach real code.
 808 #endif
 809 CORE_ADDR carp_skip_prologue (CORE_ADDR pc) { return 0; }
 810 /* #define SKIP_PROLOGUE(pc) (pc) = carp_skip_prologue (pc) */
 811
 812
 813 #if 0
 814 @item SKIP_PROLOGUE_FRAMELESS_P
 815 A C statement that should behave similarly, but that can stop as soon as
 816 the function is known to have a frame.  If not defined,
 817 @code{SKIP_PROLOGUE} will be used instead.
 818 #endif
 819 CORE_ADDR carp_skip_prologue_frameless_p (CORE_ADDR pc) { return 0; }
 820 /* #define SKIP_PROLOGUE_FRAMELESS_P(pc) (pc) = carp_skip_prologue_frameless_p (pc) */
 821
 822
 823 #if 0
 824 @item SKIP_TRAMPOLINE_CODE (pc)
 825 If the target machine has trampoline code that sits between callers and
 826 the functions being called, then define this macro to return a new PC
 827 that is at the start of the real function.
 828 #endif
 829 CORE_ADDR carp_skip_trampoline_code (CORE_ADDR pc) { return 0; }
 830 /* #define SKIP_TRAMPOLINE_CODE(pc) (pc) = carp_skip_trampoline_code (pc) */
 831
 832
 833 #if 0
 834 @item SP_REGNUM
 835 Define this to be the number of the register that serves as the stack
 836 pointer.
 837 #endif
 838 int carp_sp_regnum;
 839 /* #define SP_REGNUM carp_sp_regnum */
 840
 841
 842 #if 0
 843 @item STAB_REG_TO_REGNUM
 844 Define this to convert stab register numbers (as gotten from r
 845 declarations) into GDB regnums.  If not defined, no conversion will be
 846 done.
 847 #endif
 848 int carp_stab_reg_to_regnum (int regnum) { return 0; }
 849 /* #define STAB_REG_TO_REGNUM(regnum) carp_stab_reg_to_regnum (regnum) */
 850
 851
 852 #if 0
 853 @item STACK_ALIGN (addr)
 854 Define this to adjust the address to the alignment required for the
 855 processors stack.
 856 #endif
 857 CORE_ADDR carp_stack_align (CORE_ADDR pc) { return 0; }
 858 /* #define STACK_ALIGN(pc) carp_stack_align (pc) */
 859
 860
 861 #if 0
 862 @item STEP_SKIPS_DELAY (addr)
 863 Define this to return true if the address is of an instruction with a
 864 delay slot.  If a breakpoint has been placed in the instructions delay
 865 slot, GDB will single-step over that instruction before resuming
 866 normally.  Currently only defined for the Mips.
 867 #endif
 868
 869
 870 #if 0
 871 @item STORE_STRUCT_RETURN (type, valbuf)
 872 A C expression that stores a function return value of type @var{type},
 873 where @var{valbuf} is the address of the value to be stored.
 874 #endif
 875 void carp_store_struct_return (CORE_ADDR addr, CORE_ADDR sp) { return; }
 876 /* #define STORE_STRUCT_RETURN(addr,sp) carp_store_struct_return (addr, sp) */
 877
 878
 879 #if 0
 880 @item STORE_RETURN_VALUE (type, valbuf)
 881 A C expression that stores a function return value of type @var{type},
 882 where @var{valbuf} is the address of the value to be stored.
 883 #endif
 884 void carp_store_return_value (struct type *type, char *valbuf) { return; }
 885 /* #define STORE_RETURN_VALUE(type,valbuf) carp_store_return_value (type, valbuf) */
 886
 887
 888 #if 0
 889 @item SUN_FIXED_LBRAC_BUG
 890 (Used only for Sun-3 and Sun-4 targets.)
 891 #endif
 892
 893
 894 #if 0
 895 @item SYMBOL_RELOADING_DEFAULT
 896 The default value of the symbol-reloading variable.  (Never defined in
 897 current sources.)
 898 #endif
 899
 900
 901 #if 0
 902 @item TARGET_BYTE_ORDER
 903 The ordering of bytes in the target.  This must be defined to be either
 904 @code{BIG_ENDIAN} or @code{LITTLE_ENDIAN}.
 905 #endif
 906 int carp_target_byte_order;
 907 /* #define TARGET_BYTE_ORDER carp_target_byte_order */
 908
 909
 910 #if 0
 911 @item TARGET_CHAR_BIT
 912 Number of bits in a char; defaults to 8.
 913 #endif
 914
 915
 916 #if 0
 917 @item TARGET_COMPLEX_BIT
 918 Number of bits in a complex number; defaults to @code{2 * TARGET_FLOAT_BIT}.
 919 #endif
 920 int carp_target_complex_bit;
 921 /* #define TARGET_COMPLEX_BIT carp_target_complex_bit */
 922
 923
 924 #if 0
 925 @item TARGET_DOUBLE_BIT
 926 Number of bits in a double float; defaults to @code{8 * TARGET_CHAR_BIT}.
 927 #endif
 928 int carp_target_double_bit;
 929 /* #define TARGET_DOUBLE_BIT carp_target_double_bit */
 930
 931
 932 #if 0
 933 @item TARGET_DOUBLE_COMPLEX_BIT
 934 Number of bits in a double complex; defaults to @code{2 * TARGET_DOUBLE_BIT}.
 935 #endif
 936 int carp_target_double_complex_bit;
 937 /* #define TARGET_DOUBLE_COMPLEX_BIT carp_target_double_complex_bit */
 938
 939
 940 #if 0
 941 @item TARGET_FLOAT_BIT
 942 Number of bits in a float; defaults to @code{4 * TARGET_CHAR_BIT}.
 943 #endif
 944 int carp_target_float_bit;
 945 /* #define TARGET_FLOAT_BIT carp_target_float_bit */
 946
 947
 948 #if 0
 949 @item TARGET_INT_BIT
 950 Number of bits in an integer; defaults to @code{4 * TARGET_CHAR_BIT}.
 951 #endif
 952 int carp_target_int_bit;
 953 /* #define TARGET_INT_BIT carp_target_int_bit */
 954
 955
 956 #if 0
 957 @item TARGET_LONG_BIT
 958 Number of bits in a long integer; defaults to @code{4 * TARGET_CHAR_BIT}.
 959 #endif
 960 int carp_target_long_bit;
 961 /* #define TARGET_LONG_BIT carp_target_long_bit */
 962
 963
 964 #if 0
 965 @item TARGET_LONG_DOUBLE_BIT
 966 Number of bits in a long double float;
 967 defaults to @code{2 * TARGET_DOUBLE_BIT}.
 968 #endif
 969 int carp_target_long_double_bit;
 970 /* #define TARGET_LONG_DOUBLE_BIT carp_target_long_double_bit */
 971
 972
 973 #if 0
 974 @item TARGET_LONG_LONG_BIT
 975 Number of bits in a long long integer; defaults to @code{2 * TARGET_LONG_BIT}.
 976 #endif
 977 int carp_target_long_long_bit;
 978 /* #define TARGET_LONG_LONG_BIT carp_target_long_long_bit */
 979
 980
 981 #if 0
 982 @item TARGET_PTR_BIT
 983 Number of bits in a pointer; defaults to @code{TARGET_INT_BIT}.
 984 #endif
 985 int carp_target_ptr_bit;
 986 /* #define TARGET_PTR_BIT carp_target_ptr_bit */
 987
 988
 989 #if 0
 990 @item TARGET_SHORT_BIT
 991 Number of bits in a short integer; defaults to @code{2 * TARGET_CHAR_BIT}.
 992 #endif
 993 int carp_target_short_bit;
 994 /* #define TARGET_SHORT_BIT carp_target_short_bit */
 995
 996
 997 #if 0
 998 @item TARGET_READ_PC
 999 @item TARGET_WRITE_PC (val, pid)
1000 @item TARGET_READ_SP
1001 @item TARGET_WRITE_SP
1002 @item TARGET_READ_FP
1003 @item TARGET_WRITE_FP
1004 These change the behavior of @code{read_pc}, @code{write_pc},
1005 @code{read_sp}, @code{write_sp}, @code{read_fp} and @code{write_fp}.
1006 For most targets, these may be left undefined.  GDB will call the read
1007 and write register functions with the relevant @code{_REGNUM} argument.
1008
1009 These macros are useful when a target keeps one of these registers in a
1010 hard to get at place; for example, part in a segment register and part
1011 in an ordinary register.
1012 #endif
1013 CORE_ADDR carp_target_read_pc (int pid) { return 0; }
1014 CORE_ADDR carp_target_read_sp (void) { return 0; }
1015 CORE_ADDR carp_target_read_fp (void) { return 0; }
1016 void carp_target_write_pc (CORE_ADDR pc, int pid) { return; }
1017 void carp_target_write_sp (CORE_ADDR sp) { return; }
1018 void carp_target_write_fp (CORE_ADDR fp) { return; }
1019 /* #define TARGET_READ_PC(pid) carp_target_read_pc (pid) */
1020 /* #define TARGET_WRITE_PC(val,pid) carp_target_write_pc (val, pid) */
1021 /* #define TARGET_READ_SP() carp_target_read_sp () */
1022 /* #define TARGET_WRITE_SP(val) carp_target_write_sp (val) */
1023 /* #define TARGET_READ_FP() carp_target_read_fp () */
1024 /* #define TARGET_WRITE_FP(val) carp_target_write_fp (val) */
1025
1026
1027 #if 0
1028 @item USE_STRUCT_CONVENTION (gcc_p, type)
1029 If defined, this must be an expression that is nonzero if a value of the
1030 given @var{type} being returned from a function must have space
1031 allocated for it on the stack.  @var{gcc_p} is true if the function
1032 being considered is known to have been compiled by GCC; this is helpful
1033 for systems where GCC is known to use different calling convention than
1034 other compilers.
1035 #endif
1036
1037
1038 #if 0
1039 @item VALUE_OF_TRAPPED_INTERNALVAR
1040 #endif
1041 struct value *carp_value_of_trapped_internalvar (struct internalvar *var) { return 0; }
1042 /* #define VALUE_OF_TRAPPED_INTERNALVAR(var) carp_value_of_trapped_internalvar (var) */
1043
1044
1045 #if 0
1046 @item VARIABLES_INSIDE_BLOCK (desc, gcc_p)
1047 For dbx-style debugging information, if the compiler puts variable
1048 declarations inside LBRAC/RBRAC blocks, this should be defined to be
1049 nonzero.  @var{desc} is the value of @code{n_desc} from the
1050 @code{N_RBRAC} symbol, and @var{gcc_p} is true if GDB has noticed the
1051 presence of either the @code{GCC_COMPILED_SYMBOL} or the
1052 @code{GCC2_COMPILED_SYMBOL}.  By default, this is 0.
1053 #endif
1054
1055
1056 #if 0
1057 @item OS9K_VARIABLES_INSIDE_BLOCK (desc, gcc_p)
1058 Similarly, for OS/9000.  Defaults to 1.
1059 #endif