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