gdb/tm-rs6000.h

   1 /* Parameters for target execution on an RS6000, for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Contributed by IBM Corporation.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 extern int      symtab_relocated;
  22
  23 /* Minimum possible text address in AIX */
  24
  25 #define TEXT_SEGMENT_BASE       0x10000000
  26
  27
  28 /* text addresses in a core file does not necessarily match to symbol table,
  29    if symbol table relocation wasn't done yet. */
  30
  31 #define CORE_NEEDS_RELOCATION(PC)       \
  32   if (!symtab_relocated && !inferior_pid)       \
  33     xcoff_relocate_core ();
  34 extern void xcoff_relocate_core PARAMS ((void));
  35
  36 /* Load segment of a given pc value. */
  37
  38 #define PC_LOAD_SEGMENT(PC)     pc_load_segment_name(PC)
  39
  40 /* AIX cc seems to get this right.  */
  41
  42 #define BELIEVE_PCC_PROMOTION 1
  43
  44 /* return true if a given `pc' value is in `call dummy' function. */
  45
  46 #define PC_IN_CALL_DUMMY(STOP_PC, STOP_SP, STOP_FRAME_ADDR)     \
  47         (STOP_SP < STOP_PC && STOP_PC < STACK_END_ADDR)
  48
  49 /* For each symtab, we keep track of which BFD it came from.  */
  50 #define EXTRA_SYMTAB_INFO       \
  51         unsigned    nonreloc:1;         /* TRUE if non relocatable */
  52
  53 #define INIT_EXTRA_SYMTAB_INFO(symtab)  \
  54         symtab->nonreloc = 0;           \
  55
  56 extern unsigned int text_start, data_start;
  57 extern int inferior_pid;
  58 extern char *corefile;
  59
  60 /* setpgrp() messes up controling terminal. The other version of it
  61    requires libbsd.a. */
  62 #define setpgrp(XX,YY)          setpgid (XX, YY)
  63
  64 /* We are missing register descriptions in the system header files. Sigh! */
  65
  66 struct regs {
  67         int     gregs [32];             /* general purpose registers */
  68         int     pc;                     /* program conter       */
  69         int     ps;                     /* processor status, or machine state */
  70 };
  71
  72 struct fp_status {
  73         double  fpregs [32];            /* floating GP registers */
  74 };
  75
  76
  77 /* To be used by function_frame_info. */
  78
  79 struct aix_framedata {
  80   int   offset;                         /* # of bytes in gpr's and fpr's are saved */
  81   int   saved_gpr;                      /* smallest # of saved gpr */
  82   int   saved_fpr;                      /* smallest # of saved fpr */
  83   int   alloca_reg;                     /* alloca register number (frame ptr) */
  84   char  frameless;                      /* true if frameless functions. */
  85   char  nosavedpc;                      /* true if pc not saved. */
  86 };
  87
  88 void
  89 function_frame_info PARAMS ((CORE_ADDR, struct aix_framedata *));
  90
  91 /* Define the byte order of the machine.  */
  92
  93 #define TARGET_BYTE_ORDER       BIG_ENDIAN
  94
  95 /* AIX's assembler doesn't grok dollar signs in identifiers.
  96    So we use dots instead.  This item must be coordinated with G++. */
  97 #undef CPLUS_MARKER
  98 #define CPLUS_MARKER '.'
  99
 100 /* Offset from address of function to start of its code.
 101    Zero on most machines.  */
 102
 103 #define FUNCTION_START_OFFSET 0
 104
 105 /* Advance PC across any function entry prologue instructions
 106    to reach some "real" code.  */
 107
 108 #define SKIP_PROLOGUE(pc)       pc = skip_prologue (pc)
 109
 110 /* If PC is in some function-call trampoline code, return the PC
 111    where the function itself actually starts.  If not, return NULL.  */
 112
 113 #define SKIP_TRAMPOLINE_CODE(pc)        skip_trampoline_code (pc)
 114
 115 /* When a child process is just starting, we sneak in and relocate
 116    the symbol table (and other stuff) after the dynamic linker has
 117    figured out where they go. But we want to do this relocation just
 118    once. */
 119
 120 extern int loadinfotextindex;
 121
 122 #define SOLIB_CREATE_INFERIOR_HOOK(PID) \
 123   do {                                  \
 124     if (loadinfotextindex == 0) \
 125         xcoff_relocate_symtab (PID);    \
 126   } while (0)
 127
 128
 129 /* Number of trap signals we need to skip over, once the inferior process
 130    starts running. */
 131
 132 #define START_INFERIOR_TRAPS_EXPECTED   2
 133
 134 /* AIX might return a sigtrap, with a "stop after load" status. It should
 135    be ignored by gdb, shouldn't be mixed up with breakpoint traps. */
 136
 137 /* Another little glitch  in AIX is signal 0. I have no idea why wait(2)
 138    returns with this status word. It looks harmless. */
 139
 140 #define SIGTRAP_STOP_AFTER_LOAD(W)      \
 141  if ( (W) == 0x57c || (W) == 0x7f) {    \
 142    if ((W)==0x57c && breakpoints_inserted) {    \
 143      mark_breakpoints_out ();           \
 144      insert_breakpoints ();             \
 145      insert_step_breakpoint ();         \
 146    }                                    \
 147    resume (0, 0);                       \
 148    continue;                            \
 149  }
 150
 151 /* In xcoff, we cannot process line numbers when we see them. This is
 152    mainly because we don't know the boundaries of the include files. So,
 153    we postpone that, and then enter and sort(?) the whole line table at
 154    once, when we are closing the current symbol table in end_symtab(). */
 155
 156 #define PROCESS_LINENUMBER_HOOK()       aix_process_linenos ()
 157
 158
 159 /* When a target process or core-file has been attached, we sneak in
 160    and figure out where the shared libraries have got to. In case there
 161    is no inferior_process exists (e.g. bringing up a core file), we can't
 162    attemtp to relocate symbol table, since we don't have information about
 163    load segments. */
 164
 165 #define SOLIB_ADD(a, b, c)      \
 166    if (inferior_pid)    xcoff_relocate_symtab (inferior_pid)
 167
 168 /* Immediately after a function call, return the saved pc.
 169    Can't go through the frames for this because on some machines
 170    the new frame is not set up until the new function executes
 171    some instructions.  */
 172
 173 #define SAVED_PC_AFTER_CALL(frame) read_register (LR_REGNUM)
 174
 175 /* Address of end of stack space.  */
 176
 177 #define STACK_END_ADDR 0x2ff80000
 178
 179 /* Stack grows downward.  */
 180
 181 #define INNER_THAN <
 182
 183 #if 0
 184 /* No, we shouldn't use this. push_arguments() should leave stack in a
 185    proper alignment! */
 186 /* Stack has strict alignment. */
 187
 188 #define STACK_ALIGN(ADDR)       (((ADDR)+7)&-8)
 189 #endif
 190
 191 /* This is how argumets pushed onto stack or passed in registers. */
 192
 193 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
 194   sp = push_arguments(nargs, args, sp, struct_return, struct_addr)
 195
 196 /* Sequence of bytes for breakpoint instruction.  */
 197
 198 #define BREAKPOINT {0x7d, 0x82, 0x10, 0x08}
 199
 200 /* Amount PC must be decremented by after a breakpoint.
 201    This is often the number of bytes in BREAKPOINT
 202    but not always.  */
 203
 204 #define DECR_PC_AFTER_BREAK 0
 205
 206 /* Nonzero if instruction at PC is a return instruction.  */
 207 /* Allow any of the return instructions, including a trapv and a return
 208    from interrupt.  */
 209
 210 #define ABOUT_TO_RETURN(pc)  \
 211    ((read_memory_integer (pc, 4) & 0xfe8007ff) == 0x4e800020)
 212
 213 /* Return 1 if P points to an invalid floating point value.  */
 214
 215 #define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
 216
 217 /* Largest integer type */
 218
 219 #define LONGEST long
 220
 221 /* Name of the builtin type for the LONGEST type above. */
 222
 223 #define BUILTIN_TYPE_LONGEST builtin_type_long
 224
 225 /* Say how long (ordinary) registers are.  */
 226
 227 #define REGISTER_TYPE long
 228
 229 /* Number of machine registers */
 230
 231 #define NUM_REGS 71
 232
 233 /* Initializer for an array of names of registers.
 234    There should be NUM_REGS strings in this initializer.  */
 235
 236 #define REGISTER_NAMES  \
 237  {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",  \
 238   "r8", "r9", "r10","r11","r12","r13","r14","r15", \
 239   "r16","r17","r18","r19","r20","r21","r22","r23", \
 240   "r24","r25","r26","r27","r28","r29","r30","r31", \
 241   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",  \
 242   "f8", "f9", "f10","f11","f12","f13","f14","f15", \
 243   "f16","f17","f18","f19","f20","f21","f22","f23", \
 244   "f24","f25","f26","f27","f28","f29","f30","f31", \
 245   "pc", "ps", "cnd", "lr", "cnt", "xer", "mq" }
 246
 247 /* Register numbers of various important registers.
 248    Note that some of these values are "real" register numbers,
 249    and correspond to the general registers of the machine,
 250    and some are "phony" register numbers which are too large
 251    to be actual register numbers as far as the user is concerned
 252    but do serve to get the desired values when passed to read_register.  */
 253
 254 #define FP_REGNUM 1             /* Contains address of executing stack frame */
 255 #define SP_REGNUM 1             /* Contains address of top of stack */
 256 #define TOC_REGNUM 2            /* TOC register */
 257 #define FP0_REGNUM 32           /* Floating point register 0 */
 258 #define GP0_REGNUM 0            /* GPR register 0 */
 259 #define FP0_REGNUM 32           /* FPR (Floating point) register 0 */
 260 #define FPLAST_REGNUM 63        /* Last floating point register */
 261
 262 /* Special purpose registers... */
 263 /* P.S. keep these in the same order as in /usr/mstsave.h `mstsave' structure, for
 264    easier processing */
 265
 266 #define PC_REGNUM 64            /* Program counter (instruction address %iar) */
 267 #define PS_REGNUM 65            /* Processor (or machine) status (%msr) */
 268 #define CR_REGNUM 66            /* Condition register */
 269 #define LR_REGNUM 67            /* Link register */
 270 #define CTR_REGNUM 68           /* Count register */
 271 #define XER_REGNUM 69           /* Fixed point exception registers */
 272 #define MQ_REGNUM 70            /* Multiply/quotient register */
 273
 274 #define FIRST_SP_REGNUM 64      /* first special register number */
 275 #define LAST_SP_REGNUM  70      /* last special register number */
 276
 277 /* Total amount of space needed to store our copies of the machine's
 278    register state, the array `registers'.
 279
 280         32 4-byte gpr's
 281         32 8-byte fpr's
 282         7  4-byte special purpose registers,
 283
 284    total 416 bytes. Keep some extra space for now, in case to add more. */
 285
 286 #define REGISTER_BYTES 420
 287
 288
 289 /* Index within `registers' of the first byte of the space for
 290    register N.  */
 291
 292 #define REGISTER_BYTE(N)  \
 293  (                                                              \
 294   ((N) > FPLAST_REGNUM) ? ((((N) - FPLAST_REGNUM -1) * 4) + 384)\
 295   :((N) >= FP0_REGNUM) ? ((((N) - FP0_REGNUM) * 8) + 128)       \
 296   :((N) * 4) )
 297
 298 /* Number of bytes of storage in the actual machine representation
 299    for register N. */
 300 /* Note that the unsigned cast here forces the result of the
 301    subtractiion to very high positive values if N < FP0_REGNUM */
 302
 303 #define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
 304
 305 /* Number of bytes of storage in the program's representation
 306    for register N.  On the RS6000, all regs are 4 bytes
 307    except the floating point regs which are 8-byte doubles.  */
 308
 309 #define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
 310
 311 /* Largest value REGISTER_RAW_SIZE can have.  */
 312
 313 #define MAX_REGISTER_RAW_SIZE 8
 314
 315 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 316
 317 #define MAX_REGISTER_VIRTUAL_SIZE 8
 318
 319 /* convert a dbx stab register number (from `r' declaration) to a gdb REGNUM */
 320
 321 #define STAB_REG_TO_REGNUM(value)       (value)
 322
 323 /* Nonzero if register N requires conversion
 324    from raw format to virtual format.  */
 325
 326 #define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM && (N) <= FPLAST_REGNUM)
 327
 328 /* Convert data from raw format for register REGNUM
 329    to virtual format for register REGNUM.  */
 330
 331 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)     \
 332    bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM))
 333
 334 /* Convert data from virtual format for register REGNUM
 335    to raw format for register REGNUM.  */
 336
 337 #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
 338    bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM))
 339
 340 /* Return the GDB type object for the "standard" data type
 341    of data in register N.  */
 342
 343 #define REGISTER_VIRTUAL_TYPE(N) \
 344  (((unsigned)(N) - FP0_REGNUM) < 32 ? builtin_type_double : builtin_type_int)
 345
 346 /* Store the address of the place in which to copy the structure the
 347    subroutine will return.  This is called from call_function. */
 348 /* in RS6000, struct return addresses are passed as an extra parameter in r3.
 349    In function return, callee is not responsible of returning this address back.
 350    Since gdb needs to find it, we will store in a designated variable
 351    `rs6000_struct_return_address'. */
 352
 353 extern unsigned int rs6000_struct_return_address;
 354
 355 #define STORE_STRUCT_RETURN(ADDR, SP)   \
 356   { write_register (3, (ADDR));         \
 357     rs6000_struct_return_address = (unsigned int)(ADDR); }
 358
 359 /* Extract from an array REGBUF containing the (raw) register state
 360    a function return value of type TYPE, and copy that, in virtual format,
 361    into VALBUF.  */
 362
 363 /* #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 364   bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) */
 365
 366 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 367   extract_return_value(TYPE,REGBUF,VALBUF)
 368
 369 /* Write into appropriate registers a function return value
 370    of type TYPE, given in virtual format.  */
 371
 372 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 373   {                                                                     \
 374     if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                              \
 375                                                                         \
 376      /* Floating point values are returned starting from FPR1 and up.   \
 377         Say a double_double_double type could be returned in            \
 378         FPR1/FPR2/FPR3 triple. */                                       \
 379                                                                         \
 380       write_register_bytes (REGISTER_BYTE (FP0_REGNUM+1), (VALBUF),     \
 381                                                 TYPE_LENGTH (TYPE));    \
 382     else                                                                \
 383       /* Everything else is returned in GPR3 and up. */                 \
 384       write_register_bytes (REGISTER_BYTE (GP0_REGNUM+3), (VALBUF),     \
 385                                                 TYPE_LENGTH (TYPE));    \
 386   }
 387
 388
 389 /* Extract from an array REGBUF containing the (raw) register state
 390    the address in which a function should return its structure value,
 391    as a CORE_ADDR (or an expression that can be used as one).  */
 392
 393 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF)    rs6000_struct_return_address
 394 \f
 395 /* Describe the pointer in each stack frame to the previous stack frame
 396    (its caller).  */
 397
 398 /* FRAME_CHAIN takes a frame's nominal address
 399    and produces the frame's chain-pointer. */
 400
 401 /* In the case of the RS6000, the frame's nominal address
 402    is the address of a 4-byte word containing the calling frame's address.  */
 403
 404 #define FRAME_CHAIN(thisframe)  \
 405   (!inside_entry_file ((thisframe)->pc) ?       \
 406    read_memory_integer ((thisframe)->frame, 4) :\
 407    0)
 408
 409 /* Define other aspects of the stack frame.  */
 410
 411 /* A macro that tells us whether the function invocation represented
 412    by FI does not have a frame on the stack associated with it.  If it
 413    does not, FRAMELESS is set to 1, else 0.  */
 414
 415 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 416         FRAMELESS = frameless_function_invocation (FI, 0)
 417
 418 /* Functions calling alloca() change the value of the stack pointer. We
 419    need to use initial stack pointer (which is saved in r31 by gcc) in
 420    such cases. If a compiler emits traceback table, then we should use the
 421    alloca register specified in traceback table. FIXME. */
 422 /* Also, it is a good idea to cache information about frame's saved registers
 423    in the frame structure to speed things up. See tm-m88k.h. FIXME. */
 424
 425 #define EXTRA_FRAME_INFO        \
 426         CORE_ADDR initial_sp;                   /* initial stack pointer. */ \
 427         struct frame_saved_regs *cache_fsr;     /* saved registers        */
 428
 429 /* Frameless function invocation in IBM RS/6000 is sometimes
 430    half-done. It perfectly sets up a new frame, e.g. a new frame (in
 431    fact stack) pointer, etc, but it doesn't save the %pc.  We call
 432    frameless_function_invocation to tell us how to get the %pc.  */
 433
 434 #define INIT_EXTRA_FRAME_INFO(fromleaf, fi)     \
 435         fi->initial_sp = 0;             \
 436         fi->cache_fsr = 0;
 437
 438 #define FRAME_SAVED_PC(FRAME)                                   \
 439         (frameless_function_invocation (FRAME, 1)               \
 440          ? SAVED_PC_AFTER_CALL (FRAME)                          \
 441          : read_memory_integer (read_memory_integer ((FRAME)->frame, 4)+8, 4))
 442
 443 #define FRAME_ARGS_ADDRESS(FI)  \
 444   (((struct frame_info*)(FI))->initial_sp ?             \
 445         ((struct frame_info*)(FI))->initial_sp :        \
 446         frame_initial_stack_address (FI))
 447
 448 #define FRAME_LOCALS_ADDRESS(FI)        FRAME_ARGS_ADDRESS(FI)
 449
 450
 451 /* Set VAL to the number of args passed to frame described by FI.
 452    Can set VAL to -1, meaning no way to tell.  */
 453
 454 /* We can't tell how many args there are
 455    now that the C compiler delays popping them.  */
 456
 457 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 458
 459 /* Return number of bytes at start of arglist that are not really args.  */
 460
 461 #define FRAME_ARGS_SKIP 8       /* Not sure on this. FIXMEmgo */
 462
 463 /* Put here the code to store, into a struct frame_saved_regs,
 464    the addresses of the saved registers of frame described by FRAME_INFO.
 465    This includes special registers such as pc and fp saved in special
 466    ways in the stack frame.  sp is even more special:
 467    the address we return for it IS the sp for the next frame.  */
 468 /* In the following implementation for RS6000, we did *not* save sp. I am
 469    not sure if it will be needed. The following macro takes care of gpr's
 470    and fpr's only. */
 471
 472 #define FRAME_FIND_SAVED_REGS(FRAME_INFO, FRAME_SAVED_REGS)             \
 473 {                                                                       \
 474   int ii;                                                               \
 475   CORE_ADDR frame_addr, func_start;                                     \
 476   struct aix_framedata fdata;                                           \
 477                                                                         \
 478   /* find the start of the function and collect info about its frame. */\
 479                                                                         \
 480   func_start = get_pc_function_start ((FRAME_INFO)->pc) + FUNCTION_START_OFFSET; \
 481   function_frame_info (func_start, &fdata);                             \
 482   bzero (&(FRAME_SAVED_REGS), sizeof (FRAME_SAVED_REGS));               \
 483                                                                         \
 484   /* if there were any saved registers, figure out parent's stack pointer. */ \
 485   frame_addr = 0;                                                       \
 486   /* the following is true only if the frame doesn't have a call to alloca(), \
 487       FIXME. */                                                         \
 488   if (fdata.saved_fpr >= 0 || fdata.saved_gpr >= 0) {                   \
 489     if ((FRAME_INFO)->prev && (FRAME_INFO)->prev->frame)                \
 490       frame_addr = (FRAME_INFO)->prev->frame;                           \
 491     else                                                                \
 492       frame_addr = read_memory_integer ((FRAME_INFO)->frame, 4);        \
 493   }                                                                     \
 494                                                                         \
 495   /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr. All fpr's \
 496      from saved_fpr to fp31 are saved right underneath caller stack pointer, \
 497      starting from fp31 first. */                                       \
 498                                                                         \
 499   if (fdata.saved_fpr >= 0) {                                           \
 500     for (ii=31; ii >= fdata.saved_fpr; --ii)                            \
 501       (FRAME_SAVED_REGS).regs [FP0_REGNUM + ii] = frame_addr - ((32 - ii) * 8); \
 502     frame_addr -= (32 - fdata.saved_fpr) * 8;                           \
 503   }                                                                     \
 504                                                                         \
 505   /* if != -1, fdata.saved_gpr is the smallest number of saved_gpr. All gpr's \
 506      from saved_gpr to gpr31 are saved right under saved fprs, starting \
 507      from r31 first. */                                                 \
 508                                                                         \
 509   if (fdata.saved_gpr >= 0)                                             \
 510     for (ii=31; ii >= fdata.saved_gpr; --ii)                            \
 511       (FRAME_SAVED_REGS).regs [ii] = frame_addr - ((32 - ii) * 4);      \
 512 }
 513
 514 \f
 515 /* Things needed for making the inferior call functions.  */
 516
 517 /* Push an empty stack frame, to record the current PC, etc.  */
 518 /* Change these names into rs6k_{push, pop}_frame(). FIXMEmgo. */
 519
 520 #define PUSH_DUMMY_FRAME        push_dummy_frame ()
 521
 522 /* Discard from the stack the innermost frame,
 523    restoring all saved registers.  */
 524
 525 #define POP_FRAME       pop_frame ()
 526
 527 /* This sequence of words is the instructions:
 528
 529         mflr    r0              // 0x7c0802a6
 530                                 // save fpr's
 531         stfd    r?, num(r1)     // 0xd8010000 there should be 32 of this??
 532                                 // save gpr's
 533         stm     r0, num(r1)     // 0xbc010000
 534         stu     r1, num(r1)     // 0x94210000
 535
 536         // the function we want to branch might be in a different load
 537         // segment. reset the toc register. Note that the actual toc address
 538         // will be fix by fix_call_dummy () along with function address.
 539
 540         st      r2, 0x14(r1)    // 0x90410014 save toc register
 541         liu     r2, 0x1234      // 0x3c401234 reset a new toc value 0x12345678
 542         oril    r2, r2,0x5678   // 0x60425678
 543
 544                                 // load absolute address 0x12345678 to r0
 545         liu     r0, 0x1234      // 0x3c001234
 546         oril    r0, r0,0x5678   // 0x60005678
 547         mtctr   r0              // 0x7c0903a6 ctr <- r0
 548         bctrl                   // 0x4e800421 jump subroutine 0x12345678 (%ctr)
 549         cror    0xf, 0xf, 0xf   // 0x4def7b82
 550         brpt                    // 0x7d821008, breakpoint
 551         cror    0xf, 0xf, 0xf   // 0x4def7b82 (for 8 byte alignment)
 552
 553
 554   We actually start executing by saving the toc register first, since the pushing
 555   of the registers is done by PUSH_DUMMY_FRAME.  If this were real code,
 556   the arguments for the function called by the `bctrl' would be pushed
 557   between the `stu' and the `bctrl', and we could allow it to execute through.
 558   But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
 559   and we cannot allow to push the registers again.
 560 */
 561
 562 #define CALL_DUMMY {0x7c0802a6, 0xd8010000, 0xbc010000, 0x94210000, \
 563                     0x90410014, 0x3c401234, 0x60425678,             \
 564                     0x3c001234, 0x60005678, 0x7c0903a6, 0x4e800421, \
 565                     0x4def7b82, 0x7d821008, 0x4def7b82 }
 566
 567
 568 /* keep this as multiple of 8 (%sp requires 8 byte alignment) */
 569 #define CALL_DUMMY_LENGTH 56
 570
 571 #define CALL_DUMMY_START_OFFSET 16
 572
 573 /* Insert the specified number of args and function address
 574    into a call sequence of the above form stored at DUMMYNAME.  */
 575
 576 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, using_gcc) \
 577         fix_call_dummy(dummyname, pc, fun, nargs, type)
 578
 579 /* Flag for machine-specific stuff in shared files.  FIXME */
 580 #define IBM6000_TARGET
 581
 582 /* RS6000/AIX does not support PT_STEP.  Has to be simulated.  */
 583
 584 #define NO_SINGLE_STEP