gdb/rs6000-aix-tdep.c

   1 /* Native support code for PPC AIX, for GDB the GNU debugger.
   2
   3    Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "gdb_assert.h"
  25 #include "osabi.h"
  26 #include "regcache.h"
  27 #include "regset.h"
  28 #include "gdbtypes.h"
  29 #include "gdbcore.h"
  30 #include "target.h"
  31 #include "value.h"
  32 #include "infcall.h"
  33 #include "objfiles.h"
  34 #include "breakpoint.h"
  35 #include "rs6000-tdep.h"
  36 #include "ppc-tdep.h"
  37 #include "exceptions.h"
  38
  39 /* Hook for determining the TOC address when calling functions in the
  40    inferior under AIX. The initialization code in rs6000-nat.c sets
  41    this hook to point to find_toc_address.  */
  42
  43 CORE_ADDR (*rs6000_find_toc_address_hook) (CORE_ADDR) = NULL;
  44
  45 /* If the kernel has to deliver a signal, it pushes a sigcontext
  46    structure on the stack and then calls the signal handler, passing
  47    the address of the sigcontext in an argument register. Usually
  48    the signal handler doesn't save this register, so we have to
  49    access the sigcontext structure via an offset from the signal handler
  50    frame.
  51    The following constants were determined by experimentation on AIX 3.2.  */
  52 #define SIG_FRAME_PC_OFFSET 96
  53 #define SIG_FRAME_LR_OFFSET 108
  54 #define SIG_FRAME_FP_OFFSET 284
  55
  56
  57 /* Core file support.  */
  58
  59 static struct ppc_reg_offsets rs6000_aix32_reg_offsets =
  60 {
  61   /* General-purpose registers.  */
  62   208, /* r0_offset */
  63   4,  /* gpr_size */
  64   4,  /* xr_size */
  65   24, /* pc_offset */
  66   28, /* ps_offset */
  67   32, /* cr_offset */
  68   36, /* lr_offset */
  69   40, /* ctr_offset */
  70   44, /* xer_offset */
  71   48, /* mq_offset */
  72
  73   /* Floating-point registers.  */
  74   336, /* f0_offset */
  75   56, /* fpscr_offset */
  76   4,  /* fpscr_size */
  77
  78   /* AltiVec registers.  */
  79   -1, /* vr0_offset */
  80   -1, /* vscr_offset */
  81   -1 /* vrsave_offset */
  82 };
  83
  84 static struct ppc_reg_offsets rs6000_aix64_reg_offsets =
  85 {
  86   /* General-purpose registers.  */
  87   0, /* r0_offset */
  88   8,  /* gpr_size */
  89   4,  /* xr_size */
  90   264, /* pc_offset */
  91   256, /* ps_offset */
  92   288, /* cr_offset */
  93   272, /* lr_offset */
  94   280, /* ctr_offset */
  95   292, /* xer_offset */
  96   -1, /* mq_offset */
  97
  98   /* Floating-point registers.  */
  99   312, /* f0_offset */
 100   296, /* fpscr_offset */
 101   4,  /* fpscr_size */
 102
 103   /* AltiVec registers.  */
 104   -1, /* vr0_offset */
 105   -1, /* vscr_offset */
 106   -1 /* vrsave_offset */
 107 };
 108
 109
 110 /* Supply register REGNUM in the general-purpose register set REGSET
 111    from the buffer specified by GREGS and LEN to register cache
 112    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 113
 114 static void
 115 rs6000_aix_supply_regset (const struct regset *regset,
 116                           struct regcache *regcache, int regnum,
 117                           const void *gregs, size_t len)
 118 {
 119   ppc_supply_gregset (regset, regcache, regnum, gregs, len);
 120   ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
 121 }
 122
 123 /* Collect register REGNUM in the general-purpose register set
 124    REGSET. from register cache REGCACHE into the buffer specified by
 125    GREGS and LEN.  If REGNUM is -1, do this for all registers in
 126    REGSET.  */
 127
 128 static void
 129 rs6000_aix_collect_regset (const struct regset *regset,
 130                            const struct regcache *regcache, int regnum,
 131                            void *gregs, size_t len)
 132 {
 133   ppc_collect_gregset (regset, regcache, regnum, gregs, len);
 134   ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
 135 }
 136
 137 /* AIX register set.  */
 138
 139 static struct regset rs6000_aix32_regset =
 140 {
 141   &rs6000_aix32_reg_offsets,
 142   rs6000_aix_supply_regset,
 143   rs6000_aix_collect_regset,
 144 };
 145
 146 static struct regset rs6000_aix64_regset =
 147 {
 148   &rs6000_aix64_reg_offsets,
 149   rs6000_aix_supply_regset,
 150   rs6000_aix_collect_regset,
 151 };
 152
 153 /* Return the appropriate register set for the core section identified
 154    by SECT_NAME and SECT_SIZE.  */
 155
 156 static const struct regset *
 157 rs6000_aix_regset_from_core_section (struct gdbarch *gdbarch,
 158                                      const char *sect_name, size_t sect_size)
 159 {
 160   if (gdbarch_tdep (gdbarch)->wordsize == 4)
 161     {
 162       if (strcmp (sect_name, ".reg") == 0 && sect_size >= 592)
 163         return &rs6000_aix32_regset;
 164     }
 165   else
 166     {
 167       if (strcmp (sect_name, ".reg") == 0 && sect_size >= 576)
 168         return &rs6000_aix64_regset;
 169     }
 170
 171   return NULL;
 172 }
 173
 174
 175 /* Pass the arguments in either registers, or in the stack. In RS/6000,
 176    the first eight words of the argument list (that might be less than
 177    eight parameters if some parameters occupy more than one word) are
 178    passed in r3..r10 registers.  float and double parameters are
 179    passed in fpr's, in addition to that.  Rest of the parameters if any
 180    are passed in user stack.  There might be cases in which half of the
 181    parameter is copied into registers, the other half is pushed into
 182    stack.
 183
 184    Stack must be aligned on 64-bit boundaries when synthesizing
 185    function calls.
 186
 187    If the function is returning a structure, then the return address is passed
 188    in r3, then the first 7 words of the parameters can be passed in registers,
 189    starting from r4.  */
 190
 191 static CORE_ADDR
 192 rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 193                         struct regcache *regcache, CORE_ADDR bp_addr,
 194                         int nargs, struct value **args, CORE_ADDR sp,
 195                         int struct_return, CORE_ADDR struct_addr)
 196 {
 197   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 198   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 199   int ii;
 200   int len = 0;
 201   int argno;                    /* current argument number */
 202   int argbytes;                 /* current argument byte */
 203   gdb_byte tmp_buffer[50];
 204   int f_argno = 0;              /* current floating point argno */
 205   int wordsize = gdbarch_tdep (gdbarch)->wordsize;
 206   CORE_ADDR func_addr = find_function_addr (function, NULL);
 207
 208   struct value *arg = 0;
 209   struct type *type;
 210
 211   ULONGEST saved_sp;
 212
 213   /* The calling convention this function implements assumes the
 214      processor has floating-point registers.  We shouldn't be using it
 215      on PPC variants that lack them.  */
 216   gdb_assert (ppc_floating_point_unit_p (gdbarch));
 217
 218   /* The first eight words of ther arguments are passed in registers.
 219      Copy them appropriately.  */
 220   ii = 0;
 221
 222   /* If the function is returning a `struct', then the first word
 223      (which will be passed in r3) is used for struct return address.
 224      In that case we should advance one word and start from r4
 225      register to copy parameters.  */
 226   if (struct_return)
 227     {
 228       regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 229                                    struct_addr);
 230       ii++;
 231     }
 232
 233 /*
 234    effectively indirect call... gcc does...
 235
 236    return_val example( float, int);
 237
 238    eabi:
 239    float in fp0, int in r3
 240    offset of stack on overflow 8/16
 241    for varargs, must go by type.
 242    power open:
 243    float in r3&r4, int in r5
 244    offset of stack on overflow different
 245    both:
 246    return in r3 or f0.  If no float, must study how gcc emulates floats;
 247    pay attention to arg promotion.
 248    User may have to cast\args to handle promotion correctly
 249    since gdb won't know if prototype supplied or not.
 250  */
 251
 252   for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
 253     {
 254       int reg_size = register_size (gdbarch, ii + 3);
 255
 256       arg = args[argno];
 257       type = check_typedef (value_type (arg));
 258       len = TYPE_LENGTH (type);
 259
 260       if (TYPE_CODE (type) == TYPE_CODE_FLT)
 261         {
 262
 263           /* Floating point arguments are passed in fpr's, as well as gpr's.
 264              There are 13 fpr's reserved for passing parameters. At this point
 265              there is no way we would run out of them.  */
 266
 267           gdb_assert (len <= 8);
 268
 269           regcache_cooked_write (regcache,
 270                                  tdep->ppc_fp0_regnum + 1 + f_argno,
 271                                  value_contents (arg));
 272           ++f_argno;
 273         }
 274
 275       if (len > reg_size)
 276         {
 277
 278           /* Argument takes more than one register.  */
 279           while (argbytes < len)
 280             {
 281               gdb_byte word[MAX_REGISTER_SIZE];
 282               memset (word, 0, reg_size);
 283               memcpy (word,
 284                       ((char *) value_contents (arg)) + argbytes,
 285                       (len - argbytes) > reg_size
 286                         ? reg_size : len - argbytes);
 287               regcache_cooked_write (regcache,
 288                                     tdep->ppc_gp0_regnum + 3 + ii,
 289                                     word);
 290               ++ii, argbytes += reg_size;
 291
 292               if (ii >= 8)
 293                 goto ran_out_of_registers_for_arguments;
 294             }
 295           argbytes = 0;
 296           --ii;
 297         }
 298       else
 299         {
 300           /* Argument can fit in one register.  No problem.  */
 301           int adj = gdbarch_byte_order (gdbarch)
 302                     == BFD_ENDIAN_BIG ? reg_size - len : 0;
 303           gdb_byte word[MAX_REGISTER_SIZE];
 304
 305           memset (word, 0, reg_size);
 306           memcpy (word, value_contents (arg), len);
 307           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word);
 308         }
 309       ++argno;
 310     }
 311
 312 ran_out_of_registers_for_arguments:
 313
 314   regcache_cooked_read_unsigned (regcache,
 315                                  gdbarch_sp_regnum (gdbarch),
 316                                  &saved_sp);
 317
 318   /* Location for 8 parameters are always reserved.  */
 319   sp -= wordsize * 8;
 320
 321   /* Another six words for back chain, TOC register, link register, etc.  */
 322   sp -= wordsize * 6;
 323
 324   /* Stack pointer must be quadword aligned.  */
 325   sp &= -16;
 326
 327   /* If there are more arguments, allocate space for them in
 328      the stack, then push them starting from the ninth one.  */
 329
 330   if ((argno < nargs) || argbytes)
 331     {
 332       int space = 0, jj;
 333
 334       if (argbytes)
 335         {
 336           space += ((len - argbytes + 3) & -4);
 337           jj = argno + 1;
 338         }
 339       else
 340         jj = argno;
 341
 342       for (; jj < nargs; ++jj)
 343         {
 344           struct value *val = args[jj];
 345           space += ((TYPE_LENGTH (value_type (val))) + 3) & -4;
 346         }
 347
 348       /* Add location required for the rest of the parameters.  */
 349       space = (space + 15) & -16;
 350       sp -= space;
 351
 352       /* This is another instance we need to be concerned about
 353          securing our stack space. If we write anything underneath %sp
 354          (r1), we might conflict with the kernel who thinks he is free
 355          to use this area.  So, update %sp first before doing anything
 356          else.  */
 357
 358       regcache_raw_write_signed (regcache,
 359                                  gdbarch_sp_regnum (gdbarch), sp);
 360
 361       /* If the last argument copied into the registers didn't fit there
 362          completely, push the rest of it into stack.  */
 363
 364       if (argbytes)
 365         {
 366           write_memory (sp + 24 + (ii * 4),
 367                         value_contents (arg) + argbytes,
 368                         len - argbytes);
 369           ++argno;
 370           ii += ((len - argbytes + 3) & -4) / 4;
 371         }
 372
 373       /* Push the rest of the arguments into stack.  */
 374       for (; argno < nargs; ++argno)
 375         {
 376
 377           arg = args[argno];
 378           type = check_typedef (value_type (arg));
 379           len = TYPE_LENGTH (type);
 380
 381
 382           /* Float types should be passed in fpr's, as well as in the
 383              stack.  */
 384           if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
 385             {
 386
 387               gdb_assert (len <= 8);
 388
 389               regcache_cooked_write (regcache,
 390                                      tdep->ppc_fp0_regnum + 1 + f_argno,
 391                                      value_contents (arg));
 392               ++f_argno;
 393             }
 394
 395           write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
 396           ii += ((len + 3) & -4) / 4;
 397         }
 398     }
 399
 400   /* Set the stack pointer.  According to the ABI, the SP is meant to
 401      be set _before_ the corresponding stack space is used.  On AIX,
 402      this even applies when the target has been completely stopped!
 403      Not doing this can lead to conflicts with the kernel which thinks
 404      that it still has control over this not-yet-allocated stack
 405      region.  */
 406   regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
 407
 408   /* Set back chain properly.  */
 409   store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
 410   write_memory (sp, tmp_buffer, wordsize);
 411
 412   /* Point the inferior function call's return address at the dummy's
 413      breakpoint.  */
 414   regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
 415
 416   /* Set the TOC register, get the value from the objfile reader
 417      which, in turn, gets it from the VMAP table.  */
 418   if (rs6000_find_toc_address_hook != NULL)
 419     {
 420       CORE_ADDR tocvalue = (*rs6000_find_toc_address_hook) (func_addr);
 421       regcache_raw_write_signed (regcache, tdep->ppc_toc_regnum, tocvalue);
 422     }
 423
 424   target_store_registers (regcache, -1);
 425   return sp;
 426 }
 427
 428 static enum return_value_convention
 429 rs6000_return_value (struct gdbarch *gdbarch, struct type *func_type,
 430                      struct type *valtype, struct regcache *regcache,
 431                      gdb_byte *readbuf, const gdb_byte *writebuf)
 432 {
 433   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 434   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 435   gdb_byte buf[8];
 436
 437   /* The calling convention this function implements assumes the
 438      processor has floating-point registers.  We shouldn't be using it
 439      on PowerPC variants that lack them.  */
 440   gdb_assert (ppc_floating_point_unit_p (gdbarch));
 441
 442   /* AltiVec extension: Functions that declare a vector data type as a
 443      return value place that return value in VR2.  */
 444   if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
 445       && TYPE_LENGTH (valtype) == 16)
 446     {
 447       if (readbuf)
 448         regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
 449       if (writebuf)
 450         regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
 451
 452       return RETURN_VALUE_REGISTER_CONVENTION;
 453     }
 454
 455   /* If the called subprogram returns an aggregate, there exists an
 456      implicit first argument, whose value is the address of a caller-
 457      allocated buffer into which the callee is assumed to store its
 458      return value. All explicit parameters are appropriately
 459      relabeled.  */
 460   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 461       || TYPE_CODE (valtype) == TYPE_CODE_UNION
 462       || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
 463     return RETURN_VALUE_STRUCT_CONVENTION;
 464
 465   /* Scalar floating-point values are returned in FPR1 for float or
 466      double, and in FPR1:FPR2 for quadword precision.  Fortran
 467      complex*8 and complex*16 are returned in FPR1:FPR2, and
 468      complex*32 is returned in FPR1:FPR4.  */
 469   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
 470       && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
 471     {
 472       struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
 473       gdb_byte regval[8];
 474
 475       /* FIXME: kettenis/2007-01-01: Add support for quadword
 476          precision and complex.  */
 477
 478       if (readbuf)
 479         {
 480           regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
 481           convert_typed_floating (regval, regtype, readbuf, valtype);
 482         }
 483       if (writebuf)
 484         {
 485           convert_typed_floating (writebuf, valtype, regval, regtype);
 486           regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
 487         }
 488
 489       return RETURN_VALUE_REGISTER_CONVENTION;
 490   }
 491
 492   /* Values of the types int, long, short, pointer, and char (length
 493      is less than or equal to four bytes), as well as bit values of
 494      lengths less than or equal to 32 bits, must be returned right
 495      justified in GPR3 with signed values sign extended and unsigned
 496      values zero extended, as necessary.  */
 497   if (TYPE_LENGTH (valtype) <= tdep->wordsize)
 498     {
 499       if (readbuf)
 500         {
 501           ULONGEST regval;
 502
 503           /* For reading we don't have to worry about sign extension.  */
 504           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 505                                          &regval);
 506           store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
 507                                   regval);
 508         }
 509       if (writebuf)
 510         {
 511           /* For writing, use unpack_long since that should handle any
 512              required sign extension.  */
 513           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 514                                           unpack_long (valtype, writebuf));
 515         }
 516
 517       return RETURN_VALUE_REGISTER_CONVENTION;
 518     }
 519
 520   /* Eight-byte non-floating-point scalar values must be returned in
 521      GPR3:GPR4.  */
 522
 523   if (TYPE_LENGTH (valtype) == 8)
 524     {
 525       gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
 526       gdb_assert (tdep->wordsize == 4);
 527
 528       if (readbuf)
 529         {
 530           gdb_byte regval[8];
 531
 532           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval);
 533           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
 534                                 regval + 4);
 535           memcpy (readbuf, regval, 8);
 536         }
 537       if (writebuf)
 538         {
 539           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
 540           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
 541                                  writebuf + 4);
 542         }
 543
 544       return RETURN_VALUE_REGISTER_CONVENTION;
 545     }
 546
 547   return RETURN_VALUE_STRUCT_CONVENTION;
 548 }
 549
 550 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
 551
 552    Usually a function pointer's representation is simply the address
 553    of the function. On the RS/6000 however, a function pointer is
 554    represented by a pointer to an OPD entry. This OPD entry contains
 555    three words, the first word is the address of the function, the
 556    second word is the TOC pointer (r2), and the third word is the
 557    static chain value.  Throughout GDB it is currently assumed that a
 558    function pointer contains the address of the function, which is not
 559    easy to fix.  In addition, the conversion of a function address to
 560    a function pointer would require allocation of an OPD entry in the
 561    inferior's memory space, with all its drawbacks.  To be able to
 562    call C++ virtual methods in the inferior (which are called via
 563    function pointers), find_function_addr uses this function to get the
 564    function address from a function pointer.  */
 565
 566 /* Return real function address if ADDR (a function pointer) is in the data
 567    space and is therefore a special function pointer.  */
 568
 569 static CORE_ADDR
 570 rs6000_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
 571                                    CORE_ADDR addr,
 572                                    struct target_ops *targ)
 573 {
 574   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 575   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 576   struct obj_section *s;
 577
 578   s = find_pc_section (addr);
 579
 580   /* Normally, functions live inside a section that is executable.
 581      So, if ADDR points to a non-executable section, then treat it
 582      as a function descriptor and return the target address iff
 583      the target address itself points to a section that is executable.  */
 584   if (s && (s->the_bfd_section->flags & SEC_CODE) == 0)
 585     {
 586       CORE_ADDR pc = 0;
 587       struct obj_section *pc_section;
 588       struct gdb_exception e;
 589
 590       TRY_CATCH (e, RETURN_MASK_ERROR)
 591         {
 592           pc = read_memory_unsigned_integer (addr, tdep->wordsize, byte_order);
 593         }
 594       if (e.reason < 0)
 595         {
 596           /* An error occured during reading.  Probably a memory error
 597              due to the section not being loaded yet.  This address
 598              cannot be a function descriptor.  */
 599           return addr;
 600         }
 601       pc_section = find_pc_section (pc);
 602
 603       if (pc_section && (pc_section->the_bfd_section->flags & SEC_CODE))
 604         return pc;
 605     }
 606
 607   return addr;
 608 }
 609
 610
 611 /* Calculate the destination of a branch/jump.  Return -1 if not a branch.  */
 612
 613 static CORE_ADDR
 614 branch_dest (struct frame_info *frame, int opcode, int instr,
 615              CORE_ADDR pc, CORE_ADDR safety)
 616 {
 617   struct gdbarch *gdbarch = get_frame_arch (frame);
 618   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 619   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 620   CORE_ADDR dest;
 621   int immediate;
 622   int absolute;
 623   int ext_op;
 624
 625   absolute = (int) ((instr >> 1) & 1);
 626
 627   switch (opcode)
 628     {
 629     case 18:
 630       immediate = ((instr & ~3) << 6) >> 6;     /* br unconditional */
 631       if (absolute)
 632         dest = immediate;
 633       else
 634         dest = pc + immediate;
 635       break;
 636
 637     case 16:
 638       immediate = ((instr & ~3) << 16) >> 16;   /* br conditional */
 639       if (absolute)
 640         dest = immediate;
 641       else
 642         dest = pc + immediate;
 643       break;
 644
 645     case 19:
 646       ext_op = (instr >> 1) & 0x3ff;
 647
 648       if (ext_op == 16)         /* br conditional register */
 649         {
 650           dest = get_frame_register_unsigned (frame, tdep->ppc_lr_regnum) & ~3;
 651
 652           /* If we are about to return from a signal handler, dest is
 653              something like 0x3c90.  The current frame is a signal handler
 654              caller frame, upon completion of the sigreturn system call
 655              execution will return to the saved PC in the frame.  */
 656           if (dest < AIX_TEXT_SEGMENT_BASE)
 657             dest = read_memory_unsigned_integer
 658                      (get_frame_base (frame) + SIG_FRAME_PC_OFFSET,
 659                       tdep->wordsize, byte_order);
 660         }
 661
 662       else if (ext_op == 528)   /* br cond to count reg */
 663         {
 664           dest = get_frame_register_unsigned (frame, tdep->ppc_ctr_regnum) & ~3;
 665
 666           /* If we are about to execute a system call, dest is something
 667              like 0x22fc or 0x3b00.  Upon completion the system call
 668              will return to the address in the link register.  */
 669           if (dest < AIX_TEXT_SEGMENT_BASE)
 670             dest = get_frame_register_unsigned (frame, tdep->ppc_lr_regnum) & ~3;
 671         }
 672       else
 673         return -1;
 674       break;
 675
 676     default:
 677       return -1;
 678     }
 679   return (dest < AIX_TEXT_SEGMENT_BASE) ? safety : dest;
 680 }
 681
 682 /* AIX does not support PT_STEP.  Simulate it.  */
 683
 684 static int
 685 rs6000_software_single_step (struct frame_info *frame)
 686 {
 687   struct gdbarch *gdbarch = get_frame_arch (frame);
 688   struct address_space *aspace = get_frame_address_space (frame);
 689   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 690   int ii, insn;
 691   CORE_ADDR loc;
 692   CORE_ADDR breaks[2];
 693   int opcode;
 694
 695   loc = get_frame_pc (frame);
 696
 697   insn = read_memory_integer (loc, 4, byte_order);
 698
 699   if (ppc_deal_with_atomic_sequence (frame))
 700     return 1;
 701
 702   breaks[0] = loc + PPC_INSN_SIZE;
 703   opcode = insn >> 26;
 704   breaks[1] = branch_dest (frame, opcode, insn, loc, breaks[0]);
 705
 706   /* Don't put two breakpoints on the same address. */
 707   if (breaks[1] == breaks[0])
 708     breaks[1] = -1;
 709
 710   for (ii = 0; ii < 2; ++ii)
 711     {
 712       /* ignore invalid breakpoint. */
 713       if (breaks[ii] == -1)
 714         continue;
 715       insert_single_step_breakpoint (gdbarch, aspace, breaks[ii]);
 716     }
 717
 718   errno = 0;                    /* FIXME, don't ignore errors! */
 719   /* What errors?  {read,write}_memory call error().  */
 720   return 1;
 721 }
 722
 723 static enum gdb_osabi
 724 rs6000_aix_osabi_sniffer (bfd *abfd)
 725 {
 726
 727   if (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
 728     return GDB_OSABI_AIX;
 729
 730   return GDB_OSABI_UNKNOWN;
 731 }
 732
 733 static void
 734 rs6000_aix_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
 735 {
 736   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 737
 738   /* RS6000/AIX does not support PT_STEP.  Has to be simulated.  */
 739   set_gdbarch_software_single_step (gdbarch, rs6000_software_single_step);
 740
 741   /* Displaced stepping is currently not supported in combination with
 742      software single-stepping.  */
 743   set_gdbarch_displaced_step_copy_insn (gdbarch, NULL);
 744   set_gdbarch_displaced_step_fixup (gdbarch, NULL);
 745   set_gdbarch_displaced_step_free_closure (gdbarch, NULL);
 746   set_gdbarch_displaced_step_location (gdbarch, NULL);
 747
 748   set_gdbarch_push_dummy_call (gdbarch, rs6000_push_dummy_call);
 749   set_gdbarch_return_value (gdbarch, rs6000_return_value);
 750   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 751
 752   /* Handle RS/6000 function pointers (which are really function
 753      descriptors).  */
 754   set_gdbarch_convert_from_func_ptr_addr
 755     (gdbarch, rs6000_convert_from_func_ptr_addr);
 756
 757   /* Core file support.  */
 758   set_gdbarch_regset_from_core_section
 759     (gdbarch, rs6000_aix_regset_from_core_section);
 760
 761   if (tdep->wordsize == 8)
 762     tdep->lr_frame_offset = 16;
 763   else
 764     tdep->lr_frame_offset = 8;
 765
 766   if (tdep->wordsize == 4)
 767     /* PowerOpen / AIX 32 bit.  The saved area or red zone consists of
 768        19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
 769        Problem is, 220 isn't frame (16 byte) aligned.  Round it up to
 770        224.  */
 771     set_gdbarch_frame_red_zone_size (gdbarch, 224);
 772   else
 773     set_gdbarch_frame_red_zone_size (gdbarch, 0);
 774 }
 775
 776 /* Provide a prototype to silence -Wmissing-prototypes.  */
 777 extern initialize_file_ftype _initialize_rs6000_aix_tdep;
 778
 779 void
 780 _initialize_rs6000_aix_tdep (void)
 781 {
 782   gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
 783                                   bfd_target_xcoff_flavour,
 784                                   rs6000_aix_osabi_sniffer);
 785   gdbarch_register_osabi_sniffer (bfd_arch_powerpc,
 786                                   bfd_target_xcoff_flavour,
 787                                   rs6000_aix_osabi_sniffer);
 788
 789   gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_AIX,
 790                           rs6000_aix_init_osabi);
 791   gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_AIX,
 792                           rs6000_aix_init_osabi);
 793 }
 794