gdb/hppa-hpux-tdep.c

   1 /* Target-dependent code for HP-UX on PA-RISC.
   2
   3    Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
   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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "arch-utils.h"
  23 #include "gdbcore.h"
  24 #include "osabi.h"
  25 #include "frame.h"
  26 #include "frame-unwind.h"
  27 #include "trad-frame.h"
  28 #include "symtab.h"
  29 #include "objfiles.h"
  30 #include "inferior.h"
  31 #include "infcall.h"
  32 #include "observer.h"
  33 #include "hppa-tdep.h"
  34 #include "solib-som.h"
  35 #include "solib-pa64.h"
  36 #include "regset.h"
  37 #include "regcache.h"
  38 #include "exceptions.h"
  39
  40 #include "gdb_string.h"
  41
  42 #define IS_32BIT_TARGET(_gdbarch) \
  43         ((gdbarch_tdep (_gdbarch))->bytes_per_address == 4)
  44
  45 /* Bit in the `ss_flag' member of `struct save_state' that indicates
  46    that the 64-bit register values are live.  From
  47    <machine/save_state.h>.  */
  48 #define HPPA_HPUX_SS_WIDEREGS           0x40
  49
  50 /* Offsets of various parts of `struct save_state'.  From
  51    <machine/save_state.h>.  */
  52 #define HPPA_HPUX_SS_FLAGS_OFFSET       0
  53 #define HPPA_HPUX_SS_NARROW_OFFSET      4
  54 #define HPPA_HPUX_SS_FPBLOCK_OFFSET     256
  55 #define HPPA_HPUX_SS_WIDE_OFFSET        640
  56
  57 /* The size of `struct save_state.  */
  58 #define HPPA_HPUX_SAVE_STATE_SIZE       1152
  59
  60 /* The size of `struct pa89_save_state', which corresponds to PA-RISC
  61    1.1, the lowest common denominator that we support.  */
  62 #define HPPA_HPUX_PA89_SAVE_STATE_SIZE  512
  63
  64
  65 /* Forward declarations.  */
  66 extern void _initialize_hppa_hpux_tdep (void);
  67 extern initialize_file_ftype _initialize_hppa_hpux_tdep;
  68
  69 static int
  70 in_opd_section (CORE_ADDR pc)
  71 {
  72   struct obj_section *s;
  73   int retval = 0;
  74
  75   s = find_pc_section (pc);
  76
  77   retval = (s != NULL
  78             && s->the_bfd_section->name != NULL
  79             && strcmp (s->the_bfd_section->name, ".opd") == 0);
  80   return (retval);
  81 }
  82
  83 /* Return one if PC is in the call path of a trampoline, else return zero.
  84
  85    Note we return one for *any* call trampoline (long-call, arg-reloc), not
  86    just shared library trampolines (import, export).  */
  87
  88 static int
  89 hppa32_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch,
  90                                       CORE_ADDR pc, char *name)
  91 {
  92   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  93   struct minimal_symbol *minsym;
  94   struct unwind_table_entry *u;
  95
  96   /* First see if PC is in one of the two C-library trampolines.  */
  97   if (pc == hppa_symbol_address("$$dyncall")
  98       || pc == hppa_symbol_address("_sr4export"))
  99     return 1;
 100
 101   minsym = lookup_minimal_symbol_by_pc (pc);
 102   if (minsym && strcmp (SYMBOL_LINKAGE_NAME (minsym), ".stub") == 0)
 103     return 1;
 104
 105   /* Get the unwind descriptor corresponding to PC, return zero
 106      if no unwind was found.  */
 107   u = find_unwind_entry (pc);
 108   if (!u)
 109     return 0;
 110
 111   /* If this isn't a linker stub, then return now.  */
 112   if (u->stub_unwind.stub_type == 0)
 113     return 0;
 114
 115   /* By definition a long-branch stub is a call stub.  */
 116   if (u->stub_unwind.stub_type == LONG_BRANCH)
 117     return 1;
 118
 119   /* The call and return path execute the same instructions within
 120      an IMPORT stub!  So an IMPORT stub is both a call and return
 121      trampoline.  */
 122   if (u->stub_unwind.stub_type == IMPORT)
 123     return 1;
 124
 125   /* Parameter relocation stubs always have a call path and may have a
 126      return path.  */
 127   if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
 128       || u->stub_unwind.stub_type == EXPORT)
 129     {
 130       CORE_ADDR addr;
 131
 132       /* Search forward from the current PC until we hit a branch
 133          or the end of the stub.  */
 134       for (addr = pc; addr <= u->region_end; addr += 4)
 135         {
 136           unsigned long insn;
 137
 138           insn = read_memory_integer (addr, 4, byte_order);
 139
 140           /* Does it look like a bl?  If so then it's the call path, if
 141              we find a bv or be first, then we're on the return path.  */
 142           if ((insn & 0xfc00e000) == 0xe8000000)
 143             return 1;
 144           else if ((insn & 0xfc00e001) == 0xe800c000
 145                    || (insn & 0xfc000000) == 0xe0000000)
 146             return 0;
 147         }
 148
 149       /* Should never happen.  */
 150       warning (_("Unable to find branch in parameter relocation stub."));
 151       return 0;
 152     }
 153
 154   /* Unknown stub type.  For now, just return zero.  */
 155   return 0;
 156 }
 157
 158 static int
 159 hppa64_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch,
 160                                       CORE_ADDR pc, char *name)
 161 {
 162   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 163
 164   /* PA64 has a completely different stub/trampoline scheme.  Is it
 165      better?  Maybe.  It's certainly harder to determine with any
 166      certainty that we are in a stub because we can not refer to the
 167      unwinders to help.
 168
 169      The heuristic is simple.  Try to lookup the current PC value in th
 170      minimal symbol table.  If that fails, then assume we are not in a
 171      stub and return.
 172
 173      Then see if the PC value falls within the section bounds for the
 174      section containing the minimal symbol we found in the first
 175      step.  If it does, then assume we are not in a stub and return.
 176
 177      Finally peek at the instructions to see if they look like a stub.  */
 178   struct minimal_symbol *minsym;
 179   asection *sec;
 180   CORE_ADDR addr;
 181   int insn, i;
 182
 183   minsym = lookup_minimal_symbol_by_pc (pc);
 184   if (! minsym)
 185     return 0;
 186
 187   sec = SYMBOL_OBJ_SECTION (minsym)->the_bfd_section;
 188
 189   if (bfd_get_section_vma (sec->owner, sec) <= pc
 190       && pc < (bfd_get_section_vma (sec->owner, sec)
 191                  + bfd_section_size (sec->owner, sec)))
 192       return 0;
 193
 194   /* We might be in a stub.  Peek at the instructions.  Stubs are 3
 195      instructions long.  */
 196   insn = read_memory_integer (pc, 4, byte_order);
 197
 198   /* Find out where we think we are within the stub.  */
 199   if ((insn & 0xffffc00e) == 0x53610000)
 200     addr = pc;
 201   else if ((insn & 0xffffffff) == 0xe820d000)
 202     addr = pc - 4;
 203   else if ((insn & 0xffffc00e) == 0x537b0000)
 204     addr = pc - 8;
 205   else
 206     return 0;
 207
 208   /* Now verify each insn in the range looks like a stub instruction.  */
 209   insn = read_memory_integer (addr, 4, byte_order);
 210   if ((insn & 0xffffc00e) != 0x53610000)
 211     return 0;
 212
 213   /* Now verify each insn in the range looks like a stub instruction.  */
 214   insn = read_memory_integer (addr + 4, 4, byte_order);
 215   if ((insn & 0xffffffff) != 0xe820d000)
 216     return 0;
 217
 218   /* Now verify each insn in the range looks like a stub instruction.  */
 219   insn = read_memory_integer (addr + 8, 4, byte_order);
 220   if ((insn & 0xffffc00e) != 0x537b0000)
 221     return 0;
 222
 223   /* Looks like a stub.  */
 224   return 1;
 225 }
 226
 227 /* Return one if PC is in the return path of a trampoline, else return zero.
 228
 229    Note we return one for *any* call trampoline (long-call, arg-reloc), not
 230    just shared library trampolines (import, export).  */
 231
 232 static int
 233 hppa_hpux_in_solib_return_trampoline (struct gdbarch *gdbarch,
 234                                       CORE_ADDR pc, char *name)
 235 {
 236   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 237   struct unwind_table_entry *u;
 238
 239   /* Get the unwind descriptor corresponding to PC, return zero
 240      if no unwind was found.  */
 241   u = find_unwind_entry (pc);
 242   if (!u)
 243     return 0;
 244
 245   /* If this isn't a linker stub or it's just a long branch stub, then
 246      return zero.  */
 247   if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH)
 248     return 0;
 249
 250   /* The call and return path execute the same instructions within
 251      an IMPORT stub!  So an IMPORT stub is both a call and return
 252      trampoline.  */
 253   if (u->stub_unwind.stub_type == IMPORT)
 254     return 1;
 255
 256   /* Parameter relocation stubs always have a call path and may have a
 257      return path.  */
 258   if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
 259       || u->stub_unwind.stub_type == EXPORT)
 260     {
 261       CORE_ADDR addr;
 262
 263       /* Search forward from the current PC until we hit a branch
 264          or the end of the stub.  */
 265       for (addr = pc; addr <= u->region_end; addr += 4)
 266         {
 267           unsigned long insn;
 268
 269           insn = read_memory_integer (addr, 4, byte_order);
 270
 271           /* Does it look like a bl?  If so then it's the call path, if
 272              we find a bv or be first, then we're on the return path.  */
 273           if ((insn & 0xfc00e000) == 0xe8000000)
 274             return 0;
 275           else if ((insn & 0xfc00e001) == 0xe800c000
 276                    || (insn & 0xfc000000) == 0xe0000000)
 277             return 1;
 278         }
 279
 280       /* Should never happen.  */
 281       warning (_("Unable to find branch in parameter relocation stub."));
 282       return 0;
 283     }
 284
 285   /* Unknown stub type.  For now, just return zero.  */
 286   return 0;
 287
 288 }
 289
 290 /* Figure out if PC is in a trampoline, and if so find out where
 291    the trampoline will jump to.  If not in a trampoline, return zero.
 292
 293    Simple code examination probably is not a good idea since the code
 294    sequences in trampolines can also appear in user code.
 295
 296    We use unwinds and information from the minimal symbol table to
 297    determine when we're in a trampoline.  This won't work for ELF
 298    (yet) since it doesn't create stub unwind entries.  Whether or
 299    not ELF will create stub unwinds or normal unwinds for linker
 300    stubs is still being debated.
 301
 302    This should handle simple calls through dyncall or sr4export,
 303    long calls, argument relocation stubs, and dyncall/sr4export
 304    calling an argument relocation stub.  It even handles some stubs
 305    used in dynamic executables.  */
 306
 307 static CORE_ADDR
 308 hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 309 {
 310   struct gdbarch *gdbarch = get_frame_arch (frame);
 311   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 312   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
 313   long orig_pc = pc;
 314   long prev_inst, curr_inst, loc;
 315   struct minimal_symbol *msym;
 316   struct unwind_table_entry *u;
 317
 318   /* Addresses passed to dyncall may *NOT* be the actual address
 319      of the function.  So we may have to do something special.  */
 320   if (pc == hppa_symbol_address("$$dyncall"))
 321     {
 322       pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
 323
 324       /* If bit 30 (counting from the left) is on, then pc is the address of
 325          the PLT entry for this function, not the address of the function
 326          itself.  Bit 31 has meaning too, but only for MPE.  */
 327       if (pc & 0x2)
 328         pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, word_size,
 329                                               byte_order);
 330     }
 331   if (pc == hppa_symbol_address("$$dyncall_external"))
 332     {
 333       pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
 334       pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, word_size, byte_order);
 335     }
 336   else if (pc == hppa_symbol_address("_sr4export"))
 337     pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
 338
 339   /* Get the unwind descriptor corresponding to PC, return zero
 340      if no unwind was found.  */
 341   u = find_unwind_entry (pc);
 342   if (!u)
 343     return 0;
 344
 345   /* If this isn't a linker stub, then return now.  */
 346   /* elz: attention here! (FIXME) because of a compiler/linker
 347      error, some stubs which should have a non zero stub_unwind.stub_type
 348      have unfortunately a value of zero.  So this function would return here
 349      as if we were not in a trampoline.  To fix this, we go look at the partial
 350      symbol information, which reports this guy as a stub.
 351      (FIXME): Unfortunately, we are not that lucky: it turns out that the
 352      partial symbol information is also wrong sometimes.  This is because
 353      when it is entered (somread.c::som_symtab_read()) it can happen that
 354      if the type of the symbol (from the som) is Entry, and the symbol is
 355      in a shared library, then it can also be a trampoline.  This would be OK,
 356      except that I believe the way they decide if we are ina shared library
 357      does not work.  SOOOO..., even if we have a regular function w/o
 358      trampolines its minimal symbol can be assigned type mst_solib_trampoline.
 359      Also, if we find that the symbol is a real stub, then we fix the unwind
 360      descriptor, and define the stub type to be EXPORT.
 361      Hopefully this is correct most of the times.  */
 362   if (u->stub_unwind.stub_type == 0)
 363     {
 364
 365 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
 366    we can delete all the code which appears between the lines.  */
 367 /*--------------------------------------------------------------------------*/
 368       msym = lookup_minimal_symbol_by_pc (pc);
 369
 370       if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
 371         return orig_pc == pc ? 0 : pc & ~0x3;
 372
 373       else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
 374         {
 375           struct objfile *objfile;
 376           struct minimal_symbol *msymbol;
 377           int function_found = 0;
 378
 379           /* Go look if there is another minimal symbol with the same name as
 380              this one, but with type mst_text.  This would happen if the msym
 381              is an actual trampoline, in which case there would be another
 382              symbol with the same name corresponding to the real function.  */
 383
 384           ALL_MSYMBOLS (objfile, msymbol)
 385           {
 386             if (MSYMBOL_TYPE (msymbol) == mst_text
 387                 && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
 388                             SYMBOL_LINKAGE_NAME (msym)) == 0)
 389               {
 390                 function_found = 1;
 391                 break;
 392               }
 393           }
 394
 395           if (function_found)
 396             /* The type of msym is correct (mst_solib_trampoline), but
 397                the unwind info is wrong, so set it to the correct value.  */
 398             u->stub_unwind.stub_type = EXPORT;
 399           else
 400             /* The stub type info in the unwind is correct (this is not a
 401                trampoline), but the msym type information is wrong, it
 402                should be mst_text.  So we need to fix the msym, and also
 403                get out of this function.  */
 404             {
 405               MSYMBOL_TYPE (msym) = mst_text;
 406               return orig_pc == pc ? 0 : pc & ~0x3;
 407             }
 408         }
 409
 410 /*--------------------------------------------------------------------------*/
 411     }
 412
 413   /* It's a stub.  Search for a branch and figure out where it goes.
 414      Note we have to handle multi insn branch sequences like ldil;ble.
 415      Most (all?) other branches can be determined by examining the contents
 416      of certain registers and the stack.  */
 417
 418   loc = pc;
 419   curr_inst = 0;
 420   prev_inst = 0;
 421   while (1)
 422     {
 423       /* Make sure we haven't walked outside the range of this stub.  */
 424       if (u != find_unwind_entry (loc))
 425         {
 426           warning (_("Unable to find branch in linker stub"));
 427           return orig_pc == pc ? 0 : pc & ~0x3;
 428         }
 429
 430       prev_inst = curr_inst;
 431       curr_inst = read_memory_integer (loc, 4, byte_order);
 432
 433       /* Does it look like a branch external using %r1?  Then it's the
 434          branch from the stub to the actual function.  */
 435       if ((curr_inst & 0xffe0e000) == 0xe0202000)
 436         {
 437           /* Yup.  See if the previous instruction loaded
 438              a value into %r1.  If so compute and return the jump address.  */
 439           if ((prev_inst & 0xffe00000) == 0x20200000)
 440             return (hppa_extract_21 (prev_inst)
 441                     + hppa_extract_17 (curr_inst)) & ~0x3;
 442           else
 443             {
 444               warning (_("Unable to find ldil X,%%r1 "
 445                          "before ble Y(%%sr4,%%r1)."));
 446               return orig_pc == pc ? 0 : pc & ~0x3;
 447             }
 448         }
 449
 450       /* Does it look like a be 0(sr0,%r21)? OR
 451          Does it look like a be, n 0(sr0,%r21)? OR
 452          Does it look like a bve (r21)? (this is on PA2.0)
 453          Does it look like a bve, n(r21)? (this is also on PA2.0)
 454          That's the branch from an
 455          import stub to an export stub.
 456
 457          It is impossible to determine the target of the branch via
 458          simple examination of instructions and/or data (consider
 459          that the address in the plabel may be the address of the
 460          bind-on-reference routine in the dynamic loader).
 461
 462          So we have try an alternative approach.
 463
 464          Get the name of the symbol at our current location; it should
 465          be a stub symbol with the same name as the symbol in the
 466          shared library.
 467
 468          Then lookup a minimal symbol with the same name; we should
 469          get the minimal symbol for the target routine in the shared
 470          library as those take precedence of import/export stubs.  */
 471       if ((curr_inst == 0xe2a00000) ||
 472           (curr_inst == 0xe2a00002) ||
 473           (curr_inst == 0xeaa0d000) ||
 474           (curr_inst == 0xeaa0d002))
 475         {
 476           struct minimal_symbol *stubsym, *libsym;
 477
 478           stubsym = lookup_minimal_symbol_by_pc (loc);
 479           if (stubsym == NULL)
 480             {
 481               warning (_("Unable to find symbol for 0x%lx"), loc);
 482               return orig_pc == pc ? 0 : pc & ~0x3;
 483             }
 484
 485           libsym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (stubsym),
 486                                           NULL, NULL);
 487           if (libsym == NULL)
 488             {
 489               warning (_("Unable to find library symbol for %s."),
 490                        SYMBOL_PRINT_NAME (stubsym));
 491               return orig_pc == pc ? 0 : pc & ~0x3;
 492             }
 493
 494           return SYMBOL_VALUE (libsym);
 495         }
 496
 497       /* Does it look like bl X,%rp or bl X,%r0?  Another way to do a
 498          branch from the stub to the actual function.  */
 499       /*elz */
 500       else if ((curr_inst & 0xffe0e000) == 0xe8400000
 501                || (curr_inst & 0xffe0e000) == 0xe8000000
 502                || (curr_inst & 0xffe0e000) == 0xe800A000)
 503         return (loc + hppa_extract_17 (curr_inst) + 8) & ~0x3;
 504
 505       /* Does it look like bv (rp)?   Note this depends on the
 506          current stack pointer being the same as the stack
 507          pointer in the stub itself!  This is a branch on from the
 508          stub back to the original caller.  */
 509       /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
 510       else if ((curr_inst & 0xffe0f000) == 0xe840c000)
 511         {
 512           /* Yup.  See if the previous instruction loaded
 513              rp from sp - 8.  */
 514           if (prev_inst == 0x4bc23ff1)
 515             {
 516               CORE_ADDR sp;
 517               sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM);
 518               return read_memory_integer (sp - 8, 4, byte_order) & ~0x3;
 519             }
 520           else
 521             {
 522               warning (_("Unable to find restore of %%rp before bv (%%rp)."));
 523               return orig_pc == pc ? 0 : pc & ~0x3;
 524             }
 525         }
 526
 527       /* elz: added this case to capture the new instruction
 528          at the end of the return part of an export stub used by
 529          the PA2.0: BVE, n (rp) */
 530       else if ((curr_inst & 0xffe0f000) == 0xe840d000)
 531         {
 532           return (read_memory_integer
 533                   (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
 534                    word_size, byte_order)) & ~0x3;
 535         }
 536
 537       /* What about be,n 0(sr0,%rp)?  It's just another way we return to
 538          the original caller from the stub.  Used in dynamic executables.  */
 539       else if (curr_inst == 0xe0400002)
 540         {
 541           /* The value we jump to is sitting in sp - 24.  But that's
 542              loaded several instructions before the be instruction.
 543              I guess we could check for the previous instruction being
 544              mtsp %r1,%sr0 if we want to do sanity checking.  */
 545           return (read_memory_integer
 546                   (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
 547                    word_size, byte_order)) & ~0x3;
 548         }
 549
 550       /* Haven't found the branch yet, but we're still in the stub.
 551          Keep looking.  */
 552       loc += 4;
 553     }
 554 }
 555
 556 static void
 557 hppa_skip_permanent_breakpoint (struct regcache *regcache)
 558 {
 559   /* To step over a breakpoint instruction on the PA takes some
 560      fiddling with the instruction address queue.
 561
 562      When we stop at a breakpoint, the IA queue front (the instruction
 563      we're executing now) points at the breakpoint instruction, and
 564      the IA queue back (the next instruction to execute) points to
 565      whatever instruction we would execute after the breakpoint, if it
 566      were an ordinary instruction.  This is the case even if the
 567      breakpoint is in the delay slot of a branch instruction.
 568
 569      Clearly, to step past the breakpoint, we need to set the queue
 570      front to the back.  But what do we put in the back?  What
 571      instruction comes after that one?  Because of the branch delay
 572      slot, the next insn is always at the back + 4.  */
 573
 574   ULONGEST pcoq_tail, pcsq_tail;
 575   regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, &pcoq_tail);
 576   regcache_cooked_read_unsigned (regcache, HPPA_PCSQ_TAIL_REGNUM, &pcsq_tail);
 577
 578   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pcoq_tail);
 579   regcache_cooked_write_unsigned (regcache, HPPA_PCSQ_HEAD_REGNUM, pcsq_tail);
 580
 581   regcache_cooked_write_unsigned (regcache,
 582                                   HPPA_PCOQ_TAIL_REGNUM, pcoq_tail + 4);
 583   /* We can leave the tail's space the same, since there's no jump.  */
 584 }
 585
 586
 587 /* Signal frames.  */
 588 struct hppa_hpux_sigtramp_unwind_cache
 589 {
 590   CORE_ADDR base;
 591   struct trad_frame_saved_reg *saved_regs;
 592 };
 593
 594 static int hppa_hpux_tramp_reg[] = {
 595   HPPA_SAR_REGNUM,
 596   HPPA_PCOQ_HEAD_REGNUM,
 597   HPPA_PCSQ_HEAD_REGNUM,
 598   HPPA_PCOQ_TAIL_REGNUM,
 599   HPPA_PCSQ_TAIL_REGNUM,
 600   HPPA_EIEM_REGNUM,
 601   HPPA_IIR_REGNUM,
 602   HPPA_ISR_REGNUM,
 603   HPPA_IOR_REGNUM,
 604   HPPA_IPSW_REGNUM,
 605   -1,
 606   HPPA_SR4_REGNUM,
 607   HPPA_SR4_REGNUM + 1,
 608   HPPA_SR4_REGNUM + 2,
 609   HPPA_SR4_REGNUM + 3,
 610   HPPA_SR4_REGNUM + 4,
 611   HPPA_SR4_REGNUM + 5,
 612   HPPA_SR4_REGNUM + 6,
 613   HPPA_SR4_REGNUM + 7,
 614   HPPA_RCR_REGNUM,
 615   HPPA_PID0_REGNUM,
 616   HPPA_PID1_REGNUM,
 617   HPPA_CCR_REGNUM,
 618   HPPA_PID2_REGNUM,
 619   HPPA_PID3_REGNUM,
 620   HPPA_TR0_REGNUM,
 621   HPPA_TR0_REGNUM + 1,
 622   HPPA_TR0_REGNUM + 2,
 623   HPPA_CR27_REGNUM
 624 };
 625
 626 static struct hppa_hpux_sigtramp_unwind_cache *
 627 hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
 628                                        void **this_cache)
 629
 630 {
 631   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 632   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 633   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 634   struct hppa_hpux_sigtramp_unwind_cache *info;
 635   unsigned int flag;
 636   CORE_ADDR sp, scptr, off;
 637   int i, incr, szoff;
 638
 639   if (*this_cache)
 640     return *this_cache;
 641
 642   info = FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache);
 643   *this_cache = info;
 644   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 645
 646   sp = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
 647
 648   if (IS_32BIT_TARGET (gdbarch))
 649     scptr = sp - 1352;
 650   else
 651     scptr = sp - 1520;
 652
 653   off = scptr;
 654
 655   /* See /usr/include/machine/save_state.h for the structure of the
 656      save_state_t structure.  */
 657
 658   flag = read_memory_unsigned_integer (scptr + HPPA_HPUX_SS_FLAGS_OFFSET,
 659                                        4, byte_order);
 660
 661   if (!(flag & HPPA_HPUX_SS_WIDEREGS))
 662     {
 663       /* Narrow registers.  */
 664       off = scptr + HPPA_HPUX_SS_NARROW_OFFSET;
 665       incr = 4;
 666       szoff = 0;
 667     }
 668   else
 669     {
 670       /* Wide registers.  */
 671       off = scptr + HPPA_HPUX_SS_WIDE_OFFSET + 8;
 672       incr = 8;
 673       szoff = (tdep->bytes_per_address == 4 ? 4 : 0);
 674     }
 675
 676   for (i = 1; i < 32; i++)
 677     {
 678       info->saved_regs[HPPA_R0_REGNUM + i].addr = off + szoff;
 679       off += incr;
 680     }
 681
 682   for (i = 0; i < ARRAY_SIZE (hppa_hpux_tramp_reg); i++)
 683     {
 684       if (hppa_hpux_tramp_reg[i] > 0)
 685         info->saved_regs[hppa_hpux_tramp_reg[i]].addr = off + szoff;
 686
 687       off += incr;
 688     }
 689
 690   /* TODO: fp regs */
 691
 692   info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
 693
 694   return info;
 695 }
 696
 697 static void
 698 hppa_hpux_sigtramp_frame_this_id (struct frame_info *this_frame,
 699                                    void **this_prologue_cache,
 700                                    struct frame_id *this_id)
 701 {
 702   struct hppa_hpux_sigtramp_unwind_cache *info
 703     = hppa_hpux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 704
 705   *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
 706 }
 707
 708 static struct value *
 709 hppa_hpux_sigtramp_frame_prev_register (struct frame_info *this_frame,
 710                                         void **this_prologue_cache,
 711                                         int regnum)
 712 {
 713   struct hppa_hpux_sigtramp_unwind_cache *info
 714     = hppa_hpux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 715
 716   return hppa_frame_prev_register_helper (this_frame,
 717                                           info->saved_regs, regnum);
 718 }
 719
 720 static int
 721 hppa_hpux_sigtramp_unwind_sniffer (const struct frame_unwind *self,
 722                                    struct frame_info *this_frame,
 723                                    void **this_cache)
 724 {
 725   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 726   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 727   struct unwind_table_entry *u;
 728   CORE_ADDR pc = get_frame_pc (this_frame);
 729
 730   u = find_unwind_entry (pc);
 731
 732   /* If this is an export stub, try to get the unwind descriptor for
 733      the actual function itself.  */
 734   if (u && u->stub_unwind.stub_type == EXPORT)
 735     {
 736       gdb_byte buf[HPPA_INSN_SIZE];
 737       unsigned long insn;
 738
 739       if (!safe_frame_unwind_memory (this_frame, u->region_start,
 740                                      buf, sizeof buf))
 741         return 0;
 742
 743       insn = extract_unsigned_integer (buf, sizeof buf, byte_order);
 744       if ((insn & 0xffe0e000) == 0xe8400000)
 745         u = find_unwind_entry(u->region_start + hppa_extract_17 (insn) + 8);
 746     }
 747
 748   if (u && u->HP_UX_interrupt_marker)
 749     return 1;
 750
 751   return 0;
 752 }
 753
 754 static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind = {
 755   SIGTRAMP_FRAME,
 756   default_frame_unwind_stop_reason,
 757   hppa_hpux_sigtramp_frame_this_id,
 758   hppa_hpux_sigtramp_frame_prev_register,
 759   NULL,
 760   hppa_hpux_sigtramp_unwind_sniffer
 761 };
 762
 763 static CORE_ADDR
 764 hppa32_hpux_find_global_pointer (struct gdbarch *gdbarch,
 765                                  struct value *function)
 766 {
 767   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 768   CORE_ADDR faddr;
 769
 770   faddr = value_as_address (function);
 771
 772   /* Is this a plabel? If so, dereference it to get the gp value.  */
 773   if (faddr & 2)
 774     {
 775       int status;
 776       char buf[4];
 777
 778       faddr &= ~3;
 779
 780       status = target_read_memory (faddr + 4, buf, sizeof (buf));
 781       if (status == 0)
 782         return extract_unsigned_integer (buf, sizeof (buf), byte_order);
 783     }
 784
 785   return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
 786 }
 787
 788 static CORE_ADDR
 789 hppa64_hpux_find_global_pointer (struct gdbarch *gdbarch,
 790                                  struct value *function)
 791 {
 792   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 793   CORE_ADDR faddr;
 794   char buf[32];
 795
 796   faddr = value_as_address (function);
 797
 798   if (in_opd_section (faddr))
 799     {
 800       target_read_memory (faddr, buf, sizeof (buf));
 801       return extract_unsigned_integer (&buf[24], 8, byte_order);
 802     }
 803   else
 804     {
 805       return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
 806     }
 807 }
 808
 809 static unsigned int ldsid_pattern[] = {
 810   0x000010a0, /* ldsid (rX),rY */
 811   0x00001820, /* mtsp rY,sr0 */
 812   0xe0000000  /* be,n (sr0,rX) */
 813 };
 814
 815 static CORE_ADDR
 816 hppa_hpux_search_pattern (struct gdbarch *gdbarch,
 817                           CORE_ADDR start, CORE_ADDR end,
 818                           unsigned int *patterns, int count)
 819 {
 820   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 821   int num_insns = (end - start + HPPA_INSN_SIZE) / HPPA_INSN_SIZE;
 822   unsigned int *insns;
 823   gdb_byte *buf;
 824   int offset, i;
 825
 826   buf = alloca (num_insns * HPPA_INSN_SIZE);
 827   insns = alloca (num_insns * sizeof (unsigned int));
 828
 829   read_memory (start, buf, num_insns * HPPA_INSN_SIZE);
 830   for (i = 0; i < num_insns; i++, buf += HPPA_INSN_SIZE)
 831     insns[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
 832
 833   for (offset = 0; offset <= num_insns - count; offset++)
 834     {
 835       for (i = 0; i < count; i++)
 836         {
 837           if ((insns[offset + i] & patterns[i]) != patterns[i])
 838             break;
 839         }
 840       if (i == count)
 841         break;
 842     }
 843
 844   if (offset <= num_insns - count)
 845     return start + offset * HPPA_INSN_SIZE;
 846   else
 847     return 0;
 848 }
 849
 850 static CORE_ADDR
 851 hppa32_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
 852                                         int *argreg)
 853 {
 854   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 855   struct objfile *obj;
 856   struct obj_section *sec;
 857   struct hppa_objfile_private *priv;
 858   struct frame_info *frame;
 859   struct unwind_table_entry *u;
 860   CORE_ADDR addr, rp;
 861   char buf[4];
 862   unsigned int insn;
 863
 864   sec = find_pc_section (pc);
 865   obj = sec->objfile;
 866   priv = objfile_data (obj, hppa_objfile_priv_data);
 867
 868   if (!priv)
 869     priv = hppa_init_objfile_priv_data (obj);
 870   if (!priv)
 871     error (_("Internal error creating objfile private data."));
 872
 873   /* Use the cached value if we have one.  */
 874   if (priv->dummy_call_sequence_addr != 0)
 875     {
 876       *argreg = priv->dummy_call_sequence_reg;
 877       return priv->dummy_call_sequence_addr;
 878     }
 879
 880   /* First try a heuristic; if we are in a shared library call, our return
 881      pointer is likely to point at an export stub.  */
 882   frame = get_current_frame ();
 883   rp = frame_unwind_register_unsigned (frame, 2);
 884   u = find_unwind_entry (rp);
 885   if (u && u->stub_unwind.stub_type == EXPORT)
 886     {
 887       addr = hppa_hpux_search_pattern (gdbarch,
 888                                        u->region_start, u->region_end,
 889                                        ldsid_pattern,
 890                                        ARRAY_SIZE (ldsid_pattern));
 891       if (addr)
 892         goto found_pattern;
 893     }
 894
 895   /* Next thing to try is to look for an export stub.  */
 896   if (priv->unwind_info)
 897     {
 898       int i;
 899
 900       for (i = 0; i < priv->unwind_info->last; i++)
 901         {
 902           struct unwind_table_entry *u;
 903           u = &priv->unwind_info->table[i];
 904           if (u->stub_unwind.stub_type == EXPORT)
 905             {
 906               addr = hppa_hpux_search_pattern (gdbarch,
 907                                                u->region_start, u->region_end,
 908                                                ldsid_pattern,
 909                                                ARRAY_SIZE (ldsid_pattern));
 910               if (addr)
 911                 {
 912                   goto found_pattern;
 913                 }
 914             }
 915         }
 916     }
 917
 918   /* Finally, if this is the main executable, try to locate a sequence
 919      from noshlibs */
 920   addr = hppa_symbol_address ("noshlibs");
 921   sec = find_pc_section (addr);
 922
 923   if (sec && sec->objfile == obj)
 924     {
 925       CORE_ADDR start, end;
 926
 927       find_pc_partial_function (addr, NULL, &start, &end);
 928       if (start != 0 && end != 0)
 929         {
 930           addr = hppa_hpux_search_pattern (gdbarch, start, end, ldsid_pattern,
 931                                            ARRAY_SIZE (ldsid_pattern));
 932           if (addr)
 933             goto found_pattern;
 934         }
 935     }
 936
 937   /* Can't find a suitable sequence.  */
 938   return 0;
 939
 940 found_pattern:
 941   target_read_memory (addr, buf, sizeof (buf));
 942   insn = extract_unsigned_integer (buf, sizeof (buf), byte_order);
 943   priv->dummy_call_sequence_addr = addr;
 944   priv->dummy_call_sequence_reg = (insn >> 21) & 0x1f;
 945
 946   *argreg = priv->dummy_call_sequence_reg;
 947   return priv->dummy_call_sequence_addr;
 948 }
 949
 950 static CORE_ADDR
 951 hppa64_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
 952                                         int *argreg)
 953 {
 954   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 955   struct objfile *obj;
 956   struct obj_section *sec;
 957   struct hppa_objfile_private *priv;
 958   CORE_ADDR addr;
 959   struct minimal_symbol *msym;
 960   int i;
 961
 962   sec = find_pc_section (pc);
 963   obj = sec->objfile;
 964   priv = objfile_data (obj, hppa_objfile_priv_data);
 965
 966   if (!priv)
 967     priv = hppa_init_objfile_priv_data (obj);
 968   if (!priv)
 969     error (_("Internal error creating objfile private data."));
 970
 971   /* Use the cached value if we have one.  */
 972   if (priv->dummy_call_sequence_addr != 0)
 973     {
 974       *argreg = priv->dummy_call_sequence_reg;
 975       return priv->dummy_call_sequence_addr;
 976     }
 977
 978   /* FIXME: Without stub unwind information, locating a suitable sequence is
 979      fairly difficult.  For now, we implement a very naive and inefficient
 980      scheme; try to read in blocks of code, and look for a "bve,n (rp)"
 981      instruction.  These are likely to occur at the end of functions, so
 982      we only look at the last two instructions of each function.  */
 983   for (i = 0, msym = obj->msymbols; i < obj->minimal_symbol_count; i++, msym++)
 984     {
 985       CORE_ADDR begin, end;
 986       char *name;
 987       gdb_byte buf[2 * HPPA_INSN_SIZE];
 988       int offset;
 989
 990       find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym), &name,
 991                                 &begin, &end);
 992
 993       if (name == NULL || begin == 0 || end == 0)
 994         continue;
 995
 996       if (target_read_memory (end - sizeof (buf), buf, sizeof (buf)) == 0)
 997         {
 998           for (offset = 0; offset < sizeof (buf); offset++)
 999             {
1000               unsigned int insn;
1001
1002               insn = extract_unsigned_integer (buf + offset,
1003                                                HPPA_INSN_SIZE, byte_order);
1004               if (insn == 0xe840d002) /* bve,n (rp) */
1005                 {
1006                   addr = (end - sizeof (buf)) + offset;
1007                   goto found_pattern;
1008                 }
1009             }
1010         }
1011     }
1012
1013   /* Can't find a suitable sequence.  */
1014   return 0;
1015
1016 found_pattern:
1017   priv->dummy_call_sequence_addr = addr;
1018   /* Right now we only look for a "bve,l (rp)" sequence, so the register is
1019      always HPPA_RP_REGNUM.  */
1020   priv->dummy_call_sequence_reg = HPPA_RP_REGNUM;
1021
1022   *argreg = priv->dummy_call_sequence_reg;
1023   return priv->dummy_call_sequence_addr;
1024 }
1025
1026 static CORE_ADDR
1027 hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
1028 {
1029   struct objfile *objfile;
1030   struct minimal_symbol *funsym, *stubsym;
1031   CORE_ADDR stubaddr;
1032
1033   funsym = lookup_minimal_symbol_by_pc (funcaddr);
1034   stubaddr = 0;
1035
1036   ALL_OBJFILES (objfile)
1037     {
1038       stubsym = lookup_minimal_symbol_solib_trampoline
1039         (SYMBOL_LINKAGE_NAME (funsym), objfile);
1040
1041       if (stubsym)
1042         {
1043           struct unwind_table_entry *u;
1044
1045           u = find_unwind_entry (SYMBOL_VALUE (stubsym));
1046           if (u == NULL
1047               || (u->stub_unwind.stub_type != IMPORT
1048                   && u->stub_unwind.stub_type != IMPORT_SHLIB))
1049             continue;
1050
1051           stubaddr = SYMBOL_VALUE (stubsym);
1052
1053           /* If we found an IMPORT stub, then we can stop searching;
1054              if we found an IMPORT_SHLIB, we want to continue the search
1055              in the hopes that we will find an IMPORT stub.  */
1056           if (u->stub_unwind.stub_type == IMPORT)
1057             break;
1058         }
1059     }
1060
1061   return stubaddr;
1062 }
1063
1064 static int
1065 hppa_hpux_sr_for_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
1066 {
1067   int sr;
1068   /* The space register to use is encoded in the top 2 bits of the address.  */
1069   sr = addr >> (gdbarch_tdep (gdbarch)->bytes_per_address * 8 - 2);
1070   return sr + 4;
1071 }
1072
1073 static CORE_ADDR
1074 hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr)
1075 {
1076   /* In order for us to restore the space register to its starting state,
1077      we need the dummy trampoline to return to an instruction address in
1078      the same space as where we started the call.  We used to place the
1079      breakpoint near the current pc, however, this breaks nested dummy calls
1080      as the nested call will hit the breakpoint address and terminate
1081      prematurely.  Instead, we try to look for an address in the same space to
1082      put the breakpoint.
1083
1084      This is similar in spirit to putting the breakpoint at the "entry point"
1085      of an executable.  */
1086
1087   struct obj_section *sec;
1088   struct unwind_table_entry *u;
1089   struct minimal_symbol *msym;
1090   CORE_ADDR func;
1091   int i;
1092
1093   sec = find_pc_section (addr);
1094   if (sec)
1095     {
1096       /* First try the lowest address in the section; we can use it as long
1097          as it is "regular" code (i.e. not a stub).  */
1098       u = find_unwind_entry (obj_section_addr (sec));
1099       if (!u || u->stub_unwind.stub_type == 0)
1100         return obj_section_addr (sec);
1101
1102       /* Otherwise, we need to find a symbol for a regular function.  We
1103          do this by walking the list of msymbols in the objfile.  The symbol
1104          we find should not be the same as the function that was passed in.  */
1105
1106       /* FIXME: this is broken, because we can find a function that will be
1107          called by the dummy call target function, which will still not
1108          work.  */
1109
1110       find_pc_partial_function (addr, NULL, &func, NULL);
1111       for (i = 0, msym = sec->objfile->msymbols;
1112            i < sec->objfile->minimal_symbol_count;
1113            i++, msym++)
1114         {
1115           u = find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym));
1116           if (func != SYMBOL_VALUE_ADDRESS (msym)
1117               && (!u || u->stub_unwind.stub_type == 0))
1118             return SYMBOL_VALUE_ADDRESS (msym);
1119         }
1120     }
1121
1122   warning (_("Cannot find suitable address to place dummy breakpoint; nested "
1123              "calls may fail."));
1124   return addr - 4;
1125 }
1126
1127 static CORE_ADDR
1128 hppa_hpux_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
1129                            CORE_ADDR funcaddr,
1130                            struct value **args, int nargs,
1131                            struct type *value_type,
1132                            CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
1133                            struct regcache *regcache)
1134 {
1135   CORE_ADDR pc, stubaddr;
1136   int argreg = 0;
1137
1138   pc = regcache_read_pc (regcache);
1139
1140   /* Note: we don't want to pass a function descriptor here; push_dummy_call
1141      fills in the PIC register for us.  */
1142   funcaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funcaddr, NULL);
1143
1144   /* The simple case is where we call a function in the same space that we are
1145      currently in; in that case we don't really need to do anything.  */
1146   if (hppa_hpux_sr_for_addr (gdbarch, pc)
1147       == hppa_hpux_sr_for_addr (gdbarch, funcaddr))
1148     {
1149       /* Intraspace call.  */
1150       *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1151       *real_pc = funcaddr;
1152       regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, *bp_addr);
1153
1154       return sp;
1155     }
1156
1157   /* In order to make an interspace call, we need to go through a stub.
1158      gcc supplies an appropriate stub called "__gcc_plt_call", however, if
1159      an application is compiled with HP compilers then this stub is not
1160      available.  We used to fallback to "__d_plt_call", however that stub
1161      is not entirely useful for us because it doesn't do an interspace
1162      return back to the caller.  Also, on hppa64-hpux, there is no
1163      __gcc_plt_call available.  In order to keep the code uniform, we
1164      instead don't use either of these stubs, but instead write our own
1165      onto the stack.
1166
1167      A problem arises since the stack is located in a different space than
1168      code, so in order to branch to a stack stub, we will need to do an
1169      interspace branch.  Previous versions of gdb did this by modifying code
1170      at the current pc and doing single-stepping to set the pcsq.  Since this
1171      is highly undesirable, we use a different scheme:
1172
1173      All we really need to do the branch to the stub is a short instruction
1174      sequence like this:
1175
1176      PA1.1:
1177                 ldsid (rX),r1
1178                 mtsp r1,sr0
1179                 be,n (sr0,rX)
1180
1181      PA2.0:
1182                 bve,n (sr0,rX)
1183
1184      Instead of writing these sequences ourselves, we can find it in
1185      the instruction stream that belongs to the current space.  While this
1186      seems difficult at first, we are actually guaranteed to find the sequences
1187      in several places:
1188
1189      For 32-bit code:
1190      - in export stubs for shared libraries
1191      - in the "noshlibs" routine in the main module
1192
1193      For 64-bit code:
1194      - at the end of each "regular" function
1195
1196      We cache the address of these sequences in the objfile's private data
1197      since these operations can potentially be quite expensive.
1198
1199      So, what we do is:
1200      - write a stack trampoline
1201      - look for a suitable instruction sequence in the current space
1202      - point the sequence at the trampoline
1203      - set the return address of the trampoline to the current space
1204        (see hppa_hpux_find_dummy_call_bpaddr)
1205      - set the continuing address of the "dummy code" as the sequence.  */
1206
1207   if (IS_32BIT_TARGET (gdbarch))
1208     {
1209       static unsigned int hppa32_tramp[] = {
1210         0x0fdf1291, /* stw r31,-8(,sp) */
1211         0x02c010a1, /* ldsid (,r22),r1 */
1212         0x00011820, /* mtsp r1,sr0 */
1213         0xe6c00000, /* be,l 0(sr0,r22),%sr0,%r31 */
1214         0x081f0242, /* copy r31,rp */
1215         0x0fd11082, /* ldw -8(,sp),rp */
1216         0x004010a1, /* ldsid (,rp),r1 */
1217         0x00011820, /* mtsp r1,sr0 */
1218         0xe0400000, /* be 0(sr0,rp) */
1219         0x08000240  /* nop */
1220       };
1221
1222       /* for hppa32, we must call the function through a stub so that on
1223          return it can return to the space of our trampoline.  */
1224       stubaddr = hppa_hpux_find_import_stub_for_addr (funcaddr);
1225       if (stubaddr == 0)
1226         error (_("Cannot call external function not referenced by application "
1227                "(no import stub).\n"));
1228       regcache_cooked_write_unsigned (regcache, 22, stubaddr);
1229
1230       write_memory (sp, (char *)&hppa32_tramp, sizeof (hppa32_tramp));
1231
1232       *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1233       regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
1234
1235       *real_pc = hppa32_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1236       if (*real_pc == 0)
1237         error (_("Cannot make interspace call from here."));
1238
1239       regcache_cooked_write_unsigned (regcache, argreg, sp);
1240
1241       sp += sizeof (hppa32_tramp);
1242     }
1243   else
1244     {
1245       static unsigned int hppa64_tramp[] = {
1246         0xeac0f000, /* bve,l (r22),%r2 */
1247         0x0fdf12d1, /* std r31,-8(,sp) */
1248         0x0fd110c2, /* ldd -8(,sp),rp */
1249         0xe840d002, /* bve,n (rp) */
1250         0x08000240  /* nop */
1251       };
1252
1253       /* for hppa64, we don't need to call through a stub; all functions
1254          return via a bve.  */
1255       regcache_cooked_write_unsigned (regcache, 22, funcaddr);
1256       write_memory (sp, (char *)&hppa64_tramp, sizeof (hppa64_tramp));
1257
1258       *bp_addr = pc - 4;
1259       regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
1260
1261       *real_pc = hppa64_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1262       if (*real_pc == 0)
1263         error (_("Cannot make interspace call from here."));
1264
1265       regcache_cooked_write_unsigned (regcache, argreg, sp);
1266
1267       sp += sizeof (hppa64_tramp);
1268     }
1269
1270   sp = gdbarch_frame_align (gdbarch, sp);
1271
1272   return sp;
1273 }
1274
1275 \f
1276
1277 static void
1278 hppa_hpux_supply_ss_narrow (struct regcache *regcache,
1279                             int regnum, const char *save_state)
1280 {
1281   const char *ss_narrow = save_state + HPPA_HPUX_SS_NARROW_OFFSET;
1282   int i, offset = 0;
1283
1284   for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1285     {
1286       if (regnum == i || regnum == -1)
1287         regcache_raw_supply (regcache, i, ss_narrow + offset);
1288
1289       offset += 4;
1290     }
1291 }
1292
1293 static void
1294 hppa_hpux_supply_ss_fpblock (struct regcache *regcache,
1295                              int regnum, const char *save_state)
1296 {
1297   const char *ss_fpblock = save_state + HPPA_HPUX_SS_FPBLOCK_OFFSET;
1298   int i, offset = 0;
1299
1300   /* FIXME: We view the floating-point state as 64 single-precision
1301      registers for 32-bit code, and 32 double-precision register for
1302      64-bit code.  This distinction is artificial and should be
1303      eliminated.  If that ever happens, we should remove the if-clause
1304      below.  */
1305
1306   if (register_size (get_regcache_arch (regcache), HPPA_FP0_REGNUM) == 4)
1307     {
1308       for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 64; i++)
1309         {
1310           if (regnum == i || regnum == -1)
1311             regcache_raw_supply (regcache, i, ss_fpblock + offset);
1312
1313           offset += 4;
1314         }
1315     }
1316   else
1317     {
1318       for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32; i++)
1319         {
1320           if (regnum == i || regnum == -1)
1321             regcache_raw_supply (regcache, i, ss_fpblock + offset);
1322
1323           offset += 8;
1324         }
1325     }
1326 }
1327
1328 static void
1329 hppa_hpux_supply_ss_wide (struct regcache *regcache,
1330                           int regnum, const char *save_state)
1331 {
1332   const char *ss_wide = save_state + HPPA_HPUX_SS_WIDE_OFFSET;
1333   int i, offset = 8;
1334
1335   if (register_size (get_regcache_arch (regcache), HPPA_R1_REGNUM) == 4)
1336     offset += 4;
1337
1338   for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1339     {
1340       if (regnum == i || regnum == -1)
1341         regcache_raw_supply (regcache, i, ss_wide + offset);
1342
1343       offset += 8;
1344     }
1345 }
1346
1347 static void
1348 hppa_hpux_supply_save_state (const struct regset *regset,
1349                              struct regcache *regcache,
1350                              int regnum, const void *regs, size_t len)
1351 {
1352   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1353   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1354   const char *proc_info = regs;
1355   const char *save_state = proc_info + 8;
1356   ULONGEST flags;
1357
1358   flags = extract_unsigned_integer (save_state + HPPA_HPUX_SS_FLAGS_OFFSET,
1359                                     4, byte_order);
1360   if (regnum == -1 || regnum == HPPA_FLAGS_REGNUM)
1361     {
1362       size_t size = register_size (gdbarch, HPPA_FLAGS_REGNUM);
1363       char buf[8];
1364
1365       store_unsigned_integer (buf, size, byte_order, flags);
1366       regcache_raw_supply (regcache, HPPA_FLAGS_REGNUM, buf);
1367     }
1368
1369   /* If the SS_WIDEREGS flag is set, we really do need the full
1370      `struct save_state'.  */
1371   if (flags & HPPA_HPUX_SS_WIDEREGS && len < HPPA_HPUX_SAVE_STATE_SIZE)
1372     error (_("Register set contents too small"));
1373
1374   if (flags & HPPA_HPUX_SS_WIDEREGS)
1375     hppa_hpux_supply_ss_wide (regcache, regnum, save_state);
1376   else
1377     hppa_hpux_supply_ss_narrow (regcache, regnum, save_state);
1378
1379   hppa_hpux_supply_ss_fpblock (regcache, regnum, save_state);
1380 }
1381
1382 /* HP-UX register set.  */
1383
1384 static struct regset hppa_hpux_regset =
1385 {
1386   NULL,
1387   hppa_hpux_supply_save_state
1388 };
1389
1390 static const struct regset *
1391 hppa_hpux_regset_from_core_section (struct gdbarch *gdbarch,
1392                                     const char *sect_name, size_t sect_size)
1393 {
1394   if (strcmp (sect_name, ".reg") == 0
1395       && sect_size >= HPPA_HPUX_PA89_SAVE_STATE_SIZE + 8)
1396     return &hppa_hpux_regset;
1397
1398   return NULL;
1399 }
1400 \f
1401
1402 /* Bit in the `ss_flag' member of `struct save_state' that indicates
1403    the state was saved from a system call.  From
1404    <machine/save_state.h>.  */
1405 #define HPPA_HPUX_SS_INSYSCALL  0x02
1406
1407 static CORE_ADDR
1408 hppa_hpux_read_pc (struct regcache *regcache)
1409 {
1410   ULONGEST flags;
1411
1412   /* If we're currently in a system call return the contents of %r31.  */
1413   regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
1414   if (flags & HPPA_HPUX_SS_INSYSCALL)
1415     {
1416       ULONGEST pc;
1417       regcache_cooked_read_unsigned (regcache, HPPA_R31_REGNUM, &pc);
1418       return pc & ~0x3;
1419     }
1420
1421   return hppa_read_pc (regcache);
1422 }
1423
1424 static void
1425 hppa_hpux_write_pc (struct regcache *regcache, CORE_ADDR pc)
1426 {
1427   ULONGEST flags;
1428
1429   /* If we're currently in a system call also write PC into %r31.  */
1430   regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
1431   if (flags & HPPA_HPUX_SS_INSYSCALL)
1432     regcache_cooked_write_unsigned (regcache, HPPA_R31_REGNUM, pc | 0x3);
1433
1434   hppa_write_pc (regcache, pc);
1435 }
1436
1437 static CORE_ADDR
1438 hppa_hpux_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1439 {
1440   ULONGEST flags;
1441
1442   /* If we're currently in a system call return the contents of %r31.  */
1443   flags = frame_unwind_register_unsigned (next_frame, HPPA_FLAGS_REGNUM);
1444   if (flags & HPPA_HPUX_SS_INSYSCALL)
1445     return frame_unwind_register_unsigned (next_frame, HPPA_R31_REGNUM) & ~0x3;
1446
1447   return hppa_unwind_pc (gdbarch, next_frame);
1448 }
1449 \f
1450
1451 /* Given the current value of the pc, check to see if it is inside a stub, and
1452    if so, change the value of the pc to point to the caller of the stub.
1453    THIS_FRAME is the current frame in the current list of frames.
1454    BASE contains to stack frame base of the current frame.
1455    SAVE_REGS is the register file stored in the frame cache.  */
1456 static void
1457 hppa_hpux_unwind_adjust_stub (struct frame_info *this_frame, CORE_ADDR base,
1458                               struct trad_frame_saved_reg *saved_regs)
1459 {
1460   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1461   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1462   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1463   struct value *pcoq_head_val;
1464   ULONGEST pcoq_head;
1465   CORE_ADDR stubpc;
1466   struct unwind_table_entry *u;
1467
1468   pcoq_head_val = trad_frame_get_prev_register (this_frame, saved_regs,
1469                                                 HPPA_PCOQ_HEAD_REGNUM);
1470   pcoq_head =
1471     extract_unsigned_integer (value_contents_all (pcoq_head_val),
1472                               register_size (gdbarch, HPPA_PCOQ_HEAD_REGNUM),
1473                               byte_order);
1474
1475   u = find_unwind_entry (pcoq_head);
1476   if (u && u->stub_unwind.stub_type == EXPORT)
1477     {
1478       stubpc = read_memory_integer (base - 24, word_size, byte_order);
1479       trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1480     }
1481   else if (hppa_symbol_address ("__gcc_plt_call")
1482            == get_pc_function_start (pcoq_head))
1483     {
1484       stubpc = read_memory_integer (base - 8, word_size, byte_order);
1485       trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1486     }
1487 }
1488
1489 static void
1490 hppa_hpux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1491 {
1492   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1493
1494   if (IS_32BIT_TARGET (gdbarch))
1495     tdep->in_solib_call_trampoline = hppa32_hpux_in_solib_call_trampoline;
1496   else
1497     tdep->in_solib_call_trampoline = hppa64_hpux_in_solib_call_trampoline;
1498
1499   tdep->unwind_adjust_stub = hppa_hpux_unwind_adjust_stub;
1500
1501   set_gdbarch_in_solib_return_trampoline
1502     (gdbarch, hppa_hpux_in_solib_return_trampoline);
1503   set_gdbarch_skip_trampoline_code (gdbarch, hppa_hpux_skip_trampoline_code);
1504
1505   set_gdbarch_push_dummy_code (gdbarch, hppa_hpux_push_dummy_code);
1506   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
1507
1508   set_gdbarch_read_pc (gdbarch, hppa_hpux_read_pc);
1509   set_gdbarch_write_pc (gdbarch, hppa_hpux_write_pc);
1510   set_gdbarch_unwind_pc (gdbarch, hppa_hpux_unwind_pc);
1511   set_gdbarch_skip_permanent_breakpoint
1512     (gdbarch, hppa_skip_permanent_breakpoint);
1513
1514   set_gdbarch_regset_from_core_section
1515     (gdbarch, hppa_hpux_regset_from_core_section);
1516
1517   frame_unwind_append_unwinder (gdbarch, &hppa_hpux_sigtramp_frame_unwind);
1518 }
1519
1520 static void
1521 hppa_hpux_som_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1522 {
1523   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1524
1525   tdep->is_elf = 0;
1526
1527   tdep->find_global_pointer = hppa32_hpux_find_global_pointer;
1528
1529   hppa_hpux_init_abi (info, gdbarch);
1530   som_solib_select (gdbarch);
1531 }
1532
1533 static void
1534 hppa_hpux_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1535 {
1536   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1537
1538   tdep->is_elf = 1;
1539   tdep->find_global_pointer = hppa64_hpux_find_global_pointer;
1540
1541   hppa_hpux_init_abi (info, gdbarch);
1542   pa64_solib_select (gdbarch);
1543 }
1544
1545 static enum gdb_osabi
1546 hppa_hpux_core_osabi_sniffer (bfd *abfd)
1547 {
1548   if (strcmp (bfd_get_target (abfd), "hpux-core") == 0)
1549     return GDB_OSABI_HPUX_SOM;
1550   else if (strcmp (bfd_get_target (abfd), "elf64-hppa") == 0)
1551     {
1552       asection *section;
1553
1554       section = bfd_get_section_by_name (abfd, ".kernel");
1555       if (section)
1556         {
1557           bfd_size_type size;
1558           char *contents;
1559
1560           size = bfd_section_size (abfd, section);
1561           contents = alloca (size);
1562           if (bfd_get_section_contents (abfd, section, contents,
1563                                         (file_ptr) 0, size)
1564               && strcmp (contents, "HP-UX") == 0)
1565             return GDB_OSABI_HPUX_ELF;
1566         }
1567     }
1568
1569   return GDB_OSABI_UNKNOWN;
1570 }
1571
1572 void
1573 _initialize_hppa_hpux_tdep (void)
1574 {
1575   /* BFD doesn't set a flavour for HP-UX style core files.  It doesn't
1576      set the architecture either.  */
1577   gdbarch_register_osabi_sniffer (bfd_arch_unknown,
1578                                   bfd_target_unknown_flavour,
1579                                   hppa_hpux_core_osabi_sniffer);
1580   gdbarch_register_osabi_sniffer (bfd_arch_hppa,
1581                                   bfd_target_elf_flavour,
1582                                   hppa_hpux_core_osabi_sniffer);
1583
1584   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_HPUX_SOM,
1585                           hppa_hpux_som_init_abi);
1586   gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_HPUX_ELF,
1587                           hppa_hpux_elf_init_abi);
1588 }