gdb/rs6000-aix-tdep.c

   1 /* Native support code for PPC AIX, for GDB the GNU debugger.
   2
   3    Copyright (C) 2006-2017 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 "osabi.h"
  24 #include "regcache.h"
  25 #include "regset.h"
  26 #include "gdbtypes.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "value.h"
  30 #include "infcall.h"
  31 #include "objfiles.h"
  32 #include "breakpoint.h"
  33 #include "rs6000-tdep.h"
  34 #include "ppc-tdep.h"
  35 #include "rs6000-aix-tdep.h"
  36 #include "xcoffread.h"
  37 #include "solib.h"
  38 #include "solib-aix.h"
  39 #include "xml-utils.h"
  40
  41 /* If the kernel has to deliver a signal, it pushes a sigcontext
  42    structure on the stack and then calls the signal handler, passing
  43    the address of the sigcontext in an argument register.  Usually
  44    the signal handler doesn't save this register, so we have to
  45    access the sigcontext structure via an offset from the signal handler
  46    frame.
  47    The following constants were determined by experimentation on AIX 3.2.  */
  48 #define SIG_FRAME_PC_OFFSET 96
  49 #define SIG_FRAME_LR_OFFSET 108
  50 #define SIG_FRAME_FP_OFFSET 284
  51
  52
  53 /* Core file support.  */
  54
  55 static struct ppc_reg_offsets rs6000_aix32_reg_offsets =
  56 {
  57   /* General-purpose registers.  */
  58   208, /* r0_offset */
  59   4,  /* gpr_size */
  60   4,  /* xr_size */
  61   24, /* pc_offset */
  62   28, /* ps_offset */
  63   32, /* cr_offset */
  64   36, /* lr_offset */
  65   40, /* ctr_offset */
  66   44, /* xer_offset */
  67   48, /* mq_offset */
  68
  69   /* Floating-point registers.  */
  70   336, /* f0_offset */
  71   56, /* fpscr_offset */
  72   4,  /* fpscr_size */
  73
  74   /* AltiVec registers.  */
  75   -1, /* vr0_offset */
  76   -1, /* vscr_offset */
  77   -1 /* vrsave_offset */
  78 };
  79
  80 static struct ppc_reg_offsets rs6000_aix64_reg_offsets =
  81 {
  82   /* General-purpose registers.  */
  83   0, /* r0_offset */
  84   8,  /* gpr_size */
  85   4,  /* xr_size */
  86   264, /* pc_offset */
  87   256, /* ps_offset */
  88   288, /* cr_offset */
  89   272, /* lr_offset */
  90   280, /* ctr_offset */
  91   292, /* xer_offset */
  92   -1, /* mq_offset */
  93
  94   /* Floating-point registers.  */
  95   312, /* f0_offset */
  96   296, /* fpscr_offset */
  97   4,  /* fpscr_size */
  98
  99   /* AltiVec registers.  */
 100   -1, /* vr0_offset */
 101   -1, /* vscr_offset */
 102   -1 /* vrsave_offset */
 103 };
 104
 105
 106 /* Supply register REGNUM in the general-purpose register set REGSET
 107    from the buffer specified by GREGS and LEN to register cache
 108    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 109
 110 static void
 111 rs6000_aix_supply_regset (const struct regset *regset,
 112                           struct regcache *regcache, int regnum,
 113                           const void *gregs, size_t len)
 114 {
 115   ppc_supply_gregset (regset, regcache, regnum, gregs, len);
 116   ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
 117 }
 118
 119 /* Collect register REGNUM in the general-purpose register set
 120    REGSET, from register cache REGCACHE into the buffer specified by
 121    GREGS and LEN.  If REGNUM is -1, do this for all registers in
 122    REGSET.  */
 123
 124 static void
 125 rs6000_aix_collect_regset (const struct regset *regset,
 126                            const struct regcache *regcache, int regnum,
 127                            void *gregs, size_t len)
 128 {
 129   ppc_collect_gregset (regset, regcache, regnum, gregs, len);
 130   ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
 131 }
 132
 133 /* AIX register set.  */
 134
 135 static const struct regset rs6000_aix32_regset =
 136 {
 137   &rs6000_aix32_reg_offsets,
 138   rs6000_aix_supply_regset,
 139   rs6000_aix_collect_regset,
 140 };
 141
 142 static const struct regset rs6000_aix64_regset =
 143 {
 144   &rs6000_aix64_reg_offsets,
 145   rs6000_aix_supply_regset,
 146   rs6000_aix_collect_regset,
 147 };
 148
 149 /* Iterate over core file register note sections.  */
 150
 151 static void
 152 rs6000_aix_iterate_over_regset_sections (struct gdbarch *gdbarch,
 153                                          iterate_over_regset_sections_cb *cb,
 154                                          void *cb_data,
 155                                          const struct regcache *regcache)
 156 {
 157   if (gdbarch_tdep (gdbarch)->wordsize == 4)
 158     cb (".reg", 592, &rs6000_aix32_regset, NULL, cb_data);
 159   else
 160     cb (".reg", 576, &rs6000_aix64_regset, NULL, cb_data);
 161 }
 162
 163
 164 /* Pass the arguments in either registers, or in the stack.  In RS/6000,
 165    the first eight words of the argument list (that might be less than
 166    eight parameters if some parameters occupy more than one word) are
 167    passed in r3..r10 registers.  Float and double parameters are
 168    passed in fpr's, in addition to that.  Rest of the parameters if any
 169    are passed in user stack.  There might be cases in which half of the
 170    parameter is copied into registers, the other half is pushed into
 171    stack.
 172
 173    Stack must be aligned on 64-bit boundaries when synthesizing
 174    function calls.
 175
 176    If the function is returning a structure, then the return address is passed
 177    in r3, then the first 7 words of the parameters can be passed in registers,
 178    starting from r4.  */
 179
 180 static CORE_ADDR
 181 rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 182                         struct regcache *regcache, CORE_ADDR bp_addr,
 183                         int nargs, struct value **args, CORE_ADDR sp,
 184                         int struct_return, CORE_ADDR struct_addr)
 185 {
 186   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 187   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 188   int ii;
 189   int len = 0;
 190   int argno;                    /* current argument number */
 191   int argbytes;                 /* current argument byte */
 192   gdb_byte tmp_buffer[50];
 193   int f_argno = 0;              /* current floating point argno */
 194   int wordsize = gdbarch_tdep (gdbarch)->wordsize;
 195   CORE_ADDR func_addr = find_function_addr (function, NULL);
 196
 197   struct value *arg = 0;
 198   struct type *type;
 199
 200   ULONGEST saved_sp;
 201
 202   /* The calling convention this function implements assumes the
 203      processor has floating-point registers.  We shouldn't be using it
 204      on PPC variants that lack them.  */
 205   gdb_assert (ppc_floating_point_unit_p (gdbarch));
 206
 207   /* The first eight words of ther arguments are passed in registers.
 208      Copy them appropriately.  */
 209   ii = 0;
 210
 211   /* If the function is returning a `struct', then the first word
 212      (which will be passed in r3) is used for struct return address.
 213      In that case we should advance one word and start from r4
 214      register to copy parameters.  */
 215   if (struct_return)
 216     {
 217       regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 218                                    struct_addr);
 219       ii++;
 220     }
 221
 222 /* effectively indirect call... gcc does...
 223
 224    return_val example( float, int);
 225
 226    eabi:
 227    float in fp0, int in r3
 228    offset of stack on overflow 8/16
 229    for varargs, must go by type.
 230    power open:
 231    float in r3&r4, int in r5
 232    offset of stack on overflow different
 233    both:
 234    return in r3 or f0.  If no float, must study how gcc emulates floats;
 235    pay attention to arg promotion.
 236    User may have to cast\args to handle promotion correctly
 237    since gdb won't know if prototype supplied or not.  */
 238
 239   for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
 240     {
 241       int reg_size = register_size (gdbarch, ii + 3);
 242
 243       arg = args[argno];
 244       type = check_typedef (value_type (arg));
 245       len = TYPE_LENGTH (type);
 246
 247       if (TYPE_CODE (type) == TYPE_CODE_FLT)
 248         {
 249           /* Floating point arguments are passed in fpr's, as well as gpr's.
 250              There are 13 fpr's reserved for passing parameters.  At this point
 251              there is no way we would run out of them.
 252
 253              Always store the floating point value using the register's
 254              floating-point format.  */
 255           const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
 256           gdb_byte reg_val[MAX_REGISTER_SIZE];
 257           struct type *reg_type = register_type (gdbarch, fp_regnum);
 258
 259           gdb_assert (len <= 8);
 260
 261           convert_typed_floating (value_contents (arg), type,
 262                                   reg_val, reg_type);
 263           regcache_cooked_write (regcache, fp_regnum, reg_val);
 264           ++f_argno;
 265         }
 266
 267       if (len > reg_size)
 268         {
 269
 270           /* Argument takes more than one register.  */
 271           while (argbytes < len)
 272             {
 273               gdb_byte word[MAX_REGISTER_SIZE];
 274               memset (word, 0, reg_size);
 275               memcpy (word,
 276                       ((char *) value_contents (arg)) + argbytes,
 277                       (len - argbytes) > reg_size
 278                         ? reg_size : len - argbytes);
 279               regcache_cooked_write (regcache,
 280                                     tdep->ppc_gp0_regnum + 3 + ii,
 281                                     word);
 282               ++ii, argbytes += reg_size;
 283
 284               if (ii >= 8)
 285                 goto ran_out_of_registers_for_arguments;
 286             }
 287           argbytes = 0;
 288           --ii;
 289         }
 290       else
 291         {
 292           /* Argument can fit in one register.  No problem.  */
 293           gdb_byte word[MAX_REGISTER_SIZE];
 294
 295           memset (word, 0, reg_size);
 296           memcpy (word, value_contents (arg), len);
 297           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word);
 298         }
 299       ++argno;
 300     }
 301
 302 ran_out_of_registers_for_arguments:
 303
 304   regcache_cooked_read_unsigned (regcache,
 305                                  gdbarch_sp_regnum (gdbarch),
 306                                  &saved_sp);
 307
 308   /* Location for 8 parameters are always reserved.  */
 309   sp -= wordsize * 8;
 310
 311   /* Another six words for back chain, TOC register, link register, etc.  */
 312   sp -= wordsize * 6;
 313
 314   /* Stack pointer must be quadword aligned.  */
 315   sp &= -16;
 316
 317   /* If there are more arguments, allocate space for them in
 318      the stack, then push them starting from the ninth one.  */
 319
 320   if ((argno < nargs) || argbytes)
 321     {
 322       int space = 0, jj;
 323
 324       if (argbytes)
 325         {
 326           space += ((len - argbytes + 3) & -4);
 327           jj = argno + 1;
 328         }
 329       else
 330         jj = argno;
 331
 332       for (; jj < nargs; ++jj)
 333         {
 334           struct value *val = args[jj];
 335           space += ((TYPE_LENGTH (value_type (val))) + 3) & -4;
 336         }
 337
 338       /* Add location required for the rest of the parameters.  */
 339       space = (space + 15) & -16;
 340       sp -= space;
 341
 342       /* This is another instance we need to be concerned about
 343          securing our stack space.  If we write anything underneath %sp
 344          (r1), we might conflict with the kernel who thinks he is free
 345          to use this area.  So, update %sp first before doing anything
 346          else.  */
 347
 348       regcache_raw_write_signed (regcache,
 349                                  gdbarch_sp_regnum (gdbarch), sp);
 350
 351       /* If the last argument copied into the registers didn't fit there
 352          completely, push the rest of it into stack.  */
 353
 354       if (argbytes)
 355         {
 356           write_memory (sp + 24 + (ii * 4),
 357                         value_contents (arg) + argbytes,
 358                         len - argbytes);
 359           ++argno;
 360           ii += ((len - argbytes + 3) & -4) / 4;
 361         }
 362
 363       /* Push the rest of the arguments into stack.  */
 364       for (; argno < nargs; ++argno)
 365         {
 366
 367           arg = args[argno];
 368           type = check_typedef (value_type (arg));
 369           len = TYPE_LENGTH (type);
 370
 371
 372           /* Float types should be passed in fpr's, as well as in the
 373              stack.  */
 374           if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
 375             {
 376
 377               gdb_assert (len <= 8);
 378
 379               regcache_cooked_write (regcache,
 380                                      tdep->ppc_fp0_regnum + 1 + f_argno,
 381                                      value_contents (arg));
 382               ++f_argno;
 383             }
 384
 385           write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
 386           ii += ((len + 3) & -4) / 4;
 387         }
 388     }
 389
 390   /* Set the stack pointer.  According to the ABI, the SP is meant to
 391      be set _before_ the corresponding stack space is used.  On AIX,
 392      this even applies when the target has been completely stopped!
 393      Not doing this can lead to conflicts with the kernel which thinks
 394      that it still has control over this not-yet-allocated stack
 395      region.  */
 396   regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
 397
 398   /* Set back chain properly.  */
 399   store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
 400   write_memory (sp, tmp_buffer, wordsize);
 401
 402   /* Point the inferior function call's return address at the dummy's
 403      breakpoint.  */
 404   regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
 405
 406   /* Set the TOC register value.  */
 407   regcache_raw_write_signed (regcache, tdep->ppc_toc_regnum,
 408                              solib_aix_get_toc_value (func_addr));
 409
 410   target_store_registers (regcache, -1);
 411   return sp;
 412 }
 413
 414 static enum return_value_convention
 415 rs6000_return_value (struct gdbarch *gdbarch, struct value *function,
 416                      struct type *valtype, struct regcache *regcache,
 417                      gdb_byte *readbuf, const gdb_byte *writebuf)
 418 {
 419   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 420   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 421
 422   /* The calling convention this function implements assumes the
 423      processor has floating-point registers.  We shouldn't be using it
 424      on PowerPC variants that lack them.  */
 425   gdb_assert (ppc_floating_point_unit_p (gdbarch));
 426
 427   /* AltiVec extension: Functions that declare a vector data type as a
 428      return value place that return value in VR2.  */
 429   if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
 430       && TYPE_LENGTH (valtype) == 16)
 431     {
 432       if (readbuf)
 433         regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
 434       if (writebuf)
 435         regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
 436
 437       return RETURN_VALUE_REGISTER_CONVENTION;
 438     }
 439
 440   /* If the called subprogram returns an aggregate, there exists an
 441      implicit first argument, whose value is the address of a caller-
 442      allocated buffer into which the callee is assumed to store its
 443      return value.  All explicit parameters are appropriately
 444      relabeled.  */
 445   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 446       || TYPE_CODE (valtype) == TYPE_CODE_UNION
 447       || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
 448     return RETURN_VALUE_STRUCT_CONVENTION;
 449
 450   /* Scalar floating-point values are returned in FPR1 for float or
 451      double, and in FPR1:FPR2 for quadword precision.  Fortran
 452      complex*8 and complex*16 are returned in FPR1:FPR2, and
 453      complex*32 is returned in FPR1:FPR4.  */
 454   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
 455       && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
 456     {
 457       struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
 458       gdb_byte regval[8];
 459
 460       /* FIXME: kettenis/2007-01-01: Add support for quadword
 461          precision and complex.  */
 462
 463       if (readbuf)
 464         {
 465           regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
 466           convert_typed_floating (regval, regtype, readbuf, valtype);
 467         }
 468       if (writebuf)
 469         {
 470           convert_typed_floating (writebuf, valtype, regval, regtype);
 471           regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
 472         }
 473
 474       return RETURN_VALUE_REGISTER_CONVENTION;
 475   }
 476
 477   /* Values of the types int, long, short, pointer, and char (length
 478      is less than or equal to four bytes), as well as bit values of
 479      lengths less than or equal to 32 bits, must be returned right
 480      justified in GPR3 with signed values sign extended and unsigned
 481      values zero extended, as necessary.  */
 482   if (TYPE_LENGTH (valtype) <= tdep->wordsize)
 483     {
 484       if (readbuf)
 485         {
 486           ULONGEST regval;
 487
 488           /* For reading we don't have to worry about sign extension.  */
 489           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 490                                          &regval);
 491           store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
 492                                   regval);
 493         }
 494       if (writebuf)
 495         {
 496           /* For writing, use unpack_long since that should handle any
 497              required sign extension.  */
 498           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 499                                           unpack_long (valtype, writebuf));
 500         }
 501
 502       return RETURN_VALUE_REGISTER_CONVENTION;
 503     }
 504
 505   /* Eight-byte non-floating-point scalar values must be returned in
 506      GPR3:GPR4.  */
 507
 508   if (TYPE_LENGTH (valtype) == 8)
 509     {
 510       gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
 511       gdb_assert (tdep->wordsize == 4);
 512
 513       if (readbuf)
 514         {
 515           gdb_byte regval[8];
 516
 517           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval);
 518           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
 519                                 regval + 4);
 520           memcpy (readbuf, regval, 8);
 521         }
 522       if (writebuf)
 523         {
 524           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
 525           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
 526                                  writebuf + 4);
 527         }
 528
 529       return RETURN_VALUE_REGISTER_CONVENTION;
 530     }
 531
 532   return RETURN_VALUE_STRUCT_CONVENTION;
 533 }
 534
 535 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
 536
 537    Usually a function pointer's representation is simply the address
 538    of the function.  On the RS/6000 however, a function pointer is
 539    represented by a pointer to an OPD entry.  This OPD entry contains
 540    three words, the first word is the address of the function, the
 541    second word is the TOC pointer (r2), and the third word is the
 542    static chain value.  Throughout GDB it is currently assumed that a
 543    function pointer contains the address of the function, which is not
 544    easy to fix.  In addition, the conversion of a function address to
 545    a function pointer would require allocation of an OPD entry in the
 546    inferior's memory space, with all its drawbacks.  To be able to
 547    call C++ virtual methods in the inferior (which are called via
 548    function pointers), find_function_addr uses this function to get the
 549    function address from a function pointer.  */
 550
 551 /* Return real function address if ADDR (a function pointer) is in the data
 552    space and is therefore a special function pointer.  */
 553
 554 static CORE_ADDR
 555 rs6000_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
 556                                    CORE_ADDR addr,
 557                                    struct target_ops *targ)
 558 {
 559   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 560   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 561   struct obj_section *s;
 562
 563   s = find_pc_section (addr);
 564
 565   /* Normally, functions live inside a section that is executable.
 566      So, if ADDR points to a non-executable section, then treat it
 567      as a function descriptor and return the target address iff
 568      the target address itself points to a section that is executable.  */
 569   if (s && (s->the_bfd_section->flags & SEC_CODE) == 0)
 570     {
 571       CORE_ADDR pc = 0;
 572       struct obj_section *pc_section;
 573
 574       TRY
 575         {
 576           pc = read_memory_unsigned_integer (addr, tdep->wordsize, byte_order);
 577         }
 578       CATCH (e, RETURN_MASK_ERROR)
 579         {
 580           /* An error occured during reading.  Probably a memory error
 581              due to the section not being loaded yet.  This address
 582              cannot be a function descriptor.  */
 583           return addr;
 584         }
 585       END_CATCH
 586
 587       pc_section = find_pc_section (pc);
 588
 589       if (pc_section && (pc_section->the_bfd_section->flags & SEC_CODE))
 590         return pc;
 591     }
 592
 593   return addr;
 594 }
 595
 596
 597 /* Calculate the destination of a branch/jump.  Return -1 if not a branch.  */
 598
 599 static CORE_ADDR
 600 branch_dest (struct regcache *regcache, int opcode, int instr,
 601              CORE_ADDR pc, CORE_ADDR safety)
 602 {
 603   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 604   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 605   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 606   CORE_ADDR dest;
 607   int immediate;
 608   int absolute;
 609   int ext_op;
 610
 611   absolute = (int) ((instr >> 1) & 1);
 612
 613   switch (opcode)
 614     {
 615     case 18:
 616       immediate = ((instr & ~3) << 6) >> 6;     /* br unconditional */
 617       if (absolute)
 618         dest = immediate;
 619       else
 620         dest = pc + immediate;
 621       break;
 622
 623     case 16:
 624       immediate = ((instr & ~3) << 16) >> 16;   /* br conditional */
 625       if (absolute)
 626         dest = immediate;
 627       else
 628         dest = pc + immediate;
 629       break;
 630
 631     case 19:
 632       ext_op = (instr >> 1) & 0x3ff;
 633
 634       if (ext_op == 16)         /* br conditional register */
 635         {
 636           dest = regcache_raw_get_unsigned (regcache, tdep->ppc_lr_regnum) & ~3;
 637
 638           /* If we are about to return from a signal handler, dest is
 639              something like 0x3c90.  The current frame is a signal handler
 640              caller frame, upon completion of the sigreturn system call
 641              execution will return to the saved PC in the frame.  */
 642           if (dest < AIX_TEXT_SEGMENT_BASE)
 643             {
 644               struct frame_info *frame = get_current_frame ();
 645
 646               dest = read_memory_unsigned_integer
 647                 (get_frame_base (frame) + SIG_FRAME_PC_OFFSET,
 648                  tdep->wordsize, byte_order);
 649             }
 650         }
 651
 652       else if (ext_op == 528)   /* br cond to count reg */
 653         {
 654           dest = regcache_raw_get_unsigned (regcache,
 655                                             tdep->ppc_ctr_regnum) & ~3;
 656
 657           /* If we are about to execute a system call, dest is something
 658              like 0x22fc or 0x3b00.  Upon completion the system call
 659              will return to the address in the link register.  */
 660           if (dest < AIX_TEXT_SEGMENT_BASE)
 661             dest = regcache_raw_get_unsigned (regcache,
 662                                               tdep->ppc_lr_regnum) & ~3;
 663         }
 664       else
 665         return -1;
 666       break;
 667
 668     default:
 669       return -1;
 670     }
 671   return (dest < AIX_TEXT_SEGMENT_BASE) ? safety : dest;
 672 }
 673
 674 /* AIX does not support PT_STEP.  Simulate it.  */
 675
 676 static std::vector<CORE_ADDR>
 677 rs6000_software_single_step (struct regcache *regcache)
 678 {
 679   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 680   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 681   int ii, insn;
 682   CORE_ADDR loc;
 683   CORE_ADDR breaks[2];
 684   int opcode;
 685
 686   loc = regcache_read_pc (regcache);
 687
 688   insn = read_memory_integer (loc, 4, byte_order);
 689
 690   std::vector<CORE_ADDR> next_pcs = ppc_deal_with_atomic_sequence (regcache);
 691   if (!next_pcs.empty ())
 692     return next_pcs;
 693
 694   breaks[0] = loc + PPC_INSN_SIZE;
 695   opcode = insn >> 26;
 696   breaks[1] = branch_dest (regcache, opcode, insn, loc, breaks[0]);
 697
 698   /* Don't put two breakpoints on the same address.  */
 699   if (breaks[1] == breaks[0])
 700     breaks[1] = -1;
 701
 702   for (ii = 0; ii < 2; ++ii)
 703     {
 704       /* ignore invalid breakpoint.  */
 705       if (breaks[ii] == -1)
 706         continue;
 707
 708       next_pcs.push_back (breaks[ii]);
 709     }
 710
 711   errno = 0;                    /* FIXME, don't ignore errors!  */
 712   /* What errors?  {read,write}_memory call error().  */
 713   return next_pcs;
 714 }
 715
 716 /* Implement the "auto_wide_charset" gdbarch method for this platform.  */
 717
 718 static const char *
 719 rs6000_aix_auto_wide_charset (void)
 720 {
 721   return "UTF-16";
 722 }
 723
 724 /* Implement an osabi sniffer for RS6000/AIX.
 725
 726    This function assumes that ABFD's flavour is XCOFF.  In other words,
 727    it should be registered as a sniffer for bfd_target_xcoff_flavour
 728    objfiles only.  A failed assertion will be raised if this condition
 729    is not met.  */
 730
 731 static enum gdb_osabi
 732 rs6000_aix_osabi_sniffer (bfd *abfd)
 733 {
 734   gdb_assert (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
 735
 736   /* The only noticeable difference between Lynx178 XCOFF files and
 737      AIX XCOFF files comes from the fact that there are no shared
 738      libraries on Lynx178.  On AIX, we are betting that an executable
 739      linked with no shared library will never exist.  */
 740   if (xcoff_get_n_import_files (abfd) <= 0)
 741     return GDB_OSABI_UNKNOWN;
 742
 743   return GDB_OSABI_AIX;
 744 }
 745
 746 /* A structure encoding the offset and size of a field within
 747    a struct.  */
 748
 749 struct field_info
 750 {
 751   int offset;
 752   int size;
 753 };
 754
 755 /* A structure describing the layout of all the fields of interest
 756    in AIX's struct ld_info.  Each field in this struct corresponds
 757    to the field of the same name in struct ld_info.  */
 758
 759 struct ld_info_desc
 760 {
 761   struct field_info ldinfo_next;
 762   struct field_info ldinfo_fd;
 763   struct field_info ldinfo_textorg;
 764   struct field_info ldinfo_textsize;
 765   struct field_info ldinfo_dataorg;
 766   struct field_info ldinfo_datasize;
 767   struct field_info ldinfo_filename;
 768 };
 769
 770 /* The following data has been generated by compiling and running
 771    the following program on AIX 5.3.  */
 772
 773 #if 0
 774 #include <stddef.h>
 775 #include <stdio.h>
 776 #define __LDINFO_PTRACE32__
 777 #define __LDINFO_PTRACE64__
 778 #include <sys/ldr.h>
 779
 780 #define pinfo(type,member)                  \
 781   {                                         \
 782     struct type ldi = {0};                  \
 783                                             \
 784     printf ("  {%d, %d},\t/* %s */\n",      \
 785             offsetof (struct type, member), \
 786             sizeof (ldi.member),            \
 787             #member);                       \
 788   }                                         \
 789   while (0)
 790
 791 int
 792 main (void)
 793 {
 794   printf ("static const struct ld_info_desc ld_info32_desc =\n{\n");
 795   pinfo (__ld_info32, ldinfo_next);
 796   pinfo (__ld_info32, ldinfo_fd);
 797   pinfo (__ld_info32, ldinfo_textorg);
 798   pinfo (__ld_info32, ldinfo_textsize);
 799   pinfo (__ld_info32, ldinfo_dataorg);
 800   pinfo (__ld_info32, ldinfo_datasize);
 801   pinfo (__ld_info32, ldinfo_filename);
 802   printf ("};\n");
 803
 804   printf ("\n");
 805
 806   printf ("static const struct ld_info_desc ld_info64_desc =\n{\n");
 807   pinfo (__ld_info64, ldinfo_next);
 808   pinfo (__ld_info64, ldinfo_fd);
 809   pinfo (__ld_info64, ldinfo_textorg);
 810   pinfo (__ld_info64, ldinfo_textsize);
 811   pinfo (__ld_info64, ldinfo_dataorg);
 812   pinfo (__ld_info64, ldinfo_datasize);
 813   pinfo (__ld_info64, ldinfo_filename);
 814   printf ("};\n");
 815
 816   return 0;
 817 }
 818 #endif /* 0 */
 819
 820 /* Layout of the 32bit version of struct ld_info.  */
 821
 822 static const struct ld_info_desc ld_info32_desc =
 823 {
 824   {0, 4},       /* ldinfo_next */
 825   {4, 4},       /* ldinfo_fd */
 826   {8, 4},       /* ldinfo_textorg */
 827   {12, 4},      /* ldinfo_textsize */
 828   {16, 4},      /* ldinfo_dataorg */
 829   {20, 4},      /* ldinfo_datasize */
 830   {24, 2},      /* ldinfo_filename */
 831 };
 832
 833 /* Layout of the 64bit version of struct ld_info.  */
 834
 835 static const struct ld_info_desc ld_info64_desc =
 836 {
 837   {0, 4},       /* ldinfo_next */
 838   {8, 4},       /* ldinfo_fd */
 839   {16, 8},      /* ldinfo_textorg */
 840   {24, 8},      /* ldinfo_textsize */
 841   {32, 8},      /* ldinfo_dataorg */
 842   {40, 8},      /* ldinfo_datasize */
 843   {48, 2},      /* ldinfo_filename */
 844 };
 845
 846 /* A structured representation of one entry read from the ld_info
 847    binary data provided by the AIX loader.  */
 848
 849 struct ld_info
 850 {
 851   ULONGEST next;
 852   int fd;
 853   CORE_ADDR textorg;
 854   ULONGEST textsize;
 855   CORE_ADDR dataorg;
 856   ULONGEST datasize;
 857   char *filename;
 858   char *member_name;
 859 };
 860
 861 /* Return a struct ld_info object corresponding to the entry at
 862    LDI_BUF.
 863
 864    Note that the filename and member_name strings still point
 865    to the data in LDI_BUF.  So LDI_BUF must not be deallocated
 866    while the struct ld_info object returned is in use.  */
 867
 868 static struct ld_info
 869 rs6000_aix_extract_ld_info (struct gdbarch *gdbarch,
 870                             const gdb_byte *ldi_buf)
 871 {
 872   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 873   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 874   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 875   const struct ld_info_desc desc
 876     = tdep->wordsize == 8 ? ld_info64_desc : ld_info32_desc;
 877   struct ld_info info;
 878
 879   info.next = extract_unsigned_integer (ldi_buf + desc.ldinfo_next.offset,
 880                                         desc.ldinfo_next.size,
 881                                         byte_order);
 882   info.fd = extract_signed_integer (ldi_buf + desc.ldinfo_fd.offset,
 883                                     desc.ldinfo_fd.size,
 884                                     byte_order);
 885   info.textorg = extract_typed_address (ldi_buf + desc.ldinfo_textorg.offset,
 886                                         ptr_type);
 887   info.textsize
 888     = extract_unsigned_integer (ldi_buf + desc.ldinfo_textsize.offset,
 889                                 desc.ldinfo_textsize.size,
 890                                 byte_order);
 891   info.dataorg = extract_typed_address (ldi_buf + desc.ldinfo_dataorg.offset,
 892                                         ptr_type);
 893   info.datasize
 894     = extract_unsigned_integer (ldi_buf + desc.ldinfo_datasize.offset,
 895                                 desc.ldinfo_datasize.size,
 896                                 byte_order);
 897   info.filename = (char *) ldi_buf + desc.ldinfo_filename.offset;
 898   info.member_name = info.filename + strlen (info.filename) + 1;
 899
 900   return info;
 901 }
 902
 903 /* Append to OBJSTACK an XML string description of the shared library
 904    corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
 905    format.  */
 906
 907 static void
 908 rs6000_aix_shared_library_to_xml (struct ld_info *ldi,
 909                                   struct obstack *obstack)
 910 {
 911   char *p;
 912
 913   obstack_grow_str (obstack, "<library name=\"");
 914   p = xml_escape_text (ldi->filename);
 915   obstack_grow_str (obstack, p);
 916   xfree (p);
 917   obstack_grow_str (obstack, "\"");
 918
 919   if (ldi->member_name[0] != '\0')
 920     {
 921       obstack_grow_str (obstack, " member=\"");
 922       p = xml_escape_text (ldi->member_name);
 923       obstack_grow_str (obstack, p);
 924       xfree (p);
 925       obstack_grow_str (obstack, "\"");
 926     }
 927
 928   obstack_grow_str (obstack, " text_addr=\"");
 929   obstack_grow_str (obstack, core_addr_to_string (ldi->textorg));
 930   obstack_grow_str (obstack, "\"");
 931
 932   obstack_grow_str (obstack, " text_size=\"");
 933   obstack_grow_str (obstack, pulongest (ldi->textsize));
 934   obstack_grow_str (obstack, "\"");
 935
 936   obstack_grow_str (obstack, " data_addr=\"");
 937   obstack_grow_str (obstack, core_addr_to_string (ldi->dataorg));
 938   obstack_grow_str (obstack, "\"");
 939
 940   obstack_grow_str (obstack, " data_size=\"");
 941   obstack_grow_str (obstack, pulongest (ldi->datasize));
 942   obstack_grow_str (obstack, "\"");
 943
 944   obstack_grow_str (obstack, "></library>");
 945 }
 946
 947 /* Convert the ld_info binary data provided by the AIX loader into
 948    an XML representation following the TARGET_OBJECT_LIBRARIES_AIX
 949    format.
 950
 951    LDI_BUF is a buffer containing the ld_info data.
 952    READBUF, OFFSET and LEN follow the same semantics as target_ops'
 953    to_xfer_partial target_ops method.
 954
 955    If CLOSE_LDINFO_FD is nonzero, then this routine also closes
 956    the ldinfo_fd file descriptor.  This is useful when the ldinfo
 957    data is obtained via ptrace, as ptrace opens a file descriptor
 958    for each and every entry; but we cannot use this descriptor
 959    as the consumer of the XML library list might live in a different
 960    process.  */
 961
 962 ULONGEST
 963 rs6000_aix_ld_info_to_xml (struct gdbarch *gdbarch, const gdb_byte *ldi_buf,
 964                            gdb_byte *readbuf, ULONGEST offset, ULONGEST len,
 965                            int close_ldinfo_fd)
 966 {
 967   struct obstack obstack;
 968   const char *buf;
 969   ULONGEST len_avail;
 970
 971   obstack_init (&obstack);
 972   obstack_grow_str (&obstack, "<library-list-aix version=\"1.0\">\n");
 973
 974   while (1)
 975     {
 976       struct ld_info ldi = rs6000_aix_extract_ld_info (gdbarch, ldi_buf);
 977
 978       rs6000_aix_shared_library_to_xml (&ldi, &obstack);
 979       if (close_ldinfo_fd)
 980         close (ldi.fd);
 981
 982       if (!ldi.next)
 983         break;
 984       ldi_buf = ldi_buf + ldi.next;
 985     }
 986
 987   obstack_grow_str0 (&obstack, "</library-list-aix>\n");
 988
 989   buf = (const char *) obstack_finish (&obstack);
 990   len_avail = strlen (buf);
 991   if (offset >= len_avail)
 992     len= 0;
 993   else
 994     {
 995       if (len > len_avail - offset)
 996         len = len_avail - offset;
 997       memcpy (readbuf, buf + offset, len);
 998     }
 999
1000   obstack_free (&obstack, NULL);
1001   return len;
1002 }
1003
1004 /* Implement the core_xfer_shared_libraries_aix gdbarch method.  */
1005
1006 static ULONGEST
1007 rs6000_aix_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch,
1008                                            gdb_byte *readbuf,
1009                                            ULONGEST offset,
1010                                            ULONGEST len)
1011 {
1012   struct bfd_section *ldinfo_sec;
1013   int ldinfo_size;
1014   gdb_byte *ldinfo_buf;
1015   struct cleanup *cleanup;
1016   LONGEST result;
1017
1018   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1019   if (ldinfo_sec == NULL)
1020     error (_("cannot find .ldinfo section from core file: %s"),
1021            bfd_errmsg (bfd_get_error ()));
1022   ldinfo_size = bfd_get_section_size (ldinfo_sec);
1023
1024   ldinfo_buf = (gdb_byte *) xmalloc (ldinfo_size);
1025   cleanup = make_cleanup (xfree, ldinfo_buf);
1026
1027   if (! bfd_get_section_contents (core_bfd, ldinfo_sec,
1028                                   ldinfo_buf, 0, ldinfo_size))
1029     error (_("unable to read .ldinfo section from core file: %s"),
1030           bfd_errmsg (bfd_get_error ()));
1031
1032   result = rs6000_aix_ld_info_to_xml (gdbarch, ldinfo_buf, readbuf,
1033                                       offset, len, 0);
1034
1035   do_cleanups (cleanup);
1036   return result;
1037 }
1038
1039 static void
1040 rs6000_aix_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
1041 {
1042   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1043
1044   /* RS6000/AIX does not support PT_STEP.  Has to be simulated.  */
1045   set_gdbarch_software_single_step (gdbarch, rs6000_software_single_step);
1046
1047   /* Displaced stepping is currently not supported in combination with
1048      software single-stepping.  */
1049   set_gdbarch_displaced_step_copy_insn (gdbarch, NULL);
1050   set_gdbarch_displaced_step_fixup (gdbarch, NULL);
1051   set_gdbarch_displaced_step_free_closure (gdbarch, NULL);
1052   set_gdbarch_displaced_step_location (gdbarch, NULL);
1053
1054   set_gdbarch_push_dummy_call (gdbarch, rs6000_push_dummy_call);
1055   set_gdbarch_return_value (gdbarch, rs6000_return_value);
1056   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1057
1058   /* Handle RS/6000 function pointers (which are really function
1059      descriptors).  */
1060   set_gdbarch_convert_from_func_ptr_addr
1061     (gdbarch, rs6000_convert_from_func_ptr_addr);
1062
1063   /* Core file support.  */
1064   set_gdbarch_iterate_over_regset_sections
1065     (gdbarch, rs6000_aix_iterate_over_regset_sections);
1066   set_gdbarch_core_xfer_shared_libraries_aix
1067     (gdbarch, rs6000_aix_core_xfer_shared_libraries_aix);
1068
1069   if (tdep->wordsize == 8)
1070     tdep->lr_frame_offset = 16;
1071   else
1072     tdep->lr_frame_offset = 8;
1073
1074   if (tdep->wordsize == 4)
1075     /* PowerOpen / AIX 32 bit.  The saved area or red zone consists of
1076        19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
1077        Problem is, 220 isn't frame (16 byte) aligned.  Round it up to
1078        224.  */
1079     set_gdbarch_frame_red_zone_size (gdbarch, 224);
1080   else
1081     set_gdbarch_frame_red_zone_size (gdbarch, 0);
1082
1083   if (tdep->wordsize == 8)
1084     set_gdbarch_wchar_bit (gdbarch, 32);
1085   else
1086     set_gdbarch_wchar_bit (gdbarch, 16);
1087   set_gdbarch_wchar_signed (gdbarch, 0);
1088   set_gdbarch_auto_wide_charset (gdbarch, rs6000_aix_auto_wide_charset);
1089
1090   set_solib_ops (gdbarch, &solib_aix_so_ops);
1091 }
1092
1093 /* Provide a prototype to silence -Wmissing-prototypes.  */
1094 extern initialize_file_ftype _initialize_rs6000_aix_tdep;
1095
1096 void
1097 _initialize_rs6000_aix_tdep (void)
1098 {
1099   gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
1100                                   bfd_target_xcoff_flavour,
1101                                   rs6000_aix_osabi_sniffer);
1102   gdbarch_register_osabi_sniffer (bfd_arch_powerpc,
1103                                   bfd_target_xcoff_flavour,
1104                                   rs6000_aix_osabi_sniffer);
1105
1106   gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_AIX,
1107                           rs6000_aix_init_osabi);
1108   gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_AIX,
1109                           rs6000_aix_init_osabi);
1110 }
1111