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