gdb/hppa-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
   2
   3    Copyright 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "gdbcore.h"
  23 #include "osabi.h"
  24 #include "target.h"
  25 #include "objfiles.h"
  26 #include "solib-svr4.h"
  27 #include "glibc-tdep.h"
  28 #include "frame-unwind.h"
  29 #include "trad-frame.h"
  30 #include "dwarf2-frame.h"
  31 #include "value.h"
  32 #include "hppa-tdep.h"
  33
  34 #include "elf/common.h"
  35
  36 #if 0
  37 /* Convert DWARF register number REG to the appropriate register
  38    number used by GDB.  */
  39 static int
  40 hppa_dwarf_reg_to_regnum (int reg)
  41 {
  42   /* registers 0 - 31 are the same in both sets */
  43   if (reg < 32)
  44     return reg;
  45
  46   /* dwarf regs 32 to 85 are fpregs 4 - 31 */
  47   if (reg >= 32 && reg <= 85)
  48     return HPPA_FP4_REGNUM + (reg - 32);
  49
  50   warning (_("Unmapped DWARF Register #%d encountered."), reg);
  51   return -1;
  52 }
  53 #endif
  54
  55 static void
  56 hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid)
  57 {
  58   /* Probably this should be done by the kernel, but it isn't.  */
  59   write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid);
  60   write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid);
  61 }
  62
  63 /* An instruction to match.  */
  64 struct insn_pattern
  65 {
  66   unsigned int data;            /* See if it matches this....  */
  67   unsigned int mask;            /* ... with this mask.  */
  68 };
  69
  70 /* See bfd/elf32-hppa.c */
  71 static struct insn_pattern hppa_long_branch_stub[] = {
  72   /* ldil LR'xxx,%r1 */
  73   { 0x20200000, 0xffe00000 },
  74   /* be,n RR'xxx(%sr4,%r1) */
  75   { 0xe0202002, 0xffe02002 },
  76   { 0, 0 }
  77 };
  78
  79 static struct insn_pattern hppa_long_branch_pic_stub[] = {
  80   /* b,l .+8, %r1 */
  81   { 0xe8200000, 0xffe00000 },
  82   /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
  83   { 0x28200000, 0xffe00000 },
  84   /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
  85   { 0xe0202002, 0xffe02002 },
  86   { 0, 0 }
  87 };
  88
  89 static struct insn_pattern hppa_import_stub[] = {
  90   /* addil LR'xxx, %dp */
  91   { 0x2b600000, 0xffe00000 },
  92   /* ldw RR'xxx(%r1), %r21 */
  93   { 0x48350000, 0xffffb000 },
  94   /* bv %r0(%r21) */
  95   { 0xeaa0c000, 0xffffffff },
  96   /* ldw RR'xxx+4(%r1), %r19 */
  97   { 0x48330000, 0xffffb000 },
  98   { 0, 0 }
  99 };
 100
 101 static struct insn_pattern hppa_import_pic_stub[] = {
 102   /* addil LR'xxx,%r19 */
 103   { 0x2a600000, 0xffe00000 },
 104   /* ldw RR'xxx(%r1),%r21 */
 105   { 0x48350000, 0xffffb000 },
 106   /* bv %r0(%r21) */
 107   { 0xeaa0c000, 0xffffffff },
 108   /* ldw RR'xxx+4(%r1),%r19 */
 109   { 0x48330000, 0xffffb000 },
 110   { 0, 0 },
 111 };
 112
 113 static struct insn_pattern hppa_plt_stub[] = {
 114   /* b,l 1b, %r20 - 1b is 3 insns before here */
 115   { 0xea9f1fdd, 0xffffffff },
 116   /* depi 0,31,2,%r20 */
 117   { 0xd6801c1e, 0xffffffff },
 118   { 0, 0 }
 119 };
 120
 121 static struct insn_pattern hppa_sigtramp[] = {
 122   /* ldi 0, %r25 or ldi 1, %r25 */
 123   { 0x34190000, 0xfffffffd },
 124   /* ldi __NR_rt_sigreturn, %r20 */
 125   { 0x3414015a, 0xffffffff },
 126   /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
 127   { 0xe4008200, 0xffffffff },
 128   /* nop */
 129   { 0x08000240, 0xffffffff },
 130   { 0, 0 }
 131 };
 132
 133 #define HPPA_MAX_INSN_PATTERN_LEN (4)
 134
 135 /* Return non-zero if the instructions at PC match the series
 136    described in PATTERN, or zero otherwise.  PATTERN is an array of
 137    'struct insn_pattern' objects, terminated by an entry whose mask is
 138    zero.
 139
 140    When the match is successful, fill INSN[i] with what PATTERN[i]
 141    matched.  */
 142 static int
 143 insns_match_pattern (CORE_ADDR pc,
 144                      struct insn_pattern *pattern,
 145                      unsigned int *insn)
 146 {
 147   int i;
 148   CORE_ADDR npc = pc;
 149
 150   for (i = 0; pattern[i].mask; i++)
 151     {
 152       char buf[4];
 153
 154       deprecated_read_memory_nobpt (npc, buf, 4);
 155       insn[i] = extract_unsigned_integer (buf, 4);
 156       if ((insn[i] & pattern[i].mask) == pattern[i].data)
 157         npc += 4;
 158       else
 159         return 0;
 160     }
 161   return 1;
 162 }
 163
 164 /* The relaxed version of the insn matcher allows us to match from somewhere
 165    inside the pattern, by looking backwards in the instruction scheme.  */
 166 static int
 167 insns_match_pattern_relaxed (CORE_ADDR pc,
 168                              struct insn_pattern *pattern,
 169                              unsigned int *insn)
 170 {
 171   int pat_len = 0;
 172   int offset;
 173
 174   while (pattern[pat_len].mask)
 175     pat_len++;
 176
 177   for (offset = 0; offset < pat_len; offset++)
 178     {
 179       if (insns_match_pattern (pc - offset * 4,
 180                                pattern, insn))
 181         return 1;
 182     }
 183
 184   return 0;
 185 }
 186
 187 static int
 188 hppa_linux_in_dyncall (CORE_ADDR pc)
 189 {
 190   struct unwind_table_entry *u;
 191   u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
 192
 193   if (!u)
 194     return 0;
 195
 196   return pc >= u->region_start && pc <= u->region_end;
 197 }
 198
 199 /* There are several kinds of "trampolines" that we need to deal with:
 200    - long branch stubs: these are inserted by the linker when a branch
 201      target is too far away for a branch insn to reach
 202    - plt stubs: these should go into the .plt section, so are easy to find
 203    - import stubs: used to call from object to shared lib or shared lib to
 204      shared lib; these go in regular text sections.  In fact the linker tries
 205      to put them throughout the code because branches have limited reachability.
 206      We use the same mechanism as ppc64 to recognize the stub insn patterns.
 207    - $$dyncall: similar to hpux, hppa-linux uses $$dyncall for indirect function
 208      calls. $$dyncall is exported by libgcc.a  */
 209 static int
 210 hppa_linux_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 211 {
 212   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
 213   int r;
 214   struct unwind_table_entry *u;
 215
 216   /* on hppa-linux, linker stubs have no unwind information.  Since the pattern
 217      matching for linker stubs can be quite slow, we try to avoid it if
 218      we can.  */
 219   u = find_unwind_entry (pc);
 220
 221   r = in_plt_section (pc, name)
 222       || hppa_linux_in_dyncall (pc)
 223       || (u == NULL
 224           && (insns_match_pattern_relaxed (pc, hppa_import_stub, insn)
 225               || insns_match_pattern_relaxed (pc, hppa_import_pic_stub, insn)
 226               || insns_match_pattern_relaxed (pc, hppa_long_branch_stub, insn)
 227               || insns_match_pattern_relaxed (pc, hppa_long_branch_pic_stub, insn)));
 228
 229   return r;
 230 }
 231
 232 static CORE_ADDR
 233 hppa_linux_skip_trampoline_code (CORE_ADDR pc)
 234 {
 235   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
 236   int dp_rel, pic_rel;
 237
 238   /* dyncall handles both PLABELs and direct addresses */
 239   if (hppa_linux_in_dyncall (pc))
 240     {
 241       pc = (CORE_ADDR) read_register (22);
 242
 243       /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */
 244       if (pc & 0x2)
 245         pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
 246
 247       return pc;
 248     }
 249
 250   dp_rel = pic_rel = 0;
 251   if ((dp_rel = insns_match_pattern (pc, hppa_import_stub, insn))
 252       || (pic_rel = insns_match_pattern (pc, hppa_import_pic_stub, insn)))
 253     {
 254       /* Extract the target address from the addil/ldw sequence.  */
 255       pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
 256
 257       if (dp_rel)
 258         pc += (CORE_ADDR) read_register (27);
 259       else
 260         pc += (CORE_ADDR) read_register (19);
 261
 262       /* fallthrough */
 263     }
 264
 265   if (in_plt_section (pc, NULL))
 266     {
 267       pc = (CORE_ADDR) read_memory_integer (pc, TARGET_PTR_BIT / 8);
 268
 269       /* if the plt slot has not yet been resolved, the target will
 270          be the plt stub */
 271       if (in_plt_section (pc, NULL))
 272         {
 273           /* Sanity check: are we pointing to the plt stub? */
 274           if (insns_match_pattern (pc, hppa_plt_stub, insn))
 275             {
 276               /* this should point to the fixup routine */
 277               pc = (CORE_ADDR) read_memory_integer (pc + 8, TARGET_PTR_BIT / 8);
 278             }
 279           else
 280             {
 281               error (_("Cannot resolve plt stub at 0x%s."),
 282                      paddr_nz (pc));
 283               pc = 0;
 284             }
 285         }
 286     }
 287
 288   return pc;
 289 }
 290
 291 /* Signal frames.  */
 292
 293 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
 294
 295    Unfortunately, because of various bugs and changes to the kernel,
 296    we have several cases to deal with.
 297
 298    In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
 299    the beginning of the trampoline and struct rt_sigframe.
 300
 301    In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
 302    the 4th word in the trampoline structure.  This is wrong, it should point
 303    at the 5th word.  This is fixed in 2.6.5-rc2-pa4.
 304
 305    To detect these cases, we first take pc, align it to 64-bytes
 306    to get the beginning of the signal frame, and then check offsets 0, 4
 307    and 5 to see if we found the beginning of the trampoline.  This will
 308    tell us how to locate the sigcontext structure.
 309
 310    Note that with a 2.4 64-bit kernel, the signal context is not properly
 311    passed back to userspace so the unwind will not work correctly.  */
 312 static CORE_ADDR
 313 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
 314 {
 315   unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
 316   int offs = 0;
 317   int try;
 318   /* offsets to try to find the trampoline */
 319   static int pcoffs[] = { 0, 4*4, 5*4 };
 320   /* offsets to the rt_sigframe structure */
 321   static int sfoffs[] = { 4*4, 10*4, 10*4 };
 322   CORE_ADDR sp;
 323
 324   /* Most of the time, this will be correct.  The one case when this will
 325      fail is if the user defined an alternate stack, in which case the
 326      beginning of the stack will not be align_down (pc, 64).  */
 327   sp = align_down (pc, 64);
 328
 329   /* rt_sigreturn trampoline:
 330      3419000x ldi 0, %r25 or ldi 1, %r25   (x = 0 or 2)
 331      3414015a ldi __NR_rt_sigreturn, %r20
 332      e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
 333      08000240 nop  */
 334
 335   for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
 336     {
 337       if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
 338         {
 339           offs = sfoffs[try];
 340           break;
 341         }
 342     }
 343
 344   if (offs == 0)
 345     {
 346       if (insns_match_pattern (pc, hppa_sigtramp, dummy))
 347         {
 348           /* sigaltstack case: we have no way of knowing which offset to
 349              use in this case; default to new kernel handling. If this is
 350              wrong the unwinding will fail.  */
 351           try = 2;
 352           sp = pc - pcoffs[try];
 353         }
 354       else
 355       {
 356         return 0;
 357       }
 358     }
 359
 360   /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
 361      a struct siginfo and a struct ucontext.  struct ucontext contains
 362      a struct sigcontext. Return an offset to this sigcontext here.  Too
 363      bad we cannot include system specific headers :-(.
 364      sizeof(struct siginfo) == 128
 365      offsetof(struct ucontext, uc_mcontext) == 24.  */
 366   return sp + sfoffs[try] + 128 + 24;
 367 }
 368
 369 struct hppa_linux_sigtramp_unwind_cache
 370 {
 371   CORE_ADDR base;
 372   struct trad_frame_saved_reg *saved_regs;
 373 };
 374
 375 static struct hppa_linux_sigtramp_unwind_cache *
 376 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
 377                                         void **this_cache)
 378 {
 379   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 380   struct hppa_linux_sigtramp_unwind_cache *info;
 381   CORE_ADDR pc, scptr;
 382   int i;
 383
 384   if (*this_cache)
 385     return *this_cache;
 386
 387   info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
 388   *this_cache = info;
 389   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 390
 391   pc = frame_pc_unwind (next_frame);
 392   scptr = hppa_linux_sigtramp_find_sigcontext (pc);
 393
 394   /* structure of struct sigcontext:
 395
 396      struct sigcontext {
 397         unsigned long sc_flags;
 398         unsigned long sc_gr[32];
 399         unsigned long long sc_fr[32];
 400         unsigned long sc_iasq[2];
 401         unsigned long sc_iaoq[2];
 402         unsigned long sc_sar;           */
 403
 404   /* Skip sc_flags.  */
 405   scptr += 4;
 406
 407   /* GR[0] is the psw, we don't restore that.  */
 408   scptr += 4;
 409
 410   /* General registers.  */
 411   for (i = 1; i < 32; i++)
 412     {
 413       info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
 414       scptr += 4;
 415     }
 416
 417   /* Pad.  */
 418   scptr += 4;
 419
 420   /* FP regs; FP0-3 are not restored.  */
 421   scptr += (8 * 4);
 422
 423   for (i = 4; i < 32; i++)
 424     {
 425       info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
 426       scptr += 4;
 427       info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
 428       scptr += 4;
 429     }
 430
 431   /* IASQ/IAOQ. */
 432   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
 433   scptr += 4;
 434   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
 435   scptr += 4;
 436
 437   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
 438   scptr += 4;
 439   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
 440   scptr += 4;
 441
 442   info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
 443
 444   return info;
 445 }
 446
 447 static void
 448 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
 449                                    void **this_prologue_cache,
 450                                    struct frame_id *this_id)
 451 {
 452   struct hppa_linux_sigtramp_unwind_cache *info
 453     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 454   *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
 455 }
 456
 457 static void
 458 hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
 459                                          void **this_prologue_cache,
 460                                          int regnum, int *optimizedp,
 461                                          enum lval_type *lvalp,
 462                                          CORE_ADDR *addrp,
 463                                          int *realnump, void *valuep)
 464 {
 465   struct hppa_linux_sigtramp_unwind_cache *info
 466     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 467   hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
 468                                    optimizedp, lvalp, addrp, realnump, valuep);
 469 }
 470
 471 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
 472   SIGTRAMP_FRAME,
 473   hppa_linux_sigtramp_frame_this_id,
 474   hppa_linux_sigtramp_frame_prev_register
 475 };
 476
 477 /* hppa-linux always uses "new-style" rt-signals.  The signal handler's return
 478    address should point to a signal trampoline on the stack.  The signal
 479    trampoline is embedded in a rt_sigframe structure that is aligned on
 480    the stack.  We take advantage of the fact that sp must be 64-byte aligned,
 481    and the trampoline is small, so by rounding down the trampoline address
 482    we can find the beginning of the struct rt_sigframe.  */
 483 static const struct frame_unwind *
 484 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
 485 {
 486   CORE_ADDR pc = frame_pc_unwind (next_frame);
 487
 488   if (hppa_linux_sigtramp_find_sigcontext (pc))
 489     return &hppa_linux_sigtramp_frame_unwind;
 490
 491   return NULL;
 492 }
 493
 494 /* Attempt to find (and return) the global pointer for the given
 495    function.
 496
 497    This is a rather nasty bit of code searchs for the .dynamic section
 498    in the objfile corresponding to the pc of the function we're trying
 499    to call.  Once it finds the addresses at which the .dynamic section
 500    lives in the child process, it scans the Elf32_Dyn entries for a
 501    DT_PLTGOT tag.  If it finds one of these, the corresponding
 502    d_un.d_ptr value is the global pointer.  */
 503
 504 static CORE_ADDR
 505 hppa_linux_find_global_pointer (struct value *function)
 506 {
 507   struct obj_section *faddr_sect;
 508   CORE_ADDR faddr;
 509
 510   faddr = value_as_address (function);
 511
 512   /* Is this a plabel? If so, dereference it to get the gp value.  */
 513   if (faddr & 2)
 514     {
 515       int status;
 516       char buf[4];
 517
 518       faddr &= ~3;
 519
 520       status = target_read_memory (faddr + 4, buf, sizeof (buf));
 521       if (status == 0)
 522         return extract_unsigned_integer (buf, sizeof (buf));
 523     }
 524
 525   /* If the address is in the plt section, then the real function hasn't
 526      yet been fixed up by the linker so we cannot determine the gp of
 527      that function.  */
 528   if (in_plt_section (faddr, NULL))
 529     return 0;
 530
 531   faddr_sect = find_pc_section (faddr);
 532   if (faddr_sect != NULL)
 533     {
 534       struct obj_section *osect;
 535
 536       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
 537         {
 538           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
 539             break;
 540         }
 541
 542       if (osect < faddr_sect->objfile->sections_end)
 543         {
 544           CORE_ADDR addr;
 545
 546           addr = osect->addr;
 547           while (addr < osect->endaddr)
 548             {
 549               int status;
 550               LONGEST tag;
 551               char buf[4];
 552
 553               status = target_read_memory (addr, buf, sizeof (buf));
 554               if (status != 0)
 555                 break;
 556               tag = extract_signed_integer (buf, sizeof (buf));
 557
 558               if (tag == DT_PLTGOT)
 559                 {
 560                   CORE_ADDR global_pointer;
 561
 562                   status = target_read_memory (addr + 4, buf, sizeof (buf));
 563                   if (status != 0)
 564                     break;
 565                   global_pointer = extract_unsigned_integer (buf, sizeof (buf));
 566
 567                   /* The payoff... */
 568                   return global_pointer;
 569                 }
 570
 571               if (tag == DT_NULL)
 572                 break;
 573
 574               addr += 8;
 575             }
 576         }
 577     }
 578   return 0;
 579 }
 580
 581 /* Forward declarations.  */
 582 extern initialize_file_ftype _initialize_hppa_linux_tdep;
 583
 584 static void
 585 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 586 {
 587   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 588
 589   /* GNU/Linux is always ELF.  */
 590   tdep->is_elf = 1;
 591
 592   tdep->find_global_pointer = hppa_linux_find_global_pointer;
 593
 594   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
 595
 596   frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
 597
 598   /* GNU/Linux uses SVR4-style shared libraries.  */
 599   set_solib_svr4_fetch_link_map_offsets
 600     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 601
 602   tdep->in_solib_call_trampoline = hppa_linux_in_solib_call_trampoline;
 603   set_gdbarch_skip_trampoline_code
 604         (gdbarch, hppa_linux_skip_trampoline_code);
 605
 606   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 607   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 608
 609   /* On hppa-linux, currently, sizeof(long double) == 8.  There has been
 610      some discussions to support 128-bit long double, but it requires some
 611      more work in gcc and glibc first.  */
 612   set_gdbarch_long_double_bit (gdbarch, 64);
 613
 614 #if 0
 615   /* Dwarf-2 unwinding support.  Not yet working.  */
 616   set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 617   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 618   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 619   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
 620 #endif
 621 }
 622
 623 void
 624 _initialize_hppa_linux_tdep (void)
 625 {
 626   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
 627 }