gdb/rs6000-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996
   3    Free Software Foundation, Inc.
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24 #include "symtab.h"
  25 #include "target.h"
  26 #include "gdbcore.h"
  27 #include "symfile.h"
  28 #include "objfiles.h"
  29 #include "xcoffsolib.h"
  30
  31 extern struct obstack frame_cache_obstack;
  32
  33 extern int errno;
  34
  35 /* Nonzero if we just simulated a single step break. */
  36 int one_stepped;
  37
  38 /* Breakpoint shadows for the single step instructions will be kept here. */
  39
  40 static struct sstep_breaks {
  41   /* Address, or 0 if this is not in use.  */
  42   CORE_ADDR address;
  43   /* Shadow contents.  */
  44   char data[4];
  45 } stepBreaks[2];
  46
  47 /* Static function prototypes */
  48
  49 static CORE_ADDR find_toc_address PARAMS ((CORE_ADDR pc));
  50
  51 static CORE_ADDR branch_dest PARAMS ((int opcode, int instr, CORE_ADDR pc,
  52                                       CORE_ADDR safety));
  53
  54 static void frame_get_cache_fsr PARAMS ((struct frame_info *fi,
  55                                          struct rs6000_framedata *fdatap));
  56
  57 static void pop_dummy_frame PARAMS ((void));
  58
  59 /* Calculate the destination of a branch/jump.  Return -1 if not a branch.  */
  60
  61 static CORE_ADDR
  62 branch_dest (opcode, instr, pc, safety)
  63      int opcode;
  64      int instr;
  65      CORE_ADDR pc;
  66      CORE_ADDR safety;
  67 {
  68   CORE_ADDR dest;
  69   int immediate;
  70   int absolute;
  71   int ext_op;
  72
  73   absolute = (int) ((instr >> 1) & 1);
  74
  75   switch (opcode) {
  76      case 18    :
  77         immediate = ((instr & ~3) << 6) >> 6;   /* br unconditional */
  78         if (absolute)
  79           dest = immediate;
  80         else
  81           dest = pc + immediate;
  82         break;
  83
  84      case 16    :
  85         immediate = ((instr & ~3) << 16) >> 16; /* br conditional */
  86         if (absolute)
  87           dest = immediate;
  88         else
  89           dest = pc + immediate;
  90         break;
  91
  92       case 19   :
  93         ext_op = (instr>>1) & 0x3ff;
  94
  95         if (ext_op == 16)                       /* br conditional register */
  96           dest = read_register (LR_REGNUM) & ~3;
  97
  98         else if (ext_op == 528)                 /* br cond to count reg */
  99           {
 100             dest = read_register (CTR_REGNUM) & ~3;
 101
 102             /* If we are about to execute a system call, dest is something
 103                like 0x22fc or 0x3b00.  Upon completion the system call
 104                will return to the address in the link register.  */
 105             if (dest < TEXT_SEGMENT_BASE)
 106               dest = read_register (LR_REGNUM) & ~3;
 107           }
 108         else return -1;
 109         break;
 110
 111        default: return -1;
 112   }
 113   return (dest < TEXT_SEGMENT_BASE) ? safety : dest;
 114 }
 115
 116
 117
 118 /* AIX does not support PT_STEP. Simulate it. */
 119
 120 void
 121 single_step (signal)
 122      enum target_signal signal;
 123 {
 124 #define INSNLEN(OPCODE)  4
 125
 126   static char le_breakp[] = LITTLE_BREAKPOINT;
 127   static char be_breakp[] = BIG_BREAKPOINT;
 128   char *breakp = TARGET_BYTE_ORDER == BIG_ENDIAN ? be_breakp : le_breakp;
 129   int ii, insn;
 130   CORE_ADDR loc;
 131   CORE_ADDR breaks[2];
 132   int opcode;
 133
 134   if (!one_stepped) {
 135     loc = read_pc ();
 136
 137     insn = read_memory_integer (loc, 4);
 138
 139     breaks[0] = loc + INSNLEN(insn);
 140     opcode = insn >> 26;
 141     breaks[1] = branch_dest (opcode, insn, loc, breaks[0]);
 142
 143     /* Don't put two breakpoints on the same address. */
 144     if (breaks[1] == breaks[0])
 145       breaks[1] = -1;
 146
 147     stepBreaks[1].address = 0;
 148
 149     for (ii=0; ii < 2; ++ii) {
 150
 151       /* ignore invalid breakpoint. */
 152       if ( breaks[ii] == -1)
 153         continue;
 154
 155       read_memory (breaks[ii], stepBreaks[ii].data, 4);
 156
 157       write_memory (breaks[ii], breakp, 4);
 158       stepBreaks[ii].address = breaks[ii];
 159     }
 160
 161     one_stepped = 1;
 162   } else {
 163
 164     /* remove step breakpoints. */
 165     for (ii=0; ii < 2; ++ii)
 166       if (stepBreaks[ii].address != 0)
 167         write_memory
 168            (stepBreaks[ii].address, stepBreaks[ii].data, 4);
 169
 170     one_stepped = 0;
 171   }
 172   errno = 0;                    /* FIXME, don't ignore errors! */
 173                         /* What errors?  {read,write}_memory call error().  */
 174 }
 175
 176
 177 /* return pc value after skipping a function prologue and also return
 178    information about a function frame.
 179
 180    in struct rs6000_frameinfo fdata:
 181     - frameless is TRUE, if function does not have a frame.
 182     - nosavedpc is TRUE, if function does not save %pc value in its frame.
 183     - offset is the number of bytes used in the frame to save registers.
 184     - saved_gpr is the number of the first saved gpr.
 185     - saved_fpr is the number of the first saved fpr.
 186     - alloca_reg is the number of the register used for alloca() handling.
 187       Otherwise -1.
 188     - gpr_offset is the offset of the saved gprs
 189     - fpr_offset is the offset of the saved fprs
 190     - lr_offset is the offset of the saved lr
 191     - cr_offset is the offset of the saved cr
 192  */
 193
 194 #define SIGNED_SHORT(x)                                                 \
 195   ((sizeof (short) == 2)                                                \
 196    ? ((int)(short)(x))                                                  \
 197    : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
 198
 199 #define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
 200
 201 CORE_ADDR
 202 skip_prologue (pc, fdata)
 203      CORE_ADDR pc;
 204      struct rs6000_framedata *fdata;
 205 {
 206   CORE_ADDR orig_pc = pc;
 207   char buf[4];
 208   unsigned long op;
 209   long offset = 0;
 210   int lr_reg = 0;
 211   int cr_reg = 0;
 212   int reg;
 213   int framep = 0;
 214   int minimal_toc_loaded = 0;
 215   static struct rs6000_framedata zero_frame;
 216
 217   *fdata = zero_frame;
 218   fdata->saved_gpr = -1;
 219   fdata->saved_fpr = -1;
 220   fdata->alloca_reg = -1;
 221   fdata->frameless = 1;
 222   fdata->nosavedpc = 1;
 223
 224   if (target_read_memory (pc, buf, 4))
 225     return pc;                  /* Can't access it -- assume no prologue. */
 226
 227   /* Assume that subsequent fetches can fail with low probability.  */
 228   pc -= 4;
 229   for (;;)
 230     {
 231       pc += 4;
 232       op = read_memory_integer (pc, 4);
 233
 234       if ((op & 0xfc1fffff) == 0x7c0802a6) {            /* mflr Rx */
 235         lr_reg = (op & 0x03e00000) | 0x90010000;
 236         continue;
 237
 238       } else if ((op & 0xfc1fffff) == 0x7c000026) {     /* mfcr Rx */
 239         cr_reg = (op & 0x03e00000) | 0x90010000;
 240         continue;
 241
 242       } else if ((op & 0xfc1f0000) == 0xd8010000) {     /* stfd Rx,NUM(r1) */
 243         reg = GET_SRC_REG (op);
 244         if (fdata->saved_fpr == -1 || fdata->saved_fpr > reg) {
 245           fdata->saved_fpr = reg;
 246           fdata->fpr_offset = SIGNED_SHORT (op) + offset;
 247         }
 248         continue;
 249
 250       } else if (((op & 0xfc1f0000) == 0xbc010000) ||   /* stm Rx, NUM(r1) */
 251                  ((op & 0xfc1f0000) == 0x90010000 &&    /* st rx,NUM(r1), rx >= r13 */
 252                   (op & 0x03e00000) >= 0x01a00000)) {
 253
 254         reg = GET_SRC_REG (op);
 255         if (fdata->saved_gpr == -1 || fdata->saved_gpr > reg) {
 256           fdata->saved_gpr = reg;
 257           fdata->gpr_offset = SIGNED_SHORT (op) + offset;
 258         }
 259         continue;
 260
 261       } else if ((op & 0xffff0000) == 0x3c000000) {     /* addis 0,0,NUM, used for >= 32k frames */
 262         fdata->offset = (op & 0x0000ffff) << 16;
 263         fdata->frameless = 0;
 264         continue;
 265
 266       } else if ((op & 0xffff0000) == 0x60000000) {     /* ori 0,0,NUM, 2nd half of >= 32k frames */
 267         fdata->offset |= (op & 0x0000ffff);
 268         fdata->frameless = 0;
 269         continue;
 270
 271       } else if ((op & 0xffff0000) == lr_reg) {         /* st Rx,NUM(r1) where Rx == lr */
 272         fdata->lr_offset = SIGNED_SHORT (op) + offset;
 273         fdata->nosavedpc = 0;
 274         lr_reg = 0;
 275         continue;
 276
 277       } else if ((op & 0xffff0000) == cr_reg) {         /* st Rx,NUM(r1) where Rx == cr */
 278         fdata->cr_offset = SIGNED_SHORT (op) + offset;
 279         cr_reg = 0;
 280         continue;
 281
 282       } else if (op == 0x48000005) {                    /* bl .+4 used in -mrelocatable */
 283         continue;
 284
 285       } else if (op == 0x48000004) {                    /* b .+4 (xlc) */
 286         break;
 287
 288       } else if (((op & 0xffff0000) == 0x801e0000 ||    /* lwz 0,NUM(r30), used in V.4 -mrelocatable */
 289                   op == 0x7fc0f214) &&                  /* add r30,r0,r30, used in V.4 -mrelocatable */
 290                  lr_reg == 0x901e0000) {
 291         continue;
 292
 293       } else if ((op & 0xffff0000) == 0x3fc00000 ||     /* addis 30,0,foo@ha, used in V.4 -mminimal-toc */
 294                  (op & 0xffff0000) == 0x3bde0000) {     /* addi 30,30,foo@l */
 295         continue;
 296
 297       } else if ((op & 0xfc000000) == 0x48000000) {     /* bl foo, to save fprs??? */
 298
 299         fdata->frameless = 0;
 300         /* Don't skip over the subroutine call if it is not within the first
 301            three instructions of the prologue.  */
 302         if ((pc - orig_pc) > 8)
 303           break;
 304
 305         op = read_memory_integer (pc+4, 4);
 306
 307         /* At this point, make sure this is not a trampoline function
 308            (a function that simply calls another functions, and nothing else).
 309            If the next is not a nop, this branch was part of the function
 310            prologue. */
 311
 312         if (op == 0x4def7b82 || op == 0)                /* crorc 15, 15, 15 */
 313           break;                                        /* don't skip over this branch */
 314
 315         continue;
 316
 317       /* update stack pointer */
 318       } else if ((op & 0xffff0000) == 0x94210000) {     /* stu r1,NUM(r1) */
 319         fdata->frameless = 0;
 320         fdata->offset = SIGNED_SHORT (op);
 321         offset = fdata->offset;
 322         continue;
 323
 324       } else if (op == 0x7c21016e) {                    /* stwux 1,1,0 */
 325         fdata->frameless = 0;
 326         offset = fdata->offset;
 327         continue;
 328
 329       /* Load up minimal toc pointer */
 330       } else if ((op >> 22) == 0x20f
 331                  && ! minimal_toc_loaded) {     /* l r31,... or l r30,... */
 332         minimal_toc_loaded = 1;
 333         continue;
 334
 335       /* store parameters in stack */
 336       } else if ((op & 0xfc1f0000) == 0x90010000 ||     /* st rx,NUM(r1) */
 337                  (op & 0xfc1f0000) == 0xd8010000 ||     /* stfd Rx,NUM(r1) */
 338                  (op & 0xfc1f0000) == 0xfc010000) {     /* frsp, fp?,NUM(r1) */
 339         continue;
 340
 341       /* store parameters in stack via frame pointer */
 342       } else if (framep &&
 343                  ((op & 0xfc1f0000) == 0x901f0000 ||    /* st rx,NUM(r1) */
 344                  (op & 0xfc1f0000) == 0xd81f0000 ||     /* stfd Rx,NUM(r1) */
 345                  (op & 0xfc1f0000) == 0xfc1f0000)) {    /* frsp, fp?,NUM(r1) */
 346         continue;
 347
 348       /* Set up frame pointer */
 349       } else if (op == 0x603f0000                       /* oril r31, r1, 0x0 */
 350                  || op == 0x7c3f0b78) {                 /* mr r31, r1 */
 351         fdata->frameless = 0;
 352         framep = 1;
 353         fdata->alloca_reg = 31;
 354         continue;
 355
 356       /* Another way to set up the frame pointer.  */
 357       } else if ((op & 0xfc1fffff) == 0x38010000) {     /* addi rX, r1, 0x0 */
 358         fdata->frameless = 0;
 359         framep = 1;
 360         fdata->alloca_reg = (op & ~0x38010000) >> 21;
 361         continue;
 362
 363       } else {
 364         break;
 365       }
 366     }
 367
 368 #if 0
 369 /* I have problems with skipping over __main() that I need to address
 370  * sometime. Previously, I used to use misc_function_vector which
 371  * didn't work as well as I wanted to be.  -MGO */
 372
 373   /* If the first thing after skipping a prolog is a branch to a function,
 374      this might be a call to an initializer in main(), introduced by gcc2.
 375      We'd like to skip over it as well. Fortunately, xlc does some extra
 376      work before calling a function right after a prologue, thus we can
 377      single out such gcc2 behaviour. */
 378
 379
 380   if ((op & 0xfc000001) == 0x48000001) { /* bl foo, an initializer function? */
 381     op = read_memory_integer (pc+4, 4);
 382
 383     if (op == 0x4def7b82) {             /* cror 0xf, 0xf, 0xf (nop) */
 384
 385       /* check and see if we are in main. If so, skip over this initializer
 386          function as well. */
 387
 388       tmp = find_pc_misc_function (pc);
 389       if (tmp >= 0 && STREQ (misc_function_vector [tmp].name, "main"))
 390         return pc + 8;
 391     }
 392   }
 393 #endif /* 0 */
 394
 395   fdata->offset = - fdata->offset;
 396   return pc;
 397 }
 398
 399
 400 /*************************************************************************
 401   Support for creating pushind a dummy frame into the stack, and popping
 402   frames, etc.
 403 *************************************************************************/
 404
 405 /* The total size of dummy frame is 436, which is;
 406
 407         32 gpr's        - 128 bytes
 408         32 fpr's        - 256   "
 409         7  the rest     - 28    "
 410         and 24 extra bytes for the callee's link area. The last 24 bytes
 411         for the link area might not be necessary, since it will be taken
 412         care of by push_arguments(). */
 413
 414 #define DUMMY_FRAME_SIZE 436
 415
 416 #define DUMMY_FRAME_ADDR_SIZE 10
 417
 418 /* Make sure you initialize these in somewhere, in case gdb gives up what it
 419    was debugging and starts debugging something else. FIXMEibm */
 420
 421 static int dummy_frame_count = 0;
 422 static int dummy_frame_size = 0;
 423 static CORE_ADDR *dummy_frame_addr = 0;
 424
 425 extern int stop_stack_dummy;
 426
 427 /* push a dummy frame into stack, save all register. Currently we are saving
 428    only gpr's and fpr's, which is not good enough! FIXMEmgo */
 429
 430 void
 431 push_dummy_frame ()
 432 {
 433   /* stack pointer.  */
 434   CORE_ADDR sp;
 435   /* Same thing, target byte order.  */
 436   char sp_targ[4];
 437
 438   /* link register.  */
 439   CORE_ADDR pc;
 440   /* Same thing, target byte order.  */
 441   char pc_targ[4];
 442
 443   /* Needed to figure out where to save the dummy link area.
 444      FIXME: There should be an easier way to do this, no?  tiemann 9/9/95.  */
 445   struct rs6000_framedata fdata;
 446
 447   int ii;
 448
 449   target_fetch_registers (-1);
 450
 451   if (dummy_frame_count >= dummy_frame_size) {
 452     dummy_frame_size += DUMMY_FRAME_ADDR_SIZE;
 453     if (dummy_frame_addr)
 454       dummy_frame_addr = (CORE_ADDR*) xrealloc
 455         (dummy_frame_addr, sizeof(CORE_ADDR) * (dummy_frame_size));
 456     else
 457       dummy_frame_addr = (CORE_ADDR*)
 458         xmalloc (sizeof(CORE_ADDR) * (dummy_frame_size));
 459   }
 460
 461   sp = read_register(SP_REGNUM);
 462   pc = read_register(PC_REGNUM);
 463   store_address (pc_targ, 4, pc);
 464
 465   (void) skip_prologue (get_pc_function_start (pc) + FUNCTION_START_OFFSET, &fdata);
 466
 467   dummy_frame_addr [dummy_frame_count++] = sp;
 468
 469   /* Be careful! If the stack pointer is not decremented first, then kernel
 470      thinks he is free to use the space underneath it. And kernel actually
 471      uses that area for IPC purposes when executing ptrace(2) calls. So
 472      before writing register values into the new frame, decrement and update
 473      %sp first in order to secure your frame. */
 474
 475   /* FIXME: We don't check if the stack really has this much space.
 476      This is a problem on the ppc simulator (which only grants one page
 477      (4096 bytes) by default.  */
 478
 479   write_register (SP_REGNUM, sp-DUMMY_FRAME_SIZE);
 480
 481   /* gdb relies on the state of current_frame. We'd better update it,
 482      otherwise things like do_registers_info() wouldn't work properly! */
 483
 484   flush_cached_frames ();
 485
 486   /* save program counter in link register's space. */
 487   write_memory (sp + (fdata.lr_offset ? fdata.lr_offset : DEFAULT_LR_SAVE),
 488                 pc_targ, 4);
 489
 490   /* save all floating point and general purpose registers here. */
 491
 492   /* fpr's, f0..f31 */
 493   for (ii = 0; ii < 32; ++ii)
 494     write_memory (sp-8-(ii*8), &registers[REGISTER_BYTE (31-ii+FP0_REGNUM)], 8);
 495
 496   /* gpr's r0..r31 */
 497   for (ii=1; ii <=32; ++ii)
 498     write_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
 499
 500   /* so far, 32*2 + 32 words = 384 bytes have been written.
 501      7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
 502
 503   for (ii=1; ii <= (LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii) {
 504     write_memory (sp-384-(ii*4),
 505                &registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
 506   }
 507
 508   /* Save sp or so called back chain right here. */
 509   store_address (sp_targ, 4, sp);
 510   write_memory (sp-DUMMY_FRAME_SIZE, sp_targ, 4);
 511   sp -= DUMMY_FRAME_SIZE;
 512
 513   /* And finally, this is the back chain. */
 514   write_memory (sp+8, pc_targ, 4);
 515 }
 516
 517
 518 /* Pop a dummy frame.
 519
 520    In rs6000 when we push a dummy frame, we save all of the registers. This
 521    is usually done before user calls a function explicitly.
 522
 523    After a dummy frame is pushed, some instructions are copied into stack,
 524    and stack pointer is decremented even more.  Since we don't have a frame
 525    pointer to get back to the parent frame of the dummy, we start having
 526    trouble poping it.  Therefore, we keep a dummy frame stack, keeping
 527    addresses of dummy frames as such.  When poping happens and when we
 528    detect that was a dummy frame, we pop it back to its parent by using
 529    dummy frame stack (`dummy_frame_addr' array).
 530
 531 FIXME:  This whole concept is broken.  You should be able to detect
 532 a dummy stack frame *on the user's stack itself*.  When you do,
 533 then you know the format of that stack frame -- including its
 534 saved SP register!  There should *not* be a separate stack in the
 535 GDB process that keeps track of these dummy frames!  -- [email protected] Aug92
 536  */
 537
 538 static void
 539 pop_dummy_frame ()
 540 {
 541   CORE_ADDR sp, pc;
 542   int ii;
 543   sp = dummy_frame_addr [--dummy_frame_count];
 544
 545   /* restore all fpr's. */
 546   for (ii = 1; ii <= 32; ++ii)
 547     read_memory (sp-(ii*8), &registers[REGISTER_BYTE (32-ii+FP0_REGNUM)], 8);
 548
 549   /* restore all gpr's */
 550   for (ii=1; ii <= 32; ++ii) {
 551     read_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
 552   }
 553
 554   /* restore the rest of the registers. */
 555   for (ii=1; ii <=(LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii)
 556     read_memory (sp-384-(ii*4),
 557                 &registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
 558
 559   read_memory (sp-(DUMMY_FRAME_SIZE-8),
 560                &registers [REGISTER_BYTE(PC_REGNUM)], 4);
 561
 562   /* when a dummy frame was being pushed, we had to decrement %sp first, in
 563      order to secure astack space. Thus, saved %sp (or %r1) value, is not the
 564      one we should restore. Change it with the one we need. */
 565
 566   *(int*)&registers [REGISTER_BYTE(FP_REGNUM)] = sp;
 567
 568   /* Now we can restore all registers. */
 569
 570   target_store_registers (-1);
 571   pc = read_pc ();
 572   flush_cached_frames ();
 573 }
 574
 575
 576 /* pop the innermost frame, go back to the caller. */
 577
 578 void
 579 pop_frame ()
 580 {
 581   CORE_ADDR pc, lr, sp, prev_sp;                /* %pc, %lr, %sp */
 582   struct rs6000_framedata fdata;
 583   struct frame_info *frame = get_current_frame ();
 584   int addr, ii;
 585
 586   pc = read_pc ();
 587   sp = FRAME_FP (frame);
 588
 589   if (stop_stack_dummy && dummy_frame_count) {
 590     pop_dummy_frame ();
 591     return;
 592   }
 593
 594   /* Make sure that all registers are valid.  */
 595   read_register_bytes (0, NULL, REGISTER_BYTES);
 596
 597   /* figure out previous %pc value. If the function is frameless, it is
 598      still in the link register, otherwise walk the frames and retrieve the
 599      saved %pc value in the previous frame. */
 600
 601   addr = get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET;
 602   (void) skip_prologue (addr, &fdata);
 603
 604   if (fdata.frameless)
 605     prev_sp = sp;
 606   else
 607     prev_sp = read_memory_integer (sp, 4);
 608   if (fdata.lr_offset == 0)
 609     lr = read_register (LR_REGNUM);
 610   else
 611     lr = read_memory_integer (prev_sp + fdata.lr_offset, 4);
 612
 613   /* reset %pc value. */
 614   write_register (PC_REGNUM, lr);
 615
 616   /* reset register values if any was saved earlier. */
 617   addr = prev_sp - fdata.offset;
 618
 619   if (fdata.saved_gpr != -1)
 620     for (ii = fdata.saved_gpr; ii <= 31; ++ii) {
 621       read_memory (addr, &registers [REGISTER_BYTE (ii)], 4);
 622       addr += 4;
 623     }
 624
 625   if (fdata.saved_fpr != -1)
 626     for (ii = fdata.saved_fpr; ii <= 31; ++ii) {
 627       read_memory (addr, &registers [REGISTER_BYTE (ii+FP0_REGNUM)], 8);
 628       addr += 8;
 629   }
 630
 631   write_register (SP_REGNUM, prev_sp);
 632   target_store_registers (-1);
 633   flush_cached_frames ();
 634 }
 635
 636 /* fixup the call sequence of a dummy function, with the real function address.
 637    its argumets will be passed by gdb. */
 638
 639 void
 640 rs6000_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p)
 641      char *dummyname;
 642      CORE_ADDR pc;
 643      CORE_ADDR fun;
 644      int nargs;
 645      value_ptr *args;
 646      struct type *type;
 647      int gcc_p;
 648 {
 649 #define TOC_ADDR_OFFSET         20
 650 #define TARGET_ADDR_OFFSET      28
 651
 652   int ii;
 653   CORE_ADDR target_addr;
 654   CORE_ADDR tocvalue;
 655
 656   target_addr = fun;
 657   tocvalue = find_toc_address (target_addr);
 658
 659   ii  = *(int*)((char*)dummyname + TOC_ADDR_OFFSET);
 660   ii = (ii & 0xffff0000) | (tocvalue >> 16);
 661   *(int*)((char*)dummyname + TOC_ADDR_OFFSET) = ii;
 662
 663   ii  = *(int*)((char*)dummyname + TOC_ADDR_OFFSET+4);
 664   ii = (ii & 0xffff0000) | (tocvalue & 0x0000ffff);
 665   *(int*)((char*)dummyname + TOC_ADDR_OFFSET+4) = ii;
 666
 667   ii  = *(int*)((char*)dummyname + TARGET_ADDR_OFFSET);
 668   ii = (ii & 0xffff0000) | (target_addr >> 16);
 669   *(int*)((char*)dummyname + TARGET_ADDR_OFFSET) = ii;
 670
 671   ii  = *(int*)((char*)dummyname + TARGET_ADDR_OFFSET+4);
 672   ii = (ii & 0xffff0000) | (target_addr & 0x0000ffff);
 673   *(int*)((char*)dummyname + TARGET_ADDR_OFFSET+4) = ii;
 674 }
 675
 676 /* Pass the arguments in either registers, or in the stack. In RS6000,
 677    the first eight words of the argument list (that might be less than
 678    eight parameters if some parameters occupy more than one word) are
 679    passed in r3..r11 registers.  float and double parameters are
 680    passed in fpr's, in addition to that. Rest of the parameters if any
 681    are passed in user stack. There might be cases in which half of the
 682    parameter is copied into registers, the other half is pushed into
 683    stack.
 684
 685    If the function is returning a structure, then the return address is passed
 686    in r3, then the first 7 words of the parametes can be passed in registers,
 687    starting from r4. */
 688
 689 CORE_ADDR
 690 push_arguments (nargs, args, sp, struct_return, struct_addr)
 691      int nargs;
 692      value_ptr *args;
 693      CORE_ADDR sp;
 694      int struct_return;
 695      CORE_ADDR struct_addr;
 696 {
 697   int ii;
 698   int len = 0;
 699   int argno;                                    /* current argument number */
 700   int argbytes;                                 /* current argument byte */
 701   char tmp_buffer [50];
 702   int f_argno = 0;                              /* current floating point argno */
 703   value_ptr arg = 0;
 704   struct type *type;
 705
 706   CORE_ADDR saved_sp;
 707
 708   if ( dummy_frame_count <= 0)
 709     printf_unfiltered ("FATAL ERROR -push_arguments()! frame not found!!\n");
 710
 711   /* The first eight words of ther arguments are passed in registers. Copy
 712      them appropriately.
 713
 714      If the function is returning a `struct', then the first word (which
 715      will be passed in r3) is used for struct return address. In that
 716      case we should advance one word and start from r4 register to copy
 717      parameters. */
 718
 719   ii =  struct_return ? 1 : 0;
 720
 721   for (argno=0, argbytes=0; argno < nargs && ii<8; ++ii) {
 722
 723     arg = args[argno];
 724     type = check_typedef (VALUE_TYPE (arg));
 725     len = TYPE_LENGTH (type);
 726
 727     if (TYPE_CODE (type) == TYPE_CODE_FLT) {
 728
 729       /* floating point arguments are passed in fpr's, as well as gpr's.
 730          There are 13 fpr's reserved for passing parameters. At this point
 731          there is no way we would run out of them. */
 732
 733       if (len > 8)
 734         printf_unfiltered (
 735 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 736
 737       memcpy (&registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], VALUE_CONTENTS (arg),
 738          len);
 739       ++f_argno;
 740     }
 741
 742     if (len > 4) {
 743
 744       /* Argument takes more than one register. */
 745       while (argbytes < len) {
 746
 747         *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 748         memcpy (&registers[REGISTER_BYTE(ii+3)],
 749                          ((char*)VALUE_CONTENTS (arg))+argbytes,
 750                         (len - argbytes) > 4 ? 4 : len - argbytes);
 751         ++ii, argbytes += 4;
 752
 753         if (ii >= 8)
 754           goto ran_out_of_registers_for_arguments;
 755       }
 756       argbytes = 0;
 757       --ii;
 758     }
 759     else {        /* Argument can fit in one register. No problem. */
 760       *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 761       memcpy (&registers[REGISTER_BYTE(ii+3)], VALUE_CONTENTS (arg), len);
 762     }
 763     ++argno;
 764   }
 765
 766 ran_out_of_registers_for_arguments:
 767
 768   /* location for 8 parameters are always reserved. */
 769   sp -= 4 * 8;
 770
 771   /* another six words for back chain, TOC register, link register, etc. */
 772   sp -= 24;
 773
 774   /* if there are more arguments, allocate space for them in
 775      the stack, then push them starting from the ninth one. */
 776
 777   if ((argno < nargs) || argbytes) {
 778     int space = 0, jj;
 779
 780     if (argbytes) {
 781       space += ((len - argbytes + 3) & -4);
 782       jj = argno + 1;
 783     }
 784     else
 785       jj = argno;
 786
 787     for (; jj < nargs; ++jj) {
 788       value_ptr val = args[jj];
 789       space += ((TYPE_LENGTH (VALUE_TYPE (val))) + 3) & -4;
 790     }
 791
 792     /* add location required for the rest of the parameters */
 793     space = (space + 7) & -8;
 794     sp -= space;
 795
 796     /* This is another instance we need to be concerned about securing our
 797         stack space. If we write anything underneath %sp (r1), we might conflict
 798         with the kernel who thinks he is free to use this area. So, update %sp
 799         first before doing anything else. */
 800
 801     write_register (SP_REGNUM, sp);
 802
 803     /* if the last argument copied into the registers didn't fit there
 804        completely, push the rest of it into stack. */
 805
 806     if (argbytes) {
 807       write_memory (
 808         sp+24+(ii*4), ((char*)VALUE_CONTENTS (arg))+argbytes, len - argbytes);
 809       ++argno;
 810       ii += ((len - argbytes + 3) & -4) / 4;
 811     }
 812
 813     /* push the rest of the arguments into stack. */
 814     for (; argno < nargs; ++argno) {
 815
 816       arg = args[argno];
 817       type = check_typedef (VALUE_TYPE (arg));
 818       len = TYPE_LENGTH (type);
 819
 820
 821       /* float types should be passed in fpr's, as well as in the stack. */
 822       if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13) {
 823
 824         if (len > 8)
 825           printf_unfiltered (
 826 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 827
 828         memcpy (&registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], VALUE_CONTENTS (arg),
 829            len);
 830         ++f_argno;
 831       }
 832
 833       write_memory (sp+24+(ii*4), (char *) VALUE_CONTENTS (arg), len);
 834       ii += ((len + 3) & -4) / 4;
 835     }
 836   }
 837   else
 838     /* Secure stack areas first, before doing anything else. */
 839     write_register (SP_REGNUM, sp);
 840
 841   saved_sp = dummy_frame_addr [dummy_frame_count - 1];
 842   read_memory (saved_sp, tmp_buffer, 24);
 843   write_memory (sp, tmp_buffer, 24);
 844
 845   /* set back chain properly */
 846   store_address (tmp_buffer, 4, saved_sp);
 847   write_memory (sp, tmp_buffer, 4);
 848
 849   target_store_registers (-1);
 850   return sp;
 851 }
 852
 853 /* a given return value in `regbuf' with a type `valtype', extract and copy its
 854    value into `valbuf' */
 855
 856 void
 857 extract_return_value (valtype, regbuf, valbuf)
 858      struct type *valtype;
 859      char regbuf[REGISTER_BYTES];
 860      char *valbuf;
 861 {
 862   int offset = 0;
 863
 864   if (TYPE_CODE (valtype) == TYPE_CODE_FLT) {
 865
 866     double dd; float ff;
 867     /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
 868        We need to truncate the return value into float size (4 byte) if
 869        necessary. */
 870
 871     if (TYPE_LENGTH (valtype) > 4)              /* this is a double */
 872       memcpy (valbuf, &regbuf[REGISTER_BYTE (FP0_REGNUM + 1)],
 873                                                 TYPE_LENGTH (valtype));
 874     else {              /* float */
 875       memcpy (&dd, &regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], 8);
 876       ff = (float)dd;
 877       memcpy (valbuf, &ff, sizeof(float));
 878     }
 879   }
 880   else {
 881     /* return value is copied starting from r3. */
 882     if (TARGET_BYTE_ORDER == BIG_ENDIAN
 883         && TYPE_LENGTH (valtype) < REGISTER_RAW_SIZE (3))
 884       offset = REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype);
 885
 886     memcpy (valbuf, regbuf + REGISTER_BYTE (3) + offset,
 887             TYPE_LENGTH (valtype));
 888   }
 889 }
 890
 891
 892 /* keep structure return address in this variable.
 893    FIXME:  This is a horrid kludge which should not be allowed to continue
 894    living.  This only allows a single nested call to a structure-returning
 895    function.  Come on, guys!  -- [email protected], Aug 92  */
 896
 897 CORE_ADDR rs6000_struct_return_address;
 898
 899
 900 /* Indirect function calls use a piece of trampoline code to do context
 901    switching, i.e. to set the new TOC table. Skip such code if we are on
 902    its first instruction (as when we have single-stepped to here).
 903    Also skip shared library trampoline code (which is different from
 904    indirect function call trampolines).
 905    Result is desired PC to step until, or NULL if we are not in
 906    trampoline code.  */
 907
 908 CORE_ADDR
 909 skip_trampoline_code (pc)
 910      CORE_ADDR pc;
 911 {
 912   register unsigned int ii, op;
 913   CORE_ADDR solib_target_pc;
 914
 915   static unsigned trampoline_code[] = {
 916         0x800b0000,                     /*     l   r0,0x0(r11)  */
 917         0x90410014,                     /*    st   r2,0x14(r1)  */
 918         0x7c0903a6,                     /* mtctr   r0           */
 919         0x804b0004,                     /*     l   r2,0x4(r11)  */
 920         0x816b0008,                     /*     l  r11,0x8(r11)  */
 921         0x4e800420,                     /*  bctr                */
 922         0x4e800020,                     /*    br                */
 923         0
 924   };
 925
 926   /* If pc is in a shared library trampoline, return its target.  */
 927   solib_target_pc = find_solib_trampoline_target (pc);
 928   if (solib_target_pc)
 929     return solib_target_pc;
 930
 931   for (ii=0; trampoline_code[ii]; ++ii) {
 932     op  = read_memory_integer (pc + (ii*4), 4);
 933     if (op != trampoline_code [ii])
 934       return 0;
 935   }
 936   ii = read_register (11);              /* r11 holds destination addr   */
 937   pc = read_memory_integer (ii, 4);     /* (r11) value                  */
 938   return pc;
 939 }
 940
 941 /* Determines whether the function FI has a frame on the stack or not.  */
 942
 943 int
 944 frameless_function_invocation (fi)
 945      struct frame_info *fi;
 946 {
 947   CORE_ADDR func_start;
 948   struct rs6000_framedata fdata;
 949
 950   if (fi->next != NULL)
 951     /* Don't even think about framelessness except on the innermost frame.  */
 952     /* FIXME: Can also be frameless if fi->next->signal_handler_caller (if
 953        a signal happens while executing in a frameless function).  */
 954     return 0;
 955
 956   func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET;
 957
 958   /* If we failed to find the start of the function, it is a mistake
 959      to inspect the instructions. */
 960
 961   if (!func_start)
 962     return 0;
 963
 964   (void) skip_prologue (func_start, &fdata);
 965   return fdata.frameless;
 966 }
 967
 968 /* Return the PC saved in a frame */
 969
 970 unsigned long
 971 frame_saved_pc (fi)
 972      struct frame_info *fi;
 973 {
 974   CORE_ADDR func_start;
 975   struct rs6000_framedata fdata;
 976
 977   if (fi->signal_handler_caller)
 978     return read_memory_integer (fi->frame + SIG_FRAME_PC_OFFSET, 4);
 979
 980   func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET;
 981
 982   /* If we failed to find the start of the function, it is a mistake
 983      to inspect the instructions. */
 984   if (!func_start)
 985     return 0;
 986
 987   (void) skip_prologue (func_start, &fdata);
 988
 989   if (fdata.lr_offset == 0 && fi->next != NULL)
 990     return read_memory_integer (rs6000_frame_chain (fi) + DEFAULT_LR_SAVE, 4);
 991
 992   if (fdata.lr_offset == 0)
 993     return read_register (LR_REGNUM);
 994
 995   return read_memory_integer (rs6000_frame_chain (fi) + fdata.lr_offset, 4);
 996 }
 997
 998 /* If saved registers of frame FI are not known yet, read and cache them.
 999    &FDATAP contains rs6000_framedata; TDATAP can be NULL,
1000    in which case the framedata are read.  */
1001
1002 static void
1003 frame_get_cache_fsr (fi, fdatap)
1004      struct frame_info *fi;
1005      struct rs6000_framedata *fdatap;
1006 {
1007   int ii;
1008   CORE_ADDR frame_addr;
1009   struct rs6000_framedata work_fdata;
1010
1011   if (fi->cache_fsr)
1012     return;
1013
1014   if (fdatap == NULL) {
1015     fdatap = &work_fdata;
1016     (void) skip_prologue (get_pc_function_start (fi->pc), fdatap);
1017   }
1018
1019   fi->cache_fsr = (struct frame_saved_regs *)
1020       obstack_alloc (&frame_cache_obstack, sizeof (struct frame_saved_regs));
1021   memset (fi->cache_fsr, '\0', sizeof (struct frame_saved_regs));
1022
1023   if (fi->prev && fi->prev->frame)
1024     frame_addr = fi->prev->frame;
1025   else
1026     frame_addr = read_memory_integer (fi->frame, 4);
1027
1028   /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
1029      All fpr's from saved_fpr to fp31 are saved.  */
1030
1031   if (fdatap->saved_fpr >= 0) {
1032     int fpr_offset = frame_addr + fdatap->fpr_offset;
1033     for (ii = fdatap->saved_fpr; ii < 32; ii++) {
1034       fi->cache_fsr->regs [FP0_REGNUM + ii] = fpr_offset;
1035       fpr_offset += 8;
1036     }
1037   }
1038
1039   /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
1040      All gpr's from saved_gpr to gpr31 are saved.  */
1041
1042   if (fdatap->saved_gpr >= 0) {
1043     int gpr_offset = frame_addr + fdatap->gpr_offset;
1044     for (ii = fdatap->saved_gpr; ii < 32; ii++) {
1045       fi->cache_fsr->regs [ii] = gpr_offset;
1046       gpr_offset += 4;
1047     }
1048   }
1049
1050   /* If != 0, fdatap->cr_offset is the offset from the frame that holds
1051      the CR.  */
1052   if (fdatap->cr_offset != 0)
1053     fi->cache_fsr->regs [CR_REGNUM] = frame_addr + fdatap->cr_offset;
1054
1055   /* If != 0, fdatap->lr_offset is the offset from the frame that holds
1056      the LR.  */
1057   if (fdatap->lr_offset != 0)
1058     fi->cache_fsr->regs [LR_REGNUM] = frame_addr + fdatap->lr_offset;
1059 }
1060
1061 /* Return the address of a frame. This is the inital %sp value when the frame
1062    was first allocated. For functions calling alloca(), it might be saved in
1063    an alloca register. */
1064
1065 CORE_ADDR
1066 frame_initial_stack_address (fi)
1067      struct frame_info *fi;
1068 {
1069   CORE_ADDR tmpaddr;
1070   struct rs6000_framedata fdata;
1071   struct frame_info *callee_fi;
1072
1073   /* if the initial stack pointer (frame address) of this frame is known,
1074      just return it. */
1075
1076   if (fi->initial_sp)
1077     return fi->initial_sp;
1078
1079   /* find out if this function is using an alloca register.. */
1080
1081   (void) skip_prologue (get_pc_function_start (fi->pc), &fdata);
1082
1083   /* if saved registers of this frame are not known yet, read and cache them. */
1084
1085   if (!fi->cache_fsr)
1086     frame_get_cache_fsr (fi, &fdata);
1087
1088   /* If no alloca register used, then fi->frame is the value of the %sp for
1089      this frame, and it is good enough. */
1090
1091   if (fdata.alloca_reg < 0) {
1092     fi->initial_sp = fi->frame;
1093     return fi->initial_sp;
1094   }
1095
1096   /* This function has an alloca register. If this is the top-most frame
1097      (with the lowest address), the value in alloca register is good. */
1098
1099   if (!fi->next)
1100     return fi->initial_sp = read_register (fdata.alloca_reg);
1101
1102   /* Otherwise, this is a caller frame. Callee has usually already saved
1103      registers, but there are exceptions (such as when the callee
1104      has no parameters). Find the address in which caller's alloca
1105      register is saved. */
1106
1107   for (callee_fi = fi->next; callee_fi; callee_fi = callee_fi->next) {
1108
1109     if (!callee_fi->cache_fsr)
1110       frame_get_cache_fsr (callee_fi, NULL);
1111
1112     /* this is the address in which alloca register is saved. */
1113
1114     tmpaddr = callee_fi->cache_fsr->regs [fdata.alloca_reg];
1115     if (tmpaddr) {
1116       fi->initial_sp = read_memory_integer (tmpaddr, 4);
1117       return fi->initial_sp;
1118     }
1119
1120     /* Go look into deeper levels of the frame chain to see if any one of
1121        the callees has saved alloca register. */
1122   }
1123
1124   /* If alloca register was not saved, by the callee (or any of its callees)
1125      then the value in the register is still good. */
1126
1127   return fi->initial_sp = read_register (fdata.alloca_reg);
1128 }
1129
1130 CORE_ADDR
1131 rs6000_frame_chain (thisframe)
1132      struct frame_info *thisframe;
1133 {
1134   CORE_ADDR fp;
1135   if (inside_entry_file ((thisframe)->pc))
1136     return 0;
1137   if (thisframe->signal_handler_caller)
1138     fp = read_memory_integer (thisframe->frame + SIG_FRAME_FP_OFFSET, 4);
1139   else
1140     fp = read_memory_integer ((thisframe)->frame, 4);
1141
1142   return fp;
1143 }
1144 \f
1145 /* Keep an array of load segment information and their TOC table addresses.
1146    This info will be useful when calling a shared library function by hand. */
1147
1148 struct loadinfo {
1149   CORE_ADDR textorg, dataorg;
1150   unsigned long toc_offset;
1151 };
1152
1153 #define LOADINFOLEN     10
1154
1155 static  struct loadinfo *loadinfo = NULL;
1156 static  int     loadinfolen = 0;
1157 static  int     loadinfotocindex = 0;
1158 static  int     loadinfotextindex = 0;
1159
1160
1161 void
1162 xcoff_init_loadinfo ()
1163 {
1164   loadinfotocindex = 0;
1165   loadinfotextindex = 0;
1166
1167   if (loadinfolen == 0) {
1168     loadinfo = (struct loadinfo *)
1169                xmalloc (sizeof (struct loadinfo) * LOADINFOLEN);
1170     loadinfolen = LOADINFOLEN;
1171   }
1172 }
1173
1174
1175 /* FIXME -- this is never called!  */
1176 #if 0
1177 void
1178 free_loadinfo ()
1179 {
1180   if (loadinfo)
1181     free (loadinfo);
1182   loadinfo = NULL;
1183   loadinfolen = 0;
1184   loadinfotocindex = 0;
1185   loadinfotextindex = 0;
1186 }
1187 #endif
1188
1189 /* this is called from xcoffread.c */
1190
1191 void
1192 xcoff_add_toc_to_loadinfo (tocoff)
1193      unsigned long tocoff;
1194 {
1195   while (loadinfotocindex >= loadinfolen) {
1196     loadinfolen += LOADINFOLEN;
1197     loadinfo = (struct loadinfo *)
1198                xrealloc (loadinfo, sizeof(struct loadinfo) * loadinfolen);
1199   }
1200   loadinfo [loadinfotocindex++].toc_offset = tocoff;
1201 }
1202
1203 void
1204 add_text_to_loadinfo (textaddr, dataaddr)
1205      CORE_ADDR textaddr;
1206      CORE_ADDR dataaddr;
1207 {
1208   while (loadinfotextindex >= loadinfolen) {
1209     loadinfolen += LOADINFOLEN;
1210     loadinfo = (struct loadinfo *)
1211                xrealloc (loadinfo, sizeof(struct loadinfo) * loadinfolen);
1212   }
1213   loadinfo [loadinfotextindex].textorg = textaddr;
1214   loadinfo [loadinfotextindex].dataorg = dataaddr;
1215   ++loadinfotextindex;
1216 }
1217
1218
1219 /* Note that this assumes that the "textorg" and "dataorg" elements of
1220    a member of this array are correlated with the "toc_offset" element
1221    of the same member.  This is taken care of because the loops which
1222    assign the former (in xcoff_relocate_symtab or xcoff_relocate_core)
1223    and the latter (in scan_xcoff_symtab, via vmap_symtab, in
1224    vmap_ldinfo or xcoff_relocate_core) traverse the same objfiles in
1225    the same order.  */
1226
1227 static CORE_ADDR
1228 find_toc_address (pc)
1229      CORE_ADDR pc;
1230 {
1231   int ii, toc_entry, tocbase = 0;
1232
1233   toc_entry = -1;
1234   for (ii=0; ii < loadinfotextindex; ++ii)
1235     if (pc > loadinfo[ii].textorg && loadinfo[ii].textorg > tocbase) {
1236       toc_entry = ii;
1237       tocbase = loadinfo[ii].textorg;
1238     }
1239
1240   if (toc_entry == -1)
1241     error ("Unable to find TOC entry for pc 0x%x\n", pc);
1242   return loadinfo[toc_entry].dataorg + loadinfo[toc_entry].toc_offset;
1243 }
1244
1245 /* Return nonzero if ADDR (a function pointer) is in the data space and
1246    is therefore a special function pointer.  */
1247
1248 int
1249 is_magic_function_pointer (addr)
1250      CORE_ADDR addr;
1251 {
1252   struct obj_section *s;
1253
1254   s = find_pc_section (addr);
1255   if (s && s->the_bfd_section->flags & SEC_CODE)
1256     return 0;
1257   else
1258     return 1;
1259 }
1260
1261 #ifdef GDB_TARGET_POWERPC
1262 int
1263 gdb_print_insn_powerpc (memaddr, info)
1264      bfd_vma memaddr;
1265      disassemble_info *info;
1266 {
1267   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1268     return print_insn_big_powerpc (memaddr, info);
1269   else
1270     return print_insn_little_powerpc (memaddr, info);
1271 }
1272 #endif
1273
1274 void
1275 _initialize_rs6000_tdep ()
1276 {
1277 #ifndef ELF_OBJECT_FORMAT
1278   {
1279     extern void (*xcoff_add_toc_to_loadinfo_hook) PARAMS ((unsigned long));
1280     extern void (*xcoff_init_loadinfo_hook) PARAMS ((void));
1281
1282     /* Initialize hook in xcoffread for recording the toc offset value
1283        of a symbol table into the ldinfo structure, for native rs6000
1284        config. */
1285     xcoff_add_toc_to_loadinfo_hook = &xcoff_add_toc_to_loadinfo;
1286
1287     /* Initialize hook in xcoffread for calling xcoff_init_loadinfo in
1288        a native rs6000 config. */
1289     xcoff_init_loadinfo_hook = &xcoff_init_loadinfo;
1290   }
1291 #endif /* ELF_OBJECT_FORMAT */
1292
1293   /* FIXME, this should not be decided via ifdef. */
1294 #ifdef GDB_TARGET_POWERPC
1295   tm_print_insn = gdb_print_insn_powerpc;
1296 #else
1297   tm_print_insn = print_insn_rs6000;
1298 #endif
1299 }