gdb/config/rs6000/tm-rs6000.h

   1 /* Parameters for target execution on an RS6000, for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1997
   3    Free Software Foundation, Inc.
   4    Contributed by IBM Corporation.
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #ifdef __STDC__         /* Forward decls for prototypes */
  23 struct frame_info;
  24 struct type;
  25 struct value;
  26 #endif
  27
  28 /* Minimum possible text address in AIX */
  29
  30 #define TEXT_SEGMENT_BASE       0x10000000
  31
  32 /* Load segment of a given pc value. */
  33
  34 #define PC_LOAD_SEGMENT(PC)     pc_load_segment_name(PC)
  35 extern char *pc_load_segment_name PARAMS ((CORE_ADDR));
  36
  37 /* AIX cc seems to get this right.  */
  38
  39 #define BELIEVE_PCC_PROMOTION 1
  40
  41 /* return true if a given `pc' value is in `call dummy' function. */
  42 /* FIXME: This just checks for the end of the stack, which is broken
  43    for things like stepping through gcc nested function stubs.  */
  44 #define PC_IN_CALL_DUMMY(STOP_PC, STOP_SP, STOP_FRAME_ADDR)     \
  45         (STOP_SP < STOP_PC && STOP_PC < STACK_END_ADDR)
  46
  47 #if 0
  48 extern unsigned int text_start, data_start;
  49 extern char *corefile;
  50 #endif
  51 extern int inferior_pid;
  52
  53 /* We are missing register descriptions in the system header files. Sigh! */
  54
  55 struct regs {
  56         int     gregs [32];             /* general purpose registers */
  57         int     pc;                     /* program conter       */
  58         int     ps;                     /* processor status, or machine state */
  59 };
  60
  61 struct fp_status {
  62         double  fpregs [32];            /* floating GP registers */
  63 };
  64
  65
  66 /* To be used by skip_prologue. */
  67
  68 struct rs6000_framedata {
  69   int   offset;                         /* total size of frame --- the distance
  70                                            by which we decrement sp to allocate
  71                                            the frame */
  72   int   saved_gpr;                      /* smallest # of saved gpr */
  73   int   saved_fpr;                      /* smallest # of saved fpr */
  74   int   alloca_reg;                     /* alloca register number (frame ptr) */
  75   char  frameless;                      /* true if frameless functions. */
  76   char  nosavedpc;                      /* true if pc not saved. */
  77   int   gpr_offset;                     /* offset of saved gprs from prev sp */
  78   int   fpr_offset;                     /* offset of saved fprs from prev sp */
  79   int   lr_offset;                      /* offset of saved lr */
  80   int   cr_offset;                      /* offset of saved cr */
  81 };
  82
  83 /* Define the byte order of the machine.  */
  84
  85 #define TARGET_BYTE_ORDER_DEFAULT       BIG_ENDIAN
  86
  87 /* AIX's assembler doesn't grok dollar signs in identifiers.
  88    So we use dots instead.  This item must be coordinated with G++. */
  89 #undef CPLUS_MARKER
  90 #define CPLUS_MARKER '.'
  91
  92 /* Offset from address of function to start of its code.
  93    Zero on most machines.  */
  94
  95 #define FUNCTION_START_OFFSET 0
  96
  97 /* Advance PC across any function entry prologue instructions
  98    to reach some "real" code.  */
  99
 100 #define SKIP_PROLOGUE(pc)                                               \
 101 do {                                                                    \
 102   struct rs6000_framedata _frame;                                       \
 103   pc = skip_prologue (pc, &_frame);                                     \
 104 } while (0)
 105
 106 extern CORE_ADDR skip_prologue PARAMS((CORE_ADDR, struct rs6000_framedata *));
 107
 108
 109 /* If PC is in some function-call trampoline code, return the PC
 110    where the function itself actually starts.  If not, return NULL.  */
 111
 112 #define SKIP_TRAMPOLINE_CODE(pc)        skip_trampoline_code (pc)
 113 extern CORE_ADDR skip_trampoline_code PARAMS ((CORE_ADDR));
 114
 115 /* Number of trap signals we need to skip over, once the inferior process
 116    starts running. */
 117
 118 #define START_INFERIOR_TRAPS_EXPECTED   2
 119
 120 /* AIX has a couple of strange returns from wait().  */
 121
 122 #define CHILD_SPECIAL_WAITSTATUS(ourstatus, hoststatus) ( \
 123   /* "stop after load" status.  */ \
 124   (hoststatus) == 0x57c ? (ourstatus)->kind = TARGET_WAITKIND_LOADED, 1 : \
 125   \
 126   /* signal 0. I have no idea why wait(2) returns with this status word.  */ \
 127   /* It looks harmless. */ \
 128   (hoststatus) == 0x7f ? (ourstatus)->kind = TARGET_WAITKIND_SPURIOUS, 1 : \
 129   \
 130   /* A normal waitstatus.  Let the usual macros deal with it.  */ \
 131   0)
 132
 133 /* In xcoff, we cannot process line numbers when we see them. This is
 134    mainly because we don't know the boundaries of the include files. So,
 135    we postpone that, and then enter and sort(?) the whole line table at
 136    once, when we are closing the current symbol table in end_symtab(). */
 137
 138 #define PROCESS_LINENUMBER_HOOK()       aix_process_linenos ()
 139 extern void aix_process_linenos PARAMS ((void));
 140
 141 /* Immediately after a function call, return the saved pc.
 142    Can't go through the frames for this because on some machines
 143    the new frame is not set up until the new function executes
 144    some instructions.  */
 145
 146 #define SAVED_PC_AFTER_CALL(frame) read_register (LR_REGNUM)
 147
 148 /* Address of end of stack space.  */
 149
 150 #define STACK_END_ADDR 0x2ff80000
 151
 152 /* Stack grows downward.  */
 153
 154 #define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
 155
 156 /* This is how arguments pushed onto stack or passed in registers.
 157    Stack must be aligned on 64-bit boundaries when synthesizing
 158    function calls.  We don't need STACK_ALIGN, PUSH_ARGUMENTS will
 159    handle it. */
 160
 161 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
 162   sp = push_arguments((nargs), (args), (sp), (struct_return), (struct_addr))
 163 extern CORE_ADDR push_arguments PARAMS ((int, struct value **, CORE_ADDR,
 164                                          int, CORE_ADDR));
 165
 166 /* BREAKPOINT_FROM_PC uses the program counter value to determine the
 167    breakpoint that should be used */
 168 extern breakpoint_from_pc_fn rs6000_breakpoint_from_pc;
 169 #define BREAKPOINT_FROM_PC(pcptr, lenptr) rs6000_breakpoint_from_pc (pcptr, lenptr)
 170
 171 /* Amount PC must be decremented by after a breakpoint.
 172    This is often the number of bytes in BREAKPOINT
 173    but not always.  */
 174
 175 #define DECR_PC_AFTER_BREAK 0
 176
 177 /* Say how long (ordinary) registers are.  This is a piece of bogosity
 178    used in push_word and a few other places; REGISTER_RAW_SIZE is the
 179    real way to know how big a register is.  */
 180 #define REGISTER_SIZE 4
 181
 182
 183 /* Return the name of register number REG.  This may return "" to
 184    indicate a register number that's not used on this variant.
 185    (Register numbers may be sparse for consistency between variants.)  */
 186 #define REGISTER_NAME(reg) (rs6000_register_name(reg))
 187 extern char *rs6000_register_name (int reg);
 188
 189 /* Number of machine registers */
 190 #define NUM_REGS 183
 191
 192 /* Register numbers of various important registers.
 193    Note that some of these values are "real" register numbers,
 194    and correspond to the general registers of the machine,
 195    and some are "phony" register numbers which are too large
 196    to be actual register numbers as far as the user is concerned
 197    but do serve to get the desired values when passed to read_register.  */
 198
 199 #define FP_REGNUM 1             /* Contains address of executing stack frame */
 200 #define SP_REGNUM 1             /* Contains address of top of stack */
 201 #define TOC_REGNUM 2            /* TOC register */
 202 #define FP0_REGNUM 32           /* Floating point register 0 */
 203 #define GP0_REGNUM 0            /* GPR register 0 */
 204 #define FP0_REGNUM 32           /* FPR (Floating point) register 0 */
 205 #define FPLAST_REGNUM 63        /* Last floating point register */
 206
 207 /* Special purpose registers... */
 208 /* P.S. keep these in the same order as in /usr/mstsave.h `mstsave'
 209    structure, for easier processing */
 210
 211 #define PC_REGNUM 64            /* Program counter (instruction address %iar)*/
 212 #define PS_REGNUM 65            /* Processor (or machine) status (%msr) */
 213 #define CR_REGNUM 66            /* Condition register */
 214 #define LR_REGNUM 67            /* Link register */
 215 #define CTR_REGNUM 68           /* Count register */
 216 #define XER_REGNUM 69           /* Fixed point exception registers */
 217 #define MQ_REGNUM 70            /* Multiply/quotient register */
 218
 219 /* These #defines are used to parse core files and talk to ptrace, so they
 220    must remain fixed.  */
 221 #define FIRST_UISA_SP_REGNUM 64 /* first special register number */
 222 #define LAST_UISA_SP_REGNUM  70 /* last special register number */
 223
 224 /* This is the offset in REG_NAMES at which the `set processor'
 225    command starts plugging in its names.  */
 226 #define FIRST_VARIANT_REGISTER 66
 227
 228 /* Total amount of space needed to store our copies of the machine's
 229    register state, the array `registers'.
 230              32 4-byte gpr's
 231              32 8-byte fpr's
 232              7  4-byte UISA special purpose registers,
 233              16 4-byte segment registers,
 234              32 4-byte standard OEA special-purpose registers,
 235    and up to 64 4-byte non-standard OEA special purpose regs.
 236    total: (+ (* 32 4) (* 32 8) (* 7 4) (* 16 4) (* 32 4) (* 64 4)) 860 bytes
 237    Keep some extra space for now, in case to add more. */
 238 #define REGISTER_BYTES 880
 239
 240
 241 /* Index within `registers' of the first byte of the space for
 242    register N.  */
 243
 244 #define REGISTER_BYTE(N)  \
 245  (                                                              \
 246   ((N) > FPLAST_REGNUM) ? ((((N) - FPLAST_REGNUM -1) * 4) + 384)\
 247   :((N) >= FP0_REGNUM) ? ((((N) - FP0_REGNUM) * 8) + 128)       \
 248   :((N) * 4) )
 249
 250 /* Number of bytes of storage in the actual machine representation
 251    for register N. */
 252 /* Note that the unsigned cast here forces the result of the
 253    subtraction to very high positive values if N < FP0_REGNUM */
 254
 255 #define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
 256
 257 /* Number of bytes of storage in the program's representation
 258    for register N.  On the RS6000, all regs are 4 bytes
 259    except the floating point regs which are 8-byte doubles.  */
 260
 261 #define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
 262
 263 /* Largest value REGISTER_RAW_SIZE can have.  */
 264
 265 #define MAX_REGISTER_RAW_SIZE 8
 266
 267 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 268
 269 #define MAX_REGISTER_VIRTUAL_SIZE 8
 270
 271 /* convert a dbx stab register number (from `r' declaration) to a gdb REGNUM */
 272
 273 #define STAB_REG_TO_REGNUM(value)       (value)
 274
 275 /* Nonzero if register N requires conversion
 276    from raw format to virtual format.
 277    The register format for rs6000 floating point registers is always
 278    double, we need a conversion if the memory format is float.  */
 279
 280 #define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM && (N) <= FPLAST_REGNUM)
 281
 282 /* Convert data from raw format for register REGNUM in buffer FROM
 283    to virtual format with type TYPE in buffer TO.  */
 284
 285 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \
 286 { \
 287   if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
 288     { \
 289       double val = extract_floating ((FROM), REGISTER_RAW_SIZE (REGNUM)); \
 290       store_floating ((TO), TYPE_LENGTH (TYPE), val); \
 291     } \
 292   else \
 293     memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
 294 }
 295
 296 /* Convert data from virtual format with type TYPE in buffer FROM
 297    to raw format for register REGNUM in buffer TO.  */
 298
 299 #define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO)    \
 300 { \
 301   if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
 302     { \
 303       double val = extract_floating ((FROM), TYPE_LENGTH (TYPE)); \
 304       store_floating ((TO), REGISTER_RAW_SIZE (REGNUM), val); \
 305     } \
 306   else \
 307     memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
 308 }
 309
 310 /* Return the GDB type object for the "standard" data type
 311    of data in register N.  */
 312
 313 #define REGISTER_VIRTUAL_TYPE(N) \
 314  (((unsigned)(N) - FP0_REGNUM) < 32 ? builtin_type_double : builtin_type_int)
 315
 316 /* Store the address of the place in which to copy the structure the
 317    subroutine will return.  This is called from call_function. */
 318 /* in RS6000, struct return addresses are passed as an extra parameter in r3.
 319    In function return, callee is not responsible of returning this address back.
 320    Since gdb needs to find it, we will store in a designated variable
 321    `rs6000_struct_return_address'. */
 322
 323 extern CORE_ADDR rs6000_struct_return_address;
 324
 325 #define STORE_STRUCT_RETURN(ADDR, SP)   \
 326   { write_register (3, (ADDR));         \
 327     rs6000_struct_return_address = (ADDR); }
 328
 329 /* Extract from an array REGBUF containing the (raw) register state
 330    a function return value of type TYPE, and copy that, in virtual format,
 331    into VALBUF.  */
 332
 333 /* #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 334   memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE)) */
 335
 336 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 337   extract_return_value(TYPE,REGBUF,VALBUF)
 338 extern void extract_return_value PARAMS ((struct type *, char [], char *));
 339
 340 /* Write into appropriate registers a function return value
 341    of type TYPE, given in virtual format.  */
 342
 343 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 344   {                                                                     \
 345     if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                              \
 346                                                                         \
 347      /* Floating point values are returned starting from FPR1 and up.   \
 348         Say a double_double_double type could be returned in            \
 349         FPR1/FPR2/FPR3 triple. */                                       \
 350                                                                         \
 351       write_register_bytes (REGISTER_BYTE (FP0_REGNUM+1), (VALBUF),     \
 352                                                 TYPE_LENGTH (TYPE));    \
 353     else                                                                \
 354       /* Everything else is returned in GPR3 and up. */                 \
 355       write_register_bytes (REGISTER_BYTE (GP0_REGNUM+3), (VALBUF),     \
 356                                                 TYPE_LENGTH (TYPE));    \
 357   }
 358
 359
 360 /* Extract from an array REGBUF containing the (raw) register state
 361    the address in which a function should return its structure value,
 362    as a CORE_ADDR (or an expression that can be used as one).  */
 363
 364 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF)    rs6000_struct_return_address
 365 \f
 366 /* Describe the pointer in each stack frame to the previous stack frame
 367    (its caller).  */
 368
 369 /* FRAME_CHAIN takes a frame's nominal address
 370    and produces the frame's chain-pointer. */
 371
 372 /* In the case of the RS6000, the frame's nominal address
 373    is the address of a 4-byte word containing the calling frame's address.  */
 374
 375 #define FRAME_CHAIN(thisframe) rs6000_frame_chain (thisframe)
 376 CORE_ADDR rs6000_frame_chain PARAMS ((struct frame_info *));
 377
 378 /* Define other aspects of the stack frame.  */
 379
 380 /* A macro that tells us whether the function invocation represented
 381    by FI does not have a frame on the stack associated with it.  If it
 382    does not, FRAMELESS is set to 1, else 0.  */
 383
 384 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 385   FRAMELESS = frameless_function_invocation (FI)
 386
 387 extern int frameless_function_invocation PARAMS((struct frame_info *));
 388
 389 #define INIT_FRAME_PC_FIRST(fromleaf, prev) \
 390   prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
 391               prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
 392 #define INIT_FRAME_PC(fromleaf, prev) /* nothing */
 393 extern void rs6000_init_extra_frame_info (int fromleaf, struct frame_info *);
 394 #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) rs6000_init_extra_frame_info (fromleaf, fi)
 395
 396 /* If the kernel has to deliver a signal, it pushes a sigcontext
 397    structure on the stack and then calls the signal handler, passing
 398    the address of the sigcontext in an argument register. Usually
 399    the signal handler doesn't save this register, so we have to
 400    access the sigcontext structure via an offset from the signal handler
 401    frame.
 402    The following constants were determined by experimentation on AIX 3.2.  */
 403 #define SIG_FRAME_PC_OFFSET 96
 404 #define SIG_FRAME_LR_OFFSET 108
 405 #define SIG_FRAME_FP_OFFSET 284
 406
 407 /* Default offset from SP where the LR is stored */
 408 #define DEFAULT_LR_SAVE 8
 409
 410 /* Return saved PC from a frame */
 411 #define FRAME_SAVED_PC(FRAME)  frame_saved_pc (FRAME)
 412
 413 extern unsigned long frame_saved_pc PARAMS ((struct frame_info *));
 414
 415 extern CORE_ADDR rs6000_frame_args_address PARAMS ((struct frame_info *));
 416 #define FRAME_ARGS_ADDRESS(FI) rs6000_frame_args_address (FI)
 417
 418 #define FRAME_LOCALS_ADDRESS(FI)        FRAME_ARGS_ADDRESS(FI)
 419
 420
 421 /* Set VAL to the number of args passed to frame described by FI.
 422    Can set VAL to -1, meaning no way to tell.  */
 423
 424 /* We can't tell how many args there are
 425    now that the C compiler delays popping them.  */
 426
 427 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 428
 429 /* Return number of bytes at start of arglist that are not really args.  */
 430
 431 #define FRAME_ARGS_SKIP 8       /* Not sure on this. FIXMEmgo */
 432
 433 /* Put here the code to store, into a struct frame_saved_regs,
 434    the addresses of the saved registers of frame described by FRAME_INFO.
 435    This includes special registers such as pc and fp saved in special
 436    ways in the stack frame.  sp is even more special:
 437    the address we return for it IS the sp for the next frame.  */
 438 /* In the following implementation for RS6000, we did *not* save sp. I am
 439    not sure if it will be needed. The following macro takes care of gpr's
 440    and fpr's only. */
 441
 442 extern void rs6000_frame_init_saved_regs PARAMS ((struct frame_info *));
 443 #define FRAME_INIT_SAVED_REGS(FI) rs6000_frame_init_saved_regs (FI)
 444
 445 /* Things needed for making the inferior call functions.  */
 446
 447 /* Push an empty stack frame, to record the current PC, etc.  */
 448 /* Change these names into rs6k_{push, pop}_frame(). FIXMEmgo. */
 449
 450 #define PUSH_DUMMY_FRAME        push_dummy_frame ()
 451 extern void push_dummy_frame PARAMS ((void));
 452
 453 /* Discard from the stack the innermost frame,
 454    restoring all saved registers.  */
 455
 456 #define POP_FRAME       pop_frame ()
 457 extern void pop_frame PARAMS ((void));
 458
 459 /* This sequence of words is the instructions:
 460
 461         mflr    r0              // 0x7c0802a6
 462                                 // save fpr's
 463         stfd    r?, num(r1)     // 0xd8010000 there should be 32 of this??
 464                                 // save gpr's
 465         stm     r0, num(r1)     // 0xbc010000
 466         stu     r1, num(r1)     // 0x94210000
 467
 468         // the function we want to branch might be in a different load
 469         // segment. reset the toc register. Note that the actual toc address
 470         // will be fix by fix_call_dummy () along with function address.
 471
 472         st      r2, 0x14(r1)    // 0x90410014 save toc register
 473         liu     r2, 0x1234      // 0x3c401234 reset a new toc value 0x12345678
 474         oril    r2, r2,0x5678   // 0x60425678
 475
 476                                 // load absolute address 0x12345678 to r0
 477         liu     r0, 0x1234      // 0x3c001234
 478         oril    r0, r0,0x5678   // 0x60005678
 479         mtctr   r0              // 0x7c0903a6 ctr <- r0
 480         bctrl                   // 0x4e800421 jump subroutine 0x12345678 (%ctr)
 481         cror    0xf, 0xf, 0xf   // 0x4def7b82
 482         brpt                    // 0x7d821008, breakpoint
 483         cror    0xf, 0xf, 0xf   // 0x4def7b82 (for 8 byte alignment)
 484
 485
 486   We actually start executing by saving the toc register first, since the pushing
 487   of the registers is done by PUSH_DUMMY_FRAME.  If this were real code,
 488   the arguments for the function called by the `bctrl' would be pushed
 489   between the `stu' and the `bctrl', and we could allow it to execute through.
 490   But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
 491   and we cannot allow to push the registers again.
 492 */
 493
 494 #define CALL_DUMMY {0x7c0802a6, 0xd8010000, 0xbc010000, 0x94210000, \
 495                     0x90410014, 0x3c401234, 0x60425678,             \
 496                     0x3c001234, 0x60005678, 0x7c0903a6, 0x4e800421, \
 497                     0x4def7b82, 0x7d821008, 0x4def7b82 }
 498
 499
 500 /* keep this as multiple of 8 (%sp requires 8 byte alignment) */
 501 #define CALL_DUMMY_LENGTH 56
 502
 503 #define CALL_DUMMY_START_OFFSET 16
 504
 505 /* Insert the specified number of args and function address into a
 506    call sequence of the above form stored at DUMMYNAME.  */
 507
 508 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
 509   rs6000_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p)
 510 extern void rs6000_fix_call_dummy PARAMS ((char *, CORE_ADDR, CORE_ADDR,
 511                                            int, struct value **,
 512                                            struct type *, int));
 513
 514 /* Hook in rs6000-tdep.c for determining the TOC address when
 515    calling functions in the inferior.  */
 516 extern CORE_ADDR (*find_toc_address_hook) PARAMS ((CORE_ADDR));
 517
 518 /* xcoffread.c provides a function to determine the TOC offset
 519    for a given object file.
 520    It is used under native AIX configurations for determining the
 521    TOC address when calling functions in the inferior.  */
 522 #ifdef __STDC__
 523 struct objfile;
 524 #endif
 525 extern CORE_ADDR get_toc_offset PARAMS ((struct objfile *));
 526
 527 /* Usually a function pointer's representation is simply the address
 528    of the function. On the RS/6000 however, a function pointer is
 529    represented by a pointer to a TOC entry. This TOC entry contains
 530    three words, the first word is the address of the function, the
 531    second word is the TOC pointer (r2), and the third word is the
 532    static chain value.  Throughout GDB it is currently assumed that a
 533    function pointer contains the address of the function, which is not
 534    easy to fix.  In addition, the conversion of a function address to
 535    a function pointer would require allocation of a TOC entry in the
 536    inferior's memory space, with all its drawbacks.  To be able to
 537    call C++ virtual methods in the inferior (which are called via
 538    function pointers), find_function_addr uses this macro to get the
 539    function address from a function pointer.  */
 540
 541 #define CONVERT_FROM_FUNC_PTR_ADDR(ADDR) \
 542   (is_magic_function_pointer (ADDR) ? read_memory_integer (ADDR, 4) : (ADDR))
 543 extern int is_magic_function_pointer PARAMS ((CORE_ADDR));
 544
 545 /* Flag for machine-specific stuff in shared files.  FIXME */
 546 #define IBM6000_TARGET
 547
 548 /* RS6000/AIX does not support PT_STEP.  Has to be simulated.  */
 549
 550 #define SOFTWARE_SINGLE_STEP_P 1
 551 extern void rs6000_software_single_step PARAMS ((unsigned int, int));
 552 #define SOFTWARE_SINGLE_STEP(sig,bp_p) rs6000_software_single_step (sig, bp_p)
 553
 554 /* If the current gcc for for this target does not produce correct debugging
 555    information for float parameters, both prototyped and unprototyped, then
 556    define this macro.  This forces gdb to  always assume that floats are
 557    passed as doubles and then converted in the callee.
 558
 559    For the PowerPC, it appears that the debug info marks the parameters as
 560    floats regardless of whether the function is prototyped, but the actual
 561    values are always passed in as doubles.  Thus by setting this to 1, both
 562    types of calls will work. */
 563
 564 #define COERCE_FLOAT_TO_DOUBLE 1