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