| 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 |