gdb/rs6000-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "symtab.h"
  27 #include "target.h"
  28 #include "gdbcore.h"
  29 #include "gdbcmd.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "arch-utils.h"
  33 #include "regcache.h"
  34 #include "doublest.h"
  35 #include "value.h"
  36 #include "parser-defs.h"
  37
  38 #include "libbfd.h"             /* for bfd_default_set_arch_mach */
  39 #include "coff/internal.h"      /* for libcoff.h */
  40 #include "libcoff.h"            /* for xcoff_data */
  41 #include "coff/xcoff.h"
  42 #include "libxcoff.h"
  43
  44 #include "elf-bfd.h"
  45
  46 #include "solib-svr4.h"
  47 #include "ppc-tdep.h"
  48
  49 /* If the kernel has to deliver a signal, it pushes a sigcontext
  50    structure on the stack and then calls the signal handler, passing
  51    the address of the sigcontext in an argument register. Usually
  52    the signal handler doesn't save this register, so we have to
  53    access the sigcontext structure via an offset from the signal handler
  54    frame.
  55    The following constants were determined by experimentation on AIX 3.2.  */
  56 #define SIG_FRAME_PC_OFFSET 96
  57 #define SIG_FRAME_LR_OFFSET 108
  58 #define SIG_FRAME_FP_OFFSET 284
  59
  60 /* To be used by skip_prologue. */
  61
  62 struct rs6000_framedata
  63   {
  64     int offset;                 /* total size of frame --- the distance
  65                                    by which we decrement sp to allocate
  66                                    the frame */
  67     int saved_gpr;              /* smallest # of saved gpr */
  68     int saved_fpr;              /* smallest # of saved fpr */
  69     int saved_vr;               /* smallest # of saved vr */
  70     int alloca_reg;             /* alloca register number (frame ptr) */
  71     char frameless;             /* true if frameless functions. */
  72     char nosavedpc;             /* true if pc not saved. */
  73     int gpr_offset;             /* offset of saved gprs from prev sp */
  74     int fpr_offset;             /* offset of saved fprs from prev sp */
  75     int vr_offset;              /* offset of saved vrs from prev sp */
  76     int lr_offset;              /* offset of saved lr */
  77     int cr_offset;              /* offset of saved cr */
  78     int vrsave_offset;          /* offset of saved vrsave register */
  79   };
  80
  81 /* Description of a single register. */
  82
  83 struct reg
  84   {
  85     char *name;                 /* name of register */
  86     unsigned char sz32;         /* size on 32-bit arch, 0 if nonextant */
  87     unsigned char sz64;         /* size on 64-bit arch, 0 if nonextant */
  88     unsigned char fpr;          /* whether register is floating-point */
  89   };
  90
  91 /* Return the current architecture's gdbarch_tdep structure. */
  92
  93 #define TDEP    gdbarch_tdep (current_gdbarch)
  94
  95 /* Breakpoint shadows for the single step instructions will be kept here. */
  96
  97 static struct sstep_breaks
  98   {
  99     /* Address, or 0 if this is not in use.  */
 100     CORE_ADDR address;
 101     /* Shadow contents.  */
 102     char data[4];
 103   }
 104 stepBreaks[2];
 105
 106 /* Hook for determining the TOC address when calling functions in the
 107    inferior under AIX. The initialization code in rs6000-nat.c sets
 108    this hook to point to find_toc_address.  */
 109
 110 CORE_ADDR (*rs6000_find_toc_address_hook) (CORE_ADDR) = NULL;
 111
 112 /* Hook to set the current architecture when starting a child process.
 113    rs6000-nat.c sets this. */
 114
 115 void (*rs6000_set_host_arch_hook) (int) = NULL;
 116
 117 /* Static function prototypes */
 118
 119 static CORE_ADDR branch_dest (int opcode, int instr, CORE_ADDR pc,
 120                               CORE_ADDR safety);
 121 static CORE_ADDR skip_prologue (CORE_ADDR, CORE_ADDR,
 122                                 struct rs6000_framedata *);
 123 static void frame_get_saved_regs (struct frame_info * fi,
 124                                   struct rs6000_framedata * fdatap);
 125 static CORE_ADDR frame_initial_stack_address (struct frame_info *);
 126
 127 /* Read a LEN-byte address from debugged memory address MEMADDR. */
 128
 129 static CORE_ADDR
 130 read_memory_addr (CORE_ADDR memaddr, int len)
 131 {
 132   return read_memory_unsigned_integer (memaddr, len);
 133 }
 134
 135 static CORE_ADDR
 136 rs6000_skip_prologue (CORE_ADDR pc)
 137 {
 138   struct rs6000_framedata frame;
 139   pc = skip_prologue (pc, 0, &frame);
 140   return pc;
 141 }
 142
 143
 144 /* Fill in fi->saved_regs */
 145
 146 struct frame_extra_info
 147 {
 148   /* Functions calling alloca() change the value of the stack
 149      pointer. We need to use initial stack pointer (which is saved in
 150      r31 by gcc) in such cases. If a compiler emits traceback table,
 151      then we should use the alloca register specified in traceback
 152      table. FIXME. */
 153   CORE_ADDR initial_sp;         /* initial stack pointer. */
 154 };
 155
 156 void
 157 rs6000_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 158 {
 159   fi->extra_info = (struct frame_extra_info *)
 160     frame_obstack_alloc (sizeof (struct frame_extra_info));
 161   fi->extra_info->initial_sp = 0;
 162   if (fi->next != (CORE_ADDR) 0
 163       && fi->pc < TEXT_SEGMENT_BASE)
 164     /* We're in get_prev_frame */
 165     /* and this is a special signal frame.  */
 166     /* (fi->pc will be some low address in the kernel, */
 167     /*  to which the signal handler returns).  */
 168     fi->signal_handler_caller = 1;
 169 }
 170
 171 /* Put here the code to store, into a struct frame_saved_regs,
 172    the addresses of the saved registers of frame described by FRAME_INFO.
 173    This includes special registers such as pc and fp saved in special
 174    ways in the stack frame.  sp is even more special:
 175    the address we return for it IS the sp for the next frame.  */
 176
 177 /* In this implementation for RS/6000, we do *not* save sp. I am
 178    not sure if it will be needed. The following function takes care of gpr's
 179    and fpr's only. */
 180
 181 void
 182 rs6000_frame_init_saved_regs (struct frame_info *fi)
 183 {
 184   frame_get_saved_regs (fi, NULL);
 185 }
 186
 187 static CORE_ADDR
 188 rs6000_frame_args_address (struct frame_info *fi)
 189 {
 190   if (fi->extra_info->initial_sp != 0)
 191     return fi->extra_info->initial_sp;
 192   else
 193     return frame_initial_stack_address (fi);
 194 }
 195
 196 /* Immediately after a function call, return the saved pc.
 197    Can't go through the frames for this because on some machines
 198    the new frame is not set up until the new function executes
 199    some instructions.  */
 200
 201 static CORE_ADDR
 202 rs6000_saved_pc_after_call (struct frame_info *fi)
 203 {
 204   return read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
 205 }
 206
 207 /* Calculate the destination of a branch/jump.  Return -1 if not a branch.  */
 208
 209 static CORE_ADDR
 210 branch_dest (int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety)
 211 {
 212   CORE_ADDR dest;
 213   int immediate;
 214   int absolute;
 215   int ext_op;
 216
 217   absolute = (int) ((instr >> 1) & 1);
 218
 219   switch (opcode)
 220     {
 221     case 18:
 222       immediate = ((instr & ~3) << 6) >> 6;     /* br unconditional */
 223       if (absolute)
 224         dest = immediate;
 225       else
 226         dest = pc + immediate;
 227       break;
 228
 229     case 16:
 230       immediate = ((instr & ~3) << 16) >> 16;   /* br conditional */
 231       if (absolute)
 232         dest = immediate;
 233       else
 234         dest = pc + immediate;
 235       break;
 236
 237     case 19:
 238       ext_op = (instr >> 1) & 0x3ff;
 239
 240       if (ext_op == 16)         /* br conditional register */
 241         {
 242           dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3;
 243
 244           /* If we are about to return from a signal handler, dest is
 245              something like 0x3c90.  The current frame is a signal handler
 246              caller frame, upon completion of the sigreturn system call
 247              execution will return to the saved PC in the frame.  */
 248           if (dest < TEXT_SEGMENT_BASE)
 249             {
 250               struct frame_info *fi;
 251
 252               fi = get_current_frame ();
 253               if (fi != NULL)
 254                 dest = read_memory_addr (fi->frame + SIG_FRAME_PC_OFFSET,
 255                                          TDEP->wordsize);
 256             }
 257         }
 258
 259       else if (ext_op == 528)   /* br cond to count reg */
 260         {
 261           dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum) & ~3;
 262
 263           /* If we are about to execute a system call, dest is something
 264              like 0x22fc or 0x3b00.  Upon completion the system call
 265              will return to the address in the link register.  */
 266           if (dest < TEXT_SEGMENT_BASE)
 267             dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3;
 268         }
 269       else
 270         return -1;
 271       break;
 272
 273     default:
 274       return -1;
 275     }
 276   return (dest < TEXT_SEGMENT_BASE) ? safety : dest;
 277 }
 278
 279
 280 /* Sequence of bytes for breakpoint instruction.  */
 281
 282 #define BIG_BREAKPOINT { 0x7d, 0x82, 0x10, 0x08 }
 283 #define LITTLE_BREAKPOINT { 0x08, 0x10, 0x82, 0x7d }
 284
 285 const static unsigned char *
 286 rs6000_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
 287 {
 288   static unsigned char big_breakpoint[] = BIG_BREAKPOINT;
 289   static unsigned char little_breakpoint[] = LITTLE_BREAKPOINT;
 290   *bp_size = 4;
 291   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 292     return big_breakpoint;
 293   else
 294     return little_breakpoint;
 295 }
 296
 297
 298 /* AIX does not support PT_STEP. Simulate it. */
 299
 300 void
 301 rs6000_software_single_step (enum target_signal signal,
 302                              int insert_breakpoints_p)
 303 {
 304   CORE_ADDR dummy;
 305   int breakp_sz;
 306   const char *breakp = rs6000_breakpoint_from_pc (&dummy, &breakp_sz);
 307   int ii, insn;
 308   CORE_ADDR loc;
 309   CORE_ADDR breaks[2];
 310   int opcode;
 311
 312   if (insert_breakpoints_p)
 313     {
 314
 315       loc = read_pc ();
 316
 317       insn = read_memory_integer (loc, 4);
 318
 319       breaks[0] = loc + breakp_sz;
 320       opcode = insn >> 26;
 321       breaks[1] = branch_dest (opcode, insn, loc, breaks[0]);
 322
 323       /* Don't put two breakpoints on the same address. */
 324       if (breaks[1] == breaks[0])
 325         breaks[1] = -1;
 326
 327       stepBreaks[1].address = 0;
 328
 329       for (ii = 0; ii < 2; ++ii)
 330         {
 331
 332           /* ignore invalid breakpoint. */
 333           if (breaks[ii] == -1)
 334             continue;
 335           target_insert_breakpoint (breaks[ii], stepBreaks[ii].data);
 336           stepBreaks[ii].address = breaks[ii];
 337         }
 338
 339     }
 340   else
 341     {
 342
 343       /* remove step breakpoints. */
 344       for (ii = 0; ii < 2; ++ii)
 345         if (stepBreaks[ii].address != 0)
 346           target_remove_breakpoint (stepBreaks[ii].address,
 347                                     stepBreaks[ii].data);
 348     }
 349   errno = 0;                    /* FIXME, don't ignore errors! */
 350   /* What errors?  {read,write}_memory call error().  */
 351 }
 352
 353
 354 /* return pc value after skipping a function prologue and also return
 355    information about a function frame.
 356
 357    in struct rs6000_framedata fdata:
 358    - frameless is TRUE, if function does not have a frame.
 359    - nosavedpc is TRUE, if function does not save %pc value in its frame.
 360    - offset is the initial size of this stack frame --- the amount by
 361    which we decrement the sp to allocate the frame.
 362    - saved_gpr is the number of the first saved gpr.
 363    - saved_fpr is the number of the first saved fpr.
 364    - saved_vr is the number of the first saved vr.
 365    - alloca_reg is the number of the register used for alloca() handling.
 366    Otherwise -1.
 367    - gpr_offset is the offset of the first saved gpr from the previous frame.
 368    - fpr_offset is the offset of the first saved fpr from the previous frame.
 369    - vr_offset is the offset of the first saved vr from the previous frame.
 370    - lr_offset is the offset of the saved lr
 371    - cr_offset is the offset of the saved cr
 372    - vrsave_offset is the offset of the saved vrsave register
 373  */
 374
 375 #define SIGNED_SHORT(x)                                                 \
 376   ((sizeof (short) == 2)                                                \
 377    ? ((int)(short)(x))                                                  \
 378    : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
 379
 380 #define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
 381
 382 /* Limit the number of skipped non-prologue instructions, as the examining
 383    of the prologue is expensive.  */
 384 static int max_skip_non_prologue_insns = 10;
 385
 386 /* Given PC representing the starting address of a function, and
 387    LIM_PC which is the (sloppy) limit to which to scan when looking
 388    for a prologue, attempt to further refine this limit by using
 389    the line data in the symbol table.  If successful, a better guess
 390    on where the prologue ends is returned, otherwise the previous
 391    value of lim_pc is returned.  */
 392 static CORE_ADDR
 393 refine_prologue_limit (CORE_ADDR pc, CORE_ADDR lim_pc)
 394 {
 395   struct symtab_and_line prologue_sal;
 396
 397   prologue_sal = find_pc_line (pc, 0);
 398   if (prologue_sal.line != 0)
 399     {
 400       int i;
 401       CORE_ADDR addr = prologue_sal.end;
 402
 403       /* Handle the case in which compiler's optimizer/scheduler
 404          has moved instructions into the prologue.  We scan ahead
 405          in the function looking for address ranges whose corresponding
 406          line number is less than or equal to the first one that we
 407          found for the function.  (It can be less than when the
 408          scheduler puts a body instruction before the first prologue
 409          instruction.)  */
 410       for (i = 2 * max_skip_non_prologue_insns;
 411            i > 0 && (lim_pc == 0 || addr < lim_pc);
 412            i--)
 413         {
 414           struct symtab_and_line sal;
 415
 416           sal = find_pc_line (addr, 0);
 417           if (sal.line == 0)
 418             break;
 419           if (sal.line <= prologue_sal.line
 420               && sal.symtab == prologue_sal.symtab)
 421             {
 422               prologue_sal = sal;
 423             }
 424           addr = sal.end;
 425         }
 426
 427       if (lim_pc == 0 || prologue_sal.end < lim_pc)
 428         lim_pc = prologue_sal.end;
 429     }
 430   return lim_pc;
 431 }
 432
 433
 434 static CORE_ADDR
 435 skip_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct rs6000_framedata *fdata)
 436 {
 437   CORE_ADDR orig_pc = pc;
 438   CORE_ADDR last_prologue_pc = pc;
 439   CORE_ADDR li_found_pc = 0;
 440   char buf[4];
 441   unsigned long op;
 442   long offset = 0;
 443   long vr_saved_offset = 0;
 444   int lr_reg = -1;
 445   int cr_reg = -1;
 446   int vr_reg = -1;
 447   int vrsave_reg = -1;
 448   int reg;
 449   int framep = 0;
 450   int minimal_toc_loaded = 0;
 451   int prev_insn_was_prologue_insn = 1;
 452   int num_skip_non_prologue_insns = 0;
 453
 454   /* Attempt to find the end of the prologue when no limit is specified.
 455      Note that refine_prologue_limit() has been written so that it may
 456      be used to "refine" the limits of non-zero PC values too, but this
 457      is only safe if we 1) trust the line information provided by the
 458      compiler and 2) iterate enough to actually find the end of the
 459      prologue.
 460
 461      It may become a good idea at some point (for both performance and
 462      accuracy) to unconditionally call refine_prologue_limit().  But,
 463      until we can make a clear determination that this is beneficial,
 464      we'll play it safe and only use it to obtain a limit when none
 465      has been specified.  */
 466   if (lim_pc == 0)
 467     lim_pc = refine_prologue_limit (pc, lim_pc);
 468
 469   memset (fdata, 0, sizeof (struct rs6000_framedata));
 470   fdata->saved_gpr = -1;
 471   fdata->saved_fpr = -1;
 472   fdata->saved_vr = -1;
 473   fdata->alloca_reg = -1;
 474   fdata->frameless = 1;
 475   fdata->nosavedpc = 1;
 476
 477   for (;; pc += 4)
 478     {
 479       /* Sometimes it isn't clear if an instruction is a prologue
 480          instruction or not.  When we encounter one of these ambiguous
 481          cases, we'll set prev_insn_was_prologue_insn to 0 (false).
 482          Otherwise, we'll assume that it really is a prologue instruction. */
 483       if (prev_insn_was_prologue_insn)
 484         last_prologue_pc = pc;
 485
 486       /* Stop scanning if we've hit the limit.  */
 487       if (lim_pc != 0 && pc >= lim_pc)
 488         break;
 489
 490       prev_insn_was_prologue_insn = 1;
 491
 492       /* Fetch the instruction and convert it to an integer.  */
 493       if (target_read_memory (pc, buf, 4))
 494         break;
 495       op = extract_signed_integer (buf, 4);
 496
 497       if ((op & 0xfc1fffff) == 0x7c0802a6)
 498         {                       /* mflr Rx */
 499           lr_reg = (op & 0x03e00000) | 0x90010000;
 500           continue;
 501
 502         }
 503       else if ((op & 0xfc1fffff) == 0x7c000026)
 504         {                       /* mfcr Rx */
 505           cr_reg = (op & 0x03e00000) | 0x90010000;
 506           continue;
 507
 508         }
 509       else if ((op & 0xfc1f0000) == 0xd8010000)
 510         {                       /* stfd Rx,NUM(r1) */
 511           reg = GET_SRC_REG (op);
 512           if (fdata->saved_fpr == -1 || fdata->saved_fpr > reg)
 513             {
 514               fdata->saved_fpr = reg;
 515               fdata->fpr_offset = SIGNED_SHORT (op) + offset;
 516             }
 517           continue;
 518
 519         }
 520       else if (((op & 0xfc1f0000) == 0xbc010000) ||     /* stm Rx, NUM(r1) */
 521                (((op & 0xfc1f0000) == 0x90010000 ||     /* st rx,NUM(r1) */
 522                  (op & 0xfc1f0003) == 0xf8010000) &&    /* std rx,NUM(r1) */
 523                 (op & 0x03e00000) >= 0x01a00000))       /* rx >= r13 */
 524         {
 525
 526           reg = GET_SRC_REG (op);
 527           if (fdata->saved_gpr == -1 || fdata->saved_gpr > reg)
 528             {
 529               fdata->saved_gpr = reg;
 530               if ((op & 0xfc1f0003) == 0xf8010000)
 531                 op = (op >> 1) << 1;
 532               fdata->gpr_offset = SIGNED_SHORT (op) + offset;
 533             }
 534           continue;
 535
 536         }
 537       else if ((op & 0xffff0000) == 0x60000000)
 538         {
 539                                 /* nop */
 540           /* Allow nops in the prologue, but do not consider them to
 541              be part of the prologue unless followed by other prologue
 542              instructions. */
 543           prev_insn_was_prologue_insn = 0;
 544           continue;
 545
 546         }
 547       else if ((op & 0xffff0000) == 0x3c000000)
 548         {                       /* addis 0,0,NUM, used
 549                                    for >= 32k frames */
 550           fdata->offset = (op & 0x0000ffff) << 16;
 551           fdata->frameless = 0;
 552           continue;
 553
 554         }
 555       else if ((op & 0xffff0000) == 0x60000000)
 556         {                       /* ori 0,0,NUM, 2nd ha
 557                                    lf of >= 32k frames */
 558           fdata->offset |= (op & 0x0000ffff);
 559           fdata->frameless = 0;
 560           continue;
 561
 562         }
 563       else if (lr_reg != -1 && (op & 0xffff0000) == lr_reg)
 564         {                       /* st Rx,NUM(r1)
 565                                    where Rx == lr */
 566           fdata->lr_offset = SIGNED_SHORT (op) + offset;
 567           fdata->nosavedpc = 0;
 568           lr_reg = 0;
 569           continue;
 570
 571         }
 572       else if (cr_reg != -1 && (op & 0xffff0000) == cr_reg)
 573         {                       /* st Rx,NUM(r1)
 574                                    where Rx == cr */
 575           fdata->cr_offset = SIGNED_SHORT (op) + offset;
 576           cr_reg = 0;
 577           continue;
 578
 579         }
 580       else if (op == 0x48000005)
 581         {                       /* bl .+4 used in
 582                                    -mrelocatable */
 583           continue;
 584
 585         }
 586       else if (op == 0x48000004)
 587         {                       /* b .+4 (xlc) */
 588           break;
 589
 590         }
 591       else if ((op & 0xffff0000) == 0x3fc00000 ||  /* addis 30,0,foo@ha, used
 592                                                       in V.4 -mminimal-toc */
 593                (op & 0xffff0000) == 0x3bde0000)
 594         {                       /* addi 30,30,foo@l */
 595           continue;
 596
 597         }
 598       else if ((op & 0xfc000001) == 0x48000001)
 599         {                       /* bl foo,
 600                                    to save fprs??? */
 601
 602           fdata->frameless = 0;
 603           /* Don't skip over the subroutine call if it is not within
 604              the first three instructions of the prologue.  */
 605           if ((pc - orig_pc) > 8)
 606             break;
 607
 608           op = read_memory_integer (pc + 4, 4);
 609
 610           /* At this point, make sure this is not a trampoline
 611              function (a function that simply calls another functions,
 612              and nothing else).  If the next is not a nop, this branch
 613              was part of the function prologue. */
 614
 615           if (op == 0x4def7b82 || op == 0)      /* crorc 15, 15, 15 */
 616             break;              /* don't skip over
 617                                    this branch */
 618           continue;
 619
 620           /* update stack pointer */
 621         }
 622       else if ((op & 0xffff0000) == 0x94210000 ||       /* stu r1,NUM(r1) */
 623                (op & 0xffff0003) == 0xf8210001)         /* stdu r1,NUM(r1) */
 624         {
 625           fdata->frameless = 0;
 626           if ((op & 0xffff0003) == 0xf8210001)
 627             op = (op >> 1) << 1;
 628           fdata->offset = SIGNED_SHORT (op);
 629           offset = fdata->offset;
 630           continue;
 631
 632         }
 633       else if (op == 0x7c21016e)
 634         {                       /* stwux 1,1,0 */
 635           fdata->frameless = 0;
 636           offset = fdata->offset;
 637           continue;
 638
 639           /* Load up minimal toc pointer */
 640         }
 641       else if ((op >> 22) == 0x20f
 642                && !minimal_toc_loaded)
 643         {                       /* l r31,... or l r30,... */
 644           minimal_toc_loaded = 1;
 645           continue;
 646
 647           /* move parameters from argument registers to local variable
 648              registers */
 649         }
 650       else if ((op & 0xfc0007fe) == 0x7c000378 &&       /* mr(.)  Rx,Ry */
 651                (((op >> 21) & 31) >= 3) &&              /* R3 >= Ry >= R10 */
 652                (((op >> 21) & 31) <= 10) &&
 653                (((op >> 16) & 31) >= fdata->saved_gpr)) /* Rx: local var reg */
 654         {
 655           continue;
 656
 657           /* store parameters in stack */
 658         }
 659       else if ((op & 0xfc1f0003) == 0xf8010000 ||       /* std rx,NUM(r1) */
 660                (op & 0xfc1f0000) == 0xd8010000 ||       /* stfd Rx,NUM(r1) */
 661                (op & 0xfc1f0000) == 0xfc010000)         /* frsp, fp?,NUM(r1) */
 662         {
 663           continue;
 664
 665           /* store parameters in stack via frame pointer */
 666         }
 667       else if (framep &&
 668                ((op & 0xfc1f0000) == 0x901f0000 ||      /* st rx,NUM(r1) */
 669                 (op & 0xfc1f0000) == 0xd81f0000 ||      /* stfd Rx,NUM(r1) */
 670                 (op & 0xfc1f0000) == 0xfc1f0000))
 671         {                       /* frsp, fp?,NUM(r1) */
 672           continue;
 673
 674           /* Set up frame pointer */
 675         }
 676       else if (op == 0x603f0000 /* oril r31, r1, 0x0 */
 677                || op == 0x7c3f0b78)
 678         {                       /* mr r31, r1 */
 679           fdata->frameless = 0;
 680           framep = 1;
 681           fdata->alloca_reg = 31;
 682           continue;
 683
 684           /* Another way to set up the frame pointer.  */
 685         }
 686       else if ((op & 0xfc1fffff) == 0x38010000)
 687         {                       /* addi rX, r1, 0x0 */
 688           fdata->frameless = 0;
 689           framep = 1;
 690           fdata->alloca_reg = (op & ~0x38010000) >> 21;
 691           continue;
 692         }
 693       /* AltiVec related instructions.  */
 694       /* Store the vrsave register (spr 256) in another register for
 695          later manipulation, or load a register into the vrsave
 696          register.  2 instructions are used: mfvrsave and
 697          mtvrsave.  They are shorthand notation for mfspr Rn, SPR256
 698          and mtspr SPR256, Rn.  */
 699       /* mfspr Rn SPR256 == 011111 nnnnn 0000001000 01010100110
 700          mtspr SPR256 Rn == 011111 nnnnn 0000001000 01110100110  */
 701       else if ((op & 0xfc1fffff) == 0x7c0042a6)    /* mfvrsave Rn */
 702         {
 703           vrsave_reg = GET_SRC_REG (op);
 704           continue;
 705         }
 706       else if ((op & 0xfc1fffff) == 0x7c0043a6)     /* mtvrsave Rn */
 707         {
 708           continue;
 709         }
 710       /* Store the register where vrsave was saved to onto the stack:
 711          rS is the register where vrsave was stored in a previous
 712          instruction.  */
 713       /* 100100 sssss 00001 dddddddd dddddddd */
 714       else if ((op & 0xfc1f0000) == 0x90010000)     /* stw rS, d(r1) */
 715         {
 716           if (vrsave_reg == GET_SRC_REG (op))
 717             {
 718               fdata->vrsave_offset = SIGNED_SHORT (op) + offset;
 719               vrsave_reg = -1;
 720             }
 721           continue;
 722         }
 723       /* Compute the new value of vrsave, by modifying the register
 724          where vrsave was saved to.  */
 725       else if (((op & 0xfc000000) == 0x64000000)    /* oris Ra, Rs, UIMM */
 726                || ((op & 0xfc000000) == 0x60000000))/* ori Ra, Rs, UIMM */
 727         {
 728           continue;
 729         }
 730       /* li r0, SIMM (short for addi r0, 0, SIMM).  This is the first
 731          in a pair of insns to save the vector registers on the
 732          stack.  */
 733       /* 001110 00000 00000 iiii iiii iiii iiii  */
 734       else if ((op & 0xffff0000) == 0x38000000)    /* li r0, SIMM */
 735         {
 736           li_found_pc = pc;
 737           vr_saved_offset = SIGNED_SHORT (op);
 738         }
 739       /* Store vector register S at (r31+r0) aligned to 16 bytes.  */
 740       /* 011111 sssss 11111 00000 00111001110 */
 741       else if ((op & 0xfc1fffff) == 0x7c1f01ce)   /* stvx Vs, R31, R0 */
 742         {
 743           if (pc == (li_found_pc + 4))
 744             {
 745               vr_reg = GET_SRC_REG (op);
 746               /* If this is the first vector reg to be saved, or if
 747                  it has a lower number than others previously seen,
 748                  reupdate the frame info.  */
 749               if (fdata->saved_vr == -1 || fdata->saved_vr > vr_reg)
 750                 {
 751                   fdata->saved_vr = vr_reg;
 752                   fdata->vr_offset = vr_saved_offset + offset;
 753                 }
 754               vr_saved_offset = -1;
 755               vr_reg = -1;
 756               li_found_pc = 0;
 757             }
 758         }
 759       /* End AltiVec related instructions.  */
 760       else
 761         {
 762           /* Not a recognized prologue instruction.
 763              Handle optimizer code motions into the prologue by continuing
 764              the search if we have no valid frame yet or if the return
 765              address is not yet saved in the frame.  */
 766           if (fdata->frameless == 0
 767               && (lr_reg == -1 || fdata->nosavedpc == 0))
 768             break;
 769
 770           if (op == 0x4e800020          /* blr */
 771               || op == 0x4e800420)      /* bctr */
 772             /* Do not scan past epilogue in frameless functions or
 773                trampolines.  */
 774             break;
 775           if ((op & 0xf4000000) == 0x40000000) /* bxx */
 776             /* Never skip branches. */
 777             break;
 778
 779           if (num_skip_non_prologue_insns++ > max_skip_non_prologue_insns)
 780             /* Do not scan too many insns, scanning insns is expensive with
 781                remote targets.  */
 782             break;
 783
 784           /* Continue scanning.  */
 785           prev_insn_was_prologue_insn = 0;
 786           continue;
 787         }
 788     }
 789
 790 #if 0
 791 /* I have problems with skipping over __main() that I need to address
 792  * sometime. Previously, I used to use misc_function_vector which
 793  * didn't work as well as I wanted to be.  -MGO */
 794
 795   /* If the first thing after skipping a prolog is a branch to a function,
 796      this might be a call to an initializer in main(), introduced by gcc2.
 797      We'd like to skip over it as well. Fortunately, xlc does some extra
 798      work before calling a function right after a prologue, thus we can
 799      single out such gcc2 behaviour. */
 800
 801
 802   if ((op & 0xfc000001) == 0x48000001)
 803     {                           /* bl foo, an initializer function? */
 804       op = read_memory_integer (pc + 4, 4);
 805
 806       if (op == 0x4def7b82)
 807         {                       /* cror 0xf, 0xf, 0xf (nop) */
 808
 809           /* check and see if we are in main. If so, skip over this initializer
 810              function as well. */
 811
 812           tmp = find_pc_misc_function (pc);
 813           if (tmp >= 0 && STREQ (misc_function_vector[tmp].name, main_name ()))
 814             return pc + 8;
 815         }
 816     }
 817 #endif /* 0 */
 818
 819   fdata->offset = -fdata->offset;
 820   return last_prologue_pc;
 821 }
 822
 823
 824 /*************************************************************************
 825   Support for creating pushing a dummy frame into the stack, and popping
 826   frames, etc.
 827 *************************************************************************/
 828
 829
 830 /* Pop the innermost frame, go back to the caller. */
 831
 832 static void
 833 rs6000_pop_frame (void)
 834 {
 835   CORE_ADDR pc, lr, sp, prev_sp, addr;  /* %pc, %lr, %sp */
 836   struct rs6000_framedata fdata;
 837   struct frame_info *frame = get_current_frame ();
 838   int ii, wordsize;
 839
 840   pc = read_pc ();
 841   sp = FRAME_FP (frame);
 842
 843   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 844     {
 845       generic_pop_dummy_frame ();
 846       flush_cached_frames ();
 847       return;
 848     }
 849
 850   /* Make sure that all registers are valid.  */
 851   read_register_bytes (0, NULL, REGISTER_BYTES);
 852
 853   /* figure out previous %pc value. If the function is frameless, it is
 854      still in the link register, otherwise walk the frames and retrieve the
 855      saved %pc value in the previous frame. */
 856
 857   addr = get_pc_function_start (frame->pc);
 858   (void) skip_prologue (addr, frame->pc, &fdata);
 859
 860   wordsize = TDEP->wordsize;
 861   if (fdata.frameless)
 862     prev_sp = sp;
 863   else
 864     prev_sp = read_memory_addr (sp, wordsize);
 865   if (fdata.lr_offset == 0)
 866      lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
 867   else
 868     lr = read_memory_addr (prev_sp + fdata.lr_offset, wordsize);
 869
 870   /* reset %pc value. */
 871   write_register (PC_REGNUM, lr);
 872
 873   /* reset register values if any was saved earlier. */
 874
 875   if (fdata.saved_gpr != -1)
 876     {
 877       addr = prev_sp + fdata.gpr_offset;
 878       for (ii = fdata.saved_gpr; ii <= 31; ++ii)
 879         {
 880           read_memory (addr, &registers[REGISTER_BYTE (ii)], wordsize);
 881           addr += wordsize;
 882         }
 883     }
 884
 885   if (fdata.saved_fpr != -1)
 886     {
 887       addr = prev_sp + fdata.fpr_offset;
 888       for (ii = fdata.saved_fpr; ii <= 31; ++ii)
 889         {
 890           read_memory (addr, &registers[REGISTER_BYTE (ii + FP0_REGNUM)], 8);
 891           addr += 8;
 892         }
 893     }
 894
 895   write_register (SP_REGNUM, prev_sp);
 896   target_store_registers (-1);
 897   flush_cached_frames ();
 898 }
 899
 900 /* Fixup the call sequence of a dummy function, with the real function
 901    address.  Its arguments will be passed by gdb. */
 902
 903 static void
 904 rs6000_fix_call_dummy (char *dummyname, CORE_ADDR pc, CORE_ADDR fun,
 905                        int nargs, struct value **args, struct type *type,
 906                        int gcc_p)
 907 {
 908   int ii;
 909   CORE_ADDR target_addr;
 910
 911   if (rs6000_find_toc_address_hook != NULL)
 912     {
 913       CORE_ADDR tocvalue = (*rs6000_find_toc_address_hook) (fun);
 914       write_register (gdbarch_tdep (current_gdbarch)->ppc_toc_regnum,
 915                       tocvalue);
 916     }
 917 }
 918
 919 /* Pass the arguments in either registers, or in the stack. In RS/6000,
 920    the first eight words of the argument list (that might be less than
 921    eight parameters if some parameters occupy more than one word) are
 922    passed in r3..r10 registers.  float and double parameters are
 923    passed in fpr's, in addition to that. Rest of the parameters if any
 924    are passed in user stack. There might be cases in which half of the
 925    parameter is copied into registers, the other half is pushed into
 926    stack.
 927
 928    Stack must be aligned on 64-bit boundaries when synthesizing
 929    function calls.
 930
 931    If the function is returning a structure, then the return address is passed
 932    in r3, then the first 7 words of the parameters can be passed in registers,
 933    starting from r4. */
 934
 935 static CORE_ADDR
 936 rs6000_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 937                        int struct_return, CORE_ADDR struct_addr)
 938 {
 939   int ii;
 940   int len = 0;
 941   int argno;                    /* current argument number */
 942   int argbytes;                 /* current argument byte */
 943   char tmp_buffer[50];
 944   int f_argno = 0;              /* current floating point argno */
 945   int wordsize = TDEP->wordsize;
 946
 947   struct value *arg = 0;
 948   struct type *type;
 949
 950   CORE_ADDR saved_sp;
 951
 952   /* The first eight words of ther arguments are passed in registers. Copy
 953      them appropriately.
 954
 955      If the function is returning a `struct', then the first word (which
 956      will be passed in r3) is used for struct return address. In that
 957      case we should advance one word and start from r4 register to copy
 958      parameters. */
 959
 960   ii = struct_return ? 1 : 0;
 961
 962 /*
 963    effectively indirect call... gcc does...
 964
 965    return_val example( float, int);
 966
 967    eabi:
 968    float in fp0, int in r3
 969    offset of stack on overflow 8/16
 970    for varargs, must go by type.
 971    power open:
 972    float in r3&r4, int in r5
 973    offset of stack on overflow different
 974    both:
 975    return in r3 or f0.  If no float, must study how gcc emulates floats;
 976    pay attention to arg promotion.
 977    User may have to cast\args to handle promotion correctly
 978    since gdb won't know if prototype supplied or not.
 979  */
 980
 981   for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
 982     {
 983       int reg_size = REGISTER_RAW_SIZE (ii + 3);
 984
 985       arg = args[argno];
 986       type = check_typedef (VALUE_TYPE (arg));
 987       len = TYPE_LENGTH (type);
 988
 989       if (TYPE_CODE (type) == TYPE_CODE_FLT)
 990         {
 991
 992           /* floating point arguments are passed in fpr's, as well as gpr's.
 993              There are 13 fpr's reserved for passing parameters. At this point
 994              there is no way we would run out of them. */
 995
 996           if (len > 8)
 997             printf_unfiltered (
 998                                 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 999
1000           memcpy (&registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
1001                   VALUE_CONTENTS (arg),
1002                   len);
1003           ++f_argno;
1004         }
1005
1006       if (len > reg_size)
1007         {
1008
1009           /* Argument takes more than one register. */
1010           while (argbytes < len)
1011             {
1012               memset (&registers[REGISTER_BYTE (ii + 3)], 0, reg_size);
1013               memcpy (&registers[REGISTER_BYTE (ii + 3)],
1014                       ((char *) VALUE_CONTENTS (arg)) + argbytes,
1015                       (len - argbytes) > reg_size
1016                         ? reg_size : len - argbytes);
1017               ++ii, argbytes += reg_size;
1018
1019               if (ii >= 8)
1020                 goto ran_out_of_registers_for_arguments;
1021             }
1022           argbytes = 0;
1023           --ii;
1024         }
1025       else
1026         {                       /* Argument can fit in one register. No problem. */
1027           int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0;
1028           memset (&registers[REGISTER_BYTE (ii + 3)], 0, reg_size);
1029           memcpy ((char *)&registers[REGISTER_BYTE (ii + 3)] + adj,
1030                   VALUE_CONTENTS (arg), len);
1031         }
1032       ++argno;
1033     }
1034
1035 ran_out_of_registers_for_arguments:
1036
1037   saved_sp = read_sp ();
1038
1039   /* location for 8 parameters are always reserved. */
1040   sp -= wordsize * 8;
1041
1042   /* another six words for back chain, TOC register, link register, etc. */
1043   sp -= wordsize * 6;
1044
1045   /* stack pointer must be quadword aligned */
1046   sp &= -16;
1047
1048   /* if there are more arguments, allocate space for them in
1049      the stack, then push them starting from the ninth one. */
1050
1051   if ((argno < nargs) || argbytes)
1052     {
1053       int space = 0, jj;
1054
1055       if (argbytes)
1056         {
1057           space += ((len - argbytes + 3) & -4);
1058           jj = argno + 1;
1059         }
1060       else
1061         jj = argno;
1062
1063       for (; jj < nargs; ++jj)
1064         {
1065           struct value *val = args[jj];
1066           space += ((TYPE_LENGTH (VALUE_TYPE (val))) + 3) & -4;
1067         }
1068
1069       /* add location required for the rest of the parameters */
1070       space = (space + 15) & -16;
1071       sp -= space;
1072
1073       /* This is another instance we need to be concerned about securing our
1074          stack space. If we write anything underneath %sp (r1), we might conflict
1075          with the kernel who thinks he is free to use this area. So, update %sp
1076          first before doing anything else. */
1077
1078       write_register (SP_REGNUM, sp);
1079
1080       /* if the last argument copied into the registers didn't fit there
1081          completely, push the rest of it into stack. */
1082
1083       if (argbytes)
1084         {
1085           write_memory (sp + 24 + (ii * 4),
1086                         ((char *) VALUE_CONTENTS (arg)) + argbytes,
1087                         len - argbytes);
1088           ++argno;
1089           ii += ((len - argbytes + 3) & -4) / 4;
1090         }
1091
1092       /* push the rest of the arguments into stack. */
1093       for (; argno < nargs; ++argno)
1094         {
1095
1096           arg = args[argno];
1097           type = check_typedef (VALUE_TYPE (arg));
1098           len = TYPE_LENGTH (type);
1099
1100
1101           /* float types should be passed in fpr's, as well as in the stack. */
1102           if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
1103             {
1104
1105               if (len > 8)
1106                 printf_unfiltered (
1107                                     "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
1108
1109               memcpy (&registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
1110                       VALUE_CONTENTS (arg),
1111                       len);
1112               ++f_argno;
1113             }
1114
1115           write_memory (sp + 24 + (ii * 4), (char *) VALUE_CONTENTS (arg), len);
1116           ii += ((len + 3) & -4) / 4;
1117         }
1118     }
1119   else
1120     /* Secure stack areas first, before doing anything else. */
1121     write_register (SP_REGNUM, sp);
1122
1123   /* set back chain properly */
1124   store_address (tmp_buffer, 4, saved_sp);
1125   write_memory (sp, tmp_buffer, 4);
1126
1127   target_store_registers (-1);
1128   return sp;
1129 }
1130
1131 /* Function: ppc_push_return_address (pc, sp)
1132    Set up the return address for the inferior function call. */
1133
1134 static CORE_ADDR
1135 ppc_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1136 {
1137   write_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum,
1138                   CALL_DUMMY_ADDRESS ());
1139   return sp;
1140 }
1141
1142 /* Extract a function return value of type TYPE from raw register array
1143    REGBUF, and copy that return value into VALBUF in virtual format. */
1144
1145 static void
1146 rs6000_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
1147 {
1148   int offset = 0;
1149   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1150
1151   if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
1152     {
1153
1154       double dd;
1155       float ff;
1156       /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
1157          We need to truncate the return value into float size (4 byte) if
1158          necessary. */
1159
1160       if (TYPE_LENGTH (valtype) > 4)    /* this is a double */
1161         memcpy (valbuf,
1162                 &regbuf[REGISTER_BYTE (FP0_REGNUM + 1)],
1163                 TYPE_LENGTH (valtype));
1164       else
1165         {                       /* float */
1166           memcpy (&dd, &regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], 8);
1167           ff = (float) dd;
1168           memcpy (valbuf, &ff, sizeof (float));
1169         }
1170     }
1171   else if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1172            && TYPE_LENGTH (valtype) == 16
1173            && TYPE_VECTOR (valtype))
1174     {
1175       memcpy (valbuf, regbuf + REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
1176               TYPE_LENGTH (valtype));
1177     }
1178   else
1179     {
1180       /* return value is copied starting from r3. */
1181       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
1182           && TYPE_LENGTH (valtype) < REGISTER_RAW_SIZE (3))
1183         offset = REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype);
1184
1185       memcpy (valbuf,
1186               regbuf + REGISTER_BYTE (3) + offset,
1187               TYPE_LENGTH (valtype));
1188     }
1189 }
1190
1191 /* Keep structure return address in this variable.
1192    FIXME:  This is a horrid kludge which should not be allowed to continue
1193    living.  This only allows a single nested call to a structure-returning
1194    function.  Come on, guys!  -- [email protected], Aug 92  */
1195
1196 static CORE_ADDR rs6000_struct_return_address;
1197
1198 /* Return whether handle_inferior_event() should proceed through code
1199    starting at PC in function NAME when stepping.
1200
1201    The AIX -bbigtoc linker option generates functions @FIX0, @FIX1, etc. to
1202    handle memory references that are too distant to fit in instructions
1203    generated by the compiler.  For example, if 'foo' in the following
1204    instruction:
1205
1206      lwz r9,foo(r2)
1207
1208    is greater than 32767, the linker might replace the lwz with a branch to
1209    somewhere in @FIX1 that does the load in 2 instructions and then branches
1210    back to where execution should continue.
1211
1212    GDB should silently step over @FIX code, just like AIX dbx does.
1213    Unfortunately, the linker uses the "b" instruction for the branches,
1214    meaning that the link register doesn't get set.  Therefore, GDB's usual
1215    step_over_function() mechanism won't work.
1216
1217    Instead, use the IN_SOLIB_RETURN_TRAMPOLINE and SKIP_TRAMPOLINE_CODE hooks
1218    in handle_inferior_event() to skip past @FIX code.  */
1219
1220 int
1221 rs6000_in_solib_return_trampoline (CORE_ADDR pc, char *name)
1222 {
1223   return name && !strncmp (name, "@FIX", 4);
1224 }
1225
1226 /* Skip code that the user doesn't want to see when stepping:
1227
1228    1. Indirect function calls use a piece of trampoline code to do context
1229    switching, i.e. to set the new TOC table.  Skip such code if we are on
1230    its first instruction (as when we have single-stepped to here).
1231
1232    2. Skip shared library trampoline code (which is different from
1233    indirect function call trampolines).
1234
1235    3. Skip bigtoc fixup code.
1236
1237    Result is desired PC to step until, or NULL if we are not in
1238    code that should be skipped.  */
1239
1240 CORE_ADDR
1241 rs6000_skip_trampoline_code (CORE_ADDR pc)
1242 {
1243   register unsigned int ii, op;
1244   int rel;
1245   CORE_ADDR solib_target_pc;
1246   struct minimal_symbol *msymbol;
1247
1248   static unsigned trampoline_code[] =
1249   {
1250     0x800b0000,                 /*     l   r0,0x0(r11)  */
1251     0x90410014,                 /*    st   r2,0x14(r1)  */
1252     0x7c0903a6,                 /* mtctr   r0           */
1253     0x804b0004,                 /*     l   r2,0x4(r11)  */
1254     0x816b0008,                 /*     l  r11,0x8(r11)  */
1255     0x4e800420,                 /*  bctr                */
1256     0x4e800020,                 /*    br                */
1257     0
1258   };
1259
1260   /* Check for bigtoc fixup code.  */
1261   msymbol = lookup_minimal_symbol_by_pc (pc);
1262   if (msymbol && rs6000_in_solib_return_trampoline (pc, SYMBOL_NAME (msymbol)))
1263     {
1264       /* Double-check that the third instruction from PC is relative "b".  */
1265       op = read_memory_integer (pc + 8, 4);
1266       if ((op & 0xfc000003) == 0x48000000)
1267         {
1268           /* Extract bits 6-29 as a signed 24-bit relative word address and
1269              add it to the containing PC.  */
1270           rel = ((int)(op << 6) >> 6);
1271           return pc + 8 + rel;
1272         }
1273     }
1274
1275   /* If pc is in a shared library trampoline, return its target.  */
1276   solib_target_pc = find_solib_trampoline_target (pc);
1277   if (solib_target_pc)
1278     return solib_target_pc;
1279
1280   for (ii = 0; trampoline_code[ii]; ++ii)
1281     {
1282       op = read_memory_integer (pc + (ii * 4), 4);
1283       if (op != trampoline_code[ii])
1284         return 0;
1285     }
1286   ii = read_register (11);      /* r11 holds destination addr   */
1287   pc = read_memory_addr (ii, TDEP->wordsize); /* (r11) value */
1288   return pc;
1289 }
1290
1291 /* Determines whether the function FI has a frame on the stack or not.  */
1292
1293 int
1294 rs6000_frameless_function_invocation (struct frame_info *fi)
1295 {
1296   CORE_ADDR func_start;
1297   struct rs6000_framedata fdata;
1298
1299   /* Don't even think about framelessness except on the innermost frame
1300      or if the function was interrupted by a signal.  */
1301   if (fi->next != NULL && !fi->next->signal_handler_caller)
1302     return 0;
1303
1304   func_start = get_pc_function_start (fi->pc);
1305
1306   /* If we failed to find the start of the function, it is a mistake
1307      to inspect the instructions. */
1308
1309   if (!func_start)
1310     {
1311       /* A frame with a zero PC is usually created by dereferencing a NULL
1312          function pointer, normally causing an immediate core dump of the
1313          inferior. Mark function as frameless, as the inferior has no chance
1314          of setting up a stack frame.  */
1315       if (fi->pc == 0)
1316         return 1;
1317       else
1318         return 0;
1319     }
1320
1321   (void) skip_prologue (func_start, fi->pc, &fdata);
1322   return fdata.frameless;
1323 }
1324
1325 /* Return the PC saved in a frame */
1326
1327 CORE_ADDR
1328 rs6000_frame_saved_pc (struct frame_info *fi)
1329 {
1330   CORE_ADDR func_start;
1331   struct rs6000_framedata fdata;
1332   struct gdbarch_tdep *tdep = TDEP;
1333   int wordsize = tdep->wordsize;
1334
1335   if (fi->signal_handler_caller)
1336     return read_memory_addr (fi->frame + SIG_FRAME_PC_OFFSET, wordsize);
1337
1338   if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
1339     return generic_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
1340
1341   func_start = get_pc_function_start (fi->pc);
1342
1343   /* If we failed to find the start of the function, it is a mistake
1344      to inspect the instructions. */
1345   if (!func_start)
1346     return 0;
1347
1348   (void) skip_prologue (func_start, fi->pc, &fdata);
1349
1350   if (fdata.lr_offset == 0 && fi->next != NULL)
1351     {
1352       if (fi->next->signal_handler_caller)
1353         return read_memory_addr (fi->next->frame + SIG_FRAME_LR_OFFSET,
1354                                  wordsize);
1355       else
1356         return read_memory_addr (FRAME_CHAIN (fi) + tdep->lr_frame_offset,
1357                                  wordsize);
1358     }
1359
1360   if (fdata.lr_offset == 0)
1361     return read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
1362
1363   return read_memory_addr (FRAME_CHAIN (fi) + fdata.lr_offset, wordsize);
1364 }
1365
1366 /* If saved registers of frame FI are not known yet, read and cache them.
1367    &FDATAP contains rs6000_framedata; TDATAP can be NULL,
1368    in which case the framedata are read.  */
1369
1370 static void
1371 frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
1372 {
1373   CORE_ADDR frame_addr;
1374   struct rs6000_framedata work_fdata;
1375   struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch);
1376   int wordsize = tdep->wordsize;
1377
1378   if (fi->saved_regs)
1379     return;
1380
1381   if (fdatap == NULL)
1382     {
1383       fdatap = &work_fdata;
1384       (void) skip_prologue (get_pc_function_start (fi->pc), fi->pc, fdatap);
1385     }
1386
1387   frame_saved_regs_zalloc (fi);
1388
1389   /* If there were any saved registers, figure out parent's stack
1390      pointer. */
1391   /* The following is true only if the frame doesn't have a call to
1392      alloca(), FIXME. */
1393
1394   if (fdatap->saved_fpr == 0
1395       && fdatap->saved_gpr == 0
1396       && fdatap->saved_vr == 0
1397       && fdatap->lr_offset == 0
1398       && fdatap->cr_offset == 0
1399       && fdatap->vr_offset == 0)
1400     frame_addr = 0;
1401   else
1402     /* NOTE: cagney/2002-04-14: The ->frame points to the inner-most
1403        address of the current frame.  Things might be easier if the
1404        ->frame pointed to the outer-most address of the frame.  In the
1405        mean time, the address of the prev frame is used as the base
1406        address of this frame.  */
1407     frame_addr = FRAME_CHAIN (fi);
1408
1409   /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
1410      All fpr's from saved_fpr to fp31 are saved.  */
1411
1412   if (fdatap->saved_fpr >= 0)
1413     {
1414       int i;
1415       CORE_ADDR fpr_addr = frame_addr + fdatap->fpr_offset;
1416       for (i = fdatap->saved_fpr; i < 32; i++)
1417         {
1418           fi->saved_regs[FP0_REGNUM + i] = fpr_addr;
1419           fpr_addr += 8;
1420         }
1421     }
1422
1423   /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
1424      All gpr's from saved_gpr to gpr31 are saved.  */
1425
1426   if (fdatap->saved_gpr >= 0)
1427     {
1428       int i;
1429       CORE_ADDR gpr_addr = frame_addr + fdatap->gpr_offset;
1430       for (i = fdatap->saved_gpr; i < 32; i++)
1431         {
1432           fi->saved_regs[i] = gpr_addr;
1433           gpr_addr += wordsize;
1434         }
1435     }
1436
1437   /* if != -1, fdatap->saved_vr is the smallest number of saved_vr.
1438      All vr's from saved_vr to vr31 are saved.  */
1439   if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
1440     {
1441       if (fdatap->saved_vr >= 0)
1442         {
1443           int i;
1444           CORE_ADDR vr_addr = frame_addr + fdatap->vr_offset;
1445           for (i = fdatap->saved_vr; i < 32; i++)
1446             {
1447               fi->saved_regs[tdep->ppc_vr0_regnum + i] = vr_addr;
1448               vr_addr += REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
1449             }
1450         }
1451     }
1452
1453   /* If != 0, fdatap->cr_offset is the offset from the frame that holds
1454      the CR.  */
1455   if (fdatap->cr_offset != 0)
1456     fi->saved_regs[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset;
1457
1458   /* If != 0, fdatap->lr_offset is the offset from the frame that holds
1459      the LR.  */
1460   if (fdatap->lr_offset != 0)
1461     fi->saved_regs[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset;
1462
1463   /* If != 0, fdatap->vrsave_offset is the offset from the frame that holds
1464      the VRSAVE.  */
1465   if (fdatap->vrsave_offset != 0)
1466     fi->saved_regs[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset;
1467 }
1468
1469 /* Return the address of a frame. This is the inital %sp value when the frame
1470    was first allocated. For functions calling alloca(), it might be saved in
1471    an alloca register. */
1472
1473 static CORE_ADDR
1474 frame_initial_stack_address (struct frame_info *fi)
1475 {
1476   CORE_ADDR tmpaddr;
1477   struct rs6000_framedata fdata;
1478   struct frame_info *callee_fi;
1479
1480   /* if the initial stack pointer (frame address) of this frame is known,
1481      just return it. */
1482
1483   if (fi->extra_info->initial_sp)
1484     return fi->extra_info->initial_sp;
1485
1486   /* find out if this function is using an alloca register.. */
1487
1488   (void) skip_prologue (get_pc_function_start (fi->pc), fi->pc, &fdata);
1489
1490   /* if saved registers of this frame are not known yet, read and cache them. */
1491
1492   if (!fi->saved_regs)
1493     frame_get_saved_regs (fi, &fdata);
1494
1495   /* If no alloca register used, then fi->frame is the value of the %sp for
1496      this frame, and it is good enough. */
1497
1498   if (fdata.alloca_reg < 0)
1499     {
1500       fi->extra_info->initial_sp = fi->frame;
1501       return fi->extra_info->initial_sp;
1502     }
1503
1504   /* There is an alloca register, use its value, in the current frame,
1505      as the initial stack pointer.  */
1506   {
1507     char *tmpbuf = alloca (MAX_REGISTER_RAW_SIZE);
1508     if (frame_register_read (fi, fdata.alloca_reg, tmpbuf))
1509       {
1510         fi->extra_info->initial_sp
1511           = extract_unsigned_integer (tmpbuf,
1512                                       REGISTER_RAW_SIZE (fdata.alloca_reg));
1513       }
1514     else
1515       /* NOTE: cagney/2002-04-17: At present the only time
1516          frame_register_read will fail is when the register isn't
1517          available.  If that does happen, use the frame.  */
1518       fi->extra_info->initial_sp = fi->frame;
1519   }
1520   return fi->extra_info->initial_sp;
1521 }
1522
1523 /* Describe the pointer in each stack frame to the previous stack frame
1524    (its caller).  */
1525
1526 /* FRAME_CHAIN takes a frame's nominal address
1527    and produces the frame's chain-pointer. */
1528
1529 /* In the case of the RS/6000, the frame's nominal address
1530    is the address of a 4-byte word containing the calling frame's address.  */
1531
1532 CORE_ADDR
1533 rs6000_frame_chain (struct frame_info *thisframe)
1534 {
1535   CORE_ADDR fp, fpp, lr;
1536   int wordsize = TDEP->wordsize;
1537
1538   if (PC_IN_CALL_DUMMY (thisframe->pc, thisframe->frame, thisframe->frame))
1539     return thisframe->frame;    /* dummy frame same as caller's frame */
1540
1541   if (inside_entry_file (thisframe->pc) ||
1542       thisframe->pc == entry_point_address ())
1543     return 0;
1544
1545   if (thisframe->signal_handler_caller)
1546     fp = read_memory_addr (thisframe->frame + SIG_FRAME_FP_OFFSET,
1547                               wordsize);
1548   else if (thisframe->next != NULL
1549            && thisframe->next->signal_handler_caller
1550            && FRAMELESS_FUNCTION_INVOCATION (thisframe))
1551     /* A frameless function interrupted by a signal did not change the
1552        frame pointer.  */
1553     fp = FRAME_FP (thisframe);
1554   else
1555     fp = read_memory_addr ((thisframe)->frame, wordsize);
1556
1557   lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
1558   if (lr == entry_point_address ())
1559     if (fp != 0 && (fpp = read_memory_addr (fp, wordsize)) != 0)
1560       if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
1561         return fpp;
1562
1563   return fp;
1564 }
1565
1566 /* Return the size of register REG when words are WORDSIZE bytes long.  If REG
1567    isn't available with that word size, return 0. */
1568
1569 static int
1570 regsize (const struct reg *reg, int wordsize)
1571 {
1572   return wordsize == 8 ? reg->sz64 : reg->sz32;
1573 }
1574
1575 /* Return the name of register number N, or null if no such register exists
1576    in the current architecture. */
1577
1578 static const char *
1579 rs6000_register_name (int n)
1580 {
1581   struct gdbarch_tdep *tdep = TDEP;
1582   const struct reg *reg = tdep->regs + n;
1583
1584   if (!regsize (reg, tdep->wordsize))
1585     return NULL;
1586   return reg->name;
1587 }
1588
1589 /* Index within `registers' of the first byte of the space for
1590    register N.  */
1591
1592 static int
1593 rs6000_register_byte (int n)
1594 {
1595   return TDEP->regoff[n];
1596 }
1597
1598 /* Return the number of bytes of storage in the actual machine representation
1599    for register N if that register is available, else return 0. */
1600
1601 static int
1602 rs6000_register_raw_size (int n)
1603 {
1604   struct gdbarch_tdep *tdep = TDEP;
1605   const struct reg *reg = tdep->regs + n;
1606   return regsize (reg, tdep->wordsize);
1607 }
1608
1609 /* Return the GDB type object for the "standard" data type
1610    of data in register N.  */
1611
1612 static struct type *
1613 rs6000_register_virtual_type (int n)
1614 {
1615   struct gdbarch_tdep *tdep = TDEP;
1616   const struct reg *reg = tdep->regs + n;
1617
1618   if (reg->fpr)
1619     return builtin_type_double;
1620   else
1621     {
1622       int size = regsize (reg, tdep->wordsize);
1623       switch (size)
1624         {
1625         case 8:
1626           return builtin_type_int64;
1627           break;
1628         case 16:
1629           return builtin_type_vec128;
1630           break;
1631         default:
1632           return builtin_type_int32;
1633           break;
1634         }
1635     }
1636 }
1637
1638 /* For the PowerPC, it appears that the debug info marks float parameters as
1639    floats regardless of whether the function is prototyped, but the actual
1640    values are always passed in as doubles.  Tell gdb to always assume that
1641    floats are passed as doubles and then converted in the callee. */
1642
1643 static int
1644 rs6000_coerce_float_to_double (struct type *formal, struct type *actual)
1645 {
1646   return 1;
1647 }
1648
1649 /* Return whether register N requires conversion when moving from raw format
1650    to virtual format.
1651
1652    The register format for RS/6000 floating point registers is always
1653    double, we need a conversion if the memory format is float. */
1654
1655 static int
1656 rs6000_register_convertible (int n)
1657 {
1658   const struct reg *reg = TDEP->regs + n;
1659   return reg->fpr;
1660 }
1661
1662 /* Convert data from raw format for register N in buffer FROM
1663    to virtual format with type TYPE in buffer TO. */
1664
1665 static void
1666 rs6000_register_convert_to_virtual (int n, struct type *type,
1667                                     char *from, char *to)
1668 {
1669   if (TYPE_LENGTH (type) != REGISTER_RAW_SIZE (n))
1670     {
1671       double val = extract_floating (from, REGISTER_RAW_SIZE (n));
1672       store_floating (to, TYPE_LENGTH (type), val);
1673     }
1674   else
1675     memcpy (to, from, REGISTER_RAW_SIZE (n));
1676 }
1677
1678 /* Convert data from virtual format with type TYPE in buffer FROM
1679    to raw format for register N in buffer TO. */
1680
1681 static void
1682 rs6000_register_convert_to_raw (struct type *type, int n,
1683                                 char *from, char *to)
1684 {
1685   if (TYPE_LENGTH (type) != REGISTER_RAW_SIZE (n))
1686     {
1687       double val = extract_floating (from, TYPE_LENGTH (type));
1688       store_floating (to, REGISTER_RAW_SIZE (n), val);
1689     }
1690   else
1691     memcpy (to, from, REGISTER_RAW_SIZE (n));
1692 }
1693
1694 int
1695 altivec_register_p (int regno)
1696 {
1697   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1698   if (tdep->ppc_vr0_regnum < 0 || tdep->ppc_vrsave_regnum < 0)
1699     return 0;
1700   else
1701     return (regno >= tdep->ppc_vr0_regnum && regno <= tdep->ppc_vrsave_regnum);
1702 }
1703
1704 static void
1705 rs6000_do_altivec_registers (int regnum)
1706 {
1707   int i;
1708   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
1709   char *virtual_buffer = (char*) alloca (MAX_REGISTER_VIRTUAL_SIZE);
1710   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1711
1712   for (i = tdep->ppc_vr0_regnum; i <= tdep->ppc_vrsave_regnum; i++)
1713     {
1714       /* If we want just one reg, check that this is the one we want. */
1715       if (regnum != -1 && i != regnum)
1716         continue;
1717
1718       /* If the register name is empty, it is undefined for this
1719          processor, so don't display anything.  */
1720       if (REGISTER_NAME (i) == NULL || *(REGISTER_NAME (i)) == '\0')
1721         continue;
1722
1723       fputs_filtered (REGISTER_NAME (i), gdb_stdout);
1724       print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), gdb_stdout);
1725
1726       /* Get the data in raw format.  */
1727       if (!frame_register_read (selected_frame, i, raw_buffer))
1728         {
1729           printf_filtered ("*value not available*\n");
1730           continue;
1731         }
1732
1733       /* Convert raw data to virtual format if necessary.  */
1734       if (REGISTER_CONVERTIBLE (i))
1735         REGISTER_CONVERT_TO_VIRTUAL (i, REGISTER_VIRTUAL_TYPE (i),
1736                                      raw_buffer, virtual_buffer);
1737       else
1738         memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (i));
1739
1740       /* Print as integer in hex only.  */
1741       val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
1742                  gdb_stdout, 'x', 1, 0, Val_pretty_default);
1743       printf_filtered ("\n");
1744     }
1745 }
1746
1747 static void
1748 rs6000_altivec_registers_info (char *addr_exp, int from_tty)
1749 {
1750   int regnum, numregs;
1751   register char *end;
1752
1753   if (!target_has_registers)
1754     error ("The program has no registers now.");
1755   if (selected_frame == NULL)
1756     error ("No selected frame.");
1757
1758   if (!addr_exp)
1759     {
1760       rs6000_do_altivec_registers (-1);
1761       return;
1762     }
1763
1764   numregs = NUM_REGS + NUM_PSEUDO_REGS;
1765   do
1766     {
1767       if (addr_exp[0] == '$')
1768         addr_exp++;
1769       end = addr_exp;
1770       while (*end != '\0' && *end != ' ' && *end != '\t')
1771         ++end;
1772
1773       regnum = target_map_name_to_register (addr_exp, end - addr_exp);
1774       if (regnum < 0)
1775         {
1776           regnum = numregs;
1777           if (*addr_exp >= '0' && *addr_exp <= '9')
1778             regnum = atoi (addr_exp);   /* Take a number */
1779           if (regnum >= numregs)        /* Bad name, or bad number */
1780             error ("%.*s: invalid register", end - addr_exp, addr_exp);
1781         }
1782
1783       rs6000_do_altivec_registers (regnum);
1784
1785       addr_exp = end;
1786       while (*addr_exp == ' ' || *addr_exp == '\t')
1787         ++addr_exp;
1788     }
1789   while (*addr_exp != '\0');
1790 }
1791
1792 static void
1793 rs6000_do_registers_info (int regnum, int fpregs)
1794 {
1795   register int i;
1796   int numregs = NUM_REGS + NUM_PSEUDO_REGS;
1797   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
1798   char *virtual_buffer = (char*) alloca (MAX_REGISTER_VIRTUAL_SIZE);
1799
1800   for (i = 0; i < numregs; i++)
1801     {
1802       /* Decide between printing all regs, nonfloat regs, or specific reg.  */
1803       if (regnum == -1)
1804         {
1805           if ((TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT && !fpregs)
1806               || (altivec_register_p (i) && !fpregs))
1807             continue;
1808         }
1809       else
1810         {
1811           if (i != regnum)
1812             continue;
1813         }
1814
1815       /* If the register name is empty, it is undefined for this
1816          processor, so don't display anything.  */
1817       if (REGISTER_NAME (i) == NULL || *(REGISTER_NAME (i)) == '\0')
1818         continue;
1819
1820       fputs_filtered (REGISTER_NAME (i), gdb_stdout);
1821       print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), gdb_stdout);
1822
1823       /* Get the data in raw format.  */
1824       if (!frame_register_read (selected_frame, i, raw_buffer))
1825         {
1826           printf_filtered ("*value not available*\n");
1827           continue;
1828         }
1829
1830       /* Convert raw data to virtual format if necessary.  */
1831       if (REGISTER_CONVERTIBLE (i))
1832         REGISTER_CONVERT_TO_VIRTUAL (i, REGISTER_VIRTUAL_TYPE (i),
1833                                      raw_buffer, virtual_buffer);
1834       else
1835         memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (i));
1836
1837       /* If virtual format is floating, print it that way, and in raw hex.  */
1838       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
1839         {
1840           register int j;
1841
1842           val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
1843                      gdb_stdout, 0, 1, 0, Val_pretty_default);
1844
1845           printf_filtered ("\t(raw 0x");
1846           for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
1847             {
1848               register int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
1849                 : REGISTER_RAW_SIZE (i) - 1 - j;
1850               printf_filtered ("%02x", (unsigned char) raw_buffer[idx]);
1851             }
1852           printf_filtered (")");
1853         }
1854       else
1855         {
1856           /* Print the register in hex.  */
1857           val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
1858                      gdb_stdout, 'x', 1, 0, Val_pretty_default);
1859           /* If not a vector register, print it also in decimal.  */
1860           if (!altivec_register_p (i))
1861             {
1862               printf_filtered ("\t");
1863               val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
1864                          gdb_stdout, 0, 1, 0, Val_pretty_default);
1865             }
1866         }
1867       printf_filtered ("\n");
1868     }
1869 }
1870
1871 /* Convert a dbx stab register number (from `r' declaration) to a gdb
1872    REGNUM. */
1873 static int
1874 rs6000_stab_reg_to_regnum (int num)
1875 {
1876   int regnum;
1877   switch (num)
1878     {
1879     case 64:
1880       regnum = gdbarch_tdep (current_gdbarch)->ppc_mq_regnum;
1881       break;
1882     case 65:
1883       regnum = gdbarch_tdep (current_gdbarch)->ppc_lr_regnum;
1884       break;
1885     case 66:
1886       regnum = gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum;
1887       break;
1888     case 76:
1889       regnum = gdbarch_tdep (current_gdbarch)->ppc_xer_regnum;
1890       break;
1891     default:
1892       regnum = num;
1893       break;
1894     }
1895   return regnum;
1896 }
1897
1898 /* Store the address of the place in which to copy the structure the
1899    subroutine will return.  This is called from call_function.
1900
1901    In RS/6000, struct return addresses are passed as an extra parameter in r3.
1902    In function return, callee is not responsible of returning this address
1903    back.  Since gdb needs to find it, we will store in a designated variable
1904    `rs6000_struct_return_address'. */
1905
1906 static void
1907 rs6000_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1908 {
1909   write_register (3, addr);
1910   rs6000_struct_return_address = addr;
1911 }
1912
1913 /* Write into appropriate registers a function return value
1914    of type TYPE, given in virtual format.  */
1915
1916 static void
1917 rs6000_store_return_value (struct type *type, char *valbuf)
1918 {
1919   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1920
1921   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1922
1923     /* Floating point values are returned starting from FPR1 and up.
1924        Say a double_double_double type could be returned in
1925        FPR1/FPR2/FPR3 triple. */
1926
1927     write_register_bytes (REGISTER_BYTE (FP0_REGNUM + 1), valbuf,
1928                           TYPE_LENGTH (type));
1929   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1930     {
1931       if (TYPE_LENGTH (type) == 16
1932           && TYPE_VECTOR (type))
1933         write_register_bytes (REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
1934                               valbuf, TYPE_LENGTH (type));
1935     }
1936   else
1937     /* Everything else is returned in GPR3 and up. */
1938     write_register_bytes (REGISTER_BYTE (gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3),
1939                           valbuf, TYPE_LENGTH (type));
1940 }
1941
1942 /* Extract from an array REGBUF containing the (raw) register state
1943    the address in which a function should return its structure value,
1944    as a CORE_ADDR (or an expression that can be used as one).  */
1945
1946 static CORE_ADDR
1947 rs6000_extract_struct_value_address (char *regbuf)
1948 {
1949   return rs6000_struct_return_address;
1950 }
1951
1952 /* Return whether PC is in a dummy function call.
1953
1954    FIXME: This just checks for the end of the stack, which is broken
1955    for things like stepping through gcc nested function stubs. */
1956
1957 static int
1958 rs6000_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
1959 {
1960   return sp < pc && pc < fp;
1961 }
1962
1963 /* Hook called when a new child process is started. */
1964
1965 void
1966 rs6000_create_inferior (int pid)
1967 {
1968   if (rs6000_set_host_arch_hook)
1969     rs6000_set_host_arch_hook (pid);
1970 }
1971 \f
1972 /* Support for CONVERT_FROM_FUNC_PTR_ADDR(ADDR).
1973
1974    Usually a function pointer's representation is simply the address
1975    of the function. On the RS/6000 however, a function pointer is
1976    represented by a pointer to a TOC entry. This TOC entry contains
1977    three words, the first word is the address of the function, the
1978    second word is the TOC pointer (r2), and the third word is the
1979    static chain value.  Throughout GDB it is currently assumed that a
1980    function pointer contains the address of the function, which is not
1981    easy to fix.  In addition, the conversion of a function address to
1982    a function pointer would require allocation of a TOC entry in the
1983    inferior's memory space, with all its drawbacks.  To be able to
1984    call C++ virtual methods in the inferior (which are called via
1985    function pointers), find_function_addr uses this function to get the
1986    function address from a function pointer.  */
1987
1988 /* Return real function address if ADDR (a function pointer) is in the data
1989    space and is therefore a special function pointer.  */
1990
1991 CORE_ADDR
1992 rs6000_convert_from_func_ptr_addr (CORE_ADDR addr)
1993 {
1994   struct obj_section *s;
1995
1996   s = find_pc_section (addr);
1997   if (s && s->the_bfd_section->flags & SEC_CODE)
1998     return addr;
1999
2000   /* ADDR is in the data space, so it's a special function pointer. */
2001   return read_memory_addr (addr, TDEP->wordsize);
2002 }
2003 \f
2004
2005 /* Handling the various POWER/PowerPC variants.  */
2006
2007
2008 /* The arrays here called registers_MUMBLE hold information about available
2009    registers.
2010
2011    For each family of PPC variants, I've tried to isolate out the
2012    common registers and put them up front, so that as long as you get
2013    the general family right, GDB will correctly identify the registers
2014    common to that family.  The common register sets are:
2015
2016    For the 60x family: hid0 hid1 iabr dabr pir
2017
2018    For the 505 and 860 family: eie eid nri
2019
2020    For the 403 and 403GC: icdbdr esr dear evpr cdbcr tsr tcr pit tbhi
2021    tblo srr2 srr3 dbsr dbcr iac1 iac2 dac1 dac2 dccr iccr pbl1
2022    pbu1 pbl2 pbu2
2023
2024    Most of these register groups aren't anything formal.  I arrived at
2025    them by looking at the registers that occurred in more than one
2026    processor.
2027
2028    Note: kevinb/2002-04-30: Support for the fpscr register was added
2029    during April, 2002.  Slot 70 is being used for PowerPC and slot 71
2030    for Power.  For PowerPC, slot 70 was unused and was already in the
2031    PPC_UISA_SPRS which is ideally where fpscr should go.  For Power,
2032    slot 70 was being used for "mq", so the next available slot (71)
2033    was chosen.  It would have been nice to be able to make the
2034    register numbers the same across processor cores, but this wasn't
2035    possible without either 1) renumbering some registers for some
2036    processors or 2) assigning fpscr to a really high slot that's
2037    larger than any current register number.  Doing (1) is bad because
2038    existing stubs would break.  Doing (2) is undesirable because it
2039    would introduce a really large gap between fpscr and the rest of
2040    the registers for most processors.  */
2041
2042 /* Convenience macros for populating register arrays. */
2043
2044 /* Within another macro, convert S to a string. */
2045
2046 #define STR(s)  #s
2047
2048 /* Return a struct reg defining register NAME that's 32 bits on 32-bit systems
2049    and 64 bits on 64-bit systems. */
2050 #define R(name)         { STR(name), 4, 8, 0 }
2051
2052 /* Return a struct reg defining register NAME that's 32 bits on all
2053    systems. */
2054 #define R4(name)        { STR(name), 4, 4, 0 }
2055
2056 /* Return a struct reg defining register NAME that's 64 bits on all
2057    systems. */
2058 #define R8(name)        { STR(name), 8, 8, 0 }
2059
2060 /* Return a struct reg defining register NAME that's 128 bits on all
2061    systems. */
2062 #define R16(name)       { STR(name), 16, 16, 0 }
2063
2064 /* Return a struct reg defining floating-point register NAME. */
2065 #define F(name)         { STR(name), 8, 8, 1 }
2066
2067 /* Return a struct reg defining register NAME that's 32 bits on 32-bit
2068    systems and that doesn't exist on 64-bit systems. */
2069 #define R32(name)       { STR(name), 4, 0, 0 }
2070
2071 /* Return a struct reg defining register NAME that's 64 bits on 64-bit
2072    systems and that doesn't exist on 32-bit systems. */
2073 #define R64(name)       { STR(name), 0, 8, 0 }
2074
2075 /* Return a struct reg placeholder for a register that doesn't exist. */
2076 #define R0              { 0, 0, 0, 0 }
2077
2078 /* UISA registers common across all architectures, including POWER.  */
2079
2080 #define COMMON_UISA_REGS \
2081   /*  0 */ R(r0), R(r1), R(r2), R(r3), R(r4), R(r5), R(r6), R(r7),  \
2082   /*  8 */ R(r8), R(r9), R(r10),R(r11),R(r12),R(r13),R(r14),R(r15), \
2083   /* 16 */ R(r16),R(r17),R(r18),R(r19),R(r20),R(r21),R(r22),R(r23), \
2084   /* 24 */ R(r24),R(r25),R(r26),R(r27),R(r28),R(r29),R(r30),R(r31), \
2085   /* 32 */ F(f0), F(f1), F(f2), F(f3), F(f4), F(f5), F(f6), F(f7),  \
2086   /* 40 */ F(f8), F(f9), F(f10),F(f11),F(f12),F(f13),F(f14),F(f15), \
2087   /* 48 */ F(f16),F(f17),F(f18),F(f19),F(f20),F(f21),F(f22),F(f23), \
2088   /* 56 */ F(f24),F(f25),F(f26),F(f27),F(f28),F(f29),F(f30),F(f31), \
2089   /* 64 */ R(pc), R(ps)
2090
2091 #define COMMON_UISA_NOFP_REGS \
2092   /*  0 */ R(r0), R(r1), R(r2), R(r3), R(r4), R(r5), R(r6), R(r7),  \
2093   /*  8 */ R(r8), R(r9), R(r10),R(r11),R(r12),R(r13),R(r14),R(r15), \
2094   /* 16 */ R(r16),R(r17),R(r18),R(r19),R(r20),R(r21),R(r22),R(r23), \
2095   /* 24 */ R(r24),R(r25),R(r26),R(r27),R(r28),R(r29),R(r30),R(r31), \
2096   /* 32 */ R0,    R0,    R0,    R0,    R0,    R0,    R0,    R0,     \
2097   /* 40 */ R0,    R0,    R0,    R0,    R0,    R0,    R0,    R0,     \
2098   /* 48 */ R0,    R0,    R0,    R0,    R0,    R0,    R0,    R0,     \
2099   /* 56 */ R0,    R0,    R0,    R0,    R0,    R0,    R0,    R0,     \
2100   /* 64 */ R(pc), R(ps)
2101
2102 /* UISA-level SPRs for PowerPC.  */
2103 #define PPC_UISA_SPRS \
2104   /* 66 */ R4(cr),  R(lr), R(ctr), R4(xer), R4(fpscr)
2105
2106 /* Segment registers, for PowerPC.  */
2107 #define PPC_SEGMENT_REGS \
2108   /* 71 */ R32(sr0),  R32(sr1),  R32(sr2),  R32(sr3),  \
2109   /* 75 */ R32(sr4),  R32(sr5),  R32(sr6),  R32(sr7),  \
2110   /* 79 */ R32(sr8),  R32(sr9),  R32(sr10), R32(sr11), \
2111   /* 83 */ R32(sr12), R32(sr13), R32(sr14), R32(sr15)
2112
2113 /* OEA SPRs for PowerPC.  */
2114 #define PPC_OEA_SPRS \
2115   /*  87 */ R4(pvr), \
2116   /*  88 */ R(ibat0u), R(ibat0l), R(ibat1u), R(ibat1l), \
2117   /*  92 */ R(ibat2u), R(ibat2l), R(ibat3u), R(ibat3l), \
2118   /*  96 */ R(dbat0u), R(dbat0l), R(dbat1u), R(dbat1l), \
2119   /* 100 */ R(dbat2u), R(dbat2l), R(dbat3u), R(dbat3l), \
2120   /* 104 */ R(sdr1),   R64(asr),  R(dar),    R4(dsisr), \
2121   /* 108 */ R(sprg0),  R(sprg1),  R(sprg2),  R(sprg3),  \
2122   /* 112 */ R(srr0),   R(srr1),   R(tbl),    R(tbu),    \
2123   /* 116 */ R4(dec),   R(dabr),   R4(ear)
2124
2125 /* AltiVec registers */
2126 #define PPC_ALTIVEC_REGS \
2127   /*119*/R16(vr0), R16(vr1), R16(vr2), R16(vr3), R16(vr4), R16(vr5), R16(vr6), R16(vr7),  \
2128   /*127*/R16(vr8), R16(vr9), R16(vr10),R16(vr11),R16(vr12),R16(vr13),R16(vr14),R16(vr15), \
2129   /*135*/R16(vr16),R16(vr17),R16(vr18),R16(vr19),R16(vr20),R16(vr21),R16(vr22),R16(vr23), \
2130   /*143*/R16(vr24),R16(vr25),R16(vr26),R16(vr27),R16(vr28),R16(vr29),R16(vr30),R16(vr31), \
2131   /*151*/R4(vscr), R4(vrsave)
2132
2133 /* IBM POWER (pre-PowerPC) architecture, user-level view.  We only cover
2134    user-level SPR's. */
2135 static const struct reg registers_power[] =
2136 {
2137   COMMON_UISA_REGS,
2138   /* 66 */ R4(cnd), R(lr), R(cnt), R4(xer), R4(mq),
2139   /* 71 */ R4(fpscr)
2140 };
2141
2142 /* PowerPC UISA - a PPC processor as viewed by user-level code.  A UISA-only
2143    view of the PowerPC. */
2144 static const struct reg registers_powerpc[] =
2145 {
2146   COMMON_UISA_REGS,
2147   PPC_UISA_SPRS,
2148   PPC_ALTIVEC_REGS
2149 };
2150
2151 /* PowerPC UISA - a PPC processor as viewed by user-level
2152    code, but without floating point registers.  */
2153 static const struct reg registers_powerpc_nofp[] =
2154 {
2155   COMMON_UISA_NOFP_REGS,
2156   PPC_UISA_SPRS
2157 };
2158
2159 /* IBM PowerPC 403. */
2160 static const struct reg registers_403[] =
2161 {
2162   COMMON_UISA_REGS,
2163   PPC_UISA_SPRS,
2164   PPC_SEGMENT_REGS,
2165   PPC_OEA_SPRS,
2166   /* 119 */ R(icdbdr), R(esr),  R(dear), R(evpr),
2167   /* 123 */ R(cdbcr),  R(tsr),  R(tcr),  R(pit),
2168   /* 127 */ R(tbhi),   R(tblo), R(srr2), R(srr3),
2169   /* 131 */ R(dbsr),   R(dbcr), R(iac1), R(iac2),
2170   /* 135 */ R(dac1),   R(dac2), R(dccr), R(iccr),
2171   /* 139 */ R(pbl1),   R(pbu1), R(pbl2), R(pbu2)
2172 };
2173
2174 /* IBM PowerPC 403GC. */
2175 static const struct reg registers_403GC[] =
2176 {
2177   COMMON_UISA_REGS,
2178   PPC_UISA_SPRS,
2179   PPC_SEGMENT_REGS,
2180   PPC_OEA_SPRS,
2181   /* 119 */ R(icdbdr), R(esr),  R(dear), R(evpr),
2182   /* 123 */ R(cdbcr),  R(tsr),  R(tcr),  R(pit),
2183   /* 127 */ R(tbhi),   R(tblo), R(srr2), R(srr3),
2184   /* 131 */ R(dbsr),   R(dbcr), R(iac1), R(iac2),
2185   /* 135 */ R(dac1),   R(dac2), R(dccr), R(iccr),
2186   /* 139 */ R(pbl1),   R(pbu1), R(pbl2), R(pbu2),
2187   /* 143 */ R(zpr),    R(pid),  R(sgr),  R(dcwr),
2188   /* 147 */ R(tbhu),   R(tblu)
2189 };
2190
2191 /* Motorola PowerPC 505. */
2192 static const struct reg registers_505[] =
2193 {
2194   COMMON_UISA_REGS,
2195   PPC_UISA_SPRS,
2196   PPC_SEGMENT_REGS,
2197   PPC_OEA_SPRS,
2198   /* 119 */ R(eie), R(eid), R(nri)
2199 };
2200
2201 /* Motorola PowerPC 860 or 850. */
2202 static const struct reg registers_860[] =
2203 {
2204   COMMON_UISA_REGS,
2205   PPC_UISA_SPRS,
2206   PPC_SEGMENT_REGS,
2207   PPC_OEA_SPRS,
2208   /* 119 */ R(eie), R(eid), R(nri), R(cmpa),
2209   /* 123 */ R(cmpb), R(cmpc), R(cmpd), R(icr),
2210   /* 127 */ R(der), R(counta), R(countb), R(cmpe),
2211   /* 131 */ R(cmpf), R(cmpg), R(cmph), R(lctrl1),
2212   /* 135 */ R(lctrl2), R(ictrl), R(bar), R(ic_cst),
2213   /* 139 */ R(ic_adr), R(ic_dat), R(dc_cst), R(dc_adr),
2214   /* 143 */ R(dc_dat), R(dpdr), R(dpir), R(immr),
2215   /* 147 */ R(mi_ctr), R(mi_ap), R(mi_epn), R(mi_twc),
2216   /* 151 */ R(mi_rpn), R(md_ctr), R(m_casid), R(md_ap),
2217   /* 155 */ R(md_epn), R(md_twb), R(md_twc), R(md_rpn),
2218   /* 159 */ R(m_tw), R(mi_dbcam), R(mi_dbram0), R(mi_dbram1),
2219   /* 163 */ R(md_dbcam), R(md_dbram0), R(md_dbram1)
2220 };
2221
2222 /* Motorola PowerPC 601.  Note that the 601 has different register numbers
2223    for reading and writing RTCU and RTCL.  However, how one reads and writes a
2224    register is the stub's problem.  */
2225 static const struct reg registers_601[] =
2226 {
2227   COMMON_UISA_REGS,
2228   PPC_UISA_SPRS,
2229   PPC_SEGMENT_REGS,
2230   PPC_OEA_SPRS,
2231   /* 119 */ R(hid0), R(hid1), R(iabr), R(dabr),
2232   /* 123 */ R(pir), R(mq), R(rtcu), R(rtcl)
2233 };
2234
2235 /* Motorola PowerPC 602. */
2236 static const struct reg registers_602[] =
2237 {
2238   COMMON_UISA_REGS,
2239   PPC_UISA_SPRS,
2240   PPC_SEGMENT_REGS,
2241   PPC_OEA_SPRS,
2242   /* 119 */ R(hid0), R(hid1), R(iabr), R0,
2243   /* 123 */ R0, R(tcr), R(ibr), R(esassr),
2244   /* 127 */ R(sebr), R(ser), R(sp), R(lt)
2245 };
2246
2247 /* Motorola/IBM PowerPC 603 or 603e. */
2248 static const struct reg registers_603[] =
2249 {
2250   COMMON_UISA_REGS,
2251   PPC_UISA_SPRS,
2252   PPC_SEGMENT_REGS,
2253   PPC_OEA_SPRS,
2254   /* 119 */ R(hid0), R(hid1), R(iabr), R0,
2255   /* 123 */ R0, R(dmiss), R(dcmp), R(hash1),
2256   /* 127 */ R(hash2), R(imiss), R(icmp), R(rpa)
2257 };
2258
2259 /* Motorola PowerPC 604 or 604e. */
2260 static const struct reg registers_604[] =
2261 {
2262   COMMON_UISA_REGS,
2263   PPC_UISA_SPRS,
2264   PPC_SEGMENT_REGS,
2265   PPC_OEA_SPRS,
2266   /* 119 */ R(hid0), R(hid1), R(iabr), R(dabr),
2267   /* 123 */ R(pir), R(mmcr0), R(pmc1), R(pmc2),
2268   /* 127 */ R(sia), R(sda)
2269 };
2270
2271 /* Motorola/IBM PowerPC 750 or 740. */
2272 static const struct reg registers_750[] =
2273 {
2274   COMMON_UISA_REGS,
2275   PPC_UISA_SPRS,
2276   PPC_SEGMENT_REGS,
2277   PPC_OEA_SPRS,
2278   /* 119 */ R(hid0), R(hid1), R(iabr), R(dabr),
2279   /* 123 */ R0, R(ummcr0), R(upmc1), R(upmc2),
2280   /* 127 */ R(usia), R(ummcr1), R(upmc3), R(upmc4),
2281   /* 131 */ R(mmcr0), R(pmc1), R(pmc2), R(sia),
2282   /* 135 */ R(mmcr1), R(pmc3), R(pmc4), R(l2cr),
2283   /* 139 */ R(ictc), R(thrm1), R(thrm2), R(thrm3)
2284 };
2285
2286
2287 /* Motorola PowerPC 7400. */
2288 static const struct reg registers_7400[] =
2289 {
2290   /* gpr0-gpr31, fpr0-fpr31 */
2291   COMMON_UISA_REGS,
2292   /* ctr, xre, lr, cr */
2293   PPC_UISA_SPRS,
2294   /* sr0-sr15 */
2295   PPC_SEGMENT_REGS,
2296   PPC_OEA_SPRS,
2297   /* vr0-vr31, vrsave, vscr */
2298   PPC_ALTIVEC_REGS
2299   /* FIXME? Add more registers? */
2300 };
2301
2302 /* Information about a particular processor variant.  */
2303
2304 struct variant
2305   {
2306     /* Name of this variant.  */
2307     char *name;
2308
2309     /* English description of the variant.  */
2310     char *description;
2311
2312     /* bfd_arch_info.arch corresponding to variant. */
2313     enum bfd_architecture arch;
2314
2315     /* bfd_arch_info.mach corresponding to variant. */
2316     unsigned long mach;
2317
2318     /* Table of register names; registers[R] is the name of the register
2319        number R.  */
2320     int nregs;
2321     const struct reg *regs;
2322   };
2323
2324 #define num_registers(list) (sizeof (list) / sizeof((list)[0]))
2325
2326
2327 /* Information in this table comes from the following web sites:
2328    IBM:       http://www.chips.ibm.com:80/products/embedded/
2329    Motorola:  http://www.mot.com/SPS/PowerPC/
2330
2331    I'm sure I've got some of the variant descriptions not quite right.
2332    Please report any inaccuracies you find to GDB's maintainer.
2333
2334    If you add entries to this table, please be sure to allow the new
2335    value as an argument to the --with-cpu flag, in configure.in.  */
2336
2337 static const struct variant variants[] =
2338 {
2339   {"powerpc", "PowerPC user-level", bfd_arch_powerpc,
2340    bfd_mach_ppc, num_registers (registers_powerpc), registers_powerpc},
2341   {"power", "POWER user-level", bfd_arch_rs6000,
2342    bfd_mach_rs6k, num_registers (registers_power), registers_power},
2343   {"403", "IBM PowerPC 403", bfd_arch_powerpc,
2344    bfd_mach_ppc_403, num_registers (registers_403), registers_403},
2345   {"601", "Motorola PowerPC 601", bfd_arch_powerpc,
2346    bfd_mach_ppc_601, num_registers (registers_601), registers_601},
2347   {"602", "Motorola PowerPC 602", bfd_arch_powerpc,
2348    bfd_mach_ppc_602, num_registers (registers_602), registers_602},
2349   {"603", "Motorola/IBM PowerPC 603 or 603e", bfd_arch_powerpc,
2350    bfd_mach_ppc_603, num_registers (registers_603), registers_603},
2351   {"604", "Motorola PowerPC 604 or 604e", bfd_arch_powerpc,
2352    604, num_registers (registers_604), registers_604},
2353   {"403GC", "IBM PowerPC 403GC", bfd_arch_powerpc,
2354    bfd_mach_ppc_403gc, num_registers (registers_403GC), registers_403GC},
2355   {"505", "Motorola PowerPC 505", bfd_arch_powerpc,
2356    bfd_mach_ppc_505, num_registers (registers_505), registers_505},
2357   {"860", "Motorola PowerPC 860 or 850", bfd_arch_powerpc,
2358    bfd_mach_ppc_860, num_registers (registers_860), registers_860},
2359   {"750", "Motorola/IBM PowerPC 750 or 740", bfd_arch_powerpc,
2360    bfd_mach_ppc_750, num_registers (registers_750), registers_750},
2361   {"7400", "Motorola/IBM PowerPC 7400 (G4)", bfd_arch_powerpc,
2362    bfd_mach_ppc_7400, num_registers (registers_7400), registers_7400},
2363
2364   /* 64-bit */
2365   {"powerpc64", "PowerPC 64-bit user-level", bfd_arch_powerpc,
2366    bfd_mach_ppc64, num_registers (registers_powerpc), registers_powerpc},
2367   {"620", "Motorola PowerPC 620", bfd_arch_powerpc,
2368    bfd_mach_ppc_620, num_registers (registers_powerpc), registers_powerpc},
2369   {"630", "Motorola PowerPC 630", bfd_arch_powerpc,
2370    bfd_mach_ppc_630, num_registers (registers_powerpc), registers_powerpc},
2371   {"a35", "PowerPC A35", bfd_arch_powerpc,
2372    bfd_mach_ppc_a35, num_registers (registers_powerpc), registers_powerpc},
2373   {"rs64ii", "PowerPC rs64ii", bfd_arch_powerpc,
2374    bfd_mach_ppc_rs64ii, num_registers (registers_powerpc), registers_powerpc},
2375   {"rs64iii", "PowerPC rs64iii", bfd_arch_powerpc,
2376    bfd_mach_ppc_rs64iii, num_registers (registers_powerpc), registers_powerpc},
2377
2378   /* FIXME: I haven't checked the register sets of the following. */
2379   {"rs1", "IBM POWER RS1", bfd_arch_rs6000,
2380    bfd_mach_rs6k_rs1, num_registers (registers_power), registers_power},
2381   {"rsc", "IBM POWER RSC", bfd_arch_rs6000,
2382    bfd_mach_rs6k_rsc, num_registers (registers_power), registers_power},
2383   {"rs2", "IBM POWER RS2", bfd_arch_rs6000,
2384    bfd_mach_rs6k_rs2, num_registers (registers_power), registers_power},
2385
2386   {0, 0, 0, 0}
2387 };
2388
2389 #undef num_registers
2390
2391 /* Return the variant corresponding to architecture ARCH and machine number
2392    MACH.  If no such variant exists, return null. */
2393
2394 static const struct variant *
2395 find_variant_by_arch (enum bfd_architecture arch, unsigned long mach)
2396 {
2397   const struct variant *v;
2398
2399   for (v = variants; v->name; v++)
2400     if (arch == v->arch && mach == v->mach)
2401       return v;
2402
2403   return NULL;
2404 }
2405 \f
2406 /* Initialize the current architecture based on INFO.  If possible, re-use an
2407    architecture from ARCHES, which is a list of architectures already created
2408    during this debugging session.
2409
2410    Called e.g. at program startup, when reading a core file, and when reading
2411    a binary file. */
2412
2413 static struct gdbarch *
2414 rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2415 {
2416   struct gdbarch *gdbarch;
2417   struct gdbarch_tdep *tdep;
2418   int wordsize, from_xcoff_exec, from_elf_exec, power, i, off;
2419   struct reg *regs;
2420   const struct variant *v;
2421   enum bfd_architecture arch;
2422   unsigned long mach;
2423   bfd abfd;
2424   int sysv_abi;
2425   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
2426   gdbarch_print_insn_ftype *print_insn;
2427
2428   from_xcoff_exec = info.abfd && info.abfd->format == bfd_object &&
2429     bfd_get_flavour (info.abfd) == bfd_target_xcoff_flavour;
2430
2431   from_elf_exec = info.abfd && info.abfd->format == bfd_object &&
2432     bfd_get_flavour (info.abfd) == bfd_target_elf_flavour;
2433
2434   sysv_abi = info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour;
2435
2436   if (info.abfd)
2437     osabi = gdbarch_lookup_osabi (info.abfd);
2438
2439   /* Check word size.  If INFO is from a binary file, infer it from
2440      that, else choose a likely default. */
2441   if (from_xcoff_exec)
2442     {
2443       if (bfd_xcoff_is_xcoff64 (info.abfd))
2444         wordsize = 8;
2445       else
2446         wordsize = 4;
2447     }
2448   else if (from_elf_exec)
2449     {
2450       if (elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
2451         wordsize = 8;
2452       else
2453         wordsize = 4;
2454     }
2455   else
2456     {
2457       if (info.bfd_arch_info != NULL && info.bfd_arch_info->bits_per_word != 0)
2458         wordsize = info.bfd_arch_info->bits_per_word /
2459           info.bfd_arch_info->bits_per_byte;
2460       else
2461         wordsize = 4;
2462     }
2463
2464   /* Find a candidate among extant architectures. */
2465   for (arches = gdbarch_list_lookup_by_info (arches, &info);
2466        arches != NULL;
2467        arches = gdbarch_list_lookup_by_info (arches->next, &info))
2468     {
2469       /* Word size in the various PowerPC bfd_arch_info structs isn't
2470          meaningful, because 64-bit CPUs can run in 32-bit mode.  So, perform
2471          separate word size check. */
2472       tdep = gdbarch_tdep (arches->gdbarch);
2473       if (tdep && tdep->wordsize == wordsize && tdep->osabi == osabi)
2474         return arches->gdbarch;
2475     }
2476
2477   /* None found, create a new architecture from INFO, whose bfd_arch_info
2478      validity depends on the source:
2479        - executable             useless
2480        - rs6000_host_arch()     good
2481        - core file              good
2482        - "set arch"             trust blindly
2483        - GDB startup            useless but harmless */
2484
2485   if (!from_xcoff_exec)
2486     {
2487       arch = info.bfd_arch_info->arch;
2488       mach = info.bfd_arch_info->mach;
2489     }
2490   else
2491     {
2492       arch = bfd_arch_powerpc;
2493       mach = 0;
2494       bfd_default_set_arch_mach (&abfd, arch, mach);
2495       info.bfd_arch_info = bfd_get_arch_info (&abfd);
2496     }
2497   tdep = xmalloc (sizeof (struct gdbarch_tdep));
2498   tdep->wordsize = wordsize;
2499   tdep->osabi = osabi;
2500   gdbarch = gdbarch_alloc (&info, tdep);
2501   power = arch == bfd_arch_rs6000;
2502
2503   /* Choose variant. */
2504   v = find_variant_by_arch (arch, mach);
2505   if (!v)
2506     return NULL;
2507
2508   tdep->regs = v->regs;
2509
2510   tdep->ppc_gp0_regnum = 0;
2511   tdep->ppc_gplast_regnum = 31;
2512   tdep->ppc_toc_regnum = 2;
2513   tdep->ppc_ps_regnum = 65;
2514   tdep->ppc_cr_regnum = 66;
2515   tdep->ppc_lr_regnum = 67;
2516   tdep->ppc_ctr_regnum = 68;
2517   tdep->ppc_xer_regnum = 69;
2518   if (v->mach == bfd_mach_ppc_601)
2519     tdep->ppc_mq_regnum = 124;
2520   else if (power)
2521     tdep->ppc_mq_regnum = 70;
2522   else
2523     tdep->ppc_mq_regnum = -1;
2524   tdep->ppc_fpscr_regnum = power ? 71 : 70;
2525
2526   if (v->arch == bfd_arch_powerpc)
2527     switch (v->mach)
2528       {
2529       case bfd_mach_ppc:
2530         tdep->ppc_vr0_regnum = 71;
2531         tdep->ppc_vrsave_regnum = 104;
2532         break;
2533       case bfd_mach_ppc_7400:
2534         tdep->ppc_vr0_regnum = 119;
2535         tdep->ppc_vrsave_regnum = 153;
2536         break;
2537       default:
2538         tdep->ppc_vr0_regnum = -1;
2539         tdep->ppc_vrsave_regnum = -1;
2540         break;
2541       }
2542
2543   /* Set lr_frame_offset.  */
2544   if (wordsize == 8)
2545     tdep->lr_frame_offset = 16;
2546   else if (sysv_abi)
2547     tdep->lr_frame_offset = 4;
2548   else
2549     tdep->lr_frame_offset = 8;
2550
2551   /* Calculate byte offsets in raw register array.  */
2552   tdep->regoff = xmalloc (v->nregs * sizeof (int));
2553   for (i = off = 0; i < v->nregs; i++)
2554     {
2555       tdep->regoff[i] = off;
2556       off += regsize (v->regs + i, wordsize);
2557     }
2558
2559   /* Select instruction printer.  */
2560   if (arch == power)
2561     print_insn = print_insn_rs6000;
2562   else if (info.byte_order == BFD_ENDIAN_BIG)
2563     print_insn = print_insn_big_powerpc;
2564   else
2565     print_insn = print_insn_little_powerpc;
2566   set_gdbarch_print_insn (gdbarch, print_insn);
2567
2568   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
2569   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
2570   set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
2571   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
2572   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
2573
2574   set_gdbarch_num_regs (gdbarch, v->nregs);
2575   set_gdbarch_sp_regnum (gdbarch, 1);
2576   set_gdbarch_fp_regnum (gdbarch, 1);
2577   set_gdbarch_pc_regnum (gdbarch, 64);
2578   set_gdbarch_register_name (gdbarch, rs6000_register_name);
2579   set_gdbarch_register_size (gdbarch, wordsize);
2580   set_gdbarch_register_bytes (gdbarch, off);
2581   set_gdbarch_register_byte (gdbarch, rs6000_register_byte);
2582   set_gdbarch_register_raw_size (gdbarch, rs6000_register_raw_size);
2583   set_gdbarch_max_register_raw_size (gdbarch, 16);
2584   set_gdbarch_register_virtual_size (gdbarch, generic_register_size);
2585   set_gdbarch_max_register_virtual_size (gdbarch, 16);
2586   set_gdbarch_register_virtual_type (gdbarch, rs6000_register_virtual_type);
2587   set_gdbarch_do_registers_info (gdbarch, rs6000_do_registers_info);
2588
2589   set_gdbarch_ptr_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
2590   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
2591   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2592   set_gdbarch_long_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
2593   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2594   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2595   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2596   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2597   set_gdbarch_char_signed (gdbarch, 0);
2598
2599   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
2600   set_gdbarch_call_dummy_length (gdbarch, 0);
2601   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
2602   set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
2603   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
2604   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
2605   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
2606   set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
2607   set_gdbarch_call_dummy_p (gdbarch, 1);
2608   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
2609   set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
2610   set_gdbarch_fix_call_dummy (gdbarch, rs6000_fix_call_dummy);
2611   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
2612   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
2613   set_gdbarch_push_return_address (gdbarch, ppc_push_return_address);
2614   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2615   set_gdbarch_coerce_float_to_double (gdbarch, rs6000_coerce_float_to_double);
2616
2617   set_gdbarch_register_convertible (gdbarch, rs6000_register_convertible);
2618   set_gdbarch_register_convert_to_virtual (gdbarch, rs6000_register_convert_to_virtual);
2619   set_gdbarch_register_convert_to_raw (gdbarch, rs6000_register_convert_to_raw);
2620   set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_stab_reg_to_regnum);
2621
2622   set_gdbarch_deprecated_extract_return_value (gdbarch, rs6000_extract_return_value);
2623
2624   /* Note: kevinb/2002-04-12: I'm not convinced that rs6000_push_arguments()
2625      is correct for the SysV ABI when the wordsize is 8, but I'm also
2626      fairly certain that ppc_sysv_abi_push_arguments() will give even
2627      worse results since it only works for 32-bit code.  So, for the moment,
2628      we're better off calling rs6000_push_arguments() since it works for
2629      64-bit code.  At some point in the future, this matter needs to be
2630      revisited.  */
2631   if (sysv_abi && wordsize == 4)
2632     set_gdbarch_push_arguments (gdbarch, ppc_sysv_abi_push_arguments);
2633   else
2634     set_gdbarch_push_arguments (gdbarch, rs6000_push_arguments);
2635
2636   set_gdbarch_store_struct_return (gdbarch, rs6000_store_struct_return);
2637   set_gdbarch_store_return_value (gdbarch, rs6000_store_return_value);
2638   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, rs6000_extract_struct_value_address);
2639   set_gdbarch_pop_frame (gdbarch, rs6000_pop_frame);
2640
2641   set_gdbarch_skip_prologue (gdbarch, rs6000_skip_prologue);
2642   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2643   set_gdbarch_decr_pc_after_break (gdbarch, 0);
2644   set_gdbarch_function_start_offset (gdbarch, 0);
2645   set_gdbarch_breakpoint_from_pc (gdbarch, rs6000_breakpoint_from_pc);
2646
2647   /* Not sure on this. FIXMEmgo */
2648   set_gdbarch_frame_args_skip (gdbarch, 8);
2649
2650   if (sysv_abi)
2651     set_gdbarch_use_struct_convention (gdbarch,
2652                                        ppc_sysv_abi_use_struct_convention);
2653   else
2654     set_gdbarch_use_struct_convention (gdbarch,
2655                                        generic_use_struct_convention);
2656
2657   set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
2658
2659   set_gdbarch_frameless_function_invocation (gdbarch,
2660                                          rs6000_frameless_function_invocation);
2661   set_gdbarch_frame_chain (gdbarch, rs6000_frame_chain);
2662   set_gdbarch_frame_saved_pc (gdbarch, rs6000_frame_saved_pc);
2663
2664   set_gdbarch_frame_init_saved_regs (gdbarch, rs6000_frame_init_saved_regs);
2665   set_gdbarch_init_extra_frame_info (gdbarch, rs6000_init_extra_frame_info);
2666
2667   if (!sysv_abi)
2668     {
2669       /* Handle RS/6000 function pointers (which are really function
2670          descriptors).  */
2671       set_gdbarch_convert_from_func_ptr_addr (gdbarch,
2672         rs6000_convert_from_func_ptr_addr);
2673     }
2674   set_gdbarch_frame_args_address (gdbarch, rs6000_frame_args_address);
2675   set_gdbarch_frame_locals_address (gdbarch, rs6000_frame_args_address);
2676   set_gdbarch_saved_pc_after_call (gdbarch, rs6000_saved_pc_after_call);
2677
2678   /* We can't tell how many args there are
2679      now that the C compiler delays popping them.  */
2680   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
2681
2682   /* Hook in ABI-specific overrides, if they have been registered.  */
2683   gdbarch_init_osabi (info, gdbarch, osabi);
2684
2685   return gdbarch;
2686 }
2687
2688 static void
2689 rs6000_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
2690 {
2691   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2692
2693   if (tdep == NULL)
2694     return;
2695
2696   fprintf_unfiltered (file, "rs6000_dump_tdep: OS ABI = %s\n",
2697                       gdbarch_osabi_name (tdep->osabi));
2698 }
2699
2700 static struct cmd_list_element *info_powerpc_cmdlist = NULL;
2701
2702 static void
2703 rs6000_info_powerpc_command (char *args, int from_tty)
2704 {
2705   help_list (info_powerpc_cmdlist, "info powerpc ", class_info, gdb_stdout);
2706 }
2707
2708 /* Initialization code.  */
2709
2710 void
2711 _initialize_rs6000_tdep (void)
2712 {
2713   gdbarch_register (bfd_arch_rs6000, rs6000_gdbarch_init, rs6000_dump_tdep);
2714   gdbarch_register (bfd_arch_powerpc, rs6000_gdbarch_init, rs6000_dump_tdep);
2715
2716   /* Add root prefix command for "info powerpc" commands */
2717   add_prefix_cmd ("powerpc", class_info, rs6000_info_powerpc_command,
2718                   "Various POWERPC info specific commands.",
2719                   &info_powerpc_cmdlist, "info powerpc ", 0, &infolist);
2720
2721   add_cmd ("altivec", class_info, rs6000_altivec_registers_info,
2722            "Display the contents of the AltiVec registers.",
2723            &info_powerpc_cmdlist);
2724 }