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       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
 181 #define REGISTER_SIZE 4
 182
 183 /* Number of machine registers */
 184
 185 #define NUM_REGS 71
 186
 187 /* Initializer for an array of names of registers.
 188    There should be NUM_REGS strings in this initializer.  */
 189
 190 #define REGISTER_NAMES  \
 191  {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",  \
 192   "r8", "r9", "r10","r11","r12","r13","r14","r15", \
 193   "r16","r17","r18","r19","r20","r21","r22","r23", \
 194   "r24","r25","r26","r27","r28","r29","r30","r31", \
 195   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",  \
 196   "f8", "f9", "f10","f11","f12","f13","f14","f15", \
 197   "f16","f17","f18","f19","f20","f21","f22","f23", \
 198   "f24","f25","f26","f27","f28","f29","f30","f31", \
 199   "pc", "ps", "cnd", "lr", "cnt", "xer", "mq" }
 200
 201 /* Register numbers of various important registers.
 202    Note that some of these values are "real" register numbers,
 203    and correspond to the general registers of the machine,
 204    and some are "phony" register numbers which are too large
 205    to be actual register numbers as far as the user is concerned
 206    but do serve to get the desired values when passed to read_register.  */
 207
 208 #define FP_REGNUM 1             /* Contains address of executing stack frame */
 209 #define SP_REGNUM 1             /* Contains address of top of stack */
 210 #define TOC_REGNUM 2            /* TOC register */
 211 #define FP0_REGNUM 32           /* Floating point register 0 */
 212 #define GP0_REGNUM 0            /* GPR register 0 */
 213 #define FP0_REGNUM 32           /* FPR (Floating point) register 0 */
 214 #define FPLAST_REGNUM 63        /* Last floating point register */
 215
 216 /* Special purpose registers... */
 217 /* P.S. keep these in the same order as in /usr/mstsave.h `mstsave' structure, for
 218    easier processing */
 219
 220 #define PC_REGNUM 64            /* Program counter (instruction address %iar) */
 221 #define PS_REGNUM 65            /* Processor (or machine) status (%msr) */
 222 #define CR_REGNUM 66            /* Condition register */
 223 #define LR_REGNUM 67            /* Link register */
 224 #define CTR_REGNUM 68           /* Count register */
 225 #define XER_REGNUM 69           /* Fixed point exception registers */
 226 #define MQ_REGNUM 70            /* Multiply/quotient register */
 227
 228 #define FIRST_SP_REGNUM 64      /* first special register number */
 229 #define LAST_SP_REGNUM  70      /* last special register number */
 230
 231 /* Total amount of space needed to store our copies of the machine's
 232    register state, the array `registers'.
 233
 234         32 4-byte gpr's
 235         32 8-byte fpr's
 236         7  4-byte special purpose registers,
 237
 238    total 416 bytes. Keep some extra space for now, in case to add more. */
 239
 240 #define REGISTER_BYTES 420
 241
 242
 243 /* Index within `registers' of the first byte of the space for
 244    register N.  */
 245
 246 #define REGISTER_BYTE(N)  \
 247  (                                                              \
 248   ((N) > FPLAST_REGNUM) ? ((((N) - FPLAST_REGNUM -1) * 4) + 384)\
 249   :((N) >= FP0_REGNUM) ? ((((N) - FP0_REGNUM) * 8) + 128)       \
 250   :((N) * 4) )
 251
 252 /* Number of bytes of storage in the actual machine representation
 253    for register N. */
 254 /* Note that the unsigned cast here forces the result of the
 255    subtractiion to very high positive values if N < FP0_REGNUM */
 256
 257 #define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
 258
 259 /* Number of bytes of storage in the program's representation
 260    for register N.  On the RS6000, all regs are 4 bytes
 261    except the floating point regs which are 8-byte doubles.  */
 262
 263 #define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
 264
 265 /* Largest value REGISTER_RAW_SIZE can have.  */
 266
 267 #define MAX_REGISTER_RAW_SIZE 8
 268
 269 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 270
 271 #define MAX_REGISTER_VIRTUAL_SIZE 8
 272
 273 /* convert a dbx stab register number (from `r' declaration) to a gdb REGNUM */
 274
 275 #define STAB_REG_TO_REGNUM(value)       (value)
 276
 277 /* Nonzero if register N requires conversion
 278    from raw format to virtual format.
 279    The register format for rs6000 floating point registers is always
 280    double, we need a conversion if the memory format is float.  */
 281
 282 #define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM && (N) <= FPLAST_REGNUM)
 283
 284 /* Convert data from raw format for register REGNUM in buffer FROM
 285    to virtual format with type TYPE in buffer TO.  */
 286
 287 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \
 288 { \
 289   if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
 290     { \
 291       double val = extract_floating ((FROM), REGISTER_RAW_SIZE (REGNUM)); \
 292       store_floating ((TO), TYPE_LENGTH (TYPE), val); \
 293     } \
 294   else \
 295     memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
 296 }
 297
 298 /* Convert data from virtual format with type TYPE in buffer FROM
 299    to raw format for register REGNUM in buffer TO.  */
 300
 301 #define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO)    \
 302 { \
 303   if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
 304     { \
 305       double val = extract_floating ((FROM), TYPE_LENGTH (TYPE)); \
 306       store_floating ((TO), REGISTER_RAW_SIZE (REGNUM), val); \
 307     } \
 308   else \
 309     memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
 310 }
 311
 312 /* Return the GDB type object for the "standard" data type
 313    of data in register N.  */
 314
 315 #define REGISTER_VIRTUAL_TYPE(N) \
 316  (((unsigned)(N) - FP0_REGNUM) < 32 ? builtin_type_double : builtin_type_int)
 317
 318 /* Store the address of the place in which to copy the structure the
 319    subroutine will return.  This is called from call_function. */
 320 /* in RS6000, struct return addresses are passed as an extra parameter in r3.
 321    In function return, callee is not responsible of returning this address back.
 322    Since gdb needs to find it, we will store in a designated variable
 323    `rs6000_struct_return_address'. */
 324
 325 extern CORE_ADDR rs6000_struct_return_address;
 326
 327 #define STORE_STRUCT_RETURN(ADDR, SP)   \
 328   { write_register (3, (ADDR));         \
 329     rs6000_struct_return_address = (ADDR); }
 330
 331 /* Extract from an array REGBUF containing the (raw) register state
 332    a function return value of type TYPE, and copy that, in virtual format,
 333    into VALBUF.  */
 334
 335 /* #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 336   memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE)) */
 337
 338 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 339   extract_return_value(TYPE,REGBUF,VALBUF)
 340 extern void extract_return_value PARAMS ((struct type *, char [], char *));
 341
 342 /* Write into appropriate registers a function return value
 343    of type TYPE, given in virtual format.  */
 344
 345 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 346   {                                                                     \
 347     if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                              \
 348                                                                         \
 349      /* Floating point values are returned starting from FPR1 and up.   \
 350         Say a double_double_double type could be returned in            \
 351         FPR1/FPR2/FPR3 triple. */                                       \
 352                                                                         \
 353       write_register_bytes (REGISTER_BYTE (FP0_REGNUM+1), (VALBUF),     \
 354                                                 TYPE_LENGTH (TYPE));    \
 355     else                                                                \
 356       /* Everything else is returned in GPR3 and up. */                 \
 357       write_register_bytes (REGISTER_BYTE (GP0_REGNUM+3), (VALBUF),     \
 358                                                 TYPE_LENGTH (TYPE));    \
 359   }
 360
 361
 362 /* Extract from an array REGBUF containing the (raw) register state
 363    the address in which a function should return its structure value,
 364    as a CORE_ADDR (or an expression that can be used as one).  */
 365
 366 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF)    rs6000_struct_return_address
 367 \f
 368 /* Describe the pointer in each stack frame to the previous stack frame
 369    (its caller).  */
 370
 371 /* FRAME_CHAIN takes a frame's nominal address
 372    and produces the frame's chain-pointer. */
 373
 374 /* In the case of the RS6000, the frame's nominal address
 375    is the address of a 4-byte word containing the calling frame's address.  */
 376
 377 #define FRAME_CHAIN(thisframe) rs6000_frame_chain (thisframe)
 378 CORE_ADDR rs6000_frame_chain PARAMS ((struct frame_info *));
 379
 380 /* Define other aspects of the stack frame.  */
 381
 382 /* A macro that tells us whether the function invocation represented
 383    by FI does not have a frame on the stack associated with it.  If it
 384    does not, FRAMELESS is set to 1, else 0.  */
 385
 386 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 387   FRAMELESS = frameless_function_invocation (FI)
 388
 389 extern int frameless_function_invocation PARAMS((struct frame_info *));
 390
 391 #define INIT_FRAME_PC_FIRST(fromleaf, prev) \
 392   prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
 393               prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
 394 #define INIT_FRAME_PC(fromleaf, prev) /* nothing */
 395 extern void rs6000_init_extra_frame_info (int fromleaf, struct frame_info *);
 396 #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) rs6000_init_extra_frame_info (fromleaf, fi)
 397
 398 /* If the kernel has to deliver a signal, it pushes a sigcontext
 399    structure on the stack and then calls the signal handler, passing
 400    the address of the sigcontext in an argument register. Usually
 401    the signal handler doesn't save this register, so we have to
 402    access the sigcontext structure via an offset from the signal handler
 403    frame.
 404    The following constants were determined by experimentation on AIX 3.2.  */
 405 #define SIG_FRAME_PC_OFFSET 96
 406 #define SIG_FRAME_LR_OFFSET 108
 407 #define SIG_FRAME_FP_OFFSET 284
 408
 409 /* Default offset from SP where the LR is stored */
 410 #define DEFAULT_LR_SAVE 8
 411
 412 /* Return saved PC from a frame */
 413 #define FRAME_SAVED_PC(FRAME)  frame_saved_pc (FRAME)
 414
 415 extern unsigned long frame_saved_pc PARAMS ((struct frame_info *));
 416
 417 extern CORE_ADDR rs6000_frame_args_address PARAMS ((struct frame_info *));
 418 #define FRAME_ARGS_ADDRESS(FI) rs6000_frame_args_address (FI)
 419
 420 #define FRAME_LOCALS_ADDRESS(FI)        FRAME_ARGS_ADDRESS(FI)
 421
 422
 423 /* Set VAL to the number of args passed to frame described by FI.
 424    Can set VAL to -1, meaning no way to tell.  */
 425
 426 /* We can't tell how many args there are
 427    now that the C compiler delays popping them.  */
 428
 429 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 430
 431 /* Return number of bytes at start of arglist that are not really args.  */
 432
 433 #define FRAME_ARGS_SKIP 8       /* Not sure on this. FIXMEmgo */
 434
 435 /* Put here the code to store, into a struct frame_saved_regs,
 436    the addresses of the saved registers of frame described by FRAME_INFO.
 437    This includes special registers such as pc and fp saved in special
 438    ways in the stack frame.  sp is even more special:
 439    the address we return for it IS the sp for the next frame.  */
 440 /* In the following implementation for RS6000, we did *not* save sp. I am
 441    not sure if it will be needed. The following macro takes care of gpr's
 442    and fpr's only. */
 443
 444 extern void rs6000_frame_init_saved_regs PARAMS ((struct frame_info *));
 445 #define FRAME_INIT_SAVED_REGS(FI) rs6000_frame_init_saved_regs (FI)
 446
 447 /* Things needed for making the inferior call functions.  */
 448
 449 /* Push an empty stack frame, to record the current PC, etc.  */
 450 /* Change these names into rs6k_{push, pop}_frame(). FIXMEmgo. */
 451
 452 #define PUSH_DUMMY_FRAME        push_dummy_frame ()
 453 extern void push_dummy_frame PARAMS ((void));
 454
 455 /* Discard from the stack the innermost frame,
 456    restoring all saved registers.  */
 457
 458 #define POP_FRAME       pop_frame ()
 459 extern void pop_frame PARAMS ((void));
 460
 461 /* This sequence of words is the instructions:
 462
 463         mflr    r0              // 0x7c0802a6
 464                                 // save fpr's
 465         stfd    r?, num(r1)     // 0xd8010000 there should be 32 of this??
 466                                 // save gpr's
 467         stm     r0, num(r1)     // 0xbc010000
 468         stu     r1, num(r1)     // 0x94210000
 469
 470         // the function we want to branch might be in a different load
 471         // segment. reset the toc register. Note that the actual toc address
 472         // will be fix by fix_call_dummy () along with function address.
 473
 474         st      r2, 0x14(r1)    // 0x90410014 save toc register
 475         liu     r2, 0x1234      // 0x3c401234 reset a new toc value 0x12345678
 476         oril    r2, r2,0x5678   // 0x60425678
 477
 478                                 // load absolute address 0x12345678 to r0
 479         liu     r0, 0x1234      // 0x3c001234
 480         oril    r0, r0,0x5678   // 0x60005678
 481         mtctr   r0              // 0x7c0903a6 ctr <- r0
 482         bctrl                   // 0x4e800421 jump subroutine 0x12345678 (%ctr)
 483         cror    0xf, 0xf, 0xf   // 0x4def7b82
 484         brpt                    // 0x7d821008, breakpoint
 485         cror    0xf, 0xf, 0xf   // 0x4def7b82 (for 8 byte alignment)
 486
 487
 488   We actually start executing by saving the toc register first, since the pushing
 489   of the registers is done by PUSH_DUMMY_FRAME.  If this were real code,
 490   the arguments for the function called by the `bctrl' would be pushed
 491   between the `stu' and the `bctrl', and we could allow it to execute through.
 492   But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
 493   and we cannot allow to push the registers again.
 494 */
 495
 496 #define CALL_DUMMY {0x7c0802a6, 0xd8010000, 0xbc010000, 0x94210000, \
 497                     0x90410014, 0x3c401234, 0x60425678,             \
 498                     0x3c001234, 0x60005678, 0x7c0903a6, 0x4e800421, \
 499                     0x4def7b82, 0x7d821008, 0x4def7b82 }
 500
 501
 502 /* keep this as multiple of 8 (%sp requires 8 byte alignment) */
 503 #define CALL_DUMMY_LENGTH 56
 504
 505 #define CALL_DUMMY_START_OFFSET 16
 506
 507 /* Insert the specified number of args and function address into a
 508    call sequence of the above form stored at DUMMYNAME.  */
 509
 510 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
 511   rs6000_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p)
 512 extern void rs6000_fix_call_dummy PARAMS ((char *, CORE_ADDR, CORE_ADDR,
 513                                            int, struct value **,
 514                                            struct type *, int));
 515
 516 /* Hook in rs6000-tdep.c for determining the TOC address when
 517    calling functions in the inferior.  */
 518 extern CORE_ADDR (*find_toc_address_hook) PARAMS ((CORE_ADDR));
 519
 520 /* xcoffread.c provides a function to determine the TOC offset
 521    for a given object file.
 522    It is used under native AIX configurations for determining the
 523    TOC address when calling functions in the inferior.  */
 524 #ifdef __STDC__
 525 struct objfile;
 526 #endif
 527 extern CORE_ADDR get_toc_offset PARAMS ((struct objfile *));
 528
 529 /* Usually a function pointer's representation is simply the address
 530    of the function. On the RS/6000 however, a function pointer is
 531    represented by a pointer to a TOC entry. This TOC entry contains
 532    three words, the first word is the address of the function, the
 533    second word is the TOC pointer (r2), and the third word is the
 534    static chain value.  Throughout GDB it is currently assumed that a
 535    function pointer contains the address of the function, which is not
 536    easy to fix.  In addition, the conversion of a function address to
 537    a function pointer would require allocation of a TOC entry in the
 538    inferior's memory space, with all its drawbacks.  To be able to
 539    call C++ virtual methods in the inferior (which are called via
 540    function pointers), find_function_addr uses this macro to get the
 541    function address from a function pointer.  */
 542
 543 #define CONVERT_FROM_FUNC_PTR_ADDR(ADDR) \
 544   (is_magic_function_pointer (ADDR) ? read_memory_integer (ADDR, 4) : (ADDR))
 545 extern int is_magic_function_pointer PARAMS ((CORE_ADDR));
 546
 547 /* Flag for machine-specific stuff in shared files.  FIXME */
 548 #define IBM6000_TARGET
 549
 550 /* RS6000/AIX does not support PT_STEP.  Has to be simulated.  */
 551
 552 #define SOFTWARE_SINGLE_STEP_P 1
 553 extern void rs6000_software_single_step PARAMS ((unsigned int, int));
 554 #define SOFTWARE_SINGLE_STEP(sig,bp_p) rs6000_software_single_step (sig, bp_p)
 555
 556 /* If the current gcc for for this target does not produce correct debugging
 557    information for float parameters, both prototyped and unprototyped, then
 558    define this macro.  This forces gdb to  always assume that floats are
 559    passed as doubles and then converted in the callee.
 560
 561    For the PowerPC, it appears that the debug info marks the parameters as
 562    floats regardless of whether the function is prototyped, but the actual
 563    values are always passed in as doubles.  Thus by setting this to 1, both
 564    types of calls will work. */
 565
 566 #define COERCE_FLOAT_TO_DOUBLE 1