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