URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [elf64-hppa.c] - Diff between revs 827 and 840

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 827	Rev 840
`/* Support for HPPA 64-bit ELF`	`/* Support for HPPA 64-bit ELF`
`1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009`	`1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009`
`Free Software Foundation, Inc.`	`Free Software Foundation, Inc.`

`This file is part of BFD, the Binary File Descriptor library.`	`This file is part of BFD, the Binary File Descriptor library.`

`This program is free software; you can redistribute it and/or modify`	`This program is free software; you can redistribute it and/or modify`
`it under the terms of the GNU General Public License as published by`	`it under the terms of the GNU General Public License as published by`
`the Free Software Foundation; either version 3 of the License, or`	`the Free Software Foundation; either version 3 of the License, or`
`(at your option) any later version.`	`(at your option) any later version.`

`This program is distributed in the hope that it will be useful,`	`This program is distributed in the hope that it will be useful,`
`but WITHOUT ANY WARRANTY; without even the implied warranty of`	`but WITHOUT ANY WARRANTY; without even the implied warranty of`
`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`	`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
`GNU General Public License for more details.`	`GNU General Public License for more details.`

`You should have received a copy of the GNU General Public License`	`You should have received a copy of the GNU General Public License`
`along with this program; if not, write to the Free Software`	`along with this program; if not, write to the Free Software`
`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`	`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
`MA 02110-1301, USA. */`	`MA 02110-1301, USA. */`

`#include "alloca-conf.h"`	`#include "alloca-conf.h"`
`#include "sysdep.h"`	`#include "sysdep.h"`
`#include "bfd.h"`	`#include "bfd.h"`
`#include "libbfd.h"`	`#include "libbfd.h"`
`#include "elf-bfd.h"`	`#include "elf-bfd.h"`
`#include "elf/hppa.h"`	`#include "elf/hppa.h"`
`#include "libhppa.h"`	`#include "libhppa.h"`
`#include "elf64-hppa.h"`	`#include "elf64-hppa.h"`


`#define ARCH_SIZE 64`	`#define ARCH_SIZE 64`

`#define PLT_ENTRY_SIZE 0x10`	`#define PLT_ENTRY_SIZE 0x10`
`#define DLT_ENTRY_SIZE 0x8`	`#define DLT_ENTRY_SIZE 0x8`
`#define OPD_ENTRY_SIZE 0x20`	`#define OPD_ENTRY_SIZE 0x20`

`#define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"`	`#define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"`

`/* The stub is supposed to load the target address and target's DP`	`/* The stub is supposed to load the target address and target's DP`
`value out of the PLT, then do an external branch to the target`	`value out of the PLT, then do an external branch to the target`
`address.`	`address.`

`LDD PLTOFF(%r27),%r1`	`LDD PLTOFF(%r27),%r1`
`BVE (%r1)`	`BVE (%r1)`
`LDD PLTOFF+8(%r27),%r27`	`LDD PLTOFF+8(%r27),%r27`

`Note that we must use the LDD with a 14 bit displacement, not the one`	`Note that we must use the LDD with a 14 bit displacement, not the one`
`with a 5 bit displacement. */`	`with a 5 bit displacement. */`
`static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,`	`static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,`
`0x53, 0x7b, 0x00, 0x00 };`	`0x53, 0x7b, 0x00, 0x00 };`

`struct elf64_hppa_link_hash_entry`	`struct elf64_hppa_link_hash_entry`
`{`	`{`
`struct elf_link_hash_entry eh;`	`struct elf_link_hash_entry eh;`

`/* Offsets for this symbol in various linker sections. */`	`/* Offsets for this symbol in various linker sections. */`
`bfd_vma dlt_offset;`	`bfd_vma dlt_offset;`
`bfd_vma plt_offset;`	`bfd_vma plt_offset;`
`bfd_vma opd_offset;`	`bfd_vma opd_offset;`
`bfd_vma stub_offset;`	`bfd_vma stub_offset;`

`/* The index of the (possibly local) symbol in the input bfd and its`	`/* The index of the (possibly local) symbol in the input bfd and its`
`associated BFD. Needed so that we can have relocs against local`	`associated BFD. Needed so that we can have relocs against local`
`symbols in shared libraries. */`	`symbols in shared libraries. */`
`long sym_indx;`	`long sym_indx;`
`bfd *owner;`	`bfd *owner;`

`/* Dynamic symbols may need to have two different values. One for`	`/* Dynamic symbols may need to have two different values. One for`
`the dynamic symbol table, one for the normal symbol table.`	`the dynamic symbol table, one for the normal symbol table.`

`In such cases we store the symbol's real value and section`	`In such cases we store the symbol's real value and section`
`index here so we can restore the real value before we write`	`index here so we can restore the real value before we write`
`the normal symbol table. */`	`the normal symbol table. */`
`bfd_vma st_value;`	`bfd_vma st_value;`
`int st_shndx;`	`int st_shndx;`

`/* Used to count non-got, non-plt relocations for delayed sizing`	`/* Used to count non-got, non-plt relocations for delayed sizing`
`of relocation sections. */`	`of relocation sections. */`
`struct elf64_hppa_dyn_reloc_entry`	`struct elf64_hppa_dyn_reloc_entry`
`{`	`{`
`/* Next relocation in the chain. */`	`/* Next relocation in the chain. */`
`struct elf64_hppa_dyn_reloc_entry *next;`	`struct elf64_hppa_dyn_reloc_entry *next;`

`/* The type of the relocation. */`	`/* The type of the relocation. */`
`int type;`	`int type;`

`/* The input section of the relocation. */`	`/* The input section of the relocation. */`
`asection *sec;`	`asection *sec;`

`/* Number of relocs copied in this section. */`	`/* Number of relocs copied in this section. */`
`bfd_size_type count;`	`bfd_size_type count;`

`/* The index of the section symbol for the input section of`	`/* The index of the section symbol for the input section of`
`the relocation. Only needed when building shared libraries. */`	`the relocation. Only needed when building shared libraries. */`
`int sec_symndx;`	`int sec_symndx;`

`/* The offset within the input section of the relocation. */`	`/* The offset within the input section of the relocation. */`
`bfd_vma offset;`	`bfd_vma offset;`

`/* The addend for the relocation. */`	`/* The addend for the relocation. */`
`bfd_vma addend;`	`bfd_vma addend;`

`} *reloc_entries;`	`} *reloc_entries;`

`/* Nonzero if this symbol needs an entry in one of the linker`	`/* Nonzero if this symbol needs an entry in one of the linker`
`sections. */`	`sections. */`
`unsigned want_dlt;`	`unsigned want_dlt;`
`unsigned want_plt;`	`unsigned want_plt;`
`unsigned want_opd;`	`unsigned want_opd;`
`unsigned want_stub;`	`unsigned want_stub;`
`};`	`};`

`struct elf64_hppa_link_hash_table`	`struct elf64_hppa_link_hash_table`
`{`	`{`
`struct elf_link_hash_table root;`	`struct elf_link_hash_table root;`

`/* Shortcuts to get to the various linker defined sections. */`	`/* Shortcuts to get to the various linker defined sections. */`
`asection *dlt_sec;`	`asection *dlt_sec;`
`asection *dlt_rel_sec;`	`asection *dlt_rel_sec;`
`asection *plt_sec;`	`asection *plt_sec;`
`asection *plt_rel_sec;`	`asection *plt_rel_sec;`
`asection *opd_sec;`	`asection *opd_sec;`
`asection *opd_rel_sec;`	`asection *opd_rel_sec;`
`asection *other_rel_sec;`	`asection *other_rel_sec;`

`/* Offset of __gp within .plt section. When the PLT gets large we want`	`/* Offset of __gp within .plt section. When the PLT gets large we want`
`to slide __gp into the PLT section so that we can continue to use`	`to slide __gp into the PLT section so that we can continue to use`
`single DP relative instructions to load values out of the PLT. */`	`single DP relative instructions to load values out of the PLT. */`
`bfd_vma gp_offset;`	`bfd_vma gp_offset;`

`/* Note this is not strictly correct. We should create a stub section for`	`/* Note this is not strictly correct. We should create a stub section for`
`each input section with calls. The stub section should be placed before`	`each input section with calls. The stub section should be placed before`
`the section with the call. */`	`the section with the call. */`
`asection *stub_sec;`	`asection *stub_sec;`

`bfd_vma text_segment_base;`	`bfd_vma text_segment_base;`
`bfd_vma data_segment_base;`	`bfd_vma data_segment_base;`

`/* We build tables to map from an input section back to its`	`/* We build tables to map from an input section back to its`
`symbol index. This is the BFD for which we currently have`	`symbol index. This is the BFD for which we currently have`
`a map. */`	`a map. */`
`bfd *section_syms_bfd;`	`bfd *section_syms_bfd;`

`/* Array of symbol numbers for each input section attached to the`	`/* Array of symbol numbers for each input section attached to the`
`current BFD. */`	`current BFD. */`
`int *section_syms;`	`int *section_syms;`
`};`	`};`

`#define hppa_link_hash_table(p) \`	`#define hppa_link_hash_table(p) \`
`((struct elf64_hppa_link_hash_table *) ((p)->hash))`	`((struct elf64_hppa_link_hash_table *) ((p)->hash))`

`#define hppa_elf_hash_entry(ent) \`	`#define hppa_elf_hash_entry(ent) \`
`((struct elf64_hppa_link_hash_entry *)(ent))`	`((struct elf64_hppa_link_hash_entry *)(ent))`

`#define eh_name(eh) \`	`#define eh_name(eh) \`
`(eh ? eh->root.root.string : "<undef>")`	`(eh ? eh->root.root.string : "<undef>")`

`typedef struct bfd_hash_entry (new_hash_entry_func)`	`typedef struct bfd_hash_entry (new_hash_entry_func)`
`(struct bfd_hash_entry , struct bfd_hash_table , const char *);`	`(struct bfd_hash_entry , struct bfd_hash_table , const char *);`

`static struct bfd_link_hash_table *elf64_hppa_hash_table_create`	`static struct bfd_link_hash_table *elf64_hppa_hash_table_create`
`(bfd *abfd);`	`(bfd *abfd);`

`/* This must follow the definitions of the various derived linker`	`/* This must follow the definitions of the various derived linker`
`hash tables and shared functions. */`	`hash tables and shared functions. */`
`#include "elf-hppa.h"`	`#include "elf-hppa.h"`

`static bfd_boolean elf64_hppa_object_p`	`static bfd_boolean elf64_hppa_object_p`
`(bfd *);`	`(bfd *);`

`static void elf64_hppa_post_process_headers`	`static void elf64_hppa_post_process_headers`
`(bfd , struct bfd_link_info );`	`(bfd , struct bfd_link_info );`

`static bfd_boolean elf64_hppa_create_dynamic_sections`	`static bfd_boolean elf64_hppa_create_dynamic_sections`
`(bfd , struct bfd_link_info );`	`(bfd , struct bfd_link_info );`

`static bfd_boolean elf64_hppa_adjust_dynamic_symbol`	`static bfd_boolean elf64_hppa_adjust_dynamic_symbol`
`(struct bfd_link_info , struct elf_link_hash_entry );`	`(struct bfd_link_info , struct elf_link_hash_entry );`

`static bfd_boolean elf64_hppa_mark_milli_and_exported_functions`	`static bfd_boolean elf64_hppa_mark_milli_and_exported_functions`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean elf64_hppa_size_dynamic_sections`	`static bfd_boolean elf64_hppa_size_dynamic_sections`
`(bfd , struct bfd_link_info );`	`(bfd , struct bfd_link_info );`

`static int elf64_hppa_link_output_symbol_hook`	`static int elf64_hppa_link_output_symbol_hook`
`(struct bfd_link_info , const char , Elf_Internal_Sym *,`	`(struct bfd_link_info , const char , Elf_Internal_Sym *,`
`asection , struct elf_link_hash_entry );`	`asection , struct elf_link_hash_entry );`

`static bfd_boolean elf64_hppa_finish_dynamic_symbol`	`static bfd_boolean elf64_hppa_finish_dynamic_symbol`
`(bfd , struct bfd_link_info ,`	`(bfd , struct bfd_link_info ,`
`struct elf_link_hash_entry , Elf_Internal_Sym );`	`struct elf_link_hash_entry , Elf_Internal_Sym );`

`static enum elf_reloc_type_class elf64_hppa_reloc_type_class`	`static enum elf_reloc_type_class elf64_hppa_reloc_type_class`
`(const Elf_Internal_Rela *);`	`(const Elf_Internal_Rela *);`

`static bfd_boolean elf64_hppa_finish_dynamic_sections`	`static bfd_boolean elf64_hppa_finish_dynamic_sections`
`(bfd , struct bfd_link_info );`	`(bfd , struct bfd_link_info );`

`static bfd_boolean elf64_hppa_check_relocs`	`static bfd_boolean elf64_hppa_check_relocs`
`(bfd , struct bfd_link_info ,`	`(bfd , struct bfd_link_info ,`
`asection , const Elf_Internal_Rela );`	`asection , const Elf_Internal_Rela );`

`static bfd_boolean elf64_hppa_dynamic_symbol_p`	`static bfd_boolean elf64_hppa_dynamic_symbol_p`
`(struct elf_link_hash_entry , struct bfd_link_info );`	`(struct elf_link_hash_entry , struct bfd_link_info );`

`static bfd_boolean elf64_hppa_mark_exported_functions`	`static bfd_boolean elf64_hppa_mark_exported_functions`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean elf64_hppa_finalize_opd`	`static bfd_boolean elf64_hppa_finalize_opd`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean elf64_hppa_finalize_dlt`	`static bfd_boolean elf64_hppa_finalize_dlt`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean allocate_global_data_dlt`	`static bfd_boolean allocate_global_data_dlt`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean allocate_global_data_plt`	`static bfd_boolean allocate_global_data_plt`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean allocate_global_data_stub`	`static bfd_boolean allocate_global_data_stub`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean allocate_global_data_opd`	`static bfd_boolean allocate_global_data_opd`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean get_reloc_section`	`static bfd_boolean get_reloc_section`
`(bfd , struct elf64_hppa_link_hash_table , asection *);`	`(bfd , struct elf64_hppa_link_hash_table , asection *);`

`static bfd_boolean count_dyn_reloc`	`static bfd_boolean count_dyn_reloc`
`(bfd , struct elf64_hppa_link_hash_entry ,`	`(bfd , struct elf64_hppa_link_hash_entry ,`
`int, asection *, int, bfd_vma, bfd_vma);`	`int, asection *, int, bfd_vma, bfd_vma);`

`static bfd_boolean allocate_dynrel_entries`	`static bfd_boolean allocate_dynrel_entries`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean elf64_hppa_finalize_dynreloc`	`static bfd_boolean elf64_hppa_finalize_dynreloc`
`(struct elf_link_hash_entry , void );`	`(struct elf_link_hash_entry , void );`

`static bfd_boolean get_opd`	`static bfd_boolean get_opd`
`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`	`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`

`static bfd_boolean get_plt`	`static bfd_boolean get_plt`
`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`	`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`

`static bfd_boolean get_dlt`	`static bfd_boolean get_dlt`
`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`	`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`

`static bfd_boolean get_stub`	`static bfd_boolean get_stub`
`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`	`(bfd , struct bfd_link_info , struct elf64_hppa_link_hash_table *);`

`static int elf64_hppa_elf_get_symbol_type`	`static int elf64_hppa_elf_get_symbol_type`
`(Elf_Internal_Sym *, int);`	`(Elf_Internal_Sym *, int);`

`/* Initialize an entry in the link hash table. */`	`/* Initialize an entry in the link hash table. */`

`static struct bfd_hash_entry *`	`static struct bfd_hash_entry *`
`hppa64_link_hash_newfunc (struct bfd_hash_entry *entry,`	`hppa64_link_hash_newfunc (struct bfd_hash_entry *entry,`
`struct bfd_hash_table *table,`	`struct bfd_hash_table *table,`
`const char *string)`	`const char *string)`
`{`	`{`
`/* Allocate the structure if it has not already been allocated by a`	`/* Allocate the structure if it has not already been allocated by a`
`subclass. */`	`subclass. */`
`if (entry == NULL)`	`if (entry == NULL)`
`{`	`{`
`entry = bfd_hash_allocate (table,`	`entry = bfd_hash_allocate (table,`
`sizeof (struct elf64_hppa_link_hash_entry));`	`sizeof (struct elf64_hppa_link_hash_entry));`
`if (entry == NULL)`	`if (entry == NULL)`
`return entry;`	`return entry;`
`}`	`}`

`/* Call the allocation method of the superclass. */`	`/* Call the allocation method of the superclass. */`
`entry = _bfd_elf_link_hash_newfunc (entry, table, string);`	`entry = _bfd_elf_link_hash_newfunc (entry, table, string);`
`if (entry != NULL)`	`if (entry != NULL)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh;`	`struct elf64_hppa_link_hash_entry *hh;`

`/* Initialize our local data. All zeros. */`	`/* Initialize our local data. All zeros. */`
`hh = hppa_elf_hash_entry (entry);`	`hh = hppa_elf_hash_entry (entry);`
`memset (&hh->dlt_offset, 0,`	`memset (&hh->dlt_offset, 0,`
`(sizeof (struct elf64_hppa_link_hash_entry)`	`(sizeof (struct elf64_hppa_link_hash_entry)`
`- offsetof (struct elf64_hppa_link_hash_entry, dlt_offset)));`	`- offsetof (struct elf64_hppa_link_hash_entry, dlt_offset)));`
`}`	`}`

`return entry;`	`return entry;`
`}`	`}`

`/* Create the derived linker hash table. The PA64 ELF port uses this`	`/* Create the derived linker hash table. The PA64 ELF port uses this`
`derived hash table to keep information specific to the PA ElF`	`derived hash table to keep information specific to the PA ElF`
`linker (without using static variables). */`	`linker (without using static variables). */`

`static struct bfd_link_hash_table*`	`static struct bfd_link_hash_table*`
`elf64_hppa_hash_table_create (bfd *abfd)`	`elf64_hppa_hash_table_create (bfd *abfd)`
`{`	`{`
`struct elf64_hppa_link_hash_table *htab;`	`struct elf64_hppa_link_hash_table *htab;`
`bfd_size_type amt = sizeof (*htab);`	`bfd_size_type amt = sizeof (*htab);`

`htab = bfd_zalloc (abfd, amt);`	`htab = bfd_zalloc (abfd, amt);`
`if (htab == NULL)`	`if (htab == NULL)`
`return NULL;`	`return NULL;`

`if (!_bfd_elf_link_hash_table_init (&htab->root, abfd,`	`if (!_bfd_elf_link_hash_table_init (&htab->root, abfd,`
`hppa64_link_hash_newfunc,`	`hppa64_link_hash_newfunc,`
`sizeof (struct elf64_hppa_link_hash_entry)))`	`sizeof (struct elf64_hppa_link_hash_entry)))`
`{`	`{`
`bfd_release (abfd, htab);`	`bfd_release (abfd, htab);`
`return NULL;`	`return NULL;`
`}`	`}`

`htab->text_segment_base = (bfd_vma) -1;`	`htab->text_segment_base = (bfd_vma) -1;`
`htab->data_segment_base = (bfd_vma) -1;`	`htab->data_segment_base = (bfd_vma) -1;`

`return &htab->root.root;`	`return &htab->root.root;`
`}`	`}`

`/* Return nonzero if ABFD represents a PA2.0 ELF64 file.`	`/* Return nonzero if ABFD represents a PA2.0 ELF64 file.`

`Additionally we set the default architecture and machine. */`	`Additionally we set the default architecture and machine. */`
`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_object_p (bfd *abfd)`	`elf64_hppa_object_p (bfd *abfd)`
`{`	`{`
`Elf_Internal_Ehdr * i_ehdrp;`	`Elf_Internal_Ehdr * i_ehdrp;`
`unsigned int flags;`	`unsigned int flags;`

`i_ehdrp = elf_elfheader (abfd);`	`i_ehdrp = elf_elfheader (abfd);`
`if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)`	`if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)`
`{`	`{`
`/* GCC on hppa-linux produces binaries with OSABI=Linux,`	`/* GCC on hppa-linux produces binaries with OSABI=Linux,`
`but the kernel produces corefiles with OSABI=SysV. */`	`but the kernel produces corefiles with OSABI=SysV. */`
`if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX`	`if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX`
`&& i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */`	`&& i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */`
`return FALSE;`	`return FALSE;`
`}`	`}`
`else`	`else`
`{`	`{`
`/* HPUX produces binaries with OSABI=HPUX,`	`/* HPUX produces binaries with OSABI=HPUX,`
`but the kernel produces corefiles with OSABI=SysV. */`	`but the kernel produces corefiles with OSABI=SysV. */`
`if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX`	`if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX`
`&& i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */`	`&& i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */`
`return FALSE;`	`return FALSE;`
`}`	`}`

`flags = i_ehdrp->e_flags;`	`flags = i_ehdrp->e_flags;`
`switch (flags & (EF_PARISC_ARCH \| EF_PARISC_WIDE))`	`switch (flags & (EF_PARISC_ARCH \| EF_PARISC_WIDE))`
`{`	`{`
`case EFA_PARISC_1_0:`	`case EFA_PARISC_1_0:`
`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);`	`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);`
`case EFA_PARISC_1_1:`	`case EFA_PARISC_1_1:`
`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);`	`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);`
`case EFA_PARISC_2_0:`	`case EFA_PARISC_2_0:`
`if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)`	`if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)`
`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);`	`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);`
`else`	`else`
`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);`	`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);`
`case EFA_PARISC_2_0 \| EF_PARISC_WIDE:`	`case EFA_PARISC_2_0 \| EF_PARISC_WIDE:`
`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);`	`return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);`
`}`	`}`
`/* Don't be fussy. */`	`/* Don't be fussy. */`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Given section type (hdr->sh_type), return a boolean indicating`	`/* Given section type (hdr->sh_type), return a boolean indicating`
`whether or not the section is an elf64-hppa specific section. */`	`whether or not the section is an elf64-hppa specific section. */`
`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_section_from_shdr (bfd *abfd,`	`elf64_hppa_section_from_shdr (bfd *abfd,`
`Elf_Internal_Shdr *hdr,`	`Elf_Internal_Shdr *hdr,`
`const char *name,`	`const char *name,`
`int shindex)`	`int shindex)`
`{`	`{`
`asection *newsect;`	`asection *newsect;`

`switch (hdr->sh_type)`	`switch (hdr->sh_type)`
`{`	`{`
`case SHT_PARISC_EXT:`	`case SHT_PARISC_EXT:`
`if (strcmp (name, ".PARISC.archext") != 0)`	`if (strcmp (name, ".PARISC.archext") != 0)`
`return FALSE;`	`return FALSE;`
`break;`	`break;`
`case SHT_PARISC_UNWIND:`	`case SHT_PARISC_UNWIND:`
`if (strcmp (name, ".PARISC.unwind") != 0)`	`if (strcmp (name, ".PARISC.unwind") != 0)`
`return FALSE;`	`return FALSE;`
`break;`	`break;`
`case SHT_PARISC_DOC:`	`case SHT_PARISC_DOC:`
`case SHT_PARISC_ANNOT:`	`case SHT_PARISC_ANNOT:`
`default:`	`default:`
`return FALSE;`	`return FALSE;`
`}`	`}`

`if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))`	`if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))`
`return FALSE;`	`return FALSE;`
`newsect = hdr->bfd_section;`	`newsect = hdr->bfd_section;`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* SEC is a section containing relocs for an input BFD when linking; return`	`/* SEC is a section containing relocs for an input BFD when linking; return`
`a suitable section for holding relocs in the output BFD for a link. */`	`a suitable section for holding relocs in the output BFD for a link. */`

`static bfd_boolean`	`static bfd_boolean`
`get_reloc_section (bfd *abfd,`	`get_reloc_section (bfd *abfd,`
`struct elf64_hppa_link_hash_table *hppa_info,`	`struct elf64_hppa_link_hash_table *hppa_info,`
`asection *sec)`	`asection *sec)`
`{`	`{`
`const char *srel_name;`	`const char *srel_name;`
`asection *srel;`	`asection *srel;`
`bfd *dynobj;`	`bfd *dynobj;`

`srel_name = (bfd_elf_string_from_elf_section`	`srel_name = (bfd_elf_string_from_elf_section`
`(abfd, elf_elfheader(abfd)->e_shstrndx,`	`(abfd, elf_elfheader(abfd)->e_shstrndx,`
`elf_section_data(sec)->rel_hdr.sh_name));`	`elf_section_data(sec)->rel_hdr.sh_name));`
`if (srel_name == NULL)`	`if (srel_name == NULL)`
`return FALSE;`	`return FALSE;`

`BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela")`	`BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela")`
`&& strcmp (bfd_get_section_name (abfd, sec),`	`&& strcmp (bfd_get_section_name (abfd, sec),`
`srel_name + 5) == 0)`	`srel_name + 5) == 0)`
`\|\| (CONST_STRNEQ (srel_name, ".rel")`	`\|\| (CONST_STRNEQ (srel_name, ".rel")`
`&& strcmp (bfd_get_section_name (abfd, sec),`	`&& strcmp (bfd_get_section_name (abfd, sec),`
`srel_name + 4) == 0));`	`srel_name + 4) == 0));`

`dynobj = hppa_info->root.dynobj;`	`dynobj = hppa_info->root.dynobj;`
`if (!dynobj)`	`if (!dynobj)`
`hppa_info->root.dynobj = dynobj = abfd;`	`hppa_info->root.dynobj = dynobj = abfd;`

`srel = bfd_get_section_by_name (dynobj, srel_name);`	`srel = bfd_get_section_by_name (dynobj, srel_name);`
`if (srel == NULL)`	`if (srel == NULL)`
`{`	`{`
`srel = bfd_make_section_with_flags (dynobj, srel_name,`	`srel = bfd_make_section_with_flags (dynobj, srel_name,`
`(SEC_ALLOC`	`(SEC_ALLOC`
`\| SEC_LOAD`	`\| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_LINKER_CREATED`	`\| SEC_LINKER_CREATED`
`\| SEC_READONLY));`	`\| SEC_READONLY));`
`if (srel == NULL`	`if (srel == NULL`
`\|\| !bfd_set_section_alignment (dynobj, srel, 3))`	`\|\| !bfd_set_section_alignment (dynobj, srel, 3))`
`return FALSE;`	`return FALSE;`
`}`	`}`

`hppa_info->other_rel_sec = srel;`	`hppa_info->other_rel_sec = srel;`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Add a new entry to the list of dynamic relocations against DYN_H.`	`/* Add a new entry to the list of dynamic relocations against DYN_H.`

`We use this to keep a record of all the FPTR relocations against a`	`We use this to keep a record of all the FPTR relocations against a`
`particular symbol so that we can create FPTR relocations in the`	`particular symbol so that we can create FPTR relocations in the`
`output file. */`	`output file. */`

`static bfd_boolean`	`static bfd_boolean`
`count_dyn_reloc (bfd *abfd,`	`count_dyn_reloc (bfd *abfd,`
`struct elf64_hppa_link_hash_entry *hh,`	`struct elf64_hppa_link_hash_entry *hh,`
`int type,`	`int type,`
`asection *sec,`	`asection *sec,`
`int sec_symndx,`	`int sec_symndx,`
`bfd_vma offset,`	`bfd_vma offset,`
`bfd_vma addend)`	`bfd_vma addend)`
`{`	`{`
`struct elf64_hppa_dyn_reloc_entry *rent;`	`struct elf64_hppa_dyn_reloc_entry *rent;`

`rent = (struct elf64_hppa_dyn_reloc_entry *)`	`rent = (struct elf64_hppa_dyn_reloc_entry *)`
`bfd_alloc (abfd, (bfd_size_type) sizeof (*rent));`	`bfd_alloc (abfd, (bfd_size_type) sizeof (*rent));`
`if (!rent)`	`if (!rent)`
`return FALSE;`	`return FALSE;`

`rent->next = hh->reloc_entries;`	`rent->next = hh->reloc_entries;`
`rent->type = type;`	`rent->type = type;`
`rent->sec = sec;`	`rent->sec = sec;`
`rent->sec_symndx = sec_symndx;`	`rent->sec_symndx = sec_symndx;`
`rent->offset = offset;`	`rent->offset = offset;`
`rent->addend = addend;`	`rent->addend = addend;`
`hh->reloc_entries = rent;`	`hh->reloc_entries = rent;`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Return a pointer to the local DLT, PLT and OPD reference counts`	`/* Return a pointer to the local DLT, PLT and OPD reference counts`
`for ABFD. Returns NULL if the storage allocation fails. */`	`for ABFD. Returns NULL if the storage allocation fails. */`

`static bfd_signed_vma *`	`static bfd_signed_vma *`
`hppa64_elf_local_refcounts (bfd *abfd)`	`hppa64_elf_local_refcounts (bfd *abfd)`
`{`	`{`
`Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;`	`Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;`
`bfd_signed_vma *local_refcounts;`	`bfd_signed_vma *local_refcounts;`

`local_refcounts = elf_local_got_refcounts (abfd);`	`local_refcounts = elf_local_got_refcounts (abfd);`
`if (local_refcounts == NULL)`	`if (local_refcounts == NULL)`
`{`	`{`
`bfd_size_type size;`	`bfd_size_type size;`

`/* Allocate space for local DLT, PLT and OPD reference`	`/* Allocate space for local DLT, PLT and OPD reference`
`counts. Done this way to save polluting elf_obj_tdata`	`counts. Done this way to save polluting elf_obj_tdata`
`with another target specific pointer. */`	`with another target specific pointer. */`
`size = symtab_hdr->sh_info;`	`size = symtab_hdr->sh_info;`
`size = 3 sizeof (bfd_signed_vma);`	`size = 3 sizeof (bfd_signed_vma);`
`local_refcounts = bfd_zalloc (abfd, size);`	`local_refcounts = bfd_zalloc (abfd, size);`
`elf_local_got_refcounts (abfd) = local_refcounts;`	`elf_local_got_refcounts (abfd) = local_refcounts;`
`}`	`}`
`return local_refcounts;`	`return local_refcounts;`
`}`	`}`

`/* Scan the RELOCS and record the type of dynamic entries that each`	`/* Scan the RELOCS and record the type of dynamic entries that each`
`referenced symbol needs. */`	`referenced symbol needs. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_check_relocs (bfd *abfd,`	`elf64_hppa_check_relocs (bfd *abfd,`
`struct bfd_link_info *info,`	`struct bfd_link_info *info,`
`asection *sec,`	`asection *sec,`
`const Elf_Internal_Rela *relocs)`	`const Elf_Internal_Rela *relocs)`
`{`	`{`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`
`const Elf_Internal_Rela *relend;`	`const Elf_Internal_Rela *relend;`
`Elf_Internal_Shdr *symtab_hdr;`	`Elf_Internal_Shdr *symtab_hdr;`
`const Elf_Internal_Rela *rel;`	`const Elf_Internal_Rela *rel;`
`asection dlt, plt, *stubs;`	`asection dlt, plt, *stubs;`
`char *buf;`	`char *buf;`
`size_t buf_len;`	`size_t buf_len;`
`unsigned int sec_symndx;`	`unsigned int sec_symndx;`

`if (info->relocatable)`	`if (info->relocatable)`
`return TRUE;`	`return TRUE;`

`/* If this is the first dynamic object found in the link, create`	`/* If this is the first dynamic object found in the link, create`
`the special sections required for dynamic linking. */`	`the special sections required for dynamic linking. */`
`if (! elf_hash_table (info)->dynamic_sections_created)`	`if (! elf_hash_table (info)->dynamic_sections_created)`
`{`	`{`
`if (! _bfd_elf_link_create_dynamic_sections (abfd, info))`	`if (! _bfd_elf_link_create_dynamic_sections (abfd, info))`
`return FALSE;`	`return FALSE;`
`}`	`}`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`
`symtab_hdr = &elf_tdata (abfd)->symtab_hdr;`	`symtab_hdr = &elf_tdata (abfd)->symtab_hdr;`

`/* If necessary, build a new table holding section symbols indices`	`/* If necessary, build a new table holding section symbols indices`
`for this BFD. */`	`for this BFD. */`

`if (info->shared && hppa_info->section_syms_bfd != abfd)`	`if (info->shared && hppa_info->section_syms_bfd != abfd)`
`{`	`{`
`unsigned long i;`	`unsigned long i;`
`unsigned int highest_shndx;`	`unsigned int highest_shndx;`
`Elf_Internal_Sym *local_syms = NULL;`	`Elf_Internal_Sym *local_syms = NULL;`
`Elf_Internal_Sym isym, isymend;`	`Elf_Internal_Sym isym, isymend;`
`bfd_size_type amt;`	`bfd_size_type amt;`

`/* We're done with the old cache of section index to section symbol`	`/* We're done with the old cache of section index to section symbol`
`index information. Free it.`	`index information. Free it.`

`?!? Note we leak the last section_syms array. Presumably we`	`?!? Note we leak the last section_syms array. Presumably we`
`could free it in one of the later routines in this file. */`	`could free it in one of the later routines in this file. */`
`if (hppa_info->section_syms)`	`if (hppa_info->section_syms)`
`free (hppa_info->section_syms);`	`free (hppa_info->section_syms);`

`/* Read this BFD's local symbols. */`	`/* Read this BFD's local symbols. */`
`if (symtab_hdr->sh_info != 0)`	`if (symtab_hdr->sh_info != 0)`
`{`	`{`
`local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;`	`local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;`
`if (local_syms == NULL)`	`if (local_syms == NULL)`
`local_syms = bfd_elf_get_elf_syms (abfd, symtab_hdr,`	`local_syms = bfd_elf_get_elf_syms (abfd, symtab_hdr,`
`symtab_hdr->sh_info, 0,`	`symtab_hdr->sh_info, 0,`
`NULL, NULL, NULL);`	`NULL, NULL, NULL);`
`if (local_syms == NULL)`	`if (local_syms == NULL)`
`return FALSE;`	`return FALSE;`
`}`	`}`

`/* Record the highest section index referenced by the local symbols. */`	`/* Record the highest section index referenced by the local symbols. */`
`highest_shndx = 0;`	`highest_shndx = 0;`
`isymend = local_syms + symtab_hdr->sh_info;`	`isymend = local_syms + symtab_hdr->sh_info;`
`for (isym = local_syms; isym < isymend; isym++)`	`for (isym = local_syms; isym < isymend; isym++)`
`{`	`{`
`if (isym->st_shndx > highest_shndx`	`if (isym->st_shndx > highest_shndx`
`&& isym->st_shndx < SHN_LORESERVE)`	`&& isym->st_shndx < SHN_LORESERVE)`
`highest_shndx = isym->st_shndx;`	`highest_shndx = isym->st_shndx;`
`}`	`}`

`/* Allocate an array to hold the section index to section symbol index`	`/* Allocate an array to hold the section index to section symbol index`
`mapping. Bump by one since we start counting at zero. */`	`mapping. Bump by one since we start counting at zero. */`
`highest_shndx++;`	`highest_shndx++;`
`amt = highest_shndx;`	`amt = highest_shndx;`
`amt *= sizeof (int);`	`amt *= sizeof (int);`
`hppa_info->section_syms = (int *) bfd_malloc (amt);`	`hppa_info->section_syms = (int *) bfd_malloc (amt);`

`/* Now walk the local symbols again. If we find a section symbol,`	`/* Now walk the local symbols again. If we find a section symbol,`
`record the index of the symbol into the section_syms array. */`	`record the index of the symbol into the section_syms array. */`
`for (i = 0, isym = local_syms; isym < isymend; i++, isym++)`	`for (i = 0, isym = local_syms; isym < isymend; i++, isym++)`
`{`	`{`
`if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)`	`if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)`
`hppa_info->section_syms[isym->st_shndx] = i;`	`hppa_info->section_syms[isym->st_shndx] = i;`
`}`	`}`

`/* We are finished with the local symbols. */`	`/* We are finished with the local symbols. */`
`if (local_syms != NULL`	`if (local_syms != NULL`
`&& symtab_hdr->contents != (unsigned char *) local_syms)`	`&& symtab_hdr->contents != (unsigned char *) local_syms)`
`{`	`{`
`if (! info->keep_memory)`	`if (! info->keep_memory)`
`free (local_syms);`	`free (local_syms);`
`else`	`else`
`{`	`{`
`/* Cache the symbols for elf_link_input_bfd. */`	`/* Cache the symbols for elf_link_input_bfd. */`
`symtab_hdr->contents = (unsigned char *) local_syms;`	`symtab_hdr->contents = (unsigned char *) local_syms;`
`}`	`}`
`}`	`}`

`/* Record which BFD we built the section_syms mapping for. */`	`/* Record which BFD we built the section_syms mapping for. */`
`hppa_info->section_syms_bfd = abfd;`	`hppa_info->section_syms_bfd = abfd;`
`}`	`}`

`/* Record the symbol index for this input section. We may need it for`	`/* Record the symbol index for this input section. We may need it for`
`relocations when building shared libraries. When not building shared`	`relocations when building shared libraries. When not building shared`
`libraries this value is never really used, but assign it to zero to`	`libraries this value is never really used, but assign it to zero to`
`prevent out of bounds memory accesses in other routines. */`	`prevent out of bounds memory accesses in other routines. */`
`if (info->shared)`	`if (info->shared)`
`{`	`{`
`sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec);`	`sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec);`

`/* If we did not find a section symbol for this section, then`	`/* If we did not find a section symbol for this section, then`
`something went terribly wrong above. */`	`something went terribly wrong above. */`
`if (sec_symndx == SHN_BAD)`	`if (sec_symndx == SHN_BAD)`
`return FALSE;`	`return FALSE;`

`if (sec_symndx < SHN_LORESERVE)`	`if (sec_symndx < SHN_LORESERVE)`
`sec_symndx = hppa_info->section_syms[sec_symndx];`	`sec_symndx = hppa_info->section_syms[sec_symndx];`
`else`	`else`
`sec_symndx = 0;`	`sec_symndx = 0;`
`}`	`}`
`else`	`else`
`sec_symndx = 0;`	`sec_symndx = 0;`

`dlt = plt = stubs = NULL;`	`dlt = plt = stubs = NULL;`
`buf = NULL;`	`buf = NULL;`
`buf_len = 0;`	`buf_len = 0;`

`relend = relocs + sec->reloc_count;`	`relend = relocs + sec->reloc_count;`
`for (rel = relocs; rel < relend; ++rel)`	`for (rel = relocs; rel < relend; ++rel)`
`{`	`{`
`enum`	`enum`
`{`	`{`
`NEED_DLT = 1,`	`NEED_DLT = 1,`
`NEED_PLT = 2,`	`NEED_PLT = 2,`
`NEED_STUB = 4,`	`NEED_STUB = 4,`
`NEED_OPD = 8,`	`NEED_OPD = 8,`
`NEED_DYNREL = 16,`	`NEED_DYNREL = 16,`
`};`	`};`

`unsigned long r_symndx = ELF64_R_SYM (rel->r_info);`	`unsigned long r_symndx = ELF64_R_SYM (rel->r_info);`
`struct elf64_hppa_link_hash_entry *hh;`	`struct elf64_hppa_link_hash_entry *hh;`
`int need_entry;`	`int need_entry;`
`bfd_boolean maybe_dynamic;`	`bfd_boolean maybe_dynamic;`
`int dynrel_type = R_PARISC_NONE;`	`int dynrel_type = R_PARISC_NONE;`
`static reloc_howto_type *howto;`	`static reloc_howto_type *howto;`

`if (r_symndx >= symtab_hdr->sh_info)`	`if (r_symndx >= symtab_hdr->sh_info)`
`{`	`{`
`/* We're dealing with a global symbol -- find its hash entry`	`/* We're dealing with a global symbol -- find its hash entry`
`and mark it as being referenced. */`	`and mark it as being referenced. */`
`long indx = r_symndx - symtab_hdr->sh_info;`	`long indx = r_symndx - symtab_hdr->sh_info;`
`hh = hppa_elf_hash_entry (elf_sym_hashes (abfd)[indx]);`	`hh = hppa_elf_hash_entry (elf_sym_hashes (abfd)[indx]);`
`while (hh->eh.root.type == bfd_link_hash_indirect`	`while (hh->eh.root.type == bfd_link_hash_indirect`
`\|\| hh->eh.root.type == bfd_link_hash_warning)`	`\|\| hh->eh.root.type == bfd_link_hash_warning)`
`hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);`	`hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);`

`hh->eh.ref_regular = 1;`	`hh->eh.ref_regular = 1;`
`}`	`}`
`else`	`else`
`hh = NULL;`	`hh = NULL;`

`/* We can only get preliminary data on whether a symbol is`	`/* We can only get preliminary data on whether a symbol is`
`locally or externally defined, as not all of the input files`	`locally or externally defined, as not all of the input files`
`have yet been processed. Do something with what we know, as`	`have yet been processed. Do something with what we know, as`
`this may help reduce memory usage and processing time later. */`	`this may help reduce memory usage and processing time later. */`
`maybe_dynamic = FALSE;`	`maybe_dynamic = FALSE;`
`if (hh && ((info->shared`	`if (hh && ((info->shared`
`&& (!info->symbolic`	`&& (!info->symbolic`
`\|\| info->unresolved_syms_in_shared_libs == RM_IGNORE))`	`\|\| info->unresolved_syms_in_shared_libs == RM_IGNORE))`
`\|\| !hh->eh.def_regular`	`\|\| !hh->eh.def_regular`
`\|\| hh->eh.root.type == bfd_link_hash_defweak))`	`\|\| hh->eh.root.type == bfd_link_hash_defweak))`
`maybe_dynamic = TRUE;`	`maybe_dynamic = TRUE;`

`howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info);`	`howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info);`
`need_entry = 0;`	`need_entry = 0;`
`switch (howto->type)`	`switch (howto->type)`
`{`	`{`
`/* These are simple indirect references to symbols through the`	`/* These are simple indirect references to symbols through the`
`DLT. We need to create a DLT entry for any symbols which`	`DLT. We need to create a DLT entry for any symbols which`
`appears in a DLTIND relocation. */`	`appears in a DLTIND relocation. */`
`case R_PARISC_DLTIND21L:`	`case R_PARISC_DLTIND21L:`
`case R_PARISC_DLTIND14R:`	`case R_PARISC_DLTIND14R:`
`case R_PARISC_DLTIND14F:`	`case R_PARISC_DLTIND14F:`
`case R_PARISC_DLTIND14WR:`	`case R_PARISC_DLTIND14WR:`
`case R_PARISC_DLTIND14DR:`	`case R_PARISC_DLTIND14DR:`
`need_entry = NEED_DLT;`	`need_entry = NEED_DLT;`
`break;`	`break;`

`/* ?!? These need a DLT entry. But I have no idea what to do with`	`/* ?!? These need a DLT entry. But I have no idea what to do with`
`the "link time TP value. */`	`the "link time TP value. */`
`case R_PARISC_LTOFF_TP21L:`	`case R_PARISC_LTOFF_TP21L:`
`case R_PARISC_LTOFF_TP14R:`	`case R_PARISC_LTOFF_TP14R:`
`case R_PARISC_LTOFF_TP14F:`	`case R_PARISC_LTOFF_TP14F:`
`case R_PARISC_LTOFF_TP64:`	`case R_PARISC_LTOFF_TP64:`
`case R_PARISC_LTOFF_TP14WR:`	`case R_PARISC_LTOFF_TP14WR:`
`case R_PARISC_LTOFF_TP14DR:`	`case R_PARISC_LTOFF_TP14DR:`
`case R_PARISC_LTOFF_TP16F:`	`case R_PARISC_LTOFF_TP16F:`
`case R_PARISC_LTOFF_TP16WF:`	`case R_PARISC_LTOFF_TP16WF:`
`case R_PARISC_LTOFF_TP16DF:`	`case R_PARISC_LTOFF_TP16DF:`
`need_entry = NEED_DLT;`	`need_entry = NEED_DLT;`
`break;`	`break;`

`/* These are function calls. Depending on their precise target we`	`/* These are function calls. Depending on their precise target we`
`may need to make a stub for them. The stub uses the PLT, so we`	`may need to make a stub for them. The stub uses the PLT, so we`
`need to create PLT entries for these symbols too. */`	`need to create PLT entries for these symbols too. */`
`case R_PARISC_PCREL12F:`	`case R_PARISC_PCREL12F:`
`case R_PARISC_PCREL17F:`	`case R_PARISC_PCREL17F:`
`case R_PARISC_PCREL22F:`	`case R_PARISC_PCREL22F:`
`case R_PARISC_PCREL32:`	`case R_PARISC_PCREL32:`
`case R_PARISC_PCREL64:`	`case R_PARISC_PCREL64:`
`case R_PARISC_PCREL21L:`	`case R_PARISC_PCREL21L:`
`case R_PARISC_PCREL17R:`	`case R_PARISC_PCREL17R:`
`case R_PARISC_PCREL17C:`	`case R_PARISC_PCREL17C:`
`case R_PARISC_PCREL14R:`	`case R_PARISC_PCREL14R:`
`case R_PARISC_PCREL14F:`	`case R_PARISC_PCREL14F:`
`case R_PARISC_PCREL22C:`	`case R_PARISC_PCREL22C:`
`case R_PARISC_PCREL14WR:`	`case R_PARISC_PCREL14WR:`
`case R_PARISC_PCREL14DR:`	`case R_PARISC_PCREL14DR:`
`case R_PARISC_PCREL16F:`	`case R_PARISC_PCREL16F:`
`case R_PARISC_PCREL16WF:`	`case R_PARISC_PCREL16WF:`
`case R_PARISC_PCREL16DF:`	`case R_PARISC_PCREL16DF:`
`/* Function calls might need to go through the .plt, and`	`/* Function calls might need to go through the .plt, and`
`might need a long branch stub. */`	`might need a long branch stub. */`
`if (hh != NULL && hh->eh.type != STT_PARISC_MILLI)`	`if (hh != NULL && hh->eh.type != STT_PARISC_MILLI)`
`need_entry = (NEED_PLT \| NEED_STUB);`	`need_entry = (NEED_PLT \| NEED_STUB);`
`else`	`else`
`need_entry = 0;`	`need_entry = 0;`
`break;`	`break;`

`case R_PARISC_PLTOFF21L:`	`case R_PARISC_PLTOFF21L:`
`case R_PARISC_PLTOFF14R:`	`case R_PARISC_PLTOFF14R:`
`case R_PARISC_PLTOFF14F:`	`case R_PARISC_PLTOFF14F:`
`case R_PARISC_PLTOFF14WR:`	`case R_PARISC_PLTOFF14WR:`
`case R_PARISC_PLTOFF14DR:`	`case R_PARISC_PLTOFF14DR:`
`case R_PARISC_PLTOFF16F:`	`case R_PARISC_PLTOFF16F:`
`case R_PARISC_PLTOFF16WF:`	`case R_PARISC_PLTOFF16WF:`
`case R_PARISC_PLTOFF16DF:`	`case R_PARISC_PLTOFF16DF:`
`need_entry = (NEED_PLT);`	`need_entry = (NEED_PLT);`
`break;`	`break;`

`case R_PARISC_DIR64:`	`case R_PARISC_DIR64:`
`if (info->shared \|\| maybe_dynamic)`	`if (info->shared \|\| maybe_dynamic)`
`need_entry = (NEED_DYNREL);`	`need_entry = (NEED_DYNREL);`
`dynrel_type = R_PARISC_DIR64;`	`dynrel_type = R_PARISC_DIR64;`
`break;`	`break;`

`/* This is an indirect reference through the DLT to get the address`	`/* This is an indirect reference through the DLT to get the address`
`of a OPD descriptor. Thus we need to make a DLT entry that points`	`of a OPD descriptor. Thus we need to make a DLT entry that points`
`to an OPD entry. */`	`to an OPD entry. */`
`case R_PARISC_LTOFF_FPTR21L:`	`case R_PARISC_LTOFF_FPTR21L:`
`case R_PARISC_LTOFF_FPTR14R:`	`case R_PARISC_LTOFF_FPTR14R:`
`case R_PARISC_LTOFF_FPTR14WR:`	`case R_PARISC_LTOFF_FPTR14WR:`
`case R_PARISC_LTOFF_FPTR14DR:`	`case R_PARISC_LTOFF_FPTR14DR:`
`case R_PARISC_LTOFF_FPTR32:`	`case R_PARISC_LTOFF_FPTR32:`
`case R_PARISC_LTOFF_FPTR64:`	`case R_PARISC_LTOFF_FPTR64:`
`case R_PARISC_LTOFF_FPTR16F:`	`case R_PARISC_LTOFF_FPTR16F:`
`case R_PARISC_LTOFF_FPTR16WF:`	`case R_PARISC_LTOFF_FPTR16WF:`
`case R_PARISC_LTOFF_FPTR16DF:`	`case R_PARISC_LTOFF_FPTR16DF:`
`if (info->shared \|\| maybe_dynamic)`	`if (info->shared \|\| maybe_dynamic)`
`need_entry = (NEED_DLT \| NEED_OPD \| NEED_PLT);`	`need_entry = (NEED_DLT \| NEED_OPD \| NEED_PLT);`
`else`	`else`
`need_entry = (NEED_DLT \| NEED_OPD \| NEED_PLT);`	`need_entry = (NEED_DLT \| NEED_OPD \| NEED_PLT);`
`dynrel_type = R_PARISC_FPTR64;`	`dynrel_type = R_PARISC_FPTR64;`
`break;`	`break;`

`/* This is a simple OPD entry. */`	`/* This is a simple OPD entry. */`
`case R_PARISC_FPTR64:`	`case R_PARISC_FPTR64:`
`if (info->shared \|\| maybe_dynamic)`	`if (info->shared \|\| maybe_dynamic)`
`need_entry = (NEED_OPD \| NEED_PLT \| NEED_DYNREL);`	`need_entry = (NEED_OPD \| NEED_PLT \| NEED_DYNREL);`
`else`	`else`
`need_entry = (NEED_OPD \| NEED_PLT);`	`need_entry = (NEED_OPD \| NEED_PLT);`
`dynrel_type = R_PARISC_FPTR64;`	`dynrel_type = R_PARISC_FPTR64;`
`break;`	`break;`

`/* Add more cases as needed. */`	`/* Add more cases as needed. */`
`}`	`}`

`if (!need_entry)`	`if (!need_entry)`
`continue;`	`continue;`

`if (hh)`	`if (hh)`
`{`	`{`
`/* Stash away enough information to be able to find this symbol`	`/* Stash away enough information to be able to find this symbol`
`regardless of whether or not it is local or global. */`	`regardless of whether or not it is local or global. */`
`hh->owner = abfd;`	`hh->owner = abfd;`
`hh->sym_indx = r_symndx;`	`hh->sym_indx = r_symndx;`
`}`	`}`

`/* Create what's needed. */`	`/* Create what's needed. */`
`if (need_entry & NEED_DLT)`	`if (need_entry & NEED_DLT)`
`{`	`{`
`/* Allocate space for a DLT entry, as well as a dynamic`	`/* Allocate space for a DLT entry, as well as a dynamic`
`relocation for this entry. */`	`relocation for this entry. */`
`if (! hppa_info->dlt_sec`	`if (! hppa_info->dlt_sec`
`&& ! get_dlt (abfd, info, hppa_info))`	`&& ! get_dlt (abfd, info, hppa_info))`
`goto err_out;`	`goto err_out;`

`if (hh != NULL)`	`if (hh != NULL)`
`{`	`{`
`hh->want_dlt = 1;`	`hh->want_dlt = 1;`
`hh->eh.got.refcount += 1;`	`hh->eh.got.refcount += 1;`
`}`	`}`
`else`	`else`
`{`	`{`
`bfd_signed_vma *local_dlt_refcounts;`	`bfd_signed_vma *local_dlt_refcounts;`

`/* This is a DLT entry for a local symbol. */`	`/* This is a DLT entry for a local symbol. */`
`local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);`	`local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);`
`if (local_dlt_refcounts == NULL)`	`if (local_dlt_refcounts == NULL)`
`return FALSE;`	`return FALSE;`
`local_dlt_refcounts[r_symndx] += 1;`	`local_dlt_refcounts[r_symndx] += 1;`
`}`	`}`
`}`	`}`

`if (need_entry & NEED_PLT)`	`if (need_entry & NEED_PLT)`
`{`	`{`
`if (! hppa_info->plt_sec`	`if (! hppa_info->plt_sec`
`&& ! get_plt (abfd, info, hppa_info))`	`&& ! get_plt (abfd, info, hppa_info))`
`goto err_out;`	`goto err_out;`

`if (hh != NULL)`	`if (hh != NULL)`
`{`	`{`
`hh->want_plt = 1;`	`hh->want_plt = 1;`
`hh->eh.needs_plt = 1;`	`hh->eh.needs_plt = 1;`
`hh->eh.plt.refcount += 1;`	`hh->eh.plt.refcount += 1;`
`}`	`}`
`else`	`else`
`{`	`{`
`bfd_signed_vma *local_dlt_refcounts;`	`bfd_signed_vma *local_dlt_refcounts;`
`bfd_signed_vma *local_plt_refcounts;`	`bfd_signed_vma *local_plt_refcounts;`

`/* This is a PLT entry for a local symbol. */`	`/* This is a PLT entry for a local symbol. */`
`local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);`	`local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);`
`if (local_dlt_refcounts == NULL)`	`if (local_dlt_refcounts == NULL)`
`return FALSE;`	`return FALSE;`
`local_plt_refcounts = local_dlt_refcounts + symtab_hdr->sh_info;`	`local_plt_refcounts = local_dlt_refcounts + symtab_hdr->sh_info;`
`local_plt_refcounts[r_symndx] += 1;`	`local_plt_refcounts[r_symndx] += 1;`
`}`	`}`
`}`	`}`

`if (need_entry & NEED_STUB)`	`if (need_entry & NEED_STUB)`
`{`	`{`
`if (! hppa_info->stub_sec`	`if (! hppa_info->stub_sec`
`&& ! get_stub (abfd, info, hppa_info))`	`&& ! get_stub (abfd, info, hppa_info))`
`goto err_out;`	`goto err_out;`
`if (hh)`	`if (hh)`
`hh->want_stub = 1;`	`hh->want_stub = 1;`
`}`	`}`

`if (need_entry & NEED_OPD)`	`if (need_entry & NEED_OPD)`
`{`	`{`
`if (! hppa_info->opd_sec`	`if (! hppa_info->opd_sec`
`&& ! get_opd (abfd, info, hppa_info))`	`&& ! get_opd (abfd, info, hppa_info))`
`goto err_out;`	`goto err_out;`

`/* FPTRs are not allocated by the dynamic linker for PA64,`	`/* FPTRs are not allocated by the dynamic linker for PA64,`
`though it is possible that will change in the future. */`	`though it is possible that will change in the future. */`

`if (hh != NULL)`	`if (hh != NULL)`
`hh->want_opd = 1;`	`hh->want_opd = 1;`
`else`	`else`
`{`	`{`
`bfd_signed_vma *local_dlt_refcounts;`	`bfd_signed_vma *local_dlt_refcounts;`
`bfd_signed_vma *local_opd_refcounts;`	`bfd_signed_vma *local_opd_refcounts;`

`/* This is a OPD for a local symbol. */`	`/* This is a OPD for a local symbol. */`
`local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);`	`local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);`
`if (local_dlt_refcounts == NULL)`	`if (local_dlt_refcounts == NULL)`
`return FALSE;`	`return FALSE;`
`local_opd_refcounts = (local_dlt_refcounts`	`local_opd_refcounts = (local_dlt_refcounts`
`+ 2 * symtab_hdr->sh_info);`	`+ 2 * symtab_hdr->sh_info);`
`local_opd_refcounts[r_symndx] += 1;`	`local_opd_refcounts[r_symndx] += 1;`
`}`	`}`
`}`	`}`

`/* Add a new dynamic relocation to the chain of dynamic`	`/* Add a new dynamic relocation to the chain of dynamic`
`relocations for this symbol. */`	`relocations for this symbol. */`
`if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))`	`if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))`
`{`	`{`
`if (! hppa_info->other_rel_sec`	`if (! hppa_info->other_rel_sec`
`&& ! get_reloc_section (abfd, hppa_info, sec))`	`&& ! get_reloc_section (abfd, hppa_info, sec))`
`goto err_out;`	`goto err_out;`

`/* Count dynamic relocations against global symbols. */`	`/* Count dynamic relocations against global symbols. */`
`if (hh != NULL`	`if (hh != NULL`
`&& !count_dyn_reloc (abfd, hh, dynrel_type, sec,`	`&& !count_dyn_reloc (abfd, hh, dynrel_type, sec,`
`sec_symndx, rel->r_offset, rel->r_addend))`	`sec_symndx, rel->r_offset, rel->r_addend))`
`goto err_out;`	`goto err_out;`

`/* If we are building a shared library and we just recorded`	`/* If we are building a shared library and we just recorded`
`a dynamic R_PARISC_FPTR64 relocation, then make sure the`	`a dynamic R_PARISC_FPTR64 relocation, then make sure the`
`section symbol for this section ends up in the dynamic`	`section symbol for this section ends up in the dynamic`
`symbol table. */`	`symbol table. */`
`if (info->shared && dynrel_type == R_PARISC_FPTR64`	`if (info->shared && dynrel_type == R_PARISC_FPTR64`
`&& ! (bfd_elf_link_record_local_dynamic_symbol`	`&& ! (bfd_elf_link_record_local_dynamic_symbol`
`(info, abfd, sec_symndx)))`	`(info, abfd, sec_symndx)))`
`return FALSE;`	`return FALSE;`
`}`	`}`
`}`	`}`

`if (buf)`	`if (buf)`
`free (buf);`	`free (buf);`
`return TRUE;`	`return TRUE;`

`err_out:`	`err_out:`
`if (buf)`	`if (buf)`
`free (buf);`	`free (buf);`
`return FALSE;`	`return FALSE;`
`}`	`}`

`struct elf64_hppa_allocate_data`	`struct elf64_hppa_allocate_data`
`{`	`{`
`struct bfd_link_info *info;`	`struct bfd_link_info *info;`
`bfd_size_type ofs;`	`bfd_size_type ofs;`
`};`	`};`

`/* Should we do dynamic things to this symbol? */`	`/* Should we do dynamic things to this symbol? */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_dynamic_symbol_p (struct elf_link_hash_entry *eh,`	`elf64_hppa_dynamic_symbol_p (struct elf_link_hash_entry *eh,`
`struct bfd_link_info *info)`	`struct bfd_link_info *info)`
`{`	`{`
`/* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols`	`/* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols`
`and relocations that retrieve a function descriptor? Assume the`	`and relocations that retrieve a function descriptor? Assume the`
`worst for now. */`	`worst for now. */`
`if (_bfd_elf_dynamic_symbol_p (eh, info, 1))`	`if (_bfd_elf_dynamic_symbol_p (eh, info, 1))`
`{`	`{`
`/* ??? Why is this here and not elsewhere is_local_label_name. */`	`/* ??? Why is this here and not elsewhere is_local_label_name. */`
`if (eh->root.root.string[0] == '$' && eh->root.root.string[1] == '$')`	`if (eh->root.root.string[0] == '$' && eh->root.root.string[1] == '$')`
`return FALSE;`	`return FALSE;`

`return TRUE;`	`return TRUE;`
`}`	`}`
`else`	`else`
`return FALSE;`	`return FALSE;`
`}`	`}`

`/* Mark all functions exported by this file so that we can later allocate`	`/* Mark all functions exported by this file so that we can later allocate`
`entries in .opd for them. */`	`entries in .opd for them. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_mark_exported_functions (struct elf_link_hash_entry eh, void data)`	`elf64_hppa_mark_exported_functions (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct bfd_link_info info = (struct bfd_link_info )data;`	`struct bfd_link_info info = (struct bfd_link_info )data;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`

`if (eh->root.type == bfd_link_hash_warning)`	`if (eh->root.type == bfd_link_hash_warning)`
`eh = (struct elf_link_hash_entry *) eh->root.u.i.link;`	`eh = (struct elf_link_hash_entry *) eh->root.u.i.link;`

`if (eh`	`if (eh`
`&& (eh->root.type == bfd_link_hash_defined`	`&& (eh->root.type == bfd_link_hash_defined`
`\|\| eh->root.type == bfd_link_hash_defweak)`	`\|\| eh->root.type == bfd_link_hash_defweak)`
`&& eh->root.u.def.section->output_section != NULL`	`&& eh->root.u.def.section->output_section != NULL`
`&& eh->type == STT_FUNC)`	`&& eh->type == STT_FUNC)`
`{`	`{`
`if (! hppa_info->opd_sec`	`if (! hppa_info->opd_sec`
`&& ! get_opd (hppa_info->root.dynobj, info, hppa_info))`	`&& ! get_opd (hppa_info->root.dynobj, info, hppa_info))`
`return FALSE;`	`return FALSE;`

`hh->want_opd = 1;`	`hh->want_opd = 1;`

`/* Put a flag here for output_symbol_hook. */`	`/* Put a flag here for output_symbol_hook. */`
`hh->st_shndx = -1;`	`hh->st_shndx = -1;`
`eh->needs_plt = 1;`	`eh->needs_plt = 1;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Allocate space for a DLT entry. */`	`/* Allocate space for a DLT entry. */`

`static bfd_boolean`	`static bfd_boolean`
`allocate_global_data_dlt (struct elf_link_hash_entry eh, void data)`	`allocate_global_data_dlt (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`	`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`

`if (hh->want_dlt)`	`if (hh->want_dlt)`
`{`	`{`
`if (x->info->shared)`	`if (x->info->shared)`
`{`	`{`
`/* Possibly add the symbol to the local dynamic symbol`	`/* Possibly add the symbol to the local dynamic symbol`
`table since we might need to create a dynamic relocation`	`table since we might need to create a dynamic relocation`
`against it. */`	`against it. */`
`if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)`	`if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)`
`{`	`{`
`bfd *owner = eh->root.u.def.section->owner;`	`bfd *owner = eh->root.u.def.section->owner;`

`if (! (bfd_elf_link_record_local_dynamic_symbol`	`if (! (bfd_elf_link_record_local_dynamic_symbol`
`(x->info, owner, hh->sym_indx)))`	`(x->info, owner, hh->sym_indx)))`
`return FALSE;`	`return FALSE;`
`}`	`}`
`}`	`}`

`hh->dlt_offset = x->ofs;`	`hh->dlt_offset = x->ofs;`
`x->ofs += DLT_ENTRY_SIZE;`	`x->ofs += DLT_ENTRY_SIZE;`
`}`	`}`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Allocate space for a DLT.PLT entry. */`	`/* Allocate space for a DLT.PLT entry. */`

`static bfd_boolean`	`static bfd_boolean`
`allocate_global_data_plt (struct elf_link_hash_entry eh, void data)`	`allocate_global_data_plt (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`	`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`

`if (hh->want_plt`	`if (hh->want_plt`
`&& elf64_hppa_dynamic_symbol_p (eh, x->info)`	`&& elf64_hppa_dynamic_symbol_p (eh, x->info)`
`&& !((eh->root.type == bfd_link_hash_defined`	`&& !((eh->root.type == bfd_link_hash_defined`
`\|\| eh->root.type == bfd_link_hash_defweak)`	`\|\| eh->root.type == bfd_link_hash_defweak)`
`&& eh->root.u.def.section->output_section != NULL))`	`&& eh->root.u.def.section->output_section != NULL))`
`{`	`{`
`hh->plt_offset = x->ofs;`	`hh->plt_offset = x->ofs;`
`x->ofs += PLT_ENTRY_SIZE;`	`x->ofs += PLT_ENTRY_SIZE;`
`if (hh->plt_offset < 0x2000)`	`if (hh->plt_offset < 0x2000)`
`hppa_link_hash_table (x->info)->gp_offset = hh->plt_offset;`	`hppa_link_hash_table (x->info)->gp_offset = hh->plt_offset;`
`}`	`}`
`else`	`else`
`hh->want_plt = 0;`	`hh->want_plt = 0;`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Allocate space for a STUB entry. */`	`/* Allocate space for a STUB entry. */`

`static bfd_boolean`	`static bfd_boolean`
`allocate_global_data_stub (struct elf_link_hash_entry eh, void data)`	`allocate_global_data_stub (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`	`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`

`if (hh->want_stub`	`if (hh->want_stub`
`&& elf64_hppa_dynamic_symbol_p (eh, x->info)`	`&& elf64_hppa_dynamic_symbol_p (eh, x->info)`
`&& !((eh->root.type == bfd_link_hash_defined`	`&& !((eh->root.type == bfd_link_hash_defined`
`\|\| eh->root.type == bfd_link_hash_defweak)`	`\|\| eh->root.type == bfd_link_hash_defweak)`
`&& eh->root.u.def.section->output_section != NULL))`	`&& eh->root.u.def.section->output_section != NULL))`
`{`	`{`
`hh->stub_offset = x->ofs;`	`hh->stub_offset = x->ofs;`
`x->ofs += sizeof (plt_stub);`	`x->ofs += sizeof (plt_stub);`
`}`	`}`
`else`	`else`
`hh->want_stub = 0;`	`hh->want_stub = 0;`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Allocate space for a FPTR entry. */`	`/* Allocate space for a FPTR entry. */`

`static bfd_boolean`	`static bfd_boolean`
`allocate_global_data_opd (struct elf_link_hash_entry eh, void data)`	`allocate_global_data_opd (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`	`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`

`if (hh && hh->want_opd)`	`if (hh && hh->want_opd)`
`{`	`{`
`while (hh->eh.root.type == bfd_link_hash_indirect`	`while (hh->eh.root.type == bfd_link_hash_indirect`
`\|\| hh->eh.root.type == bfd_link_hash_warning)`	`\|\| hh->eh.root.type == bfd_link_hash_warning)`
`hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);`	`hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);`

`/* We never need an opd entry for a symbol which is not`	`/* We never need an opd entry for a symbol which is not`
`defined by this output file. */`	`defined by this output file. */`
`if (hh && (hh->eh.root.type == bfd_link_hash_undefined`	`if (hh && (hh->eh.root.type == bfd_link_hash_undefined`
`\|\| hh->eh.root.type == bfd_link_hash_undefweak`	`\|\| hh->eh.root.type == bfd_link_hash_undefweak`
`\|\| hh->eh.root.u.def.section->output_section == NULL))`	`\|\| hh->eh.root.u.def.section->output_section == NULL))`
`hh->want_opd = 0;`	`hh->want_opd = 0;`

`/* If we are creating a shared library, took the address of a local`	`/* If we are creating a shared library, took the address of a local`
`function or might export this function from this object file, then`	`function or might export this function from this object file, then`
`we have to create an opd descriptor. */`	`we have to create an opd descriptor. */`
`else if (x->info->shared`	`else if (x->info->shared`
`\|\| hh == NULL`	`\|\| hh == NULL`
`\|\| (hh->eh.dynindx == -1 && hh->eh.type != STT_PARISC_MILLI)`	`\|\| (hh->eh.dynindx == -1 && hh->eh.type != STT_PARISC_MILLI)`
`\|\| (hh->eh.root.type == bfd_link_hash_defined`	`\|\| (hh->eh.root.type == bfd_link_hash_defined`
`\|\| hh->eh.root.type == bfd_link_hash_defweak))`	`\|\| hh->eh.root.type == bfd_link_hash_defweak))`
`{`	`{`
`/* If we are creating a shared library, then we will have to`	`/* If we are creating a shared library, then we will have to`
`create a runtime relocation for the symbol to properly`	`create a runtime relocation for the symbol to properly`
`initialize the .opd entry. Make sure the symbol gets`	`initialize the .opd entry. Make sure the symbol gets`
`added to the dynamic symbol table. */`	`added to the dynamic symbol table. */`
`if (x->info->shared`	`if (x->info->shared`
`&& (hh == NULL \|\| (hh->eh.dynindx == -1)))`	`&& (hh == NULL \|\| (hh->eh.dynindx == -1)))`
`{`	`{`
`bfd *owner;`	`bfd *owner;`
`/* PR 6511: Default to using the dynamic symbol table. */`	`/* PR 6511: Default to using the dynamic symbol table. */`
`owner = (hh->owner ? hh->owner: eh->root.u.def.section->owner);`	`owner = (hh->owner ? hh->owner: eh->root.u.def.section->owner);`

`if (!bfd_elf_link_record_local_dynamic_symbol`	`if (!bfd_elf_link_record_local_dynamic_symbol`
`(x->info, owner, hh->sym_indx))`	`(x->info, owner, hh->sym_indx))`
`return FALSE;`	`return FALSE;`
`}`	`}`

`/* This may not be necessary or desirable anymore now that`	`/* This may not be necessary or desirable anymore now that`
`we have some support for dealing with section symbols`	`we have some support for dealing with section symbols`
`in dynamic relocs. But name munging does make the result`	`in dynamic relocs. But name munging does make the result`
`much easier to debug. ie, the EPLT reloc will reference`	`much easier to debug. ie, the EPLT reloc will reference`
`a symbol like .foobar, instead of .text + offset. */`	`a symbol like .foobar, instead of .text + offset. */`
`if (x->info->shared && eh)`	`if (x->info->shared && eh)`
`{`	`{`
`char *new_name;`	`char *new_name;`
`struct elf_link_hash_entry *nh;`	`struct elf_link_hash_entry *nh;`

`new_name = alloca (strlen (eh->root.root.string) + 2);`	`new_name = alloca (strlen (eh->root.root.string) + 2);`
`new_name[0] = '.';`	`new_name[0] = '.';`
`strcpy (new_name + 1, eh->root.root.string);`	`strcpy (new_name + 1, eh->root.root.string);`

`nh = elf_link_hash_lookup (elf_hash_table (x->info),`	`nh = elf_link_hash_lookup (elf_hash_table (x->info),`
`new_name, TRUE, TRUE, TRUE);`	`new_name, TRUE, TRUE, TRUE);`

`nh->root.type = eh->root.type;`	`nh->root.type = eh->root.type;`
`nh->root.u.def.value = eh->root.u.def.value;`	`nh->root.u.def.value = eh->root.u.def.value;`
`nh->root.u.def.section = eh->root.u.def.section;`	`nh->root.u.def.section = eh->root.u.def.section;`

`if (! bfd_elf_link_record_dynamic_symbol (x->info, nh))`	`if (! bfd_elf_link_record_dynamic_symbol (x->info, nh))`
`return FALSE;`	`return FALSE;`

`}`	`}`
`hh->opd_offset = x->ofs;`	`hh->opd_offset = x->ofs;`
`x->ofs += OPD_ENTRY_SIZE;`	`x->ofs += OPD_ENTRY_SIZE;`
`}`	`}`

`/* Otherwise we do not need an opd entry. */`	`/* Otherwise we do not need an opd entry. */`
`else`	`else`
`hh->want_opd = 0;`	`hh->want_opd = 0;`
`}`	`}`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* HP requires the EI_OSABI field to be filled in. The assignment to`	`/* HP requires the EI_OSABI field to be filled in. The assignment to`
`EI_ABIVERSION may not be strictly necessary. */`	`EI_ABIVERSION may not be strictly necessary. */`

`static void`	`static void`
`elf64_hppa_post_process_headers (bfd *abfd,`	`elf64_hppa_post_process_headers (bfd *abfd,`
`struct bfd_link_info *link_info ATTRIBUTE_UNUSED)`	`struct bfd_link_info *link_info ATTRIBUTE_UNUSED)`
`{`	`{`
`Elf_Internal_Ehdr * i_ehdrp;`	`Elf_Internal_Ehdr * i_ehdrp;`

`i_ehdrp = elf_elfheader (abfd);`	`i_ehdrp = elf_elfheader (abfd);`

`i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;`	`i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;`
`i_ehdrp->e_ident[EI_ABIVERSION] = 1;`	`i_ehdrp->e_ident[EI_ABIVERSION] = 1;`
`}`	`}`

`/* Create function descriptor section (.opd). This section is called .opd`	`/* Create function descriptor section (.opd). This section is called .opd`
`because it contains "official procedure descriptors". The "official"`	`because it contains "official procedure descriptors". The "official"`
`refers to the fact that these descriptors are used when taking the address`	`refers to the fact that these descriptors are used when taking the address`
`of a procedure, thus ensuring a unique address for each procedure. */`	`of a procedure, thus ensuring a unique address for each procedure. */`

`static bfd_boolean`	`static bfd_boolean`
`get_opd (bfd *abfd,`	`get_opd (bfd *abfd,`
`struct bfd_link_info *info ATTRIBUTE_UNUSED,`	`struct bfd_link_info *info ATTRIBUTE_UNUSED,`
`struct elf64_hppa_link_hash_table *hppa_info)`	`struct elf64_hppa_link_hash_table *hppa_info)`
`{`	`{`
`asection *opd;`	`asection *opd;`
`bfd *dynobj;`	`bfd *dynobj;`

`opd = hppa_info->opd_sec;`	`opd = hppa_info->opd_sec;`
`if (!opd)`	`if (!opd)`
`{`	`{`
`dynobj = hppa_info->root.dynobj;`	`dynobj = hppa_info->root.dynobj;`
`if (!dynobj)`	`if (!dynobj)`
`hppa_info->root.dynobj = dynobj = abfd;`	`hppa_info->root.dynobj = dynobj = abfd;`

`opd = bfd_make_section_with_flags (dynobj, ".opd",`	`opd = bfd_make_section_with_flags (dynobj, ".opd",`
`(SEC_ALLOC`	`(SEC_ALLOC`
`\| SEC_LOAD`	`\| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (!opd`	`if (!opd`
`\|\| !bfd_set_section_alignment (abfd, opd, 3))`	`\|\| !bfd_set_section_alignment (abfd, opd, 3))`
`{`	`{`
`BFD_ASSERT (0);`	`BFD_ASSERT (0);`
`return FALSE;`	`return FALSE;`
`}`	`}`

`hppa_info->opd_sec = opd;`	`hppa_info->opd_sec = opd;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Create the PLT section. */`	`/* Create the PLT section. */`

`static bfd_boolean`	`static bfd_boolean`
`get_plt (bfd *abfd,`	`get_plt (bfd *abfd,`
`struct bfd_link_info *info ATTRIBUTE_UNUSED,`	`struct bfd_link_info *info ATTRIBUTE_UNUSED,`
`struct elf64_hppa_link_hash_table *hppa_info)`	`struct elf64_hppa_link_hash_table *hppa_info)`
`{`	`{`
`asection *plt;`	`asection *plt;`
`bfd *dynobj;`	`bfd *dynobj;`

`plt = hppa_info->plt_sec;`	`plt = hppa_info->plt_sec;`
`if (!plt)`	`if (!plt)`
`{`	`{`
`dynobj = hppa_info->root.dynobj;`	`dynobj = hppa_info->root.dynobj;`
`if (!dynobj)`	`if (!dynobj)`
`hppa_info->root.dynobj = dynobj = abfd;`	`hppa_info->root.dynobj = dynobj = abfd;`

`plt = bfd_make_section_with_flags (dynobj, ".plt",`	`plt = bfd_make_section_with_flags (dynobj, ".plt",`
`(SEC_ALLOC`	`(SEC_ALLOC`
`\| SEC_LOAD`	`\| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (!plt`	`if (!plt`
`\|\| !bfd_set_section_alignment (abfd, plt, 3))`	`\|\| !bfd_set_section_alignment (abfd, plt, 3))`
`{`	`{`
`BFD_ASSERT (0);`	`BFD_ASSERT (0);`
`return FALSE;`	`return FALSE;`
`}`	`}`

`hppa_info->plt_sec = plt;`	`hppa_info->plt_sec = plt;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Create the DLT section. */`	`/* Create the DLT section. */`

`static bfd_boolean`	`static bfd_boolean`
`get_dlt (bfd *abfd,`	`get_dlt (bfd *abfd,`
`struct bfd_link_info *info ATTRIBUTE_UNUSED,`	`struct bfd_link_info *info ATTRIBUTE_UNUSED,`
`struct elf64_hppa_link_hash_table *hppa_info)`	`struct elf64_hppa_link_hash_table *hppa_info)`
`{`	`{`
`asection *dlt;`	`asection *dlt;`
`bfd *dynobj;`	`bfd *dynobj;`

`dlt = hppa_info->dlt_sec;`	`dlt = hppa_info->dlt_sec;`
`if (!dlt)`	`if (!dlt)`
`{`	`{`
`dynobj = hppa_info->root.dynobj;`	`dynobj = hppa_info->root.dynobj;`
`if (!dynobj)`	`if (!dynobj)`
`hppa_info->root.dynobj = dynobj = abfd;`	`hppa_info->root.dynobj = dynobj = abfd;`

`dlt = bfd_make_section_with_flags (dynobj, ".dlt",`	`dlt = bfd_make_section_with_flags (dynobj, ".dlt",`
`(SEC_ALLOC`	`(SEC_ALLOC`
`\| SEC_LOAD`	`\| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (!dlt`	`if (!dlt`
`\|\| !bfd_set_section_alignment (abfd, dlt, 3))`	`\|\| !bfd_set_section_alignment (abfd, dlt, 3))`
`{`	`{`
`BFD_ASSERT (0);`	`BFD_ASSERT (0);`
`return FALSE;`	`return FALSE;`
`}`	`}`

`hppa_info->dlt_sec = dlt;`	`hppa_info->dlt_sec = dlt;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Create the stubs section. */`	`/* Create the stubs section. */`

`static bfd_boolean`	`static bfd_boolean`
`get_stub (bfd *abfd,`	`get_stub (bfd *abfd,`
`struct bfd_link_info *info ATTRIBUTE_UNUSED,`	`struct bfd_link_info *info ATTRIBUTE_UNUSED,`
`struct elf64_hppa_link_hash_table *hppa_info)`	`struct elf64_hppa_link_hash_table *hppa_info)`
`{`	`{`
`asection *stub;`	`asection *stub;`
`bfd *dynobj;`	`bfd *dynobj;`

`stub = hppa_info->stub_sec;`	`stub = hppa_info->stub_sec;`
`if (!stub)`	`if (!stub)`
`{`	`{`
`dynobj = hppa_info->root.dynobj;`	`dynobj = hppa_info->root.dynobj;`
`if (!dynobj)`	`if (!dynobj)`
`hppa_info->root.dynobj = dynobj = abfd;`	`hppa_info->root.dynobj = dynobj = abfd;`

`stub = bfd_make_section_with_flags (dynobj, ".stub",`	`stub = bfd_make_section_with_flags (dynobj, ".stub",`
`(SEC_ALLOC \| SEC_LOAD`	`(SEC_ALLOC \| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_READONLY`	`\| SEC_READONLY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (!stub`	`if (!stub`
`\|\| !bfd_set_section_alignment (abfd, stub, 3))`	`\|\| !bfd_set_section_alignment (abfd, stub, 3))`
`{`	`{`
`BFD_ASSERT (0);`	`BFD_ASSERT (0);`
`return FALSE;`	`return FALSE;`
`}`	`}`

`hppa_info->stub_sec = stub;`	`hppa_info->stub_sec = stub;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Create sections necessary for dynamic linking. This is only a rough`	`/* Create sections necessary for dynamic linking. This is only a rough`
`cut and will likely change as we learn more about the somewhat`	`cut and will likely change as we learn more about the somewhat`
`unusual dynamic linking scheme HP uses.`	`unusual dynamic linking scheme HP uses.`

`.stub:`	`.stub:`
`Contains code to implement cross-space calls. The first time one`	`Contains code to implement cross-space calls. The first time one`
`of the stubs is used it will call into the dynamic linker, later`	`of the stubs is used it will call into the dynamic linker, later`
`calls will go straight to the target.`	`calls will go straight to the target.`

`The only stub we support right now looks like`	`The only stub we support right now looks like`

`ldd OFFSET(%dp),%r1`	`ldd OFFSET(%dp),%r1`
`bve %r0(%r1)`	`bve %r0(%r1)`
`ldd OFFSET+8(%dp),%dp`	`ldd OFFSET+8(%dp),%dp`

`Other stubs may be needed in the future. We may want the remove`	`Other stubs may be needed in the future. We may want the remove`
`the break/nop instruction. It is only used right now to keep the`	`the break/nop instruction. It is only used right now to keep the`
`offset of a .plt entry and a .stub entry in sync.`	`offset of a .plt entry and a .stub entry in sync.`

`.dlt:`	`.dlt:`
`This is what most people call the .got. HP used a different name.`	`This is what most people call the .got. HP used a different name.`
`Losers.`	`Losers.`

`.rela.dlt:`	`.rela.dlt:`
`Relocations for the DLT.`	`Relocations for the DLT.`

`.plt:`	`.plt:`
`Function pointers as address,gp pairs.`	`Function pointers as address,gp pairs.`

`.rela.plt:`	`.rela.plt:`
`Should contain dynamic IPLT (and EPLT?) relocations.`	`Should contain dynamic IPLT (and EPLT?) relocations.`

`.opd:`	`.opd:`
`FPTRS`	`FPTRS`

`.rela.opd:`	`.rela.opd:`
`EPLT relocations for symbols exported from shared libraries. */`	`EPLT relocations for symbols exported from shared libraries. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_create_dynamic_sections (bfd *abfd,`	`elf64_hppa_create_dynamic_sections (bfd *abfd,`
`struct bfd_link_info *info)`	`struct bfd_link_info *info)`
`{`	`{`
`asection *s;`	`asection *s;`

`if (! get_stub (abfd, info, hppa_link_hash_table (info)))`	`if (! get_stub (abfd, info, hppa_link_hash_table (info)))`
`return FALSE;`	`return FALSE;`

`if (! get_dlt (abfd, info, hppa_link_hash_table (info)))`	`if (! get_dlt (abfd, info, hppa_link_hash_table (info)))`
`return FALSE;`	`return FALSE;`

`if (! get_plt (abfd, info, hppa_link_hash_table (info)))`	`if (! get_plt (abfd, info, hppa_link_hash_table (info)))`
`return FALSE;`	`return FALSE;`

`if (! get_opd (abfd, info, hppa_link_hash_table (info)))`	`if (! get_opd (abfd, info, hppa_link_hash_table (info)))`
`return FALSE;`	`return FALSE;`

`s = bfd_make_section_with_flags (abfd, ".rela.dlt",`	`s = bfd_make_section_with_flags (abfd, ".rela.dlt",`
`(SEC_ALLOC \| SEC_LOAD`	`(SEC_ALLOC \| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_READONLY`	`\| SEC_READONLY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (s == NULL`	`if (s == NULL`
`\|\| !bfd_set_section_alignment (abfd, s, 3))`	`\|\| !bfd_set_section_alignment (abfd, s, 3))`
`return FALSE;`	`return FALSE;`
`hppa_link_hash_table (info)->dlt_rel_sec = s;`	`hppa_link_hash_table (info)->dlt_rel_sec = s;`

`s = bfd_make_section_with_flags (abfd, ".rela.plt",`	`s = bfd_make_section_with_flags (abfd, ".rela.plt",`
`(SEC_ALLOC \| SEC_LOAD`	`(SEC_ALLOC \| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_READONLY`	`\| SEC_READONLY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (s == NULL`	`if (s == NULL`
`\|\| !bfd_set_section_alignment (abfd, s, 3))`	`\|\| !bfd_set_section_alignment (abfd, s, 3))`
`return FALSE;`	`return FALSE;`
`hppa_link_hash_table (info)->plt_rel_sec = s;`	`hppa_link_hash_table (info)->plt_rel_sec = s;`

`s = bfd_make_section_with_flags (abfd, ".rela.data",`	`s = bfd_make_section_with_flags (abfd, ".rela.data",`
`(SEC_ALLOC \| SEC_LOAD`	`(SEC_ALLOC \| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_READONLY`	`\| SEC_READONLY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (s == NULL`	`if (s == NULL`
`\|\| !bfd_set_section_alignment (abfd, s, 3))`	`\|\| !bfd_set_section_alignment (abfd, s, 3))`
`return FALSE;`	`return FALSE;`
`hppa_link_hash_table (info)->other_rel_sec = s;`	`hppa_link_hash_table (info)->other_rel_sec = s;`

`s = bfd_make_section_with_flags (abfd, ".rela.opd",`	`s = bfd_make_section_with_flags (abfd, ".rela.opd",`
`(SEC_ALLOC \| SEC_LOAD`	`(SEC_ALLOC \| SEC_LOAD`
`\| SEC_HAS_CONTENTS`	`\| SEC_HAS_CONTENTS`
`\| SEC_IN_MEMORY`	`\| SEC_IN_MEMORY`
`\| SEC_READONLY`	`\| SEC_READONLY`
`\| SEC_LINKER_CREATED));`	`\| SEC_LINKER_CREATED));`
`if (s == NULL`	`if (s == NULL`
`\|\| !bfd_set_section_alignment (abfd, s, 3))`	`\|\| !bfd_set_section_alignment (abfd, s, 3))`
`return FALSE;`	`return FALSE;`
`hppa_link_hash_table (info)->opd_rel_sec = s;`	`hppa_link_hash_table (info)->opd_rel_sec = s;`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Allocate dynamic relocations for those symbols that turned out`	`/* Allocate dynamic relocations for those symbols that turned out`
`to be dynamic. */`	`to be dynamic. */`

`static bfd_boolean`	`static bfd_boolean`
`allocate_dynrel_entries (struct elf_link_hash_entry eh, void data)`	`allocate_dynrel_entries (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`	`struct elf64_hppa_allocate_data x = (struct elf64_hppa_allocate_data )data;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`
`struct elf64_hppa_dyn_reloc_entry *rent;`	`struct elf64_hppa_dyn_reloc_entry *rent;`
`bfd_boolean dynamic_symbol, shared;`	`bfd_boolean dynamic_symbol, shared;`

`hppa_info = hppa_link_hash_table (x->info);`	`hppa_info = hppa_link_hash_table (x->info);`
`dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, x->info);`	`dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, x->info);`
`shared = x->info->shared;`	`shared = x->info->shared;`

`/* We may need to allocate relocations for a non-dynamic symbol`	`/* We may need to allocate relocations for a non-dynamic symbol`
`when creating a shared library. */`	`when creating a shared library. */`
`if (!dynamic_symbol && !shared)`	`if (!dynamic_symbol && !shared)`
`return TRUE;`	`return TRUE;`

`/* Take care of the normal data relocations. */`	`/* Take care of the normal data relocations. */`

`for (rent = hh->reloc_entries; rent; rent = rent->next)`	`for (rent = hh->reloc_entries; rent; rent = rent->next)`
`{`	`{`
`/* Allocate one iff we are building a shared library, the relocation`	`/* Allocate one iff we are building a shared library, the relocation`
`isn't a R_PARISC_FPTR64, or we don't want an opd entry. */`	`isn't a R_PARISC_FPTR64, or we don't want an opd entry. */`
`if (!shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)`	`if (!shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)`
`continue;`	`continue;`

`hppa_info->other_rel_sec->size += sizeof (Elf64_External_Rela);`	`hppa_info->other_rel_sec->size += sizeof (Elf64_External_Rela);`

`/* Make sure this symbol gets into the dynamic symbol table if it is`	`/* Make sure this symbol gets into the dynamic symbol table if it is`
`not already recorded. ?!? This should not be in the loop since`	`not already recorded. ?!? This should not be in the loop since`
`the symbol need only be added once. */`	`the symbol need only be added once. */`
`if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)`	`if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)`
`if (!bfd_elf_link_record_local_dynamic_symbol`	`if (!bfd_elf_link_record_local_dynamic_symbol`
`(x->info, rent->sec->owner, hh->sym_indx))`	`(x->info, rent->sec->owner, hh->sym_indx))`
`return FALSE;`	`return FALSE;`
`}`	`}`

`/* Take care of the GOT and PLT relocations. */`	`/* Take care of the GOT and PLT relocations. */`

`if ((dynamic_symbol \|\| shared) && hh->want_dlt)`	`if ((dynamic_symbol \|\| shared) && hh->want_dlt)`
`hppa_info->dlt_rel_sec->size += sizeof (Elf64_External_Rela);`	`hppa_info->dlt_rel_sec->size += sizeof (Elf64_External_Rela);`

`/* If we are building a shared library, then every symbol that has an`	`/* If we are building a shared library, then every symbol that has an`
`opd entry will need an EPLT relocation to relocate the symbol's address`	`opd entry will need an EPLT relocation to relocate the symbol's address`
`and __gp value based on the runtime load address. */`	`and __gp value based on the runtime load address. */`
`if (shared && hh->want_opd)`	`if (shared && hh->want_opd)`
`hppa_info->opd_rel_sec->size += sizeof (Elf64_External_Rela);`	`hppa_info->opd_rel_sec->size += sizeof (Elf64_External_Rela);`

`if (hh->want_plt && dynamic_symbol)`	`if (hh->want_plt && dynamic_symbol)`
`{`	`{`
`bfd_size_type t = 0;`	`bfd_size_type t = 0;`

`/* Dynamic symbols get one IPLT relocation. Local symbols in`	`/* Dynamic symbols get one IPLT relocation. Local symbols in`
`shared libraries get two REL relocations. Local symbols in`	`shared libraries get two REL relocations. Local symbols in`
`main applications get nothing. */`	`main applications get nothing. */`
`if (dynamic_symbol)`	`if (dynamic_symbol)`
`t = sizeof (Elf64_External_Rela);`	`t = sizeof (Elf64_External_Rela);`
`else if (shared)`	`else if (shared)`
`t = 2 * sizeof (Elf64_External_Rela);`	`t = 2 * sizeof (Elf64_External_Rela);`

`hppa_info->plt_rel_sec->size += t;`	`hppa_info->plt_rel_sec->size += t;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Adjust a symbol defined by a dynamic object and referenced by a`	`/* Adjust a symbol defined by a dynamic object and referenced by a`
`regular object. */`	`regular object. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,`	`elf64_hppa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,`
`struct elf_link_hash_entry *eh)`	`struct elf_link_hash_entry *eh)`
`{`	`{`
`/* ??? Undefined symbols with PLT entries should be re-defined`	`/* ??? Undefined symbols with PLT entries should be re-defined`
`to be the PLT entry. */`	`to be the PLT entry. */`

`/* If this is a weak symbol, and there is a real definition, the`	`/* If this is a weak symbol, and there is a real definition, the`
`processor independent code will have arranged for us to see the`	`processor independent code will have arranged for us to see the`
`real definition first, and we can just use the same value. */`	`real definition first, and we can just use the same value. */`
`if (eh->u.weakdef != NULL)`	`if (eh->u.weakdef != NULL)`
`{`	`{`
`BFD_ASSERT (eh->u.weakdef->root.type == bfd_link_hash_defined`	`BFD_ASSERT (eh->u.weakdef->root.type == bfd_link_hash_defined`
`\|\| eh->u.weakdef->root.type == bfd_link_hash_defweak);`	`\|\| eh->u.weakdef->root.type == bfd_link_hash_defweak);`
`eh->root.u.def.section = eh->u.weakdef->root.u.def.section;`	`eh->root.u.def.section = eh->u.weakdef->root.u.def.section;`
`eh->root.u.def.value = eh->u.weakdef->root.u.def.value;`	`eh->root.u.def.value = eh->u.weakdef->root.u.def.value;`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* If this is a reference to a symbol defined by a dynamic object which`	`/* If this is a reference to a symbol defined by a dynamic object which`
`is not a function, we might allocate the symbol in our .dynbss section`	`is not a function, we might allocate the symbol in our .dynbss section`
`and allocate a COPY dynamic relocation.`	`and allocate a COPY dynamic relocation.`

`But PA64 code is canonically PIC, so as a rule we can avoid this sort`	`But PA64 code is canonically PIC, so as a rule we can avoid this sort`
`of hackery. */`	`of hackery. */`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* This function is called via elf_link_hash_traverse to mark millicode`	`/* This function is called via elf_link_hash_traverse to mark millicode`
`symbols with a dynindx of -1 and to remove the string table reference`	`symbols with a dynindx of -1 and to remove the string table reference`
`from the dynamic symbol table. If the symbol is not a millicode symbol,`	`from the dynamic symbol table. If the symbol is not a millicode symbol,`
`elf64_hppa_mark_exported_functions is called. */`	`elf64_hppa_mark_exported_functions is called. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry *eh,`	`elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry *eh,`
`void *data)`	`void *data)`
`{`	`{`
`struct elf_link_hash_entry *elf = eh;`	`struct elf_link_hash_entry *elf = eh;`
`struct bfd_link_info info = (struct bfd_link_info )data;`	`struct bfd_link_info info = (struct bfd_link_info )data;`

`if (elf->root.type == bfd_link_hash_warning)`	`if (elf->root.type == bfd_link_hash_warning)`
`elf = (struct elf_link_hash_entry *) elf->root.u.i.link;`	`elf = (struct elf_link_hash_entry *) elf->root.u.i.link;`

`if (elf->type == STT_PARISC_MILLI)`	`if (elf->type == STT_PARISC_MILLI)`
`{`	`{`
`if (elf->dynindx != -1)`	`if (elf->dynindx != -1)`
`{`	`{`
`elf->dynindx = -1;`	`elf->dynindx = -1;`
`_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,`	`_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,`
`elf->dynstr_index);`	`elf->dynstr_index);`
`}`	`}`
`return TRUE;`	`return TRUE;`
`}`	`}`

`return elf64_hppa_mark_exported_functions (eh, data);`	`return elf64_hppa_mark_exported_functions (eh, data);`
`}`	`}`

`/* Set the final sizes of the dynamic sections and allocate memory for`	`/* Set the final sizes of the dynamic sections and allocate memory for`
`the contents of our special sections. */`	`the contents of our special sections. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_size_dynamic_sections (bfd output_bfd, struct bfd_link_info info)`	`elf64_hppa_size_dynamic_sections (bfd output_bfd, struct bfd_link_info info)`
`{`	`{`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`
`struct elf64_hppa_allocate_data data;`	`struct elf64_hppa_allocate_data data;`
`bfd *dynobj;`	`bfd *dynobj;`
`bfd *ibfd;`	`bfd *ibfd;`
`asection *sec;`	`asection *sec;`
`bfd_boolean plt;`	`bfd_boolean plt;`
`bfd_boolean relocs;`	`bfd_boolean relocs;`
`bfd_boolean reltext;`	`bfd_boolean reltext;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`

`dynobj = elf_hash_table (info)->dynobj;`	`dynobj = elf_hash_table (info)->dynobj;`
`BFD_ASSERT (dynobj != NULL);`	`BFD_ASSERT (dynobj != NULL);`

`/* Mark each function this program exports so that we will allocate`	`/* Mark each function this program exports so that we will allocate`
`space in the .opd section for each function's FPTR. If we are`	`space in the .opd section for each function's FPTR. If we are`
`creating dynamic sections, change the dynamic index of millicode`	`creating dynamic sections, change the dynamic index of millicode`
`symbols to -1 and remove them from the string table for .dynstr.`	`symbols to -1 and remove them from the string table for .dynstr.`

`We have to traverse the main linker hash table since we have to`	`We have to traverse the main linker hash table since we have to`
`find functions which may not have been mentioned in any relocs. */`	`find functions which may not have been mentioned in any relocs. */`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`(elf_hash_table (info)->dynamic_sections_created`	`(elf_hash_table (info)->dynamic_sections_created`
`? elf64_hppa_mark_milli_and_exported_functions`	`? elf64_hppa_mark_milli_and_exported_functions`
`: elf64_hppa_mark_exported_functions),`	`: elf64_hppa_mark_exported_functions),`
`info);`	`info);`

`if (elf_hash_table (info)->dynamic_sections_created)`	`if (elf_hash_table (info)->dynamic_sections_created)`
`{`	`{`
`/* Set the contents of the .interp section to the interpreter. */`	`/* Set the contents of the .interp section to the interpreter. */`
`if (info->executable)`	`if (info->executable)`
`{`	`{`
`sec = bfd_get_section_by_name (dynobj, ".interp");`	`sec = bfd_get_section_by_name (dynobj, ".interp");`
`BFD_ASSERT (sec != NULL);`	`BFD_ASSERT (sec != NULL);`
`sec->size = sizeof ELF_DYNAMIC_INTERPRETER;`	`sec->size = sizeof ELF_DYNAMIC_INTERPRETER;`
`sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;`	`sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`/* We may have created entries in the .rela.got section.`	`/* We may have created entries in the .rela.got section.`
`However, if we are not creating the dynamic sections, we will`	`However, if we are not creating the dynamic sections, we will`
`not actually use these entries. Reset the size of .rela.dlt,`	`not actually use these entries. Reset the size of .rela.dlt,`
`which will cause it to get stripped from the output file`	`which will cause it to get stripped from the output file`
`below. */`	`below. */`
`sec = bfd_get_section_by_name (dynobj, ".rela.dlt");`	`sec = bfd_get_section_by_name (dynobj, ".rela.dlt");`
`if (sec != NULL)`	`if (sec != NULL)`
`sec->size = 0;`	`sec->size = 0;`
`}`	`}`

`/* Set up DLT, PLT and OPD offsets for local syms, and space for local`	`/* Set up DLT, PLT and OPD offsets for local syms, and space for local`
`dynamic relocs. */`	`dynamic relocs. */`
`for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)`	`for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)`
`{`	`{`
`bfd_signed_vma *local_dlt;`	`bfd_signed_vma *local_dlt;`
`bfd_signed_vma *end_local_dlt;`	`bfd_signed_vma *end_local_dlt;`
`bfd_signed_vma *local_plt;`	`bfd_signed_vma *local_plt;`
`bfd_signed_vma *end_local_plt;`	`bfd_signed_vma *end_local_plt;`
`bfd_signed_vma *local_opd;`	`bfd_signed_vma *local_opd;`
`bfd_signed_vma *end_local_opd;`	`bfd_signed_vma *end_local_opd;`
`bfd_size_type locsymcount;`	`bfd_size_type locsymcount;`
`Elf_Internal_Shdr *symtab_hdr;`	`Elf_Internal_Shdr *symtab_hdr;`
`asection *srel;`	`asection *srel;`

`if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)`	`if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)`
`continue;`	`continue;`

`for (sec = ibfd->sections; sec != NULL; sec = sec->next)`	`for (sec = ibfd->sections; sec != NULL; sec = sec->next)`
`{`	`{`
`struct elf64_hppa_dyn_reloc_entry *hdh_p;`	`struct elf64_hppa_dyn_reloc_entry *hdh_p;`

`for (hdh_p = ((struct elf64_hppa_dyn_reloc_entry *)`	`for (hdh_p = ((struct elf64_hppa_dyn_reloc_entry *)`
`elf_section_data (sec)->local_dynrel);`	`elf_section_data (sec)->local_dynrel);`
`hdh_p != NULL;`	`hdh_p != NULL;`
`hdh_p = hdh_p->next)`	`hdh_p = hdh_p->next)`
`{`	`{`
`if (!bfd_is_abs_section (hdh_p->sec)`	`if (!bfd_is_abs_section (hdh_p->sec)`
`&& bfd_is_abs_section (hdh_p->sec->output_section))`	`&& bfd_is_abs_section (hdh_p->sec->output_section))`
`{`	`{`
`/* Input section has been discarded, either because`	`/* Input section has been discarded, either because`
`it is a copy of a linkonce section or due to`	`it is a copy of a linkonce section or due to`
`linker script /DISCARD/, so we'll be discarding`	`linker script /DISCARD/, so we'll be discarding`
`the relocs too. */`	`the relocs too. */`
`}`	`}`
`else if (hdh_p->count != 0)`	`else if (hdh_p->count != 0)`
`{`	`{`
`srel = elf_section_data (hdh_p->sec)->sreloc;`	`srel = elf_section_data (hdh_p->sec)->sreloc;`
`srel->size += hdh_p->count * sizeof (Elf64_External_Rela);`	`srel->size += hdh_p->count * sizeof (Elf64_External_Rela);`
`if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)`	`if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)`
`info->flags \|= DF_TEXTREL;`	`info->flags \|= DF_TEXTREL;`
`}`	`}`
`}`	`}`
`}`	`}`

`local_dlt = elf_local_got_refcounts (ibfd);`	`local_dlt = elf_local_got_refcounts (ibfd);`
`if (!local_dlt)`	`if (!local_dlt)`
`continue;`	`continue;`

`symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;`	`symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;`
`locsymcount = symtab_hdr->sh_info;`	`locsymcount = symtab_hdr->sh_info;`
`end_local_dlt = local_dlt + locsymcount;`	`end_local_dlt = local_dlt + locsymcount;`
`sec = hppa_info->dlt_sec;`	`sec = hppa_info->dlt_sec;`
`srel = hppa_info->dlt_rel_sec;`	`srel = hppa_info->dlt_rel_sec;`
`for (; local_dlt < end_local_dlt; ++local_dlt)`	`for (; local_dlt < end_local_dlt; ++local_dlt)`
`{`	`{`
`if (*local_dlt > 0)`	`if (*local_dlt > 0)`
`{`	`{`
`*local_dlt = sec->size;`	`*local_dlt = sec->size;`
`sec->size += DLT_ENTRY_SIZE;`	`sec->size += DLT_ENTRY_SIZE;`
`if (info->shared)`	`if (info->shared)`
`{`	`{`
`srel->size += sizeof (Elf64_External_Rela);`	`srel->size += sizeof (Elf64_External_Rela);`
`}`	`}`
`}`	`}`
`else`	`else`
`*local_dlt = (bfd_vma) -1;`	`*local_dlt = (bfd_vma) -1;`
`}`	`}`

`local_plt = end_local_dlt;`	`local_plt = end_local_dlt;`
`end_local_plt = local_plt + locsymcount;`	`end_local_plt = local_plt + locsymcount;`
`if (! hppa_info->root.dynamic_sections_created)`	`if (! hppa_info->root.dynamic_sections_created)`
`{`	`{`
`/* Won't be used, but be safe. */`	`/* Won't be used, but be safe. */`
`for (; local_plt < end_local_plt; ++local_plt)`	`for (; local_plt < end_local_plt; ++local_plt)`
`*local_plt = (bfd_vma) -1;`	`*local_plt = (bfd_vma) -1;`
`}`	`}`
`else`	`else`
`{`	`{`
`sec = hppa_info->plt_sec;`	`sec = hppa_info->plt_sec;`
`srel = hppa_info->plt_rel_sec;`	`srel = hppa_info->plt_rel_sec;`
`for (; local_plt < end_local_plt; ++local_plt)`	`for (; local_plt < end_local_plt; ++local_plt)`
`{`	`{`
`if (*local_plt > 0)`	`if (*local_plt > 0)`
`{`	`{`
`*local_plt = sec->size;`	`*local_plt = sec->size;`
`sec->size += PLT_ENTRY_SIZE;`	`sec->size += PLT_ENTRY_SIZE;`
`if (info->shared)`	`if (info->shared)`
`srel->size += sizeof (Elf64_External_Rela);`	`srel->size += sizeof (Elf64_External_Rela);`
`}`	`}`
`else`	`else`
`*local_plt = (bfd_vma) -1;`	`*local_plt = (bfd_vma) -1;`
`}`	`}`
`}`	`}`

`local_opd = end_local_plt;`	`local_opd = end_local_plt;`
`end_local_opd = local_opd + locsymcount;`	`end_local_opd = local_opd + locsymcount;`
`if (! hppa_info->root.dynamic_sections_created)`	`if (! hppa_info->root.dynamic_sections_created)`
`{`	`{`
`/* Won't be used, but be safe. */`	`/* Won't be used, but be safe. */`
`for (; local_opd < end_local_opd; ++local_opd)`	`for (; local_opd < end_local_opd; ++local_opd)`
`*local_opd = (bfd_vma) -1;`	`*local_opd = (bfd_vma) -1;`
`}`	`}`
`else`	`else`
`{`	`{`
`sec = hppa_info->opd_sec;`	`sec = hppa_info->opd_sec;`
`srel = hppa_info->opd_rel_sec;`	`srel = hppa_info->opd_rel_sec;`
`for (; local_opd < end_local_opd; ++local_opd)`	`for (; local_opd < end_local_opd; ++local_opd)`
`{`	`{`
`if (*local_opd > 0)`	`if (*local_opd > 0)`
`{`	`{`
`*local_opd = sec->size;`	`*local_opd = sec->size;`
`sec->size += OPD_ENTRY_SIZE;`	`sec->size += OPD_ENTRY_SIZE;`
`if (info->shared)`	`if (info->shared)`
`srel->size += sizeof (Elf64_External_Rela);`	`srel->size += sizeof (Elf64_External_Rela);`
`}`	`}`
`else`	`else`
`*local_opd = (bfd_vma) -1;`	`*local_opd = (bfd_vma) -1;`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Allocate the GOT entries. */`	`/* Allocate the GOT entries. */`

`data.info = info;`	`data.info = info;`
`if (hppa_info->dlt_sec)`	`if (hppa_info->dlt_sec)`
`{`	`{`
`data.ofs = hppa_info->dlt_sec->size;`	`data.ofs = hppa_info->dlt_sec->size;`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`allocate_global_data_dlt, &data);`	`allocate_global_data_dlt, &data);`
`hppa_info->dlt_sec->size = data.ofs;`	`hppa_info->dlt_sec->size = data.ofs;`
`}`	`}`

`if (hppa_info->plt_sec)`	`if (hppa_info->plt_sec)`
`{`	`{`
`data.ofs = hppa_info->plt_sec->size;`	`data.ofs = hppa_info->plt_sec->size;`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`allocate_global_data_plt, &data);`	`allocate_global_data_plt, &data);`
`hppa_info->plt_sec->size = data.ofs;`	`hppa_info->plt_sec->size = data.ofs;`
`}`	`}`

`if (hppa_info->stub_sec)`	`if (hppa_info->stub_sec)`
`{`	`{`
`data.ofs = 0x0;`	`data.ofs = 0x0;`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`allocate_global_data_stub, &data);`	`allocate_global_data_stub, &data);`
`hppa_info->stub_sec->size = data.ofs;`	`hppa_info->stub_sec->size = data.ofs;`
`}`	`}`

`/* Allocate space for entries in the .opd section. */`	`/* Allocate space for entries in the .opd section. */`
`if (hppa_info->opd_sec)`	`if (hppa_info->opd_sec)`
`{`	`{`
`data.ofs = hppa_info->opd_sec->size;`	`data.ofs = hppa_info->opd_sec->size;`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`allocate_global_data_opd, &data);`	`allocate_global_data_opd, &data);`
`hppa_info->opd_sec->size = data.ofs;`	`hppa_info->opd_sec->size = data.ofs;`
`}`	`}`

`/* Now allocate space for dynamic relocations, if necessary. */`	`/* Now allocate space for dynamic relocations, if necessary. */`
`if (hppa_info->root.dynamic_sections_created)`	`if (hppa_info->root.dynamic_sections_created)`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`allocate_dynrel_entries, &data);`	`allocate_dynrel_entries, &data);`

`/* The sizes of all the sections are set. Allocate memory for them. */`	`/* The sizes of all the sections are set. Allocate memory for them. */`
`plt = FALSE;`	`plt = FALSE;`
`relocs = FALSE;`	`relocs = FALSE;`
`reltext = FALSE;`	`reltext = FALSE;`
`for (sec = dynobj->sections; sec != NULL; sec = sec->next)`	`for (sec = dynobj->sections; sec != NULL; sec = sec->next)`
`{`	`{`
`const char *name;`	`const char *name;`

`if ((sec->flags & SEC_LINKER_CREATED) == 0)`	`if ((sec->flags & SEC_LINKER_CREATED) == 0)`
`continue;`	`continue;`

`/* It's OK to base decisions on the section name, because none`	`/* It's OK to base decisions on the section name, because none`
`of the dynobj section names depend upon the input files. */`	`of the dynobj section names depend upon the input files. */`
`name = bfd_get_section_name (dynobj, sec);`	`name = bfd_get_section_name (dynobj, sec);`

`if (strcmp (name, ".plt") == 0)`	`if (strcmp (name, ".plt") == 0)`
`{`	`{`
`/* Remember whether there is a PLT. */`	`/* Remember whether there is a PLT. */`
`plt = sec->size != 0;`	`plt = sec->size != 0;`
`}`	`}`
`else if (strcmp (name, ".opd") == 0`	`else if (strcmp (name, ".opd") == 0`
`\|\| CONST_STRNEQ (name, ".dlt")`	`\|\| CONST_STRNEQ (name, ".dlt")`
`\|\| strcmp (name, ".stub") == 0`	`\|\| strcmp (name, ".stub") == 0`
`\|\| strcmp (name, ".got") == 0)`	`\|\| strcmp (name, ".got") == 0)`
`{`	`{`
`/* Strip this section if we don't need it; see the comment below. */`	`/* Strip this section if we don't need it; see the comment below. */`
`}`	`}`
`else if (CONST_STRNEQ (name, ".rela"))`	`else if (CONST_STRNEQ (name, ".rela"))`
`{`	`{`
`if (sec->size != 0)`	`if (sec->size != 0)`
`{`	`{`
`asection *target;`	`asection *target;`

`/* Remember whether there are any reloc sections other`	`/* Remember whether there are any reloc sections other`
`than .rela.plt. */`	`than .rela.plt. */`
`if (strcmp (name, ".rela.plt") != 0)`	`if (strcmp (name, ".rela.plt") != 0)`
`{`	`{`
`const char *outname;`	`const char *outname;`

`relocs = TRUE;`	`relocs = TRUE;`

`/* If this relocation section applies to a read only`	`/* If this relocation section applies to a read only`
`section, then we probably need a DT_TEXTREL`	`section, then we probably need a DT_TEXTREL`
`entry. The entries in the .rela.plt section`	`entry. The entries in the .rela.plt section`
`really apply to the .got section, which we`	`really apply to the .got section, which we`
`created ourselves and so know is not readonly. */`	`created ourselves and so know is not readonly. */`
`outname = bfd_get_section_name (output_bfd,`	`outname = bfd_get_section_name (output_bfd,`
`sec->output_section);`	`sec->output_section);`
`target = bfd_get_section_by_name (output_bfd, outname + 4);`	`target = bfd_get_section_by_name (output_bfd, outname + 4);`
`if (target != NULL`	`if (target != NULL`
`&& (target->flags & SEC_READONLY) != 0`	`&& (target->flags & SEC_READONLY) != 0`
`&& (target->flags & SEC_ALLOC) != 0)`	`&& (target->flags & SEC_ALLOC) != 0)`
`reltext = TRUE;`	`reltext = TRUE;`
`}`	`}`

`/* We use the reloc_count field as a counter if we need`	`/* We use the reloc_count field as a counter if we need`
`to copy relocs into the output file. */`	`to copy relocs into the output file. */`
`sec->reloc_count = 0;`	`sec->reloc_count = 0;`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`/* It's not one of our sections, so don't allocate space. */`	`/* It's not one of our sections, so don't allocate space. */`
`continue;`	`continue;`
`}`	`}`

`if (sec->size == 0)`	`if (sec->size == 0)`
`{`	`{`
`/* If we don't need this section, strip it from the`	`/* If we don't need this section, strip it from the`
`output file. This is mostly to handle .rela.bss and`	`output file. This is mostly to handle .rela.bss and`
`.rela.plt. We must create both sections in`	`.rela.plt. We must create both sections in`
`create_dynamic_sections, because they must be created`	`create_dynamic_sections, because they must be created`
`before the linker maps input sections to output`	`before the linker maps input sections to output`
`sections. The linker does that before`	`sections. The linker does that before`
`adjust_dynamic_symbol is called, and it is that`	`adjust_dynamic_symbol is called, and it is that`
`function which decides whether anything needs to go`	`function which decides whether anything needs to go`
`into these sections. */`	`into these sections. */`
`sec->flags \|= SEC_EXCLUDE;`	`sec->flags \|= SEC_EXCLUDE;`
`continue;`	`continue;`
`}`	`}`

`if ((sec->flags & SEC_HAS_CONTENTS) == 0)`	`if ((sec->flags & SEC_HAS_CONTENTS) == 0)`
`continue;`	`continue;`

`/* Allocate memory for the section contents if it has not`	`/* Allocate memory for the section contents if it has not`
`been allocated already. We use bfd_zalloc here in case`	`been allocated already. We use bfd_zalloc here in case`
`unused entries are not reclaimed before the section's`	`unused entries are not reclaimed before the section's`
`contents are written out. This should not happen, but this`	`contents are written out. This should not happen, but this`
`way if it does, we get a R_PARISC_NONE reloc instead of`	`way if it does, we get a R_PARISC_NONE reloc instead of`
`garbage. */`	`garbage. */`
`if (sec->contents == NULL)`	`if (sec->contents == NULL)`
`{`	`{`
`sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);`	`sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);`
`if (sec->contents == NULL)`	`if (sec->contents == NULL)`
`return FALSE;`	`return FALSE;`
`}`	`}`
`}`	`}`

`if (elf_hash_table (info)->dynamic_sections_created)`	`if (elf_hash_table (info)->dynamic_sections_created)`
`{`	`{`
`/* Always create a DT_PLTGOT. It actually has nothing to do with`	`/* Always create a DT_PLTGOT. It actually has nothing to do with`
`the PLT, it is how we communicate the __gp value of a load`	`the PLT, it is how we communicate the __gp value of a load`
`module to the dynamic linker. */`	`module to the dynamic linker. */`
`#define add_dynamic_entry(TAG, VAL) \`	`#define add_dynamic_entry(TAG, VAL) \`
`_bfd_elf_add_dynamic_entry (info, TAG, VAL)`	`_bfd_elf_add_dynamic_entry (info, TAG, VAL)`

`if (!add_dynamic_entry (DT_HP_DLD_FLAGS, 0)`	`if (!add_dynamic_entry (DT_HP_DLD_FLAGS, 0)`
`\|\| !add_dynamic_entry (DT_PLTGOT, 0))`	`\|\| !add_dynamic_entry (DT_PLTGOT, 0))`
`return FALSE;`	`return FALSE;`

`/* Add some entries to the .dynamic section. We fill in the`	`/* Add some entries to the .dynamic section. We fill in the`
`values later, in elf64_hppa_finish_dynamic_sections, but we`	`values later, in elf64_hppa_finish_dynamic_sections, but we`
`must add the entries now so that we get the correct size for`	`must add the entries now so that we get the correct size for`
`the .dynamic section. The DT_DEBUG entry is filled in by the`	`the .dynamic section. The DT_DEBUG entry is filled in by the`
`dynamic linker and used by the debugger. */`	`dynamic linker and used by the debugger. */`
`if (! info->shared)`	`if (! info->shared)`
`{`	`{`
`if (!add_dynamic_entry (DT_DEBUG, 0)`	`if (!add_dynamic_entry (DT_DEBUG, 0)`
`\|\| !add_dynamic_entry (DT_HP_DLD_HOOK, 0)`	`\|\| !add_dynamic_entry (DT_HP_DLD_HOOK, 0)`
`\|\| !add_dynamic_entry (DT_HP_LOAD_MAP, 0))`	`\|\| !add_dynamic_entry (DT_HP_LOAD_MAP, 0))`
`return FALSE;`	`return FALSE;`
`}`	`}`

`/* Force DT_FLAGS to always be set.`	`/* Force DT_FLAGS to always be set.`
`Required by HPUX 11.00 patch PHSS_26559. */`	`Required by HPUX 11.00 patch PHSS_26559. */`
`if (!add_dynamic_entry (DT_FLAGS, (info)->flags))`	`if (!add_dynamic_entry (DT_FLAGS, (info)->flags))`
`return FALSE;`	`return FALSE;`

`if (plt)`	`if (plt)`
`{`	`{`
`if (!add_dynamic_entry (DT_PLTRELSZ, 0)`	`if (!add_dynamic_entry (DT_PLTRELSZ, 0)`
`\|\| !add_dynamic_entry (DT_PLTREL, DT_RELA)`	`\|\| !add_dynamic_entry (DT_PLTREL, DT_RELA)`
`\|\| !add_dynamic_entry (DT_JMPREL, 0))`	`\|\| !add_dynamic_entry (DT_JMPREL, 0))`
`return FALSE;`	`return FALSE;`
`}`	`}`

`if (relocs)`	`if (relocs)`
`{`	`{`
`if (!add_dynamic_entry (DT_RELA, 0)`	`if (!add_dynamic_entry (DT_RELA, 0)`
`\|\| !add_dynamic_entry (DT_RELASZ, 0)`	`\|\| !add_dynamic_entry (DT_RELASZ, 0)`
`\|\| !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))`	`\|\| !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))`
`return FALSE;`	`return FALSE;`
`}`	`}`

`if (reltext)`	`if (reltext)`
`{`	`{`
`if (!add_dynamic_entry (DT_TEXTREL, 0))`	`if (!add_dynamic_entry (DT_TEXTREL, 0))`
`return FALSE;`	`return FALSE;`
`info->flags \|= DF_TEXTREL;`	`info->flags \|= DF_TEXTREL;`
`}`	`}`
`}`	`}`
`#undef add_dynamic_entry`	`#undef add_dynamic_entry`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Called after we have output the symbol into the dynamic symbol`	`/* Called after we have output the symbol into the dynamic symbol`
`table, but before we output the symbol into the normal symbol`	`table, but before we output the symbol into the normal symbol`
`table.`	`table.`

`For some symbols we had to change their address when outputting`	`For some symbols we had to change their address when outputting`
`the dynamic symbol table. We undo that change here so that`	`the dynamic symbol table. We undo that change here so that`
`the symbols have their expected value in the normal symbol`	`the symbols have their expected value in the normal symbol`
`table. Ick. */`	`table. Ick. */`

`static int`	`static int`
`elf64_hppa_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,`	`elf64_hppa_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,`
`const char *name,`	`const char *name,`
`Elf_Internal_Sym *sym,`	`Elf_Internal_Sym *sym,`
`asection *input_sec ATTRIBUTE_UNUSED,`	`asection *input_sec ATTRIBUTE_UNUSED,`
`struct elf_link_hash_entry *eh)`	`struct elf_link_hash_entry *eh)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`

`/* We may be called with the file symbol or section symbols.`	`/* We may be called with the file symbol or section symbols.`
`They never need munging, so it is safe to ignore them. */`	`They never need munging, so it is safe to ignore them. */`
`if (!name \|\| !eh)`	`if (!name \|\| !eh)`
`return 1;`	`return 1;`

`/* Function symbols for which we created .opd entries may have been`	`/* Function symbols for which we created .opd entries may have been`
`munged by finish_dynamic_symbol and have to be un-munged here.`	`munged by finish_dynamic_symbol and have to be un-munged here.`

`Note that finish_dynamic_symbol sometimes turns dynamic symbols`	`Note that finish_dynamic_symbol sometimes turns dynamic symbols`
`into non-dynamic ones, so we initialize st_shndx to -1 in`	`into non-dynamic ones, so we initialize st_shndx to -1 in`
`mark_exported_functions and check to see if it was overwritten`	`mark_exported_functions and check to see if it was overwritten`
`here instead of just checking eh->dynindx. */`	`here instead of just checking eh->dynindx. */`
`if (hh->want_opd && hh->st_shndx != -1)`	`if (hh->want_opd && hh->st_shndx != -1)`
`{`	`{`
`/* Restore the saved value and section index. */`	`/* Restore the saved value and section index. */`
`sym->st_value = hh->st_value;`	`sym->st_value = hh->st_value;`
`sym->st_shndx = hh->st_shndx;`	`sym->st_shndx = hh->st_shndx;`
`}`	`}`

`return 1;`	`return 1;`
`}`	`}`

`/* Finish up dynamic symbol handling. We set the contents of various`	`/* Finish up dynamic symbol handling. We set the contents of various`
`dynamic sections here. */`	`dynamic sections here. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_finish_dynamic_symbol (bfd *output_bfd,`	`elf64_hppa_finish_dynamic_symbol (bfd *output_bfd,`
`struct bfd_link_info *info,`	`struct bfd_link_info *info,`
`struct elf_link_hash_entry *eh,`	`struct elf_link_hash_entry *eh,`
`Elf_Internal_Sym *sym)`	`Elf_Internal_Sym *sym)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`asection stub, splt, sdlt, sopd, spltrel, sdltrel;`	`asection stub, splt, sdlt, sopd, spltrel, sdltrel;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`

`stub = hppa_info->stub_sec;`	`stub = hppa_info->stub_sec;`
`splt = hppa_info->plt_sec;`	`splt = hppa_info->plt_sec;`
`sdlt = hppa_info->dlt_sec;`	`sdlt = hppa_info->dlt_sec;`
`sopd = hppa_info->opd_sec;`	`sopd = hppa_info->opd_sec;`
`spltrel = hppa_info->plt_rel_sec;`	`spltrel = hppa_info->plt_rel_sec;`
`sdltrel = hppa_info->dlt_rel_sec;`	`sdltrel = hppa_info->dlt_rel_sec;`

`/* Incredible. It is actually necessary to NOT use the symbol's real`	`/* Incredible. It is actually necessary to NOT use the symbol's real`
`value when building the dynamic symbol table for a shared library.`	`value when building the dynamic symbol table for a shared library.`
`At least for symbols that refer to functions.`	`At least for symbols that refer to functions.`

`We will store a new value and section index into the symbol long`	`We will store a new value and section index into the symbol long`
`enough to output it into the dynamic symbol table, then we restore`	`enough to output it into the dynamic symbol table, then we restore`
`the original values (in elf64_hppa_link_output_symbol_hook). */`	`the original values (in elf64_hppa_link_output_symbol_hook). */`
`if (hh->want_opd)`	`if (hh->want_opd)`
`{`	`{`
`BFD_ASSERT (sopd != NULL);`	`BFD_ASSERT (sopd != NULL);`

`/* Save away the original value and section index so that we`	`/* Save away the original value and section index so that we`
`can restore them later. */`	`can restore them later. */`
`hh->st_value = sym->st_value;`	`hh->st_value = sym->st_value;`
`hh->st_shndx = sym->st_shndx;`	`hh->st_shndx = sym->st_shndx;`

`/* For the dynamic symbol table entry, we want the value to be`	`/* For the dynamic symbol table entry, we want the value to be`
`address of this symbol's entry within the .opd section. */`	`address of this symbol's entry within the .opd section. */`
`sym->st_value = (hh->opd_offset`	`sym->st_value = (hh->opd_offset`
`+ sopd->output_offset`	`+ sopd->output_offset`
`+ sopd->output_section->vma);`	`+ sopd->output_section->vma);`
`sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,`	`sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,`
`sopd->output_section);`	`sopd->output_section);`
`}`	`}`

`/* Initialize a .plt entry if requested. */`	`/* Initialize a .plt entry if requested. */`
`if (hh->want_plt`	`if (hh->want_plt`
`&& elf64_hppa_dynamic_symbol_p (eh, info))`	`&& elf64_hppa_dynamic_symbol_p (eh, info))`
`{`	`{`
`bfd_vma value;`	`bfd_vma value;`
`Elf_Internal_Rela rel;`	`Elf_Internal_Rela rel;`
`bfd_byte *loc;`	`bfd_byte *loc;`

`BFD_ASSERT (splt != NULL && spltrel != NULL);`	`BFD_ASSERT (splt != NULL && spltrel != NULL);`

`/* We do not actually care about the value in the PLT entry`	`/* We do not actually care about the value in the PLT entry`
`if we are creating a shared library and the symbol is`	`if we are creating a shared library and the symbol is`
`still undefined, we create a dynamic relocation to fill`	`still undefined, we create a dynamic relocation to fill`
`in the correct value. */`	`in the correct value. */`
`if (info->shared && eh->root.type == bfd_link_hash_undefined)`	`if (info->shared && eh->root.type == bfd_link_hash_undefined)`
`value = 0;`	`value = 0;`
`else`	`else`
`value = (eh->root.u.def.value + eh->root.u.def.section->vma);`	`value = (eh->root.u.def.value + eh->root.u.def.section->vma);`

`/* Fill in the entry in the procedure linkage table.`	`/* Fill in the entry in the procedure linkage table.`

`The format of a plt entry is`	`The format of a plt entry is`
`<funcaddr> <__gp>.`	`<funcaddr> <__gp>.`

`plt_offset is the offset within the PLT section at which to`	`plt_offset is the offset within the PLT section at which to`
`install the PLT entry.`	`install the PLT entry.`

`We are modifying the in-memory PLT contents here, so we do not add`	`We are modifying the in-memory PLT contents here, so we do not add`
`in the output_offset of the PLT section. */`	`in the output_offset of the PLT section. */`

`bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset);`	`bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset);`
`value = _bfd_get_gp_value (splt->output_section->owner);`	`value = _bfd_get_gp_value (splt->output_section->owner);`
`bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset + 0x8);`	`bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset + 0x8);`

`/* Create a dynamic IPLT relocation for this entry.`	`/* Create a dynamic IPLT relocation for this entry.`

`We are creating a relocation in the output file's PLT section,`	`We are creating a relocation in the output file's PLT section,`
`which is included within the DLT secton. So we do need to include`	`which is included within the DLT secton. So we do need to include`
`the PLT's output_offset in the computation of the relocation's`	`the PLT's output_offset in the computation of the relocation's`
`address. */`	`address. */`
`rel.r_offset = (hh->plt_offset + splt->output_offset`	`rel.r_offset = (hh->plt_offset + splt->output_offset`
`+ splt->output_section->vma);`	`+ splt->output_section->vma);`
`rel.r_info = ELF64_R_INFO (hh->eh.dynindx, R_PARISC_IPLT);`	`rel.r_info = ELF64_R_INFO (hh->eh.dynindx, R_PARISC_IPLT);`
`rel.r_addend = 0;`	`rel.r_addend = 0;`

`loc = spltrel->contents;`	`loc = spltrel->contents;`
`loc += spltrel->reloc_count++ * sizeof (Elf64_External_Rela);`	`loc += spltrel->reloc_count++ * sizeof (Elf64_External_Rela);`
`bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel, loc);`	`bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel, loc);`
`}`	`}`

`/* Initialize an external call stub entry if requested. */`	`/* Initialize an external call stub entry if requested. */`
`if (hh->want_stub`	`if (hh->want_stub`
`&& elf64_hppa_dynamic_symbol_p (eh, info))`	`&& elf64_hppa_dynamic_symbol_p (eh, info))`
`{`	`{`
`bfd_vma value;`	`bfd_vma value;`
`int insn;`	`int insn;`
`unsigned int max_offset;`	`unsigned int max_offset;`

`BFD_ASSERT (stub != NULL);`	`BFD_ASSERT (stub != NULL);`

`/* Install the generic stub template.`	`/* Install the generic stub template.`

`We are modifying the contents of the stub section, so we do not`	`We are modifying the contents of the stub section, so we do not`
`need to include the stub section's output_offset here. */`	`need to include the stub section's output_offset here. */`
`memcpy (stub->contents + hh->stub_offset, plt_stub, sizeof (plt_stub));`	`memcpy (stub->contents + hh->stub_offset, plt_stub, sizeof (plt_stub));`

`/* Fix up the first ldd instruction.`	`/* Fix up the first ldd instruction.`

`We are modifying the contents of the STUB section in memory,`	`We are modifying the contents of the STUB section in memory,`
`so we do not need to include its output offset in this computation.`	`so we do not need to include its output offset in this computation.`

`Note the plt_offset value is the value of the PLT entry relative to`	`Note the plt_offset value is the value of the PLT entry relative to`
`the start of the PLT section. These instructions will reference`	`the start of the PLT section. These instructions will reference`
`data relative to the value of __gp, which may not necessarily have`	`data relative to the value of __gp, which may not necessarily have`
`the same address as the start of the PLT section.`	`the same address as the start of the PLT section.`

`gp_offset contains the offset of __gp within the PLT section. */`	`gp_offset contains the offset of __gp within the PLT section. */`
`value = hh->plt_offset - hppa_info->gp_offset;`	`value = hh->plt_offset - hppa_info->gp_offset;`

`insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset);`	`insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset);`
`if (output_bfd->arch_info->mach >= 25)`	`if (output_bfd->arch_info->mach >= 25)`
`{`	`{`
`/* Wide mode allows 16 bit offsets. */`	`/* Wide mode allows 16 bit offsets. */`
`max_offset = 32768;`	`max_offset = 32768;`
`insn &= ~ 0xfff1;`	`insn &= ~ 0xfff1;`
`insn \|= re_assemble_16 ((int) value);`	`insn \|= re_assemble_16 ((int) value);`
`}`	`}`
`else`	`else`
`{`	`{`
`max_offset = 8192;`	`max_offset = 8192;`
`insn &= ~ 0x3ff1;`	`insn &= ~ 0x3ff1;`
`insn \|= re_assemble_14 ((int) value);`	`insn \|= re_assemble_14 ((int) value);`
`}`	`}`

`if ((value & 7) \|\| value + max_offset >= 2*max_offset - 8)`	`if ((value & 7) \|\| value + max_offset >= 2*max_offset - 8)`
`{`	`{`
`(*_bfd_error_handler) (_("stub entry for %s cannot load .plt, dp offset = %ld"),`	`(*_bfd_error_handler) (_("stub entry for %s cannot load .plt, dp offset = %ld"),`
`hh->eh.root.root.string,`	`hh->eh.root.root.string,`
`(long) value);`	`(long) value);`
`return FALSE;`	`return FALSE;`
`}`	`}`

`bfd_put_32 (stub->owner, (bfd_vma) insn,`	`bfd_put_32 (stub->owner, (bfd_vma) insn,`
`stub->contents + hh->stub_offset);`	`stub->contents + hh->stub_offset);`

`/* Fix up the second ldd instruction. */`	`/* Fix up the second ldd instruction. */`
`value += 8;`	`value += 8;`
`insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset + 8);`	`insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset + 8);`
`if (output_bfd->arch_info->mach >= 25)`	`if (output_bfd->arch_info->mach >= 25)`
`{`	`{`
`insn &= ~ 0xfff1;`	`insn &= ~ 0xfff1;`
`insn \|= re_assemble_16 ((int) value);`	`insn \|= re_assemble_16 ((int) value);`
`}`	`}`
`else`	`else`
`{`	`{`
`insn &= ~ 0x3ff1;`	`insn &= ~ 0x3ff1;`
`insn \|= re_assemble_14 ((int) value);`	`insn \|= re_assemble_14 ((int) value);`
`}`	`}`
`bfd_put_32 (stub->owner, (bfd_vma) insn,`	`bfd_put_32 (stub->owner, (bfd_vma) insn,`
`stub->contents + hh->stub_offset + 8);`	`stub->contents + hh->stub_offset + 8);`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* The .opd section contains FPTRs for each function this file`	`/* The .opd section contains FPTRs for each function this file`
`exports. Initialize the FPTR entries. */`	`exports. Initialize the FPTR entries. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_finalize_opd (struct elf_link_hash_entry eh, void data)`	`elf64_hppa_finalize_opd (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct bfd_link_info info = (struct bfd_link_info )data;`	`struct bfd_link_info info = (struct bfd_link_info )data;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`
`asection *sopd;`	`asection *sopd;`
`asection *sopdrel;`	`asection *sopdrel;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`
`sopd = hppa_info->opd_sec;`	`sopd = hppa_info->opd_sec;`
`sopdrel = hppa_info->opd_rel_sec;`	`sopdrel = hppa_info->opd_rel_sec;`

`if (hh->want_opd)`	`if (hh->want_opd)`
`{`	`{`
`bfd_vma value;`	`bfd_vma value;`

`/* The first two words of an .opd entry are zero.`	`/* The first two words of an .opd entry are zero.`

`We are modifying the contents of the OPD section in memory, so we`	`We are modifying the contents of the OPD section in memory, so we`
`do not need to include its output offset in this computation. */`	`do not need to include its output offset in this computation. */`
`memset (sopd->contents + hh->opd_offset, 0, 16);`	`memset (sopd->contents + hh->opd_offset, 0, 16);`

`value = (eh->root.u.def.value`	`value = (eh->root.u.def.value`
`+ eh->root.u.def.section->output_section->vma`	`+ eh->root.u.def.section->output_section->vma`
`+ eh->root.u.def.section->output_offset);`	`+ eh->root.u.def.section->output_offset);`

`/* The next word is the address of the function. */`	`/* The next word is the address of the function. */`
`bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 16);`	`bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 16);`

`/* The last word is our local __gp value. */`	`/* The last word is our local __gp value. */`
`value = _bfd_get_gp_value (sopd->output_section->owner);`	`value = _bfd_get_gp_value (sopd->output_section->owner);`
`bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 24);`	`bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 24);`
`}`	`}`

`/* If we are generating a shared library, we must generate EPLT relocations`	`/* If we are generating a shared library, we must generate EPLT relocations`
`for each entry in the .opd, even for static functions (they may have`	`for each entry in the .opd, even for static functions (they may have`
`had their address taken). */`	`had their address taken). */`
`if (info->shared && hh->want_opd)`	`if (info->shared && hh->want_opd)`
`{`	`{`
`Elf_Internal_Rela rel;`	`Elf_Internal_Rela rel;`
`bfd_byte *loc;`	`bfd_byte *loc;`
`int dynindx;`	`int dynindx;`

`/* We may need to do a relocation against a local symbol, in`	`/* We may need to do a relocation against a local symbol, in`
`which case we have to look up it's dynamic symbol index off`	`which case we have to look up it's dynamic symbol index off`
`the local symbol hash table. */`	`the local symbol hash table. */`
`if (eh->dynindx != -1)`	`if (eh->dynindx != -1)`
`dynindx = eh->dynindx;`	`dynindx = eh->dynindx;`
`else`	`else`
`dynindx`	`dynindx`
`= _bfd_elf_link_lookup_local_dynindx (info, hh->owner,`	`= _bfd_elf_link_lookup_local_dynindx (info, hh->owner,`
`hh->sym_indx);`	`hh->sym_indx);`

`/* The offset of this relocation is the absolute address of the`	`/* The offset of this relocation is the absolute address of the`
`.opd entry for this symbol. */`	`.opd entry for this symbol. */`
`rel.r_offset = (hh->opd_offset + sopd->output_offset`	`rel.r_offset = (hh->opd_offset + sopd->output_offset`
`+ sopd->output_section->vma);`	`+ sopd->output_section->vma);`

`/* If H is non-null, then we have an external symbol.`	`/* If H is non-null, then we have an external symbol.`

`It is imperative that we use a different dynamic symbol for the`	`It is imperative that we use a different dynamic symbol for the`
`EPLT relocation if the symbol has global scope.`	`EPLT relocation if the symbol has global scope.`

`In the dynamic symbol table, the function symbol will have a value`	`In the dynamic symbol table, the function symbol will have a value`
`which is address of the function's .opd entry.`	`which is address of the function's .opd entry.`

`Thus, we can not use that dynamic symbol for the EPLT relocation`	`Thus, we can not use that dynamic symbol for the EPLT relocation`
`(if we did, the data in the .opd would reference itself rather`	`(if we did, the data in the .opd would reference itself rather`
`than the actual address of the function). Instead we have to use`	`than the actual address of the function). Instead we have to use`
`a new dynamic symbol which has the same value as the original global`	`a new dynamic symbol which has the same value as the original global`
`function symbol.`	`function symbol.`

`We prefix the original symbol with a "." and use the new symbol in`	`We prefix the original symbol with a "." and use the new symbol in`
`the EPLT relocation. This new symbol has already been recorded in`	`the EPLT relocation. This new symbol has already been recorded in`
`the symbol table, we just have to look it up and use it.`	`the symbol table, we just have to look it up and use it.`

`We do not have such problems with static functions because we do`	`We do not have such problems with static functions because we do`
`not make their addresses in the dynamic symbol table point to`	`not make their addresses in the dynamic symbol table point to`
`the .opd entry. Ultimately this should be safe since a static`	`the .opd entry. Ultimately this should be safe since a static`
`function can not be directly referenced outside of its shared`	`function can not be directly referenced outside of its shared`
`library.`	`library.`

`We do have to play similar games for FPTR relocations in shared`	`We do have to play similar games for FPTR relocations in shared`
`libraries, including those for static symbols. See the FPTR`	`libraries, including those for static symbols. See the FPTR`
`handling in elf64_hppa_finalize_dynreloc. */`	`handling in elf64_hppa_finalize_dynreloc. */`
`if (eh)`	`if (eh)`
`{`	`{`
`char *new_name;`	`char *new_name;`
`struct elf_link_hash_entry *nh;`	`struct elf_link_hash_entry *nh;`

`new_name = alloca (strlen (eh->root.root.string) + 2);`	`new_name = alloca (strlen (eh->root.root.string) + 2);`
`new_name[0] = '.';`	`new_name[0] = '.';`
`strcpy (new_name + 1, eh->root.root.string);`	`strcpy (new_name + 1, eh->root.root.string);`

`nh = elf_link_hash_lookup (elf_hash_table (info),`	`nh = elf_link_hash_lookup (elf_hash_table (info),`
`new_name, TRUE, TRUE, FALSE);`	`new_name, TRUE, TRUE, FALSE);`

`/* All we really want from the new symbol is its dynamic`	`/* All we really want from the new symbol is its dynamic`
`symbol index. */`	`symbol index. */`
`if (nh)`	`if (nh)`
`dynindx = nh->dynindx;`	`dynindx = nh->dynindx;`
`}`	`}`

`rel.r_addend = 0;`	`rel.r_addend = 0;`
`rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);`	`rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);`

`loc = sopdrel->contents;`	`loc = sopdrel->contents;`
`loc += sopdrel->reloc_count++ * sizeof (Elf64_External_Rela);`	`loc += sopdrel->reloc_count++ * sizeof (Elf64_External_Rela);`
`bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel, loc);`	`bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel, loc);`
`}`	`}`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* The .dlt section contains addresses for items referenced through the`	`/* The .dlt section contains addresses for items referenced through the`
`dlt. Note that we can have a DLTIND relocation for a local symbol, thus`	`dlt. Note that we can have a DLTIND relocation for a local symbol, thus`
`we can not depend on finish_dynamic_symbol to initialize the .dlt. */`	`we can not depend on finish_dynamic_symbol to initialize the .dlt. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_finalize_dlt (struct elf_link_hash_entry eh, void data)`	`elf64_hppa_finalize_dlt (struct elf_link_hash_entry eh, void data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct bfd_link_info info = (struct bfd_link_info )data;`	`struct bfd_link_info info = (struct bfd_link_info )data;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`
`asection sdlt, sdltrel;`	`asection sdlt, sdltrel;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`

`sdlt = hppa_info->dlt_sec;`	`sdlt = hppa_info->dlt_sec;`
`sdltrel = hppa_info->dlt_rel_sec;`	`sdltrel = hppa_info->dlt_rel_sec;`

`/* H/DYN_H may refer to a local variable and we know it's`	`/* H/DYN_H may refer to a local variable and we know it's`
`address, so there is no need to create a relocation. Just install`	`address, so there is no need to create a relocation. Just install`
`the proper value into the DLT, note this shortcut can not be`	`the proper value into the DLT, note this shortcut can not be`
`skipped when building a shared library. */`	`skipped when building a shared library. */`
`if (! info->shared && hh && hh->want_dlt)`	`if (! info->shared && hh && hh->want_dlt)`
`{`	`{`
`bfd_vma value;`	`bfd_vma value;`

`/* If we had an LTOFF_FPTR style relocation we want the DLT entry`	`/* If we had an LTOFF_FPTR style relocation we want the DLT entry`
`to point to the FPTR entry in the .opd section.`	`to point to the FPTR entry in the .opd section.`

`We include the OPD's output offset in this computation as`	`We include the OPD's output offset in this computation as`
`we are referring to an absolute address in the resulting`	`we are referring to an absolute address in the resulting`
`object file. */`	`object file. */`
`if (hh->want_opd)`	`if (hh->want_opd)`
`{`	`{`
`value = (hh->opd_offset`	`value = (hh->opd_offset`
`+ hppa_info->opd_sec->output_offset`	`+ hppa_info->opd_sec->output_offset`
`+ hppa_info->opd_sec->output_section->vma);`	`+ hppa_info->opd_sec->output_section->vma);`
`}`	`}`
`else if ((eh->root.type == bfd_link_hash_defined`	`else if ((eh->root.type == bfd_link_hash_defined`
`\|\| eh->root.type == bfd_link_hash_defweak)`	`\|\| eh->root.type == bfd_link_hash_defweak)`
`&& eh->root.u.def.section)`	`&& eh->root.u.def.section)`
`{`	`{`
`value = eh->root.u.def.value + eh->root.u.def.section->output_offset;`	`value = eh->root.u.def.value + eh->root.u.def.section->output_offset;`
`if (eh->root.u.def.section->output_section)`	`if (eh->root.u.def.section->output_section)`
`value += eh->root.u.def.section->output_section->vma;`	`value += eh->root.u.def.section->output_section->vma;`
`else`	`else`
`value += eh->root.u.def.section->vma;`	`value += eh->root.u.def.section->vma;`
`}`	`}`
`else`	`else`
`/* We have an undefined function reference. */`	`/* We have an undefined function reference. */`
`value = 0;`	`value = 0;`

`/* We do not need to include the output offset of the DLT section`	`/* We do not need to include the output offset of the DLT section`
`here because we are modifying the in-memory contents. */`	`here because we are modifying the in-memory contents. */`
`bfd_put_64 (sdlt->owner, value, sdlt->contents + hh->dlt_offset);`	`bfd_put_64 (sdlt->owner, value, sdlt->contents + hh->dlt_offset);`
`}`	`}`

`/* Create a relocation for the DLT entry associated with this symbol.`	`/* Create a relocation for the DLT entry associated with this symbol.`
`When building a shared library the symbol does not have to be dynamic. */`	`When building a shared library the symbol does not have to be dynamic. */`
`if (hh->want_dlt`	`if (hh->want_dlt`
`&& (elf64_hppa_dynamic_symbol_p (eh, info) \|\| info->shared))`	`&& (elf64_hppa_dynamic_symbol_p (eh, info) \|\| info->shared))`
`{`	`{`
`Elf_Internal_Rela rel;`	`Elf_Internal_Rela rel;`
`bfd_byte *loc;`	`bfd_byte *loc;`
`int dynindx;`	`int dynindx;`

`/* We may need to do a relocation against a local symbol, in`	`/* We may need to do a relocation against a local symbol, in`
`which case we have to look up it's dynamic symbol index off`	`which case we have to look up it's dynamic symbol index off`
`the local symbol hash table. */`	`the local symbol hash table. */`
`if (eh && eh->dynindx != -1)`	`if (eh && eh->dynindx != -1)`
`dynindx = eh->dynindx;`	`dynindx = eh->dynindx;`
`else`	`else`
`dynindx`	`dynindx`
`= _bfd_elf_link_lookup_local_dynindx (info, hh->owner,`	`= _bfd_elf_link_lookup_local_dynindx (info, hh->owner,`
`hh->sym_indx);`	`hh->sym_indx);`

`/* Create a dynamic relocation for this entry. Do include the output`	`/* Create a dynamic relocation for this entry. Do include the output`
`offset of the DLT entry since we need an absolute address in the`	`offset of the DLT entry since we need an absolute address in the`
`resulting object file. */`	`resulting object file. */`
`rel.r_offset = (hh->dlt_offset + sdlt->output_offset`	`rel.r_offset = (hh->dlt_offset + sdlt->output_offset`
`+ sdlt->output_section->vma);`	`+ sdlt->output_section->vma);`
`if (eh && eh->type == STT_FUNC)`	`if (eh && eh->type == STT_FUNC)`
`rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);`	`rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);`
`else`	`else`
`rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);`	`rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);`
`rel.r_addend = 0;`	`rel.r_addend = 0;`

`loc = sdltrel->contents;`	`loc = sdltrel->contents;`
`loc += sdltrel->reloc_count++ * sizeof (Elf64_External_Rela);`	`loc += sdltrel->reloc_count++ * sizeof (Elf64_External_Rela);`
`bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel, loc);`	`bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel, loc);`
`}`	`}`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Finalize the dynamic relocations. Specifically the FPTR relocations`	`/* Finalize the dynamic relocations. Specifically the FPTR relocations`
`for dynamic functions used to initialize static data. */`	`for dynamic functions used to initialize static data. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_finalize_dynreloc (struct elf_link_hash_entry *eh,`	`elf64_hppa_finalize_dynreloc (struct elf_link_hash_entry *eh,`
`void *data)`	`void *data)`
`{`	`{`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`struct bfd_link_info info = (struct bfd_link_info )data;`	`struct bfd_link_info info = (struct bfd_link_info )data;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`
`int dynamic_symbol;`	`int dynamic_symbol;`

`dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, info);`	`dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, info);`

`if (!dynamic_symbol && !info->shared)`	`if (!dynamic_symbol && !info->shared)`
`return TRUE;`	`return TRUE;`

`if (hh->reloc_entries)`	`if (hh->reloc_entries)`
`{`	`{`
`struct elf64_hppa_dyn_reloc_entry *rent;`	`struct elf64_hppa_dyn_reloc_entry *rent;`
`int dynindx;`	`int dynindx;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`

`/* We may need to do a relocation against a local symbol, in`	`/* We may need to do a relocation against a local symbol, in`
`which case we have to look up it's dynamic symbol index off`	`which case we have to look up it's dynamic symbol index off`
`the local symbol hash table. */`	`the local symbol hash table. */`
`if (eh->dynindx != -1)`	`if (eh->dynindx != -1)`
`dynindx = eh->dynindx;`	`dynindx = eh->dynindx;`
`else`	`else`
`dynindx`	`dynindx`
`= _bfd_elf_link_lookup_local_dynindx (info, hh->owner,`	`= _bfd_elf_link_lookup_local_dynindx (info, hh->owner,`
`hh->sym_indx);`	`hh->sym_indx);`

`for (rent = hh->reloc_entries; rent; rent = rent->next)`	`for (rent = hh->reloc_entries; rent; rent = rent->next)`
`{`	`{`
`Elf_Internal_Rela rel;`	`Elf_Internal_Rela rel;`
`bfd_byte *loc;`	`bfd_byte *loc;`

`/* Allocate one iff we are building a shared library, the relocation`	`/* Allocate one iff we are building a shared library, the relocation`
`isn't a R_PARISC_FPTR64, or we don't want an opd entry. */`	`isn't a R_PARISC_FPTR64, or we don't want an opd entry. */`
`if (!info->shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)`	`if (!info->shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)`
`continue;`	`continue;`

`/* Create a dynamic relocation for this entry.`	`/* Create a dynamic relocation for this entry.`

`We need the output offset for the reloc's section because`	`We need the output offset for the reloc's section because`
`we are creating an absolute address in the resulting object`	`we are creating an absolute address in the resulting object`
`file. */`	`file. */`
`rel.r_offset = (rent->offset + rent->sec->output_offset`	`rel.r_offset = (rent->offset + rent->sec->output_offset`
`+ rent->sec->output_section->vma);`	`+ rent->sec->output_section->vma);`

`/* An FPTR64 relocation implies that we took the address of`	`/* An FPTR64 relocation implies that we took the address of`
`a function and that the function has an entry in the .opd`	`a function and that the function has an entry in the .opd`
`section. We want the FPTR64 relocation to reference the`	`section. We want the FPTR64 relocation to reference the`
`entry in .opd.`	`entry in .opd.`

`We could munge the symbol value in the dynamic symbol table`	`We could munge the symbol value in the dynamic symbol table`
`(in fact we already do for functions with global scope) to point`	`(in fact we already do for functions with global scope) to point`
`to the .opd entry. Then we could use that dynamic symbol in`	`to the .opd entry. Then we could use that dynamic symbol in`
`this relocation.`	`this relocation.`

`Or we could do something sensible, not munge the symbol's`	`Or we could do something sensible, not munge the symbol's`
`address and instead just use a different symbol to reference`	`address and instead just use a different symbol to reference`
`the .opd entry. At least that seems sensible until you`	`the .opd entry. At least that seems sensible until you`
`realize there's no local dynamic symbols we can use for that`	`realize there's no local dynamic symbols we can use for that`
`purpose. Thus the hair in the check_relocs routine.`	`purpose. Thus the hair in the check_relocs routine.`

`We use a section symbol recorded by check_relocs as the`	`We use a section symbol recorded by check_relocs as the`
`base symbol for the relocation. The addend is the difference`	`base symbol for the relocation. The addend is the difference`
`between the section symbol and the address of the .opd entry. */`	`between the section symbol and the address of the .opd entry. */`
`if (info->shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)`	`if (info->shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)`
`{`	`{`
`bfd_vma value, value2;`	`bfd_vma value, value2;`

`/* First compute the address of the opd entry for this symbol. */`	`/* First compute the address of the opd entry for this symbol. */`
`value = (hh->opd_offset`	`value = (hh->opd_offset`
`+ hppa_info->opd_sec->output_section->vma`	`+ hppa_info->opd_sec->output_section->vma`
`+ hppa_info->opd_sec->output_offset);`	`+ hppa_info->opd_sec->output_offset);`

`/* Compute the value of the start of the section with`	`/* Compute the value of the start of the section with`
`the relocation. */`	`the relocation. */`
`value2 = (rent->sec->output_section->vma`	`value2 = (rent->sec->output_section->vma`
`+ rent->sec->output_offset);`	`+ rent->sec->output_offset);`

`/* Compute the difference between the start of the section`	`/* Compute the difference between the start of the section`
`with the relocation and the opd entry. */`	`with the relocation and the opd entry. */`
`value -= value2;`	`value -= value2;`

`/* The result becomes the addend of the relocation. */`	`/* The result becomes the addend of the relocation. */`
`rel.r_addend = value;`	`rel.r_addend = value;`

`/* The section symbol becomes the symbol for the dynamic`	`/* The section symbol becomes the symbol for the dynamic`
`relocation. */`	`relocation. */`
`dynindx`	`dynindx`
`= _bfd_elf_link_lookup_local_dynindx (info,`	`= _bfd_elf_link_lookup_local_dynindx (info,`
`rent->sec->owner,`	`rent->sec->owner,`
`rent->sec_symndx);`	`rent->sec_symndx);`
`}`	`}`
`else`	`else`
`rel.r_addend = rent->addend;`	`rel.r_addend = rent->addend;`

`rel.r_info = ELF64_R_INFO (dynindx, rent->type);`	`rel.r_info = ELF64_R_INFO (dynindx, rent->type);`

`loc = hppa_info->other_rel_sec->contents;`	`loc = hppa_info->other_rel_sec->contents;`
`loc += (hppa_info->other_rel_sec->reloc_count++`	`loc += (hppa_info->other_rel_sec->reloc_count++`
`* sizeof (Elf64_External_Rela));`	`* sizeof (Elf64_External_Rela));`
`bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,`	`bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,`
`&rel, loc);`	`&rel, loc);`
`}`	`}`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Used to decide how to sort relocs in an optimal manner for the`	`/* Used to decide how to sort relocs in an optimal manner for the`
`dynamic linker, before writing them out. */`	`dynamic linker, before writing them out. */`

`static enum elf_reloc_type_class`	`static enum elf_reloc_type_class`
`elf64_hppa_reloc_type_class (const Elf_Internal_Rela *rela)`	`elf64_hppa_reloc_type_class (const Elf_Internal_Rela *rela)`
`{`	`{`
`if (ELF64_R_SYM (rela->r_info) == 0)`	`if (ELF64_R_SYM (rela->r_info) == 0)`
`return reloc_class_relative;`	`return reloc_class_relative;`

`switch ((int) ELF64_R_TYPE (rela->r_info))`	`switch ((int) ELF64_R_TYPE (rela->r_info))`
`{`	`{`
`case R_PARISC_IPLT:`	`case R_PARISC_IPLT:`
`return reloc_class_plt;`	`return reloc_class_plt;`
`case R_PARISC_COPY:`	`case R_PARISC_COPY:`
`return reloc_class_copy;`	`return reloc_class_copy;`
`default:`	`default:`
`return reloc_class_normal;`	`return reloc_class_normal;`
`}`	`}`
`}`	`}`

`/* Finish up the dynamic sections. */`	`/* Finish up the dynamic sections. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_finish_dynamic_sections (bfd *output_bfd,`	`elf64_hppa_finish_dynamic_sections (bfd *output_bfd,`
`struct bfd_link_info *info)`	`struct bfd_link_info *info)`
`{`	`{`
`bfd *dynobj;`	`bfd *dynobj;`
`asection *sdyn;`	`asection *sdyn;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`

`/* Finalize the contents of the .opd section. */`	`/* Finalize the contents of the .opd section. */`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`elf64_hppa_finalize_opd,`	`elf64_hppa_finalize_opd,`
`info);`	`info);`

`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`elf64_hppa_finalize_dynreloc,`	`elf64_hppa_finalize_dynreloc,`
`info);`	`info);`

`/* Finalize the contents of the .dlt section. */`	`/* Finalize the contents of the .dlt section. */`
`dynobj = elf_hash_table (info)->dynobj;`	`dynobj = elf_hash_table (info)->dynobj;`
`/* Finalize the contents of the .dlt section. */`	`/* Finalize the contents of the .dlt section. */`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`elf64_hppa_finalize_dlt,`	`elf64_hppa_finalize_dlt,`
`info);`	`info);`

`sdyn = bfd_get_section_by_name (dynobj, ".dynamic");`	`sdyn = bfd_get_section_by_name (dynobj, ".dynamic");`

`if (elf_hash_table (info)->dynamic_sections_created)`	`if (elf_hash_table (info)->dynamic_sections_created)`
`{`	`{`
`Elf64_External_Dyn dyncon, dynconend;`	`Elf64_External_Dyn dyncon, dynconend;`

`BFD_ASSERT (sdyn != NULL);`	`BFD_ASSERT (sdyn != NULL);`

`dyncon = (Elf64_External_Dyn *) sdyn->contents;`	`dyncon = (Elf64_External_Dyn *) sdyn->contents;`
`dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);`	`dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);`
`for (; dyncon < dynconend; dyncon++)`	`for (; dyncon < dynconend; dyncon++)`
`{`	`{`
`Elf_Internal_Dyn dyn;`	`Elf_Internal_Dyn dyn;`
`asection *s;`	`asection *s;`

`bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);`	`bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);`

`switch (dyn.d_tag)`	`switch (dyn.d_tag)`
`{`	`{`
`default:`	`default:`
`break;`	`break;`

`case DT_HP_LOAD_MAP:`	`case DT_HP_LOAD_MAP:`
`/* Compute the absolute address of 16byte scratchpad area`	`/* Compute the absolute address of 16byte scratchpad area`
`for the dynamic linker.`	`for the dynamic linker.`

`By convention the linker script will allocate the scratchpad`	`By convention the linker script will allocate the scratchpad`
`area at the start of the .data section. So all we have to`	`area at the start of the .data section. So all we have to`
`to is find the start of the .data section. */`	`to is find the start of the .data section. */`
`s = bfd_get_section_by_name (output_bfd, ".data");`	`s = bfd_get_section_by_name (output_bfd, ".data");`
`dyn.d_un.d_ptr = s->vma;`	`dyn.d_un.d_ptr = s->vma;`
`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`	`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`
`break;`	`break;`

`case DT_PLTGOT:`	`case DT_PLTGOT:`
`/* HP's use PLTGOT to set the GOT register. */`	`/* HP's use PLTGOT to set the GOT register. */`
`dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);`	`dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);`
`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`	`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`
`break;`	`break;`

`case DT_JMPREL:`	`case DT_JMPREL:`
`s = hppa_info->plt_rel_sec;`	`s = hppa_info->plt_rel_sec;`
`dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;`	`dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;`
`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`	`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`
`break;`	`break;`

`case DT_PLTRELSZ:`	`case DT_PLTRELSZ:`
`s = hppa_info->plt_rel_sec;`	`s = hppa_info->plt_rel_sec;`
`dyn.d_un.d_val = s->size;`	`dyn.d_un.d_val = s->size;`
`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`	`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`
`break;`	`break;`

`case DT_RELA:`	`case DT_RELA:`
`s = hppa_info->other_rel_sec;`	`s = hppa_info->other_rel_sec;`
`if (! s \|\| ! s->size)`	`if (! s \|\| ! s->size)`
`s = hppa_info->dlt_rel_sec;`	`s = hppa_info->dlt_rel_sec;`
`if (! s \|\| ! s->size)`	`if (! s \|\| ! s->size)`
`s = hppa_info->opd_rel_sec;`	`s = hppa_info->opd_rel_sec;`
`dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;`	`dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;`
`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`	`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`
`break;`	`break;`

`case DT_RELASZ:`	`case DT_RELASZ:`
`s = hppa_info->other_rel_sec;`	`s = hppa_info->other_rel_sec;`
`dyn.d_un.d_val = s->size;`	`dyn.d_un.d_val = s->size;`
`s = hppa_info->dlt_rel_sec;`	`s = hppa_info->dlt_rel_sec;`
`dyn.d_un.d_val += s->size;`	`dyn.d_un.d_val += s->size;`
`s = hppa_info->opd_rel_sec;`	`s = hppa_info->opd_rel_sec;`
`dyn.d_un.d_val += s->size;`	`dyn.d_un.d_val += s->size;`
`/* There is some question about whether or not the size of`	`/* There is some question about whether or not the size of`
`the PLT relocs should be included here. HP's tools do`	`the PLT relocs should be included here. HP's tools do`
`it, so we'll emulate them. */`	`it, so we'll emulate them. */`
`s = hppa_info->plt_rel_sec;`	`s = hppa_info->plt_rel_sec;`
`dyn.d_un.d_val += s->size;`	`dyn.d_un.d_val += s->size;`
`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`	`bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);`
`break;`	`break;`

`}`	`}`
`}`	`}`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Support for core dump NOTE sections. */`	`/* Support for core dump NOTE sections. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_grok_prstatus (bfd abfd, Elf_Internal_Note note)`	`elf64_hppa_grok_prstatus (bfd abfd, Elf_Internal_Note note)`
`{`	`{`
`int offset;`	`int offset;`
`size_t size;`	`size_t size;`

`switch (note->descsz)`	`switch (note->descsz)`
`{`	`{`
`default:`	`default:`
`return FALSE;`	`return FALSE;`

`case 760: /* Linux/hppa */`	`case 760: /* Linux/hppa */`
`/* pr_cursig */`	`/* pr_cursig */`
`elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);`	`elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);`

`/* pr_pid */`	`/* pr_pid */`
`elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);`	`elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);`

`/* pr_reg */`	`/* pr_reg */`
`offset = 112;`	`offset = 112;`
`size = 640;`	`size = 640;`

`break;`	`break;`
`}`	`}`

`/* Make a ".reg/999" section. */`	`/* Make a ".reg/999" section. */`
`return _bfd_elfcore_make_pseudosection (abfd, ".reg",`	`return _bfd_elfcore_make_pseudosection (abfd, ".reg",`
`size, note->descpos + offset);`	`size, note->descpos + offset);`
`}`	`}`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_grok_psinfo (bfd abfd, Elf_Internal_Note note)`	`elf64_hppa_grok_psinfo (bfd abfd, Elf_Internal_Note note)`
`{`	`{`
`char * command;`	`char * command;`
`int n;`	`int n;`

`switch (note->descsz)`	`switch (note->descsz)`
`{`	`{`
`default:`	`default:`
`return FALSE;`	`return FALSE;`

`case 136: /* Linux/hppa elf_prpsinfo. */`	`case 136: /* Linux/hppa elf_prpsinfo. */`
`elf_tdata (abfd)->core_program`	`elf_tdata (abfd)->core_program`
`= _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);`	`= _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);`
`elf_tdata (abfd)->core_command`	`elf_tdata (abfd)->core_command`
`= _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);`	`= _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);`
`}`	`}`

`/* Note that for some reason, a spurious space is tacked`	`/* Note that for some reason, a spurious space is tacked`
`onto the end of the args in some (at least one anyway)`	`onto the end of the args in some (at least one anyway)`
`implementations, so strip it off if it exists. */`	`implementations, so strip it off if it exists. */`
`command = elf_tdata (abfd)->core_command;`	`command = elf_tdata (abfd)->core_command;`
`n = strlen (command);`	`n = strlen (command);`

`if (0 < n && command[n - 1] == ' ')`	`if (0 < n && command[n - 1] == ' ')`
`command[n - 1] = '\0';`	`command[n - 1] = '\0';`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Return the number of additional phdrs we will need.`	`/* Return the number of additional phdrs we will need.`

`The generic ELF code only creates PT_PHDRs for executables. The HP`	`The generic ELF code only creates PT_PHDRs for executables. The HP`
`dynamic linker requires PT_PHDRs for dynamic libraries too.`	`dynamic linker requires PT_PHDRs for dynamic libraries too.`

`This routine indicates that the backend needs one additional program`	`This routine indicates that the backend needs one additional program`
`header for that case.`	`header for that case.`

`Note we do not have access to the link info structure here, so we have`	`Note we do not have access to the link info structure here, so we have`
`to guess whether or not we are building a shared library based on the`	`to guess whether or not we are building a shared library based on the`
`existence of a .interp section. */`	`existence of a .interp section. */`

`static int`	`static int`
`elf64_hppa_additional_program_headers (bfd *abfd,`	`elf64_hppa_additional_program_headers (bfd *abfd,`
`struct bfd_link_info *info ATTRIBUTE_UNUSED)`	`struct bfd_link_info *info ATTRIBUTE_UNUSED)`
`{`	`{`
`asection *s;`	`asection *s;`

`/* If we are creating a shared library, then we have to create a`	`/* If we are creating a shared library, then we have to create a`
`PT_PHDR segment. HP's dynamic linker chokes without it. */`	`PT_PHDR segment. HP's dynamic linker chokes without it. */`
`s = bfd_get_section_by_name (abfd, ".interp");`	`s = bfd_get_section_by_name (abfd, ".interp");`
`if (! s)`	`if (! s)`
`return 1;`	`return 1;`
`return 0;`	`return 0;`
`}`	`}`

`/* Allocate and initialize any program headers required by this`	`/* Allocate and initialize any program headers required by this`
`specific backend.`	`specific backend.`

`The generic ELF code only creates PT_PHDRs for executables. The HP`	`The generic ELF code only creates PT_PHDRs for executables. The HP`
`dynamic linker requires PT_PHDRs for dynamic libraries too.`	`dynamic linker requires PT_PHDRs for dynamic libraries too.`

`This allocates the PT_PHDR and initializes it in a manner suitable`	`This allocates the PT_PHDR and initializes it in a manner suitable`
`for the HP linker.`	`for the HP linker.`

`Note we do not have access to the link info structure here, so we have`	`Note we do not have access to the link info structure here, so we have`
`to guess whether or not we are building a shared library based on the`	`to guess whether or not we are building a shared library based on the`
`existence of a .interp section. */`	`existence of a .interp section. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_modify_segment_map (bfd *abfd,`	`elf64_hppa_modify_segment_map (bfd *abfd,`
`struct bfd_link_info *info ATTRIBUTE_UNUSED)`	`struct bfd_link_info *info ATTRIBUTE_UNUSED)`
`{`	`{`
`struct elf_segment_map *m;`	`struct elf_segment_map *m;`
`asection *s;`	`asection *s;`

`s = bfd_get_section_by_name (abfd, ".interp");`	`s = bfd_get_section_by_name (abfd, ".interp");`
`if (! s)`	`if (! s)`
`{`	`{`
`for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)`	`for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)`
`if (m->p_type == PT_PHDR)`	`if (m->p_type == PT_PHDR)`
`break;`	`break;`
`if (m == NULL)`	`if (m == NULL)`
`{`	`{`
`m = ((struct elf_segment_map *)`	`m = ((struct elf_segment_map *)`
`bfd_zalloc (abfd, (bfd_size_type) sizeof *m));`	`bfd_zalloc (abfd, (bfd_size_type) sizeof *m));`
`if (m == NULL)`	`if (m == NULL)`
`return FALSE;`	`return FALSE;`

`m->p_type = PT_PHDR;`	`m->p_type = PT_PHDR;`
`m->p_flags = PF_R \| PF_X;`	`m->p_flags = PF_R \| PF_X;`
`m->p_flags_valid = 1;`	`m->p_flags_valid = 1;`
`m->p_paddr_valid = 1;`	`m->p_paddr_valid = 1;`
`m->includes_phdrs = 1;`	`m->includes_phdrs = 1;`

`m->next = elf_tdata (abfd)->segment_map;`	`m->next = elf_tdata (abfd)->segment_map;`
`elf_tdata (abfd)->segment_map = m;`	`elf_tdata (abfd)->segment_map = m;`
`}`	`}`
`}`	`}`

`for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)`	`for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)`
`if (m->p_type == PT_LOAD)`	`if (m->p_type == PT_LOAD)`
`{`	`{`
`unsigned int i;`	`unsigned int i;`

`for (i = 0; i < m->count; i++)`	`for (i = 0; i < m->count; i++)`
`{`	`{`
`/* The code "hint" is not really a hint. It is a requirement`	`/* The code "hint" is not really a hint. It is a requirement`
`for certain versions of the HP dynamic linker. Worse yet,`	`for certain versions of the HP dynamic linker. Worse yet,`
`it must be set even if the shared library does not have`	`it must be set even if the shared library does not have`
`any code in its "text" segment (thus the check for .hash`	`any code in its "text" segment (thus the check for .hash`
`to catch this situation). */`	`to catch this situation). */`
`if (m->sections[i]->flags & SEC_CODE`	`if (m->sections[i]->flags & SEC_CODE`
`\|\| (strcmp (m->sections[i]->name, ".hash") == 0))`	`\|\| (strcmp (m->sections[i]->name, ".hash") == 0))`
`m->p_flags \|= (PF_X \| PF_HP_CODE);`	`m->p_flags \|= (PF_X \| PF_HP_CODE);`
`}`	`}`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Called when writing out an object file to decide the type of a`	`/* Called when writing out an object file to decide the type of a`
`symbol. */`	`symbol. */`
`static int`	`static int`
`elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym,`	`elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym,`
`int type)`	`int type)`
`{`	`{`
`if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)`	`if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)`
`return STT_PARISC_MILLI;`	`return STT_PARISC_MILLI;`
`else`	`else`
`return type;`	`return type;`
`}`	`}`

`/* Support HP specific sections for core files. */`	`/* Support HP specific sections for core files. */`
`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_section_from_phdr (bfd abfd, Elf_Internal_Phdr hdr, int index,`	`elf64_hppa_section_from_phdr (bfd abfd, Elf_Internal_Phdr hdr, int index,`
`const char *typename)`	`const char *typename)`
`{`	`{`
`if (hdr->p_type == PT_HP_CORE_KERNEL)`	`if (hdr->p_type == PT_HP_CORE_KERNEL)`
`{`	`{`
`asection *sect;`	`asection *sect;`

`if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))`	`if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))`
`return FALSE;`	`return FALSE;`

`sect = bfd_make_section_anyway (abfd, ".kernel");`	`sect = bfd_make_section_anyway (abfd, ".kernel");`
`if (sect == NULL)`	`if (sect == NULL)`
`return FALSE;`	`return FALSE;`
`sect->size = hdr->p_filesz;`	`sect->size = hdr->p_filesz;`
`sect->filepos = hdr->p_offset;`	`sect->filepos = hdr->p_offset;`
`sect->flags = SEC_HAS_CONTENTS \| SEC_READONLY;`	`sect->flags = SEC_HAS_CONTENTS \| SEC_READONLY;`
`return TRUE;`	`return TRUE;`
`}`	`}`

`if (hdr->p_type == PT_HP_CORE_PROC)`	`if (hdr->p_type == PT_HP_CORE_PROC)`
`{`	`{`
`int sig;`	`int sig;`

`if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0)`	`if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0)`
`return FALSE;`	`return FALSE;`
`if (bfd_bread (&sig, 4, abfd) != 4)`	`if (bfd_bread (&sig, 4, abfd) != 4)`
`return FALSE;`	`return FALSE;`

`elf_tdata (abfd)->core_signal = sig;`	`elf_tdata (abfd)->core_signal = sig;`

`if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))`	`if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))`
`return FALSE;`	`return FALSE;`

`/* GDB uses the ".reg" section to read register contents. */`	`/* GDB uses the ".reg" section to read register contents. */`
`return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz,`	`return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz,`
`hdr->p_offset);`	`hdr->p_offset);`
`}`	`}`

`if (hdr->p_type == PT_HP_CORE_LOADABLE`	`if (hdr->p_type == PT_HP_CORE_LOADABLE`
`\|\| hdr->p_type == PT_HP_CORE_STACK`	`\|\| hdr->p_type == PT_HP_CORE_STACK`
`\|\| hdr->p_type == PT_HP_CORE_MMF)`	`\|\| hdr->p_type == PT_HP_CORE_MMF)`
`hdr->p_type = PT_LOAD;`	`hdr->p_type = PT_LOAD;`

`return _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename);`	`return _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename);`
`}`	`}`

`/* Hook called by the linker routine which adds symbols from an object`	`/* Hook called by the linker routine which adds symbols from an object`
`file. HP's libraries define symbols with HP specific section`	`file. HP's libraries define symbols with HP specific section`
`indices, which we have to handle. */`	`indices, which we have to handle. */`

`static bfd_boolean`	`static bfd_boolean`
`elf_hppa_add_symbol_hook (bfd *abfd,`	`elf_hppa_add_symbol_hook (bfd *abfd,`
`struct bfd_link_info *info ATTRIBUTE_UNUSED,`	`struct bfd_link_info *info ATTRIBUTE_UNUSED,`
`Elf_Internal_Sym *sym,`	`Elf_Internal_Sym *sym,`
`const char **namep ATTRIBUTE_UNUSED,`	`const char **namep ATTRIBUTE_UNUSED,`
`flagword *flagsp ATTRIBUTE_UNUSED,`	`flagword *flagsp ATTRIBUTE_UNUSED,`
`asection **secp,`	`asection **secp,`
`bfd_vma *valp)`	`bfd_vma *valp)`
`{`	`{`
`unsigned int index = sym->st_shndx;`	`unsigned int index = sym->st_shndx;`

`switch (index)`	`switch (index)`
`{`	`{`
`case SHN_PARISC_ANSI_COMMON:`	`case SHN_PARISC_ANSI_COMMON:`
`*secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");`	`*secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");`
`(*secp)->flags \|= SEC_IS_COMMON;`	`(*secp)->flags \|= SEC_IS_COMMON;`
`*valp = sym->st_size;`	`*valp = sym->st_size;`
`break;`	`break;`

`case SHN_PARISC_HUGE_COMMON:`	`case SHN_PARISC_HUGE_COMMON:`
`*secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common");`	`*secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common");`
`(*secp)->flags \|= SEC_IS_COMMON;`	`(*secp)->flags \|= SEC_IS_COMMON;`
`*valp = sym->st_size;`	`*valp = sym->st_size;`
`break;`	`break;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`static bfd_boolean`	`static bfd_boolean`
`elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry *h,`	`elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry *h,`
`void *data)`	`void *data)`
`{`	`{`
`struct bfd_link_info *info = data;`	`struct bfd_link_info *info = data;`

`if (h->root.type == bfd_link_hash_warning)`	`if (h->root.type == bfd_link_hash_warning)`
`h = (struct elf_link_hash_entry *) h->root.u.i.link;`	`h = (struct elf_link_hash_entry *) h->root.u.i.link;`

`/* If we are not creating a shared library, and this symbol is`	`/* If we are not creating a shared library, and this symbol is`
`referenced by a shared library but is not defined anywhere, then`	`referenced by a shared library but is not defined anywhere, then`
`the generic code will warn that it is undefined.`	`the generic code will warn that it is undefined.`

`This behavior is undesirable on HPs since the standard shared`	`This behavior is undesirable on HPs since the standard shared`
`libraries contain references to undefined symbols.`	`libraries contain references to undefined symbols.`

`So we twiddle the flags associated with such symbols so that they`	`So we twiddle the flags associated with such symbols so that they`
`will not trigger the warning. ?!? FIXME. This is horribly fragile.`	`will not trigger the warning. ?!? FIXME. This is horribly fragile.`

`Ultimately we should have better controls over the generic ELF BFD`	`Ultimately we should have better controls over the generic ELF BFD`
`linker code. */`	`linker code. */`
`if (! info->relocatable`	`if (! info->relocatable`
`&& info->unresolved_syms_in_shared_libs != RM_IGNORE`	`&& info->unresolved_syms_in_shared_libs != RM_IGNORE`
`&& h->root.type == bfd_link_hash_undefined`	`&& h->root.type == bfd_link_hash_undefined`
`&& h->ref_dynamic`	`&& h->ref_dynamic`
`&& !h->ref_regular)`	`&& !h->ref_regular)`
`{`	`{`
`h->ref_dynamic = 0;`	`h->ref_dynamic = 0;`
`h->pointer_equality_needed = 1;`	`h->pointer_equality_needed = 1;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`static bfd_boolean`	`static bfd_boolean`
`elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry *h,`	`elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry *h,`
`void *data)`	`void *data)`
`{`	`{`
`struct bfd_link_info *info = data;`	`struct bfd_link_info *info = data;`

`if (h->root.type == bfd_link_hash_warning)`	`if (h->root.type == bfd_link_hash_warning)`
`h = (struct elf_link_hash_entry *) h->root.u.i.link;`	`h = (struct elf_link_hash_entry *) h->root.u.i.link;`

`/* If we are not creating a shared library, and this symbol is`	`/* If we are not creating a shared library, and this symbol is`
`referenced by a shared library but is not defined anywhere, then`	`referenced by a shared library but is not defined anywhere, then`
`the generic code will warn that it is undefined.`	`the generic code will warn that it is undefined.`

`This behavior is undesirable on HPs since the standard shared`	`This behavior is undesirable on HPs since the standard shared`
`libraries contain references to undefined symbols.`	`libraries contain references to undefined symbols.`

`So we twiddle the flags associated with such symbols so that they`	`So we twiddle the flags associated with such symbols so that they`
`will not trigger the warning. ?!? FIXME. This is horribly fragile.`	`will not trigger the warning. ?!? FIXME. This is horribly fragile.`

`Ultimately we should have better controls over the generic ELF BFD`	`Ultimately we should have better controls over the generic ELF BFD`
`linker code. */`	`linker code. */`
`if (! info->relocatable`	`if (! info->relocatable`
`&& info->unresolved_syms_in_shared_libs != RM_IGNORE`	`&& info->unresolved_syms_in_shared_libs != RM_IGNORE`
`&& h->root.type == bfd_link_hash_undefined`	`&& h->root.type == bfd_link_hash_undefined`
`&& !h->ref_dynamic`	`&& !h->ref_dynamic`
`&& !h->ref_regular`	`&& !h->ref_regular`
`&& h->pointer_equality_needed)`	`&& h->pointer_equality_needed)`
`{`	`{`
`h->ref_dynamic = 1;`	`h->ref_dynamic = 1;`
`h->pointer_equality_needed = 0;`	`h->pointer_equality_needed = 0;`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`static bfd_boolean`	`static bfd_boolean`
`elf_hppa_is_dynamic_loader_symbol (const char *name)`	`elf_hppa_is_dynamic_loader_symbol (const char *name)`
`{`	`{`
`return (! strcmp (name, "__CPU_REVISION")`	`return (! strcmp (name, "__CPU_REVISION")`
`\|\| ! strcmp (name, "__CPU_KEYBITS_1")`	`\|\| ! strcmp (name, "__CPU_KEYBITS_1")`
`\|\| ! strcmp (name, "__SYSTEM_ID_D")`	`\|\| ! strcmp (name, "__SYSTEM_ID_D")`
`\|\| ! strcmp (name, "__FPU_MODEL")`	`\|\| ! strcmp (name, "__FPU_MODEL")`
`\|\| ! strcmp (name, "__FPU_REVISION")`	`\|\| ! strcmp (name, "__FPU_REVISION")`
`\|\| ! strcmp (name, "__ARGC")`	`\|\| ! strcmp (name, "__ARGC")`
`\|\| ! strcmp (name, "__ARGV")`	`\|\| ! strcmp (name, "__ARGV")`
`\|\| ! strcmp (name, "__ENVP")`	`\|\| ! strcmp (name, "__ENVP")`
`\|\| ! strcmp (name, "__TLS_SIZE_D")`	`\|\| ! strcmp (name, "__TLS_SIZE_D")`
`\|\| ! strcmp (name, "__LOAD_INFO")`	`\|\| ! strcmp (name, "__LOAD_INFO")`
`\|\| ! strcmp (name, "__systab"));`	`\|\| ! strcmp (name, "__systab"));`
`}`	`}`

`/* Record the lowest address for the data and text segments. */`	`/* Record the lowest address for the data and text segments. */`
`static void`	`static void`
`elf_hppa_record_segment_addrs (bfd *abfd,`	`elf_hppa_record_segment_addrs (bfd *abfd,`
`asection *section,`	`asection *section,`
`void *data)`	`void *data)`
`{`	`{`
`struct elf64_hppa_link_hash_table *hppa_info = data;`	`struct elf64_hppa_link_hash_table *hppa_info = data;`

`if ((section->flags & (SEC_ALLOC \| SEC_LOAD)) == (SEC_ALLOC \| SEC_LOAD))`	`if ((section->flags & (SEC_ALLOC \| SEC_LOAD)) == (SEC_ALLOC \| SEC_LOAD))`
`{`	`{`
`bfd_vma value;`	`bfd_vma value;`
`Elf_Internal_Phdr *p;`	`Elf_Internal_Phdr *p;`

`p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);`	`p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);`
`BFD_ASSERT (p != NULL);`	`BFD_ASSERT (p != NULL);`
`value = p->p_vaddr;`	`value = p->p_vaddr;`

`if (section->flags & SEC_READONLY)`	`if (section->flags & SEC_READONLY)`
`{`	`{`
`if (value < hppa_info->text_segment_base)`	`if (value < hppa_info->text_segment_base)`
`hppa_info->text_segment_base = value;`	`hppa_info->text_segment_base = value;`
`}`	`}`
`else`	`else`
`{`	`{`
`if (value < hppa_info->data_segment_base)`	`if (value < hppa_info->data_segment_base)`
`hppa_info->data_segment_base = value;`	`hppa_info->data_segment_base = value;`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Called after we have seen all the input files/sections, but before`	`/* Called after we have seen all the input files/sections, but before`
`final symbol resolution and section placement has been determined.`	`final symbol resolution and section placement has been determined.`

`We use this hook to (possibly) provide a value for __gp, then we`	`We use this hook to (possibly) provide a value for __gp, then we`
`fall back to the generic ELF final link routine. */`	`fall back to the generic ELF final link routine. */`

`static bfd_boolean`	`static bfd_boolean`
`elf_hppa_final_link (bfd abfd, struct bfd_link_info info)`	`elf_hppa_final_link (bfd abfd, struct bfd_link_info info)`
`{`	`{`
`bfd_boolean retval;`	`bfd_boolean retval;`
`struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);`	`struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);`

`if (! info->relocatable)`	`if (! info->relocatable)`
`{`	`{`
`struct elf_link_hash_entry *gp;`	`struct elf_link_hash_entry *gp;`
`bfd_vma gp_val;`	`bfd_vma gp_val;`

`/* The linker script defines a value for __gp iff it was referenced`	`/* The linker script defines a value for __gp iff it was referenced`
`by one of the objects being linked. First try to find the symbol`	`by one of the objects being linked. First try to find the symbol`
`in the hash table. If that fails, just compute the value __gp`	`in the hash table. If that fails, just compute the value __gp`
`should have had. */`	`should have had. */`
`gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,`	`gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,`
`FALSE, FALSE);`	`FALSE, FALSE);`

`if (gp)`	`if (gp)`
`{`	`{`

`/* Adjust the value of __gp as we may want to slide it into the`	`/* Adjust the value of __gp as we may want to slide it into the`
`.plt section so that the stubs can access PLT entries without`	`.plt section so that the stubs can access PLT entries without`
`using an addil sequence. */`	`using an addil sequence. */`
`gp->root.u.def.value += hppa_info->gp_offset;`	`gp->root.u.def.value += hppa_info->gp_offset;`

`gp_val = (gp->root.u.def.section->output_section->vma`	`gp_val = (gp->root.u.def.section->output_section->vma`
`+ gp->root.u.def.section->output_offset`	`+ gp->root.u.def.section->output_offset`
`+ gp->root.u.def.value);`	`+ gp->root.u.def.value);`
`}`	`}`
`else`	`else`
`{`	`{`
`asection *sec;`	`asection *sec;`

`/* First look for a .plt section. If found, then __gp is the`	`/* First look for a .plt section. If found, then __gp is the`
`address of the .plt + gp_offset.`	`address of the .plt + gp_offset.`

`If no .plt is found, then look for .dlt, .opd and .data (in`	`If no .plt is found, then look for .dlt, .opd and .data (in`
`that order) and set __gp to the base address of whichever`	`that order) and set __gp to the base address of whichever`
`section is found first. */`	`section is found first. */`

`sec = hppa_info->plt_sec;`	`sec = hppa_info->plt_sec;`
`if (sec && ! (sec->flags & SEC_EXCLUDE))`	`if (sec && ! (sec->flags & SEC_EXCLUDE))`
`gp_val = (sec->output_offset`	`gp_val = (sec->output_offset`
`+ sec->output_section->vma`	`+ sec->output_section->vma`
`+ hppa_info->gp_offset);`	`+ hppa_info->gp_offset);`
`else`	`else`
`{`	`{`
`sec = hppa_info->dlt_sec;`	`sec = hppa_info->dlt_sec;`
`if (!sec \|\| (sec->flags & SEC_EXCLUDE))`	`if (!sec \|\| (sec->flags & SEC_EXCLUDE))`
`sec = hppa_info->opd_sec;`	`sec = hppa_info->opd_sec;`
`if (!sec \|\| (sec->flags & SEC_EXCLUDE))`	`if (!sec \|\| (sec->flags & SEC_EXCLUDE))`
`sec = bfd_get_section_by_name (abfd, ".data");`	`sec = bfd_get_section_by_name (abfd, ".data");`
`if (!sec \|\| (sec->flags & SEC_EXCLUDE))`	`if (!sec \|\| (sec->flags & SEC_EXCLUDE))`
`gp_val = 0;`	`gp_val = 0;`
`else`	`else`
`gp_val = sec->output_offset + sec->output_section->vma;`	`gp_val = sec->output_offset + sec->output_section->vma;`
`}`	`}`
`}`	`}`

`/* Install whatever value we found/computed for __gp. */`	`/* Install whatever value we found/computed for __gp. */`
`_bfd_set_gp_value (abfd, gp_val);`	`_bfd_set_gp_value (abfd, gp_val);`
`}`	`}`

`/* We need to know the base of the text and data segments so that we`	`/* We need to know the base of the text and data segments so that we`
`can perform SEGREL relocations. We will record the base addresses`	`can perform SEGREL relocations. We will record the base addresses`
`when we encounter the first SEGREL relocation. */`	`when we encounter the first SEGREL relocation. */`
`hppa_info->text_segment_base = (bfd_vma)-1;`	`hppa_info->text_segment_base = (bfd_vma)-1;`
`hppa_info->data_segment_base = (bfd_vma)-1;`	`hppa_info->data_segment_base = (bfd_vma)-1;`

`/* HP's shared libraries have references to symbols that are not`	`/* HP's shared libraries have references to symbols that are not`
`defined anywhere. The generic ELF BFD linker code will complain`	`defined anywhere. The generic ELF BFD linker code will complain`
`about such symbols.`	`about such symbols.`

`So we detect the losing case and arrange for the flags on the symbol`	`So we detect the losing case and arrange for the flags on the symbol`
`to indicate that it was never referenced. This keeps the generic`	`to indicate that it was never referenced. This keeps the generic`
`ELF BFD link code happy and appears to not create any secondary`	`ELF BFD link code happy and appears to not create any secondary`
`problems. Ultimately we need a way to control the behavior of the`	`problems. Ultimately we need a way to control the behavior of the`
`generic ELF BFD link code better. */`	`generic ELF BFD link code better. */`
`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`elf_hppa_unmark_useless_dynamic_symbols,`	`elf_hppa_unmark_useless_dynamic_symbols,`
`info);`	`info);`

`/* Invoke the regular ELF backend linker to do all the work. */`	`/* Invoke the regular ELF backend linker to do all the work. */`
`retval = bfd_elf_final_link (abfd, info);`	`retval = bfd_elf_final_link (abfd, info);`

`elf_link_hash_traverse (elf_hash_table (info),`	`elf_link_hash_traverse (elf_hash_table (info),`
`elf_hppa_remark_useless_dynamic_symbols,`	`elf_hppa_remark_useless_dynamic_symbols,`
`info);`	`info);`

`/* If we're producing a final executable, sort the contents of the`	`/* If we're producing a final executable, sort the contents of the`
`unwind section. */`	`unwind section. */`
`if (retval)`	`if (retval)`
`retval = elf_hppa_sort_unwind (abfd);`	`retval = elf_hppa_sort_unwind (abfd);`

`return retval;`	`return retval;`
`}`	`}`

`/* Relocate the given INSN. VALUE should be the actual value we want`	`/* Relocate the given INSN. VALUE should be the actual value we want`
`to insert into the instruction, ie by this point we should not be`	`to insert into the instruction, ie by this point we should not be`
`concerned with computing an offset relative to the DLT, PC, etc.`	`concerned with computing an offset relative to the DLT, PC, etc.`
`Instead this routine is meant to handle the bit manipulations needed`	`Instead this routine is meant to handle the bit manipulations needed`
`to insert the relocation into the given instruction. */`	`to insert the relocation into the given instruction. */`

`static int`	`static int`
`elf_hppa_relocate_insn (int insn, int sym_value, unsigned int r_type)`	`elf_hppa_relocate_insn (int insn, int sym_value, unsigned int r_type)`
`{`	`{`
`switch (r_type)`	`switch (r_type)`
`{`	`{`
`/* This is any 22 bit branch. In PA2.0 syntax it corresponds to`	`/* This is any 22 bit branch. In PA2.0 syntax it corresponds to`
`the "B" instruction. */`	`the "B" instruction. */`
`case R_PARISC_PCREL22F:`	`case R_PARISC_PCREL22F:`
`case R_PARISC_PCREL22C:`	`case R_PARISC_PCREL22C:`
`return (insn & ~0x3ff1ffd) \| re_assemble_22 (sym_value);`	`return (insn & ~0x3ff1ffd) \| re_assemble_22 (sym_value);`

`/* This is any 12 bit branch. */`	`/* This is any 12 bit branch. */`
`case R_PARISC_PCREL12F:`	`case R_PARISC_PCREL12F:`
`return (insn & ~0x1ffd) \| re_assemble_12 (sym_value);`	`return (insn & ~0x1ffd) \| re_assemble_12 (sym_value);`

`/* This is any 17 bit branch. In PA2.0 syntax it also corresponds`	`/* This is any 17 bit branch. In PA2.0 syntax it also corresponds`
`to the "B" instruction as well as BE. */`	`to the "B" instruction as well as BE. */`
`case R_PARISC_PCREL17F:`	`case R_PARISC_PCREL17F:`
`case R_PARISC_DIR17F:`	`case R_PARISC_DIR17F:`
`case R_PARISC_DIR17R:`	`case R_PARISC_DIR17R:`
`case R_PARISC_PCREL17C:`	`case R_PARISC_PCREL17C:`
`case R_PARISC_PCREL17R:`	`case R_PARISC_PCREL17R:`
`return (insn & ~0x1f1ffd) \| re_assemble_17 (sym_value);`	`return (insn & ~0x1f1ffd) \| re_assemble_17 (sym_value);`

`/* ADDIL or LDIL instructions. */`	`/* ADDIL or LDIL instructions. */`
`case R_PARISC_DLTREL21L:`	`case R_PARISC_DLTREL21L:`
`case R_PARISC_DLTIND21L:`	`case R_PARISC_DLTIND21L:`
`case R_PARISC_LTOFF_FPTR21L:`	`case R_PARISC_LTOFF_FPTR21L:`
`case R_PARISC_PCREL21L:`	`case R_PARISC_PCREL21L:`
`case R_PARISC_LTOFF_TP21L:`	`case R_PARISC_LTOFF_TP21L:`
`case R_PARISC_DPREL21L:`	`case R_PARISC_DPREL21L:`
`case R_PARISC_PLTOFF21L:`	`case R_PARISC_PLTOFF21L:`
`case R_PARISC_DIR21L:`	`case R_PARISC_DIR21L:`
`return (insn & ~0x1fffff) \| re_assemble_21 (sym_value);`	`return (insn & ~0x1fffff) \| re_assemble_21 (sym_value);`

`/* LDO and integer loads/stores with 14 bit displacements. */`	`/* LDO and integer loads/stores with 14 bit displacements. */`
`case R_PARISC_DLTREL14R:`	`case R_PARISC_DLTREL14R:`
`case R_PARISC_DLTREL14F:`	`case R_PARISC_DLTREL14F:`
`case R_PARISC_DLTIND14R:`	`case R_PARISC_DLTIND14R:`
`case R_PARISC_DLTIND14F:`	`case R_PARISC_DLTIND14F:`
`case R_PARISC_LTOFF_FPTR14R:`	`case R_PARISC_LTOFF_FPTR14R:`
`case R_PARISC_PCREL14R:`	`case R_PARISC_PCREL14R:`
`case R_PARISC_PCREL14F:`	`case R_PARISC_PCREL14F:`
`case R_PARISC_LTOFF_TP14R:`	`case R_PARISC_LTOFF_TP14R:`
`case R_PARISC_LTOFF_TP14F:`	`case R_PARISC_LTOFF_TP14F:`
`case R_PARISC_DPREL14R:`	`case R_PARISC_DPREL14R:`
`case R_PARISC_DPREL14F:`	`case R_PARISC_DPREL14F:`
`case R_PARISC_PLTOFF14R:`	`case R_PARISC_PLTOFF14R:`
`case R_PARISC_PLTOFF14F:`	`case R_PARISC_PLTOFF14F:`
`case R_PARISC_DIR14R:`	`case R_PARISC_DIR14R:`
`case R_PARISC_DIR14F:`	`case R_PARISC_DIR14F:`
`return (insn & ~0x3fff) \| low_sign_unext (sym_value, 14);`	`return (insn & ~0x3fff) \| low_sign_unext (sym_value, 14);`

`/* PA2.0W LDO and integer loads/stores with 16 bit displacements. */`	`/* PA2.0W LDO and integer loads/stores with 16 bit displacements. */`
`case R_PARISC_LTOFF_FPTR16F:`	`case R_PARISC_LTOFF_FPTR16F:`
`case R_PARISC_PCREL16F:`	`case R_PARISC_PCREL16F:`
`case R_PARISC_LTOFF_TP16F:`	`case R_PARISC_LTOFF_TP16F:`
`case R_PARISC_GPREL16F:`	`case R_PARISC_GPREL16F:`
`case R_PARISC_PLTOFF16F:`	`case R_PARISC_PLTOFF16F:`
`case R_PARISC_DIR16F:`	`case R_PARISC_DIR16F:`
`case R_PARISC_LTOFF16F:`	`case R_PARISC_LTOFF16F:`
`return (insn & ~0xffff) \| re_assemble_16 (sym_value);`	`return (insn & ~0xffff) \| re_assemble_16 (sym_value);`

`/* Doubleword loads and stores with a 14 bit displacement. */`	`/* Doubleword loads and stores with a 14 bit displacement. */`
`case R_PARISC_DLTREL14DR:`	`case R_PARISC_DLTREL14DR:`
`case R_PARISC_DLTIND14DR:`	`case R_PARISC_DLTIND14DR:`
`case R_PARISC_LTOFF_FPTR14DR:`	`case R_PARISC_LTOFF_FPTR14DR:`
`case R_PARISC_LTOFF_FPTR16DF:`	`case R_PARISC_LTOFF_FPTR16DF:`
`case R_PARISC_PCREL14DR:`	`case R_PARISC_PCREL14DR:`
`case R_PARISC_PCREL16DF:`	`case R_PARISC_PCREL16DF:`
`case R_PARISC_LTOFF_TP14DR:`	`case R_PARISC_LTOFF_TP14DR:`
`case R_PARISC_LTOFF_TP16DF:`	`case R_PARISC_LTOFF_TP16DF:`
`case R_PARISC_DPREL14DR:`	`case R_PARISC_DPREL14DR:`
`case R_PARISC_GPREL16DF:`	`case R_PARISC_GPREL16DF:`
`case R_PARISC_PLTOFF14DR:`	`case R_PARISC_PLTOFF14DR:`
`case R_PARISC_PLTOFF16DF:`	`case R_PARISC_PLTOFF16DF:`
`case R_PARISC_DIR14DR:`	`case R_PARISC_DIR14DR:`
`case R_PARISC_DIR16DF:`	`case R_PARISC_DIR16DF:`
`case R_PARISC_LTOFF16DF:`	`case R_PARISC_LTOFF16DF:`
`return (insn & ~0x3ff1) \| (((sym_value & 0x2000) >> 13)`	`return (insn & ~0x3ff1) \| (((sym_value & 0x2000) >> 13)`
`\| ((sym_value & 0x1ff8) << 1));`	`\| ((sym_value & 0x1ff8) << 1));`

`/* Floating point single word load/store instructions. */`	`/* Floating point single word load/store instructions. */`
`case R_PARISC_DLTREL14WR:`	`case R_PARISC_DLTREL14WR:`
`case R_PARISC_DLTIND14WR:`	`case R_PARISC_DLTIND14WR:`
`case R_PARISC_LTOFF_FPTR14WR:`	`case R_PARISC_LTOFF_FPTR14WR:`
`case R_PARISC_LTOFF_FPTR16WF:`	`case R_PARISC_LTOFF_FPTR16WF:`
`case R_PARISC_PCREL14WR:`	`case R_PARISC_PCREL14WR:`
`case R_PARISC_PCREL16WF:`	`case R_PARISC_PCREL16WF:`
`case R_PARISC_LTOFF_TP14WR:`	`case R_PARISC_LTOFF_TP14WR:`
`case R_PARISC_LTOFF_TP16WF:`	`case R_PARISC_LTOFF_TP16WF:`
`case R_PARISC_DPREL14WR:`	`case R_PARISC_DPREL14WR:`
`case R_PARISC_GPREL16WF:`	`case R_PARISC_GPREL16WF:`
`case R_PARISC_PLTOFF14WR:`	`case R_PARISC_PLTOFF14WR:`
`case R_PARISC_PLTOFF16WF:`	`case R_PARISC_PLTOFF16WF:`
`case R_PARISC_DIR16WF:`	`case R_PARISC_DIR16WF:`
`case R_PARISC_DIR14WR:`	`case R_PARISC_DIR14WR:`
`case R_PARISC_LTOFF16WF:`	`case R_PARISC_LTOFF16WF:`
`return (insn & ~0x3ff9) \| (((sym_value & 0x2000) >> 13)`	`return (insn & ~0x3ff9) \| (((sym_value & 0x2000) >> 13)`
`\| ((sym_value & 0x1ffc) << 1));`	`\| ((sym_value & 0x1ffc) << 1));`

`default:`	`default:`
`return insn;`	`return insn;`
`}`	`}`
`}`	`}`

`/* Compute the value for a relocation (REL) during a final link stage,`	`/* Compute the value for a relocation (REL) during a final link stage,`
`then insert the value into the proper location in CONTENTS.`	`then insert the value into the proper location in CONTENTS.`

`VALUE is a tentative value for the relocation and may be overridden`	`VALUE is a tentative value for the relocation and may be overridden`
`and modified here based on the specific relocation to be performed.`	`and modified here based on the specific relocation to be performed.`

`For example we do conversions for PC-relative branches in this routine`	`For example we do conversions for PC-relative branches in this routine`
`or redirection of calls to external routines to stubs.`	`or redirection of calls to external routines to stubs.`

`The work of actually applying the relocation is left to a helper`	`The work of actually applying the relocation is left to a helper`
`routine in an attempt to reduce the complexity and size of this`	`routine in an attempt to reduce the complexity and size of this`
`function. */`	`function. */`

`static bfd_reloc_status_type`	`static bfd_reloc_status_type`
`elf_hppa_final_link_relocate (Elf_Internal_Rela *rel,`	`elf_hppa_final_link_relocate (Elf_Internal_Rela *rel,`
`bfd *input_bfd,`	`bfd *input_bfd,`
`bfd *output_bfd,`	`bfd *output_bfd,`
`asection *input_section,`	`asection *input_section,`
`bfd_byte *contents,`	`bfd_byte *contents,`
`bfd_vma value,`	`bfd_vma value,`
`struct bfd_link_info *info,`	`struct bfd_link_info *info,`
`asection *sym_sec,`	`asection *sym_sec,`
`struct elf_link_hash_entry *eh)`	`struct elf_link_hash_entry *eh)`
`{`	`{`
`struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);`	`struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);`
`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`	`struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);`
`bfd_vma *local_offsets;`	`bfd_vma *local_offsets;`
`Elf_Internal_Shdr *symtab_hdr;`	`Elf_Internal_Shdr *symtab_hdr;`
`int insn;`	`int insn;`
`bfd_vma max_branch_offset = 0;`	`bfd_vma max_branch_offset = 0;`
`bfd_vma offset = rel->r_offset;`	`bfd_vma offset = rel->r_offset;`
`bfd_signed_vma addend = rel->r_addend;`	`bfd_signed_vma addend = rel->r_addend;`
`reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);`	`reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);`
`unsigned int r_symndx = ELF_R_SYM (rel->r_info);`	`unsigned int r_symndx = ELF_R_SYM (rel->r_info);`
`unsigned int r_type = howto->type;`	`unsigned int r_type = howto->type;`
`bfd_byte *hit_data = contents + offset;`	`bfd_byte *hit_data = contents + offset;`

`symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;`	`symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;`
`local_offsets = elf_local_got_offsets (input_bfd);`	`local_offsets = elf_local_got_offsets (input_bfd);`
`insn = bfd_get_32 (input_bfd, hit_data);`	`insn = bfd_get_32 (input_bfd, hit_data);`

`switch (r_type)`	`switch (r_type)`
`{`	`{`
`case R_PARISC_NONE:`	`case R_PARISC_NONE:`
`break;`	`break;`

`/* Basic function call support.`	`/* Basic function call support.`

`Note for a call to a function defined in another dynamic library`	`Note for a call to a function defined in another dynamic library`
`we want to redirect the call to a stub. */`	`we want to redirect the call to a stub. */`

`/* PC relative relocs without an implicit offset. */`	`/* PC relative relocs without an implicit offset. */`
`case R_PARISC_PCREL21L:`	`case R_PARISC_PCREL21L:`
`case R_PARISC_PCREL14R:`	`case R_PARISC_PCREL14R:`
`case R_PARISC_PCREL14F:`	`case R_PARISC_PCREL14F:`
`case R_PARISC_PCREL14WR:`	`case R_PARISC_PCREL14WR:`
`case R_PARISC_PCREL14DR:`	`case R_PARISC_PCREL14DR:`
`case R_PARISC_PCREL16F:`	`case R_PARISC_PCREL16F:`
`case R_PARISC_PCREL16WF:`	`case R_PARISC_PCREL16WF:`
`case R_PARISC_PCREL16DF:`	`case R_PARISC_PCREL16DF:`
`{`	`{`
`/* If this is a call to a function defined in another dynamic`	`/* If this is a call to a function defined in another dynamic`
`library, then redirect the call to the local stub for this`	`library, then redirect the call to the local stub for this`
`function. */`	`function. */`
`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`	`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`
`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`	`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`
`+ hppa_info->stub_sec->output_section->vma);`	`+ hppa_info->stub_sec->output_section->vma);`

`/* Turn VALUE into a proper PC relative address. */`	`/* Turn VALUE into a proper PC relative address. */`
`value -= (offset + input_section->output_offset`	`value -= (offset + input_section->output_offset`
`+ input_section->output_section->vma);`	`+ input_section->output_section->vma);`

`/* Adjust for any field selectors. */`	`/* Adjust for any field selectors. */`
`if (r_type == R_PARISC_PCREL21L)`	`if (r_type == R_PARISC_PCREL21L)`
`value = hppa_field_adjust (value, -8 + addend, e_lsel);`	`value = hppa_field_adjust (value, -8 + addend, e_lsel);`
`else if (r_type == R_PARISC_PCREL14F`	`else if (r_type == R_PARISC_PCREL14F`
`\|\| r_type == R_PARISC_PCREL16F`	`\|\| r_type == R_PARISC_PCREL16F`
`\|\| r_type == R_PARISC_PCREL16WF`	`\|\| r_type == R_PARISC_PCREL16WF`
`\|\| r_type == R_PARISC_PCREL16DF)`	`\|\| r_type == R_PARISC_PCREL16DF)`
`value = hppa_field_adjust (value, -8 + addend, e_fsel);`	`value = hppa_field_adjust (value, -8 + addend, e_fsel);`
`else`	`else`
`value = hppa_field_adjust (value, -8 + addend, e_rsel);`	`value = hppa_field_adjust (value, -8 + addend, e_rsel);`

`/* Apply the relocation to the given instruction. */`	`/* Apply the relocation to the given instruction. */`
`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`	`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`
`break;`	`break;`
`}`	`}`

`case R_PARISC_PCREL12F:`	`case R_PARISC_PCREL12F:`
`case R_PARISC_PCREL22F:`	`case R_PARISC_PCREL22F:`
`case R_PARISC_PCREL17F:`	`case R_PARISC_PCREL17F:`
`case R_PARISC_PCREL22C:`	`case R_PARISC_PCREL22C:`
`case R_PARISC_PCREL17C:`	`case R_PARISC_PCREL17C:`
`case R_PARISC_PCREL17R:`	`case R_PARISC_PCREL17R:`
`{`	`{`
`/* If this is a call to a function defined in another dynamic`	`/* If this is a call to a function defined in another dynamic`
`library, then redirect the call to the local stub for this`	`library, then redirect the call to the local stub for this`
`function. */`	`function. */`
`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`	`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`
`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`	`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`
`+ hppa_info->stub_sec->output_section->vma);`	`+ hppa_info->stub_sec->output_section->vma);`

`/* Turn VALUE into a proper PC relative address. */`	`/* Turn VALUE into a proper PC relative address. */`
`value -= (offset + input_section->output_offset`	`value -= (offset + input_section->output_offset`
`+ input_section->output_section->vma);`	`+ input_section->output_section->vma);`
`addend -= 8;`	`addend -= 8;`

`if (r_type == (unsigned int) R_PARISC_PCREL22F)`	`if (r_type == (unsigned int) R_PARISC_PCREL22F)`
`max_branch_offset = (1 << (22-1)) << 2;`	`max_branch_offset = (1 << (22-1)) << 2;`
`else if (r_type == (unsigned int) R_PARISC_PCREL17F)`	`else if (r_type == (unsigned int) R_PARISC_PCREL17F)`
`max_branch_offset = (1 << (17-1)) << 2;`	`max_branch_offset = (1 << (17-1)) << 2;`
`else if (r_type == (unsigned int) R_PARISC_PCREL12F)`	`else if (r_type == (unsigned int) R_PARISC_PCREL12F)`
`max_branch_offset = (1 << (12-1)) << 2;`	`max_branch_offset = (1 << (12-1)) << 2;`

`/* Make sure we can reach the branch target. */`	`/* Make sure we can reach the branch target. */`
`if (max_branch_offset != 0`	`if (max_branch_offset != 0`
`&& value + addend + max_branch_offset >= 2*max_branch_offset)`	`&& value + addend + max_branch_offset >= 2*max_branch_offset)`
`{`	`{`
`(*_bfd_error_handler)`	`(*_bfd_error_handler)`
`(_("%B(%A+0x%lx): cannot reach %s"),`	`(_("%B(%A+0x%lx): cannot reach %s"),`
`input_bfd,`	`input_bfd,`
`input_section,`	`input_section,`
`offset,`	`offset,`
`eh->root.root.string);`	`eh->root.root.string);`
`bfd_set_error (bfd_error_bad_value);`	`bfd_set_error (bfd_error_bad_value);`
`return bfd_reloc_notsupported;`	`return bfd_reloc_notsupported;`
`}`	`}`

`/* Adjust for any field selectors. */`	`/* Adjust for any field selectors. */`
`if (r_type == R_PARISC_PCREL17R)`	`if (r_type == R_PARISC_PCREL17R)`
`value = hppa_field_adjust (value, addend, e_rsel);`	`value = hppa_field_adjust (value, addend, e_rsel);`
`else`	`else`
`value = hppa_field_adjust (value, addend, e_fsel);`	`value = hppa_field_adjust (value, addend, e_fsel);`

`/* All branches are implicitly shifted by 2 places. */`	`/* All branches are implicitly shifted by 2 places. */`
`value >>= 2;`	`value >>= 2;`

`/* Apply the relocation to the given instruction. */`	`/* Apply the relocation to the given instruction. */`
`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`	`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`
`break;`	`break;`
`}`	`}`

`/* Indirect references to data through the DLT. */`	`/* Indirect references to data through the DLT. */`
`case R_PARISC_DLTIND14R:`	`case R_PARISC_DLTIND14R:`
`case R_PARISC_DLTIND14F:`	`case R_PARISC_DLTIND14F:`
`case R_PARISC_DLTIND14DR:`	`case R_PARISC_DLTIND14DR:`
`case R_PARISC_DLTIND14WR:`	`case R_PARISC_DLTIND14WR:`
`case R_PARISC_DLTIND21L:`	`case R_PARISC_DLTIND21L:`
`case R_PARISC_LTOFF_FPTR14R:`	`case R_PARISC_LTOFF_FPTR14R:`
`case R_PARISC_LTOFF_FPTR14DR:`	`case R_PARISC_LTOFF_FPTR14DR:`
`case R_PARISC_LTOFF_FPTR14WR:`	`case R_PARISC_LTOFF_FPTR14WR:`
`case R_PARISC_LTOFF_FPTR21L:`	`case R_PARISC_LTOFF_FPTR21L:`
`case R_PARISC_LTOFF_FPTR16F:`	`case R_PARISC_LTOFF_FPTR16F:`
`case R_PARISC_LTOFF_FPTR16WF:`	`case R_PARISC_LTOFF_FPTR16WF:`
`case R_PARISC_LTOFF_FPTR16DF:`	`case R_PARISC_LTOFF_FPTR16DF:`
`case R_PARISC_LTOFF_TP21L:`	`case R_PARISC_LTOFF_TP21L:`
`case R_PARISC_LTOFF_TP14R:`	`case R_PARISC_LTOFF_TP14R:`
`case R_PARISC_LTOFF_TP14F:`	`case R_PARISC_LTOFF_TP14F:`
`case R_PARISC_LTOFF_TP14WR:`	`case R_PARISC_LTOFF_TP14WR:`
`case R_PARISC_LTOFF_TP14DR:`	`case R_PARISC_LTOFF_TP14DR:`
`case R_PARISC_LTOFF_TP16F:`	`case R_PARISC_LTOFF_TP16F:`
`case R_PARISC_LTOFF_TP16WF:`	`case R_PARISC_LTOFF_TP16WF:`
`case R_PARISC_LTOFF_TP16DF:`	`case R_PARISC_LTOFF_TP16DF:`
`case R_PARISC_LTOFF16F:`	`case R_PARISC_LTOFF16F:`
`case R_PARISC_LTOFF16WF:`	`case R_PARISC_LTOFF16WF:`
`case R_PARISC_LTOFF16DF:`	`case R_PARISC_LTOFF16DF:`
`{`	`{`
`bfd_vma off;`	`bfd_vma off;`

`/* If this relocation was against a local symbol, then we still`	`/* If this relocation was against a local symbol, then we still`
`have not set up the DLT entry (it's not convenient to do so`	`have not set up the DLT entry (it's not convenient to do so`
`in the "finalize_dlt" routine because it is difficult to get`	`in the "finalize_dlt" routine because it is difficult to get`
`to the local symbol's value).`	`to the local symbol's value).`

`So, if this is a local symbol (h == NULL), then we need to`	`So, if this is a local symbol (h == NULL), then we need to`
`fill in its DLT entry.`	`fill in its DLT entry.`

`Similarly we may still need to set up an entry in .opd for`	`Similarly we may still need to set up an entry in .opd for`
`a local function which had its address taken. */`	`a local function which had its address taken. */`
`if (hh == NULL)`	`if (hh == NULL)`
`{`	`{`
`bfd_vma local_opd_offsets, local_dlt_offsets;`	`bfd_vma local_opd_offsets, local_dlt_offsets;`

`if (local_offsets == NULL)`	`if (local_offsets == NULL)`
`abort ();`	`abort ();`

`/* Now do .opd creation if needed. */`	`/* Now do .opd creation if needed. */`
`if (r_type == R_PARISC_LTOFF_FPTR14R`	`if (r_type == R_PARISC_LTOFF_FPTR14R`
`\|\| r_type == R_PARISC_LTOFF_FPTR14DR`	`\|\| r_type == R_PARISC_LTOFF_FPTR14DR`
`\|\| r_type == R_PARISC_LTOFF_FPTR14WR`	`\|\| r_type == R_PARISC_LTOFF_FPTR14WR`
`\|\| r_type == R_PARISC_LTOFF_FPTR21L`	`\|\| r_type == R_PARISC_LTOFF_FPTR21L`
`\|\| r_type == R_PARISC_LTOFF_FPTR16F`	`\|\| r_type == R_PARISC_LTOFF_FPTR16F`
`\|\| r_type == R_PARISC_LTOFF_FPTR16WF`	`\|\| r_type == R_PARISC_LTOFF_FPTR16WF`
`\|\| r_type == R_PARISC_LTOFF_FPTR16DF)`	`\|\| r_type == R_PARISC_LTOFF_FPTR16DF)`
`{`	`{`
`local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;`	`local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;`
`off = local_opd_offsets[r_symndx];`	`off = local_opd_offsets[r_symndx];`

`/* The last bit records whether we've already initialised`	`/* The last bit records whether we've already initialised`
`this local .opd entry. */`	`this local .opd entry. */`
`if ((off & 1) != 0)`	`if ((off & 1) != 0)`
`{`	`{`
`BFD_ASSERT (off != (bfd_vma) -1);`	`BFD_ASSERT (off != (bfd_vma) -1);`
`off &= ~1;`	`off &= ~1;`
`}`	`}`
`else`	`else`
`{`	`{`
`local_opd_offsets[r_symndx] \|= 1;`	`local_opd_offsets[r_symndx] \|= 1;`

`/* The first two words of an .opd entry are zero. */`	`/* The first two words of an .opd entry are zero. */`
`memset (hppa_info->opd_sec->contents + off, 0, 16);`	`memset (hppa_info->opd_sec->contents + off, 0, 16);`

`/* The next word is the address of the function. */`	`/* The next word is the address of the function. */`
`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`	`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`
`(hppa_info->opd_sec->contents + off + 16));`	`(hppa_info->opd_sec->contents + off + 16));`

`/* The last word is our local __gp value. */`	`/* The last word is our local __gp value. */`
`value = _bfd_get_gp_value`	`value = _bfd_get_gp_value`
`(hppa_info->opd_sec->output_section->owner);`	`(hppa_info->opd_sec->output_section->owner);`
`bfd_put_64 (hppa_info->opd_sec->owner, value,`	`bfd_put_64 (hppa_info->opd_sec->owner, value,`
`(hppa_info->opd_sec->contents + off + 24));`	`(hppa_info->opd_sec->contents + off + 24));`
`}`	`}`

`/* The DLT value is the address of the .opd entry. */`	`/* The DLT value is the address of the .opd entry. */`
`value = (off`	`value = (off`
`+ hppa_info->opd_sec->output_offset`	`+ hppa_info->opd_sec->output_offset`
`+ hppa_info->opd_sec->output_section->vma);`	`+ hppa_info->opd_sec->output_section->vma);`
`addend = 0;`	`addend = 0;`
`}`	`}`

`local_dlt_offsets = local_offsets;`	`local_dlt_offsets = local_offsets;`
`off = local_dlt_offsets[r_symndx];`	`off = local_dlt_offsets[r_symndx];`

`if ((off & 1) != 0)`	`if ((off & 1) != 0)`
`{`	`{`
`BFD_ASSERT (off != (bfd_vma) -1);`	`BFD_ASSERT (off != (bfd_vma) -1);`
`off &= ~1;`	`off &= ~1;`
`}`	`}`
`else`	`else`
`{`	`{`
`local_dlt_offsets[r_symndx] \|= 1;`	`local_dlt_offsets[r_symndx] \|= 1;`
`bfd_put_64 (hppa_info->dlt_sec->owner,`	`bfd_put_64 (hppa_info->dlt_sec->owner,`
`value + addend,`	`value + addend,`
`hppa_info->dlt_sec->contents + off);`	`hppa_info->dlt_sec->contents + off);`
`}`	`}`
`}`	`}`
`else`	`else`
`off = hh->dlt_offset;`	`off = hh->dlt_offset;`

`/* We want the value of the DLT offset for this symbol, not`	`/* We want the value of the DLT offset for this symbol, not`
`the symbol's actual address. Note that __gp may not point`	`the symbol's actual address. Note that __gp may not point`
`to the start of the DLT, so we have to compute the absolute`	`to the start of the DLT, so we have to compute the absolute`
`address, then subtract out the value of __gp. */`	`address, then subtract out the value of __gp. */`
`value = (off`	`value = (off`
`+ hppa_info->dlt_sec->output_offset`	`+ hppa_info->dlt_sec->output_offset`
`+ hppa_info->dlt_sec->output_section->vma);`	`+ hppa_info->dlt_sec->output_section->vma);`
`value -= _bfd_get_gp_value (output_bfd);`	`value -= _bfd_get_gp_value (output_bfd);`

`/* All DLTIND relocations are basically the same at this point,`	`/* All DLTIND relocations are basically the same at this point,`
`except that we need different field selectors for the 21bit`	`except that we need different field selectors for the 21bit`
`version vs the 14bit versions. */`	`version vs the 14bit versions. */`
`if (r_type == R_PARISC_DLTIND21L`	`if (r_type == R_PARISC_DLTIND21L`
`\|\| r_type == R_PARISC_LTOFF_FPTR21L`	`\|\| r_type == R_PARISC_LTOFF_FPTR21L`
`\|\| r_type == R_PARISC_LTOFF_TP21L)`	`\|\| r_type == R_PARISC_LTOFF_TP21L)`
`value = hppa_field_adjust (value, 0, e_lsel);`	`value = hppa_field_adjust (value, 0, e_lsel);`
`else if (r_type == R_PARISC_DLTIND14F`	`else if (r_type == R_PARISC_DLTIND14F`
`\|\| r_type == R_PARISC_LTOFF_FPTR16F`	`\|\| r_type == R_PARISC_LTOFF_FPTR16F`
`\|\| r_type == R_PARISC_LTOFF_FPTR16WF`	`\|\| r_type == R_PARISC_LTOFF_FPTR16WF`
`\|\| r_type == R_PARISC_LTOFF_FPTR16DF`	`\|\| r_type == R_PARISC_LTOFF_FPTR16DF`
`\|\| r_type == R_PARISC_LTOFF16F`	`\|\| r_type == R_PARISC_LTOFF16F`
`\|\| r_type == R_PARISC_LTOFF16DF`	`\|\| r_type == R_PARISC_LTOFF16DF`
`\|\| r_type == R_PARISC_LTOFF16WF`	`\|\| r_type == R_PARISC_LTOFF16WF`
`\|\| r_type == R_PARISC_LTOFF_TP16F`	`\|\| r_type == R_PARISC_LTOFF_TP16F`
`\|\| r_type == R_PARISC_LTOFF_TP16WF`	`\|\| r_type == R_PARISC_LTOFF_TP16WF`
`\|\| r_type == R_PARISC_LTOFF_TP16DF)`	`\|\| r_type == R_PARISC_LTOFF_TP16DF)`
`value = hppa_field_adjust (value, 0, e_fsel);`	`value = hppa_field_adjust (value, 0, e_fsel);`
`else`	`else`
`value = hppa_field_adjust (value, 0, e_rsel);`	`value = hppa_field_adjust (value, 0, e_rsel);`

`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`	`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`
`break;`	`break;`
`}`	`}`

`case R_PARISC_DLTREL14R:`	`case R_PARISC_DLTREL14R:`
`case R_PARISC_DLTREL14F:`	`case R_PARISC_DLTREL14F:`
`case R_PARISC_DLTREL14DR:`	`case R_PARISC_DLTREL14DR:`
`case R_PARISC_DLTREL14WR:`	`case R_PARISC_DLTREL14WR:`
`case R_PARISC_DLTREL21L:`	`case R_PARISC_DLTREL21L:`
`case R_PARISC_DPREL21L:`	`case R_PARISC_DPREL21L:`
`case R_PARISC_DPREL14WR:`	`case R_PARISC_DPREL14WR:`
`case R_PARISC_DPREL14DR:`	`case R_PARISC_DPREL14DR:`
`case R_PARISC_DPREL14R:`	`case R_PARISC_DPREL14R:`
`case R_PARISC_DPREL14F:`	`case R_PARISC_DPREL14F:`
`case R_PARISC_GPREL16F:`	`case R_PARISC_GPREL16F:`
`case R_PARISC_GPREL16WF:`	`case R_PARISC_GPREL16WF:`
`case R_PARISC_GPREL16DF:`	`case R_PARISC_GPREL16DF:`
`{`	`{`
`/* Subtract out the global pointer value to make value a DLT`	`/* Subtract out the global pointer value to make value a DLT`
`relative address. */`	`relative address. */`
`value -= _bfd_get_gp_value (output_bfd);`	`value -= _bfd_get_gp_value (output_bfd);`

`/* All DLTREL relocations are basically the same at this point,`	`/* All DLTREL relocations are basically the same at this point,`
`except that we need different field selectors for the 21bit`	`except that we need different field selectors for the 21bit`
`version vs the 14bit versions. */`	`version vs the 14bit versions. */`
`if (r_type == R_PARISC_DLTREL21L`	`if (r_type == R_PARISC_DLTREL21L`
`\|\| r_type == R_PARISC_DPREL21L)`	`\|\| r_type == R_PARISC_DPREL21L)`
`value = hppa_field_adjust (value, addend, e_lrsel);`	`value = hppa_field_adjust (value, addend, e_lrsel);`
`else if (r_type == R_PARISC_DLTREL14F`	`else if (r_type == R_PARISC_DLTREL14F`
`\|\| r_type == R_PARISC_DPREL14F`	`\|\| r_type == R_PARISC_DPREL14F`
`\|\| r_type == R_PARISC_GPREL16F`	`\|\| r_type == R_PARISC_GPREL16F`
`\|\| r_type == R_PARISC_GPREL16WF`	`\|\| r_type == R_PARISC_GPREL16WF`
`\|\| r_type == R_PARISC_GPREL16DF)`	`\|\| r_type == R_PARISC_GPREL16DF)`
`value = hppa_field_adjust (value, addend, e_fsel);`	`value = hppa_field_adjust (value, addend, e_fsel);`
`else`	`else`
`value = hppa_field_adjust (value, addend, e_rrsel);`	`value = hppa_field_adjust (value, addend, e_rrsel);`

`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`	`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`
`break;`	`break;`
`}`	`}`

`case R_PARISC_DIR21L:`	`case R_PARISC_DIR21L:`
`case R_PARISC_DIR17R:`	`case R_PARISC_DIR17R:`
`case R_PARISC_DIR17F:`	`case R_PARISC_DIR17F:`
`case R_PARISC_DIR14R:`	`case R_PARISC_DIR14R:`
`case R_PARISC_DIR14F:`	`case R_PARISC_DIR14F:`
`case R_PARISC_DIR14WR:`	`case R_PARISC_DIR14WR:`
`case R_PARISC_DIR14DR:`	`case R_PARISC_DIR14DR:`
`case R_PARISC_DIR16F:`	`case R_PARISC_DIR16F:`
`case R_PARISC_DIR16WF:`	`case R_PARISC_DIR16WF:`
`case R_PARISC_DIR16DF:`	`case R_PARISC_DIR16DF:`
`{`	`{`
`/* All DIR relocations are basically the same at this point,`	`/* All DIR relocations are basically the same at this point,`
`except that branch offsets need to be divided by four, and`	`except that branch offsets need to be divided by four, and`
`we need different field selectors. Note that we don't`	`we need different field selectors. Note that we don't`
`redirect absolute calls to local stubs. */`	`redirect absolute calls to local stubs. */`

`if (r_type == R_PARISC_DIR21L)`	`if (r_type == R_PARISC_DIR21L)`
`value = hppa_field_adjust (value, addend, e_lrsel);`	`value = hppa_field_adjust (value, addend, e_lrsel);`
`else if (r_type == R_PARISC_DIR17F`	`else if (r_type == R_PARISC_DIR17F`
`\|\| r_type == R_PARISC_DIR16F`	`\|\| r_type == R_PARISC_DIR16F`
`\|\| r_type == R_PARISC_DIR16WF`	`\|\| r_type == R_PARISC_DIR16WF`
`\|\| r_type == R_PARISC_DIR16DF`	`\|\| r_type == R_PARISC_DIR16DF`
`\|\| r_type == R_PARISC_DIR14F)`	`\|\| r_type == R_PARISC_DIR14F)`
`value = hppa_field_adjust (value, addend, e_fsel);`	`value = hppa_field_adjust (value, addend, e_fsel);`
`else`	`else`
`value = hppa_field_adjust (value, addend, e_rrsel);`	`value = hppa_field_adjust (value, addend, e_rrsel);`

`if (r_type == R_PARISC_DIR17R \|\| r_type == R_PARISC_DIR17F)`	`if (r_type == R_PARISC_DIR17R \|\| r_type == R_PARISC_DIR17F)`
`/* All branches are implicitly shifted by 2 places. */`	`/* All branches are implicitly shifted by 2 places. */`
`value >>= 2;`	`value >>= 2;`

`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`	`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`
`break;`	`break;`
`}`	`}`

`case R_PARISC_PLTOFF21L:`	`case R_PARISC_PLTOFF21L:`
`case R_PARISC_PLTOFF14R:`	`case R_PARISC_PLTOFF14R:`
`case R_PARISC_PLTOFF14F:`	`case R_PARISC_PLTOFF14F:`
`case R_PARISC_PLTOFF14WR:`	`case R_PARISC_PLTOFF14WR:`
`case R_PARISC_PLTOFF14DR:`	`case R_PARISC_PLTOFF14DR:`
`case R_PARISC_PLTOFF16F:`	`case R_PARISC_PLTOFF16F:`
`case R_PARISC_PLTOFF16WF:`	`case R_PARISC_PLTOFF16WF:`
`case R_PARISC_PLTOFF16DF:`	`case R_PARISC_PLTOFF16DF:`
`{`	`{`
`/* We want the value of the PLT offset for this symbol, not`	`/* We want the value of the PLT offset for this symbol, not`
`the symbol's actual address. Note that __gp may not point`	`the symbol's actual address. Note that __gp may not point`
`to the start of the DLT, so we have to compute the absolute`	`to the start of the DLT, so we have to compute the absolute`
`address, then subtract out the value of __gp. */`	`address, then subtract out the value of __gp. */`
`value = (hh->plt_offset`	`value = (hh->plt_offset`
`+ hppa_info->plt_sec->output_offset`	`+ hppa_info->plt_sec->output_offset`
`+ hppa_info->plt_sec->output_section->vma);`	`+ hppa_info->plt_sec->output_section->vma);`
`value -= _bfd_get_gp_value (output_bfd);`	`value -= _bfd_get_gp_value (output_bfd);`

`/* All PLTOFF relocations are basically the same at this point,`	`/* All PLTOFF relocations are basically the same at this point,`
`except that we need different field selectors for the 21bit`	`except that we need different field selectors for the 21bit`
`version vs the 14bit versions. */`	`version vs the 14bit versions. */`
`if (r_type == R_PARISC_PLTOFF21L)`	`if (r_type == R_PARISC_PLTOFF21L)`
`value = hppa_field_adjust (value, addend, e_lrsel);`	`value = hppa_field_adjust (value, addend, e_lrsel);`
`else if (r_type == R_PARISC_PLTOFF14F`	`else if (r_type == R_PARISC_PLTOFF14F`
`\|\| r_type == R_PARISC_PLTOFF16F`	`\|\| r_type == R_PARISC_PLTOFF16F`
`\|\| r_type == R_PARISC_PLTOFF16WF`	`\|\| r_type == R_PARISC_PLTOFF16WF`
`\|\| r_type == R_PARISC_PLTOFF16DF)`	`\|\| r_type == R_PARISC_PLTOFF16DF)`
`value = hppa_field_adjust (value, addend, e_fsel);`	`value = hppa_field_adjust (value, addend, e_fsel);`
`else`	`else`
`value = hppa_field_adjust (value, addend, e_rrsel);`	`value = hppa_field_adjust (value, addend, e_rrsel);`

`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`	`insn = elf_hppa_relocate_insn (insn, (int) value, r_type);`
`break;`	`break;`
`}`	`}`

`case R_PARISC_LTOFF_FPTR32:`	`case R_PARISC_LTOFF_FPTR32:`
`{`	`{`
`/* We may still need to create the FPTR itself if it was for`	`/* We may still need to create the FPTR itself if it was for`
`a local symbol. */`	`a local symbol. */`
`if (hh == NULL)`	`if (hh == NULL)`
`{`	`{`
`/* The first two words of an .opd entry are zero. */`	`/* The first two words of an .opd entry are zero. */`
`memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);`	`memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);`

`/* The next word is the address of the function. */`	`/* The next word is the address of the function. */`
`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`	`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`
`(hppa_info->opd_sec->contents`	`(hppa_info->opd_sec->contents`
`+ hh->opd_offset + 16));`	`+ hh->opd_offset + 16));`

`/* The last word is our local __gp value. */`	`/* The last word is our local __gp value. */`
`value = _bfd_get_gp_value`	`value = _bfd_get_gp_value`
`(hppa_info->opd_sec->output_section->owner);`	`(hppa_info->opd_sec->output_section->owner);`
`bfd_put_64 (hppa_info->opd_sec->owner, value,`	`bfd_put_64 (hppa_info->opd_sec->owner, value,`
`hppa_info->opd_sec->contents + hh->opd_offset + 24);`	`hppa_info->opd_sec->contents + hh->opd_offset + 24);`

`/* The DLT value is the address of the .opd entry. */`	`/* The DLT value is the address of the .opd entry. */`
`value = (hh->opd_offset`	`value = (hh->opd_offset`
`+ hppa_info->opd_sec->output_offset`	`+ hppa_info->opd_sec->output_offset`
`+ hppa_info->opd_sec->output_section->vma);`	`+ hppa_info->opd_sec->output_section->vma);`

`bfd_put_64 (hppa_info->dlt_sec->owner,`	`bfd_put_64 (hppa_info->dlt_sec->owner,`
`value,`	`value,`
`hppa_info->dlt_sec->contents + hh->dlt_offset);`	`hppa_info->dlt_sec->contents + hh->dlt_offset);`
`}`	`}`

`/* We want the value of the DLT offset for this symbol, not`	`/* We want the value of the DLT offset for this symbol, not`
`the symbol's actual address. Note that __gp may not point`	`the symbol's actual address. Note that __gp may not point`
`to the start of the DLT, so we have to compute the absolute`	`to the start of the DLT, so we have to compute the absolute`
`address, then subtract out the value of __gp. */`	`address, then subtract out the value of __gp. */`
`value = (hh->dlt_offset`	`value = (hh->dlt_offset`
`+ hppa_info->dlt_sec->output_offset`	`+ hppa_info->dlt_sec->output_offset`
`+ hppa_info->dlt_sec->output_section->vma);`	`+ hppa_info->dlt_sec->output_section->vma);`
`value -= _bfd_get_gp_value (output_bfd);`	`value -= _bfd_get_gp_value (output_bfd);`
`bfd_put_32 (input_bfd, value, hit_data);`	`bfd_put_32 (input_bfd, value, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`
`}`	`}`

`case R_PARISC_LTOFF_FPTR64:`	`case R_PARISC_LTOFF_FPTR64:`
`case R_PARISC_LTOFF_TP64:`	`case R_PARISC_LTOFF_TP64:`
`{`	`{`
`/* We may still need to create the FPTR itself if it was for`	`/* We may still need to create the FPTR itself if it was for`
`a local symbol. */`	`a local symbol. */`
`if (eh == NULL && r_type == R_PARISC_LTOFF_FPTR64)`	`if (eh == NULL && r_type == R_PARISC_LTOFF_FPTR64)`
`{`	`{`
`/* The first two words of an .opd entry are zero. */`	`/* The first two words of an .opd entry are zero. */`
`memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);`	`memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);`

`/* The next word is the address of the function. */`	`/* The next word is the address of the function. */`
`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`	`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`
`(hppa_info->opd_sec->contents`	`(hppa_info->opd_sec->contents`
`+ hh->opd_offset + 16));`	`+ hh->opd_offset + 16));`

`/* The last word is our local __gp value. */`	`/* The last word is our local __gp value. */`
`value = _bfd_get_gp_value`	`value = _bfd_get_gp_value`
`(hppa_info->opd_sec->output_section->owner);`	`(hppa_info->opd_sec->output_section->owner);`
`bfd_put_64 (hppa_info->opd_sec->owner, value,`	`bfd_put_64 (hppa_info->opd_sec->owner, value,`
`hppa_info->opd_sec->contents + hh->opd_offset + 24);`	`hppa_info->opd_sec->contents + hh->opd_offset + 24);`

`/* The DLT value is the address of the .opd entry. */`	`/* The DLT value is the address of the .opd entry. */`
`value = (hh->opd_offset`	`value = (hh->opd_offset`
`+ hppa_info->opd_sec->output_offset`	`+ hppa_info->opd_sec->output_offset`
`+ hppa_info->opd_sec->output_section->vma);`	`+ hppa_info->opd_sec->output_section->vma);`

`bfd_put_64 (hppa_info->dlt_sec->owner,`	`bfd_put_64 (hppa_info->dlt_sec->owner,`
`value,`	`value,`
`hppa_info->dlt_sec->contents + hh->dlt_offset);`	`hppa_info->dlt_sec->contents + hh->dlt_offset);`
`}`	`}`

`/* We want the value of the DLT offset for this symbol, not`	`/* We want the value of the DLT offset for this symbol, not`
`the symbol's actual address. Note that __gp may not point`	`the symbol's actual address. Note that __gp may not point`
`to the start of the DLT, so we have to compute the absolute`	`to the start of the DLT, so we have to compute the absolute`
`address, then subtract out the value of __gp. */`	`address, then subtract out the value of __gp. */`
`value = (hh->dlt_offset`	`value = (hh->dlt_offset`
`+ hppa_info->dlt_sec->output_offset`	`+ hppa_info->dlt_sec->output_offset`
`+ hppa_info->dlt_sec->output_section->vma);`	`+ hppa_info->dlt_sec->output_section->vma);`
`value -= _bfd_get_gp_value (output_bfd);`	`value -= _bfd_get_gp_value (output_bfd);`
`bfd_put_64 (input_bfd, value, hit_data);`	`bfd_put_64 (input_bfd, value, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`
`}`	`}`

`case R_PARISC_DIR32:`	`case R_PARISC_DIR32:`
`bfd_put_32 (input_bfd, value + addend, hit_data);`	`bfd_put_32 (input_bfd, value + addend, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`

`case R_PARISC_DIR64:`	`case R_PARISC_DIR64:`
`bfd_put_64 (input_bfd, value + addend, hit_data);`	`bfd_put_64 (input_bfd, value + addend, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`

`case R_PARISC_GPREL64:`	`case R_PARISC_GPREL64:`
`/* Subtract out the global pointer value to make value a DLT`	`/* Subtract out the global pointer value to make value a DLT`
`relative address. */`	`relative address. */`
`value -= _bfd_get_gp_value (output_bfd);`	`value -= _bfd_get_gp_value (output_bfd);`

`bfd_put_64 (input_bfd, value + addend, hit_data);`	`bfd_put_64 (input_bfd, value + addend, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`

`case R_PARISC_LTOFF64:`	`case R_PARISC_LTOFF64:`
`/* We want the value of the DLT offset for this symbol, not`	`/* We want the value of the DLT offset for this symbol, not`
`the symbol's actual address. Note that __gp may not point`	`the symbol's actual address. Note that __gp may not point`
`to the start of the DLT, so we have to compute the absolute`	`to the start of the DLT, so we have to compute the absolute`
`address, then subtract out the value of __gp. */`	`address, then subtract out the value of __gp. */`
`value = (hh->dlt_offset`	`value = (hh->dlt_offset`
`+ hppa_info->dlt_sec->output_offset`	`+ hppa_info->dlt_sec->output_offset`
`+ hppa_info->dlt_sec->output_section->vma);`	`+ hppa_info->dlt_sec->output_section->vma);`
`value -= _bfd_get_gp_value (output_bfd);`	`value -= _bfd_get_gp_value (output_bfd);`

`bfd_put_64 (input_bfd, value + addend, hit_data);`	`bfd_put_64 (input_bfd, value + addend, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`

`case R_PARISC_PCREL32:`	`case R_PARISC_PCREL32:`
`{`	`{`
`/* If this is a call to a function defined in another dynamic`	`/* If this is a call to a function defined in another dynamic`
`library, then redirect the call to the local stub for this`	`library, then redirect the call to the local stub for this`
`function. */`	`function. */`
`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`	`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`
`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`	`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`
`+ hppa_info->stub_sec->output_section->vma);`	`+ hppa_info->stub_sec->output_section->vma);`

`/* Turn VALUE into a proper PC relative address. */`	`/* Turn VALUE into a proper PC relative address. */`
`value -= (offset + input_section->output_offset`	`value -= (offset + input_section->output_offset`
`+ input_section->output_section->vma);`	`+ input_section->output_section->vma);`

`value += addend;`	`value += addend;`
`value -= 8;`	`value -= 8;`
`bfd_put_32 (input_bfd, value, hit_data);`	`bfd_put_32 (input_bfd, value, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`
`}`	`}`

`case R_PARISC_PCREL64:`	`case R_PARISC_PCREL64:`
`{`	`{`
`/* If this is a call to a function defined in another dynamic`	`/* If this is a call to a function defined in another dynamic`
`library, then redirect the call to the local stub for this`	`library, then redirect the call to the local stub for this`
`function. */`	`function. */`
`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`	`if (sym_sec == NULL \|\| sym_sec->output_section == NULL)`
`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`	`value = (hh->stub_offset + hppa_info->stub_sec->output_offset`
`+ hppa_info->stub_sec->output_section->vma);`	`+ hppa_info->stub_sec->output_section->vma);`

`/* Turn VALUE into a proper PC relative address. */`	`/* Turn VALUE into a proper PC relative address. */`
`value -= (offset + input_section->output_offset`	`value -= (offset + input_section->output_offset`
`+ input_section->output_section->vma);`	`+ input_section->output_section->vma);`

`value += addend;`	`value += addend;`
`value -= 8;`	`value -= 8;`
`bfd_put_64 (input_bfd, value, hit_data);`	`bfd_put_64 (input_bfd, value, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`
`}`	`}`

`case R_PARISC_FPTR64:`	`case R_PARISC_FPTR64:`
`{`	`{`
`bfd_vma off;`	`bfd_vma off;`

`/* We may still need to create the FPTR itself if it was for`	`/* We may still need to create the FPTR itself if it was for`
`a local symbol. */`	`a local symbol. */`
`if (hh == NULL)`	`if (hh == NULL)`
`{`	`{`
`bfd_vma *local_opd_offsets;`	`bfd_vma *local_opd_offsets;`

`if (local_offsets == NULL)`	`if (local_offsets == NULL)`
`abort ();`	`abort ();`

`local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;`	`local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;`
`off = local_opd_offsets[r_symndx];`	`off = local_opd_offsets[r_symndx];`

`/* The last bit records whether we've already initialised`	`/* The last bit records whether we've already initialised`
`this local .opd entry. */`	`this local .opd entry. */`
`if ((off & 1) != 0)`	`if ((off & 1) != 0)`
`{`	`{`
`BFD_ASSERT (off != (bfd_vma) -1);`	`BFD_ASSERT (off != (bfd_vma) -1);`
`off &= ~1;`	`off &= ~1;`
`}`	`}`
`else`	`else`
`{`	`{`
`/* The first two words of an .opd entry are zero. */`	`/* The first two words of an .opd entry are zero. */`
`memset (hppa_info->opd_sec->contents + off, 0, 16);`	`memset (hppa_info->opd_sec->contents + off, 0, 16);`

`/* The next word is the address of the function. */`	`/* The next word is the address of the function. */`
`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`	`bfd_put_64 (hppa_info->opd_sec->owner, value + addend,`
`(hppa_info->opd_sec->contents + off + 16));`	`(hppa_info->opd_sec->contents + off + 16));`

`/* The last word is our local __gp value. */`	`/* The last word is our local __gp value. */`
`value = _bfd_get_gp_value`	`value = _bfd_get_gp_value`
`(hppa_info->opd_sec->output_section->owner);`	`(hppa_info->opd_sec->output_section->owner);`
`bfd_put_64 (hppa_info->opd_sec->owner, value,`	`bfd_put_64 (hppa_info->opd_sec->owner, value,`
`hppa_info->opd_sec->contents + off + 24);`	`hppa_info->opd_sec->contents + off + 24);`
`}`	`}`
`}`	`}`
`else`	`else`
`off = hh->opd_offset;`	`off = hh->opd_offset;`

`if (hh == NULL \|\| hh->want_opd)`	`if (hh == NULL \|\| hh->want_opd)`
`/* We want the value of the OPD offset for this symbol. */`	`/* We want the value of the OPD offset for this symbol. */`
`value = (off`	`value = (off`
`+ hppa_info->opd_sec->output_offset`	`+ hppa_info->opd_sec->output_offset`
`+ hppa_info->opd_sec->output_section->vma);`	`+ hppa_info->opd_sec->output_section->vma);`
`else`	`else`
`/* We want the address of the symbol. */`	`/* We want the address of the symbol. */`
`value += addend;`	`value += addend;`

`bfd_put_64 (input_bfd, value, hit_data);`	`bfd_put_64 (input_bfd, value, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`
`}`	`}`

`case R_PARISC_SECREL32:`	`case R_PARISC_SECREL32:`
`if (sym_sec)`	`if (sym_sec)`
`value -= sym_sec->output_section->vma;`	`value -= sym_sec->output_section->vma;`
`bfd_put_32 (input_bfd, value + addend, hit_data);`	`bfd_put_32 (input_bfd, value + addend, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`

`case R_PARISC_SEGREL32:`	`case R_PARISC_SEGREL32:`
`case R_PARISC_SEGREL64:`	`case R_PARISC_SEGREL64:`
`{`	`{`
`/* If this is the first SEGREL relocation, then initialize`	`/* If this is the first SEGREL relocation, then initialize`
`the segment base values. */`	`the segment base values. */`
`if (hppa_info->text_segment_base == (bfd_vma) -1)`	`if (hppa_info->text_segment_base == (bfd_vma) -1)`
`bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,`	`bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,`
`hppa_info);`	`hppa_info);`

`/* VALUE holds the absolute address. We want to include the`	`/* VALUE holds the absolute address. We want to include the`
`addend, then turn it into a segment relative address.`	`addend, then turn it into a segment relative address.`

`The segment is derived from SYM_SEC. We assume that there are`	`The segment is derived from SYM_SEC. We assume that there are`
`only two segments of note in the resulting executable/shlib.`	`only two segments of note in the resulting executable/shlib.`
`A readonly segment (.text) and a readwrite segment (.data). */`	`A readonly segment (.text) and a readwrite segment (.data). */`
`value += addend;`	`value += addend;`

`if (sym_sec->flags & SEC_CODE)`	`if (sym_sec->flags & SEC_CODE)`
`value -= hppa_info->text_segment_base;`	`value -= hppa_info->text_segment_base;`
`else`	`else`
`value -= hppa_info->data_segment_base;`	`value -= hppa_info->data_segment_base;`

`if (r_type == R_PARISC_SEGREL32)`	`if (r_type == R_PARISC_SEGREL32)`
`bfd_put_32 (input_bfd, value, hit_data);`	`bfd_put_32 (input_bfd, value, hit_data);`
`else`	`else`
`bfd_put_64 (input_bfd, value, hit_data);`	`bfd_put_64 (input_bfd, value, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`
`}`	`}`

`/* Something we don't know how to handle. */`	`/* Something we don't know how to handle. */`
`default:`	`default:`
`return bfd_reloc_notsupported;`	`return bfd_reloc_notsupported;`
`}`	`}`

`/* Update the instruction word. */`	`/* Update the instruction word. */`
`bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);`	`bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);`
`return bfd_reloc_ok;`	`return bfd_reloc_ok;`
`}`	`}`

`/* Relocate an HPPA ELF section. */`	`/* Relocate an HPPA ELF section. */`

`static bfd_boolean`	`static bfd_boolean`
`elf64_hppa_relocate_section (bfd *output_bfd,`	`elf64_hppa_relocate_section (bfd *output_bfd,`
`struct bfd_link_info *info,`	`struct bfd_link_info *info,`
`bfd *input_bfd,`	`bfd *input_bfd,`
`asection *input_section,`	`asection *input_section,`
`bfd_byte *contents,`	`bfd_byte *contents,`
`Elf_Internal_Rela *relocs,`	`Elf_Internal_Rela *relocs,`
`Elf_Internal_Sym *local_syms,`	`Elf_Internal_Sym *local_syms,`
`asection **local_sections)`	`asection **local_sections)`
`{`	`{`
`Elf_Internal_Shdr *symtab_hdr;`	`Elf_Internal_Shdr *symtab_hdr;`
`Elf_Internal_Rela *rel;`	`Elf_Internal_Rela *rel;`
`Elf_Internal_Rela *relend;`	`Elf_Internal_Rela *relend;`
`struct elf64_hppa_link_hash_table *hppa_info;`	`struct elf64_hppa_link_hash_table *hppa_info;`

`hppa_info = hppa_link_hash_table (info);`	`hppa_info = hppa_link_hash_table (info);`
`symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;`	`symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;`

`rel = relocs;`	`rel = relocs;`
`relend = relocs + input_section->reloc_count;`	`relend = relocs + input_section->reloc_count;`
`for (; rel < relend; rel++)`	`for (; rel < relend; rel++)`
`{`	`{`
`int r_type;`	`int r_type;`
`reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);`	`reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);`
`unsigned long r_symndx;`	`unsigned long r_symndx;`
`struct elf_link_hash_entry *eh;`	`struct elf_link_hash_entry *eh;`
`Elf_Internal_Sym *sym;`	`Elf_Internal_Sym *sym;`
`asection *sym_sec;`	`asection *sym_sec;`
`bfd_vma relocation;`	`bfd_vma relocation;`
`bfd_reloc_status_type r;`	`bfd_reloc_status_type r;`
`bfd_boolean warned_undef;`	`bfd_boolean warned_undef;`

`r_type = ELF_R_TYPE (rel->r_info);`	`r_type = ELF_R_TYPE (rel->r_info);`
`if (r_type < 0 \|\| r_type >= (int) R_PARISC_UNIMPLEMENTED)`	`if (r_type < 0 \|\| r_type >= (int) R_PARISC_UNIMPLEMENTED)`
`{`	`{`
`bfd_set_error (bfd_error_bad_value);`	`bfd_set_error (bfd_error_bad_value);`
`return FALSE;`	`return FALSE;`
`}`	`}`
`if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY`	`if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY`
`\|\| r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)`	`\|\| r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)`
`continue;`	`continue;`

`/* This is a final link. */`	`/* This is a final link. */`
`r_symndx = ELF_R_SYM (rel->r_info);`	`r_symndx = ELF_R_SYM (rel->r_info);`
`eh = NULL;`	`eh = NULL;`
`sym = NULL;`	`sym = NULL;`
`sym_sec = NULL;`	`sym_sec = NULL;`
`warned_undef = FALSE;`	`warned_undef = FALSE;`
`if (r_symndx < symtab_hdr->sh_info)`	`if (r_symndx < symtab_hdr->sh_info)`
`{`	`{`
`/* This is a local symbol, hh defaults to NULL. */`	`/* This is a local symbol, hh defaults to NULL. */`
`sym = local_syms + r_symndx;`	`sym = local_syms + r_symndx;`
`sym_sec = local_sections[r_symndx];`	`sym_sec = local_sections[r_symndx];`
`relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);`	`relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);`
`}`	`}`
`else`	`else`
`{`	`{`
`/* This is not a local symbol. */`	`/* This is not a local symbol. */`
`bfd_boolean unresolved_reloc;`	`bfd_boolean unresolved_reloc;`
`struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);`	`struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);`

`/* It seems this can happen with erroneous or unsupported`	`/* It seems this can happen with erroneous or unsupported`
`input (mixing a.out and elf in an archive, for example.) */`	`input (mixing a.out and elf in an archive, for example.) */`
`if (sym_hashes == NULL)`	`if (sym_hashes == NULL)`
`return FALSE;`	`return FALSE;`

`eh = sym_hashes[r_symndx - symtab_hdr->sh_info];`	`eh = sym_hashes[r_symndx - symtab_hdr->sh_info];`

`while (eh->root.type == bfd_link_hash_indirect`	`while (eh->root.type == bfd_link_hash_indirect`
`\|\| eh->root.type == bfd_link_hash_warning)`	`\|\| eh->root.type == bfd_link_hash_warning)`
`eh = (struct elf_link_hash_entry *) eh->root.u.i.link;`	`eh = (struct elf_link_hash_entry *) eh->root.u.i.link;`

`warned_undef = FALSE;`	`warned_undef = FALSE;`
`unresolved_reloc = FALSE;`	`unresolved_reloc = FALSE;`
`relocation = 0;`	`relocation = 0;`
`if (eh->root.type == bfd_link_hash_defined`	`if (eh->root.type == bfd_link_hash_defined`
`\|\| eh->root.type == bfd_link_hash_defweak)`	`\|\| eh->root.type == bfd_link_hash_defweak)`
`{`	`{`
`sym_sec = eh->root.u.def.section;`	`sym_sec = eh->root.u.def.section;`
`if (sym_sec == NULL`	`if (sym_sec == NULL`
`\|\| sym_sec->output_section == NULL)`	`\|\| sym_sec->output_section == NULL)`
`/* Set a flag that will be cleared later if we find a`	`/* Set a flag that will be cleared later if we find a`
`relocation value for this symbol. output_section`	`relocation value for this symbol. output_section`
`is typically NULL for symbols satisfied by a shared`	`is typically NULL for symbols satisfied by a shared`
`library. */`	`library. */`
`unresolved_reloc = TRUE;`	`unresolved_reloc = TRUE;`
`else`	`else`
`relocation = (eh->root.u.def.value`	`relocation = (eh->root.u.def.value`
`+ sym_sec->output_section->vma`	`+ sym_sec->output_section->vma`
`+ sym_sec->output_offset);`	`+ sym_sec->output_offset);`
`}`	`}`
`else if (eh->root.type == bfd_link_hash_undefweak)`	`else if (eh->root.type == bfd_link_hash_undefweak)`
`;`	`;`
`else if (info->unresolved_syms_in_objects == RM_IGNORE`	`else if (info->unresolved_syms_in_objects == RM_IGNORE`
`&& ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)`	`&& ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)`
`;`	`;`
`else if (!info->relocatable`	`else if (!info->relocatable`
`&& elf_hppa_is_dynamic_loader_symbol (eh->root.root.string))`	`&& elf_hppa_is_dynamic_loader_symbol (eh->root.root.string))`
`continue;`	`continue;`
`else if (!info->relocatable)`	`else if (!info->relocatable)`
`{`	`{`
`bfd_boolean err;`	`bfd_boolean err;`
`err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR`	`err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR`
`\|\| ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT);`	`\|\| ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT);`
`if (!info->callbacks->undefined_symbol (info,`	`if (!info->callbacks->undefined_symbol (info,`
`eh->root.root.string,`	`eh->root.root.string,`
`input_bfd,`	`input_bfd,`
`input_section,`	`input_section,`
`rel->r_offset, err))`	`rel->r_offset, err))`
`return FALSE;`	`return FALSE;`
`warned_undef = TRUE;`	`warned_undef = TRUE;`
`}`	`}`

`if (!info->relocatable`	`if (!info->relocatable`
`&& relocation == 0`	`&& relocation == 0`
`&& eh->root.type != bfd_link_hash_defined`	`&& eh->root.type != bfd_link_hash_defined`
`&& eh->root.type != bfd_link_hash_defweak`	`&& eh->root.type != bfd_link_hash_defweak`
`&& eh->root.type != bfd_link_hash_undefweak)`	`&& eh->root.type != bfd_link_hash_undefweak)`
`{`	`{`
`if (info->unresolved_syms_in_objects == RM_IGNORE`	`if (info->unresolved_syms_in_objects == RM_IGNORE`
`&& ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT`	`&& ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT`
`&& eh->type == STT_PARISC_MILLI)`	`&& eh->type == STT_PARISC_MILLI)`
`{`	`{`
`if (! info->callbacks->undefined_symbol`	`if (! info->callbacks->undefined_symbol`
`(info, eh_name (eh), input_bfd,`	`(info, eh_name (eh), input_bfd,`
`input_section, rel->r_offset, FALSE))`	`input_section, rel->r_offset, FALSE))`
`return FALSE;`	`return FALSE;`
`warned_undef = TRUE;`	`warned_undef = TRUE;`
`}`	`}`
`}`	`}`
`}`	`}`

`if (sym_sec != NULL && elf_discarded_section (sym_sec))`	`if (sym_sec != NULL && elf_discarded_section (sym_sec))`
`{`	`{`
`/* For relocs against symbols from removed linkonce sections,`	`/* For relocs against symbols from removed linkonce sections,`
`or sections discarded by a linker script, we just want the`	`or sections discarded by a linker script, we just want the`
`section contents zeroed. Avoid any special processing. */`	`section contents zeroed. Avoid any special processing. */`
`_bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);`	`_bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);`
`rel->r_info = 0;`	`rel->r_info = 0;`
`rel->r_addend = 0;`	`rel->r_addend = 0;`
`continue;`	`continue;`
`}`	`}`

`if (info->relocatable)`	`if (info->relocatable)`
`continue;`	`continue;`

`r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,`	`r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,`
`input_section, contents,`	`input_section, contents,`
`relocation, info, sym_sec,`	`relocation, info, sym_sec,`
`eh);`	`eh);`

`if (r != bfd_reloc_ok)`	`if (r != bfd_reloc_ok)`
`{`	`{`
`switch (r)`	`switch (r)`
`{`	`{`
`default:`	`default:`
`abort ();`	`abort ();`
`case bfd_reloc_overflow:`	`case bfd_reloc_overflow:`
`{`	`{`
`const char *sym_name;`	`const char *sym_name;`

`if (eh != NULL)`	`if (eh != NULL)`
`sym_name = NULL;`	`sym_name = NULL;`
`else`	`else`
`{`	`{`
`sym_name = bfd_elf_string_from_elf_section (input_bfd,`	`sym_name = bfd_elf_string_from_elf_section (input_bfd,`
`symtab_hdr->sh_link,`	`symtab_hdr->sh_link,`
`sym->st_name);`	`sym->st_name);`
`if (sym_name == NULL)`	`if (sym_name == NULL)`
`return FALSE;`	`return FALSE;`
`if (*sym_name == '\0')`	`if (*sym_name == '\0')`
`sym_name = bfd_section_name (input_bfd, sym_sec);`	`sym_name = bfd_section_name (input_bfd, sym_sec);`
`}`	`}`

`if (!((*info->callbacks->reloc_overflow)`	`if (!((*info->callbacks->reloc_overflow)`
`(info, (eh ? &eh->root : NULL), sym_name,`	`(info, (eh ? &eh->root : NULL), sym_name,`
`howto->name, (bfd_vma) 0, input_bfd,`	`howto->name, (bfd_vma) 0, input_bfd,`
`input_section, rel->r_offset)))`	`input_section, rel->r_offset)))`
`return FALSE;`	`return FALSE;`
`}`	`}`
`break;`	`break;`
`}`	`}`
`}`	`}`
`}`	`}`
`return TRUE;`	`return TRUE;`
`}`	`}`

`static const struct bfd_elf_special_section elf64_hppa_special_sections[] =`	`static const struct bfd_elf_special_section elf64_hppa_special_sections[] =`
`{`	`{`
`{ STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },`	`{ STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },`
`{ STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },`	`{ STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },`
`{ STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`	`{ STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`
`{ STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`	`{ STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`
`{ STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`	`{ STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`
`{ STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`	`{ STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },`
`{ STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS },`	`{ STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS },`
`{ NULL, 0, 0, 0, 0 }`	`{ NULL, 0, 0, 0, 0 }`
`};`	`};`

`/* The hash bucket size is the standard one, namely 4. */`	`/* The hash bucket size is the standard one, namely 4. */`

`const struct elf_size_info hppa64_elf_size_info =`	`const struct elf_size_info hppa64_elf_size_info =`
`{`	`{`
`sizeof (Elf64_External_Ehdr),`	`sizeof (Elf64_External_Ehdr),`
`sizeof (Elf64_External_Phdr),`	`sizeof (Elf64_External_Phdr),`
`sizeof (Elf64_External_Shdr),`	`sizeof (Elf64_External_Shdr),`
`sizeof (Elf64_External_Rel),`	`sizeof (Elf64_External_Rel),`
`sizeof (Elf64_External_Rela),`	`sizeof (Elf64_External_Rela),`
`sizeof (Elf64_External_Sym),`	`sizeof (Elf64_External_Sym),`
`sizeof (Elf64_External_Dyn),`	`sizeof (Elf64_External_Dyn),`
`sizeof (Elf_External_Note),`	`sizeof (Elf_External_Note),`
`4,`	`4,`
`1,`	`1,`
`64, 3,`	`64, 3,`
`ELFCLASS64, EV_CURRENT,`	`ELFCLASS64, EV_CURRENT,`
`bfd_elf64_write_out_phdrs,`	`bfd_elf64_write_out_phdrs,`
`bfd_elf64_write_shdrs_and_ehdr,`	`bfd_elf64_write_shdrs_and_ehdr,`
`bfd_elf64_checksum_contents,`	`bfd_elf64_checksum_contents,`
`bfd_elf64_write_relocs,`	`bfd_elf64_write_relocs,`
`bfd_elf64_swap_symbol_in,`	`bfd_elf64_swap_symbol_in,`
`bfd_elf64_swap_symbol_out,`	`bfd_elf64_swap_symbol_out,`
`bfd_elf64_slurp_reloc_table,`	`bfd_elf64_slurp_reloc_table,`
`bfd_elf64_slurp_symbol_table,`	`bfd_elf64_slurp_symbol_table,`
`bfd_elf64_swap_dyn_in,`	`bfd_elf64_swap_dyn_in,`
`bfd_elf64_swap_dyn_out,`	`bfd_elf64_swap_dyn_out,`
`bfd_elf64_swap_reloc_in,`	`bfd_elf64_swap_reloc_in,`
`bfd_elf64_swap_reloc_out,`	`bfd_elf64_swap_reloc_out,`
`bfd_elf64_swap_reloca_in,`	`bfd_elf64_swap_reloca_in,`
`bfd_elf64_swap_reloca_out`	`bfd_elf64_swap_reloca_out`
`};`	`};`

`#define TARGET_BIG_SYM bfd_elf64_hppa_vec`	`#define TARGET_BIG_SYM bfd_elf64_hppa_vec`
`#define TARGET_BIG_NAME "elf64-hppa"`	`#define TARGET_BIG_NAME "elf64-hppa"`
`#define ELF_ARCH bfd_arch_hppa`	`#define ELF_ARCH bfd_arch_hppa`
`#define ELF_MACHINE_CODE EM_PARISC`	`#define ELF_MACHINE_CODE EM_PARISC`
`/* This is not strictly correct. The maximum page size for PA2.0 is`	`/* This is not strictly correct. The maximum page size for PA2.0 is`
`64M. But everything still uses 4k. */`	`64M. But everything still uses 4k. */`
`#define ELF_MAXPAGESIZE 0x1000`	`#define ELF_MAXPAGESIZE 0x1000`
`#define ELF_OSABI ELFOSABI_HPUX`	`#define ELF_OSABI ELFOSABI_HPUX`

`#define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup`	`#define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup`
`#define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup`	`#define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup`
`#define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name`	`#define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name`
`#define elf_info_to_howto elf_hppa_info_to_howto`	`#define elf_info_to_howto elf_hppa_info_to_howto`
`#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel`	`#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel`

`#define elf_backend_section_from_shdr elf64_hppa_section_from_shdr`	`#define elf_backend_section_from_shdr elf64_hppa_section_from_shdr`
`#define elf_backend_object_p elf64_hppa_object_p`	`#define elf_backend_object_p elf64_hppa_object_p`
`#define elf_backend_final_write_processing \`	`#define elf_backend_final_write_processing \`
`elf_hppa_final_write_processing`	`elf_hppa_final_write_processing`
`#define elf_backend_fake_sections elf_hppa_fake_sections`	`#define elf_backend_fake_sections elf_hppa_fake_sections`
`#define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook`	`#define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook`

`#define elf_backend_relocate_section elf_hppa_relocate_section`	`#define elf_backend_relocate_section elf_hppa_relocate_section`

`#define bfd_elf64_bfd_final_link elf_hppa_final_link`	`#define bfd_elf64_bfd_final_link elf_hppa_final_link`

`#define elf_backend_create_dynamic_sections \`	`#define elf_backend_create_dynamic_sections \`
`elf64_hppa_create_dynamic_sections`	`elf64_hppa_create_dynamic_sections`
`#define elf_backend_post_process_headers elf64_hppa_post_process_headers`	`#define elf_backend_post_process_headers elf64_hppa_post_process_headers`

`#define elf_backend_omit_section_dynsym \`	`#define elf_backend_omit_section_dynsym \`
`((bfd_boolean () (bfd , struct bfd_link_info , asection )) bfd_true)`	`((bfd_boolean () (bfd , struct bfd_link_info , asection )) bfd_true)`
`#define elf_backend_adjust_dynamic_symbol \`	`#define elf_backend_adjust_dynamic_symbol \`
`elf64_hppa_adjust_dynamic_symbol`	`elf64_hppa_adjust_dynamic_symbol`

`#define elf_backend_size_dynamic_sections \`	`#define elf_backend_size_dynamic_sections \`
`elf64_hppa_size_dynamic_sections`	`elf64_hppa_size_dynamic_sections`

`#define elf_backend_finish_dynamic_symbol \`	`#define elf_backend_finish_dynamic_symbol \`
`elf64_hppa_finish_dynamic_symbol`	`elf64_hppa_finish_dynamic_symbol`
`#define elf_backend_finish_dynamic_sections \`	`#define elf_backend_finish_dynamic_sections \`
`elf64_hppa_finish_dynamic_sections`	`elf64_hppa_finish_dynamic_sections`
`#define elf_backend_grok_prstatus elf64_hppa_grok_prstatus`	`#define elf_backend_grok_prstatus elf64_hppa_grok_prstatus`
`#define elf_backend_grok_psinfo elf64_hppa_grok_psinfo`	`#define elf_backend_grok_psinfo elf64_hppa_grok_psinfo`

`/* Stuff for the BFD linker: */`	`/* Stuff for the BFD linker: */`
`#define bfd_elf64_bfd_link_hash_table_create \`	`#define bfd_elf64_bfd_link_hash_table_create \`
`elf64_hppa_hash_table_create`	`elf64_hppa_hash_table_create`

`#define elf_backend_check_relocs \`	`#define elf_backend_check_relocs \`
`elf64_hppa_check_relocs`	`elf64_hppa_check_relocs`

`#define elf_backend_size_info \`	`#define elf_backend_size_info \`
`hppa64_elf_size_info`	`hppa64_elf_size_info`

`#define elf_backend_additional_program_headers \`	`#define elf_backend_additional_program_headers \`
`elf64_hppa_additional_program_headers`	`elf64_hppa_additional_program_headers`

`#define elf_backend_modify_segment_map \`	`#define elf_backend_modify_segment_map \`
`elf64_hppa_modify_segment_map`	`elf64_hppa_modify_segment_map`

`#define elf_backend_link_output_symbol_hook \`	`#define elf_backend_link_output_symbol_hook \`
`elf64_hppa_link_output_symbol_hook`	`elf64_hppa_link_output_symbol_hook`

`#define elf_backend_want_got_plt 0`	`#define elf_backend_want_got_plt 0`
`#define elf_backend_plt_readonly 0`	`#define elf_backend_plt_readonly 0`
`#define elf_backend_want_plt_sym 0`	`#define elf_backend_want_plt_sym 0`
`#define elf_backend_got_header_size 0`	`#define elf_backend_got_header_size 0`
`#define elf_backend_type_change_ok TRUE`	`#define elf_backend_type_change_ok TRUE`
`#define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type`	`#define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type`
`#define elf_backend_reloc_type_class elf64_hppa_reloc_type_class`	`#define elf_backend_reloc_type_class elf64_hppa_reloc_type_class`
`#define elf_backend_rela_normal 1`	`#define elf_backend_rela_normal 1`
`#define elf_backend_special_sections elf64_hppa_special_sections`	`#define elf_backend_special_sections elf64_hppa_special_sections`
`#define elf_backend_action_discarded elf_hppa_action_discarded`	`#define elf_backend_action_discarded elf_hppa_action_discarded`
`#define elf_backend_section_from_phdr elf64_hppa_section_from_phdr`	`#define elf_backend_section_from_phdr elf64_hppa_section_from_phdr`

`#define elf64_bed elf64_hppa_hpux_bed`	`#define elf64_bed elf64_hppa_hpux_bed`

`#include "elf64-target.h"`	`#include "elf64-target.h"`

`#undef TARGET_BIG_SYM`	`#undef TARGET_BIG_SYM`
`#define TARGET_BIG_SYM bfd_elf64_hppa_linux_vec`	`#define TARGET_BIG_SYM bfd_elf64_hppa_linux_vec`
`#undef TARGET_BIG_NAME`	`#undef TARGET_BIG_NAME`
`#define TARGET_BIG_NAME "elf64-hppa-linux"`	`#define TARGET_BIG_NAME "elf64-hppa-linux"`
`#undef ELF_OSABI`	`#undef ELF_OSABI`
`#define ELF_OSABI ELFOSABI_LINUX`	`#define ELF_OSABI ELFOSABI_LINUX`
`#undef elf_backend_post_process_headers`	`#undef elf_backend_post_process_headers`
`#define elf_backend_post_process_headers _bfd_elf_set_osabi`	`#define elf_backend_post_process_headers _bfd_elf_set_osabi`
`#undef elf64_bed`	`#undef elf64_bed`
`#define elf64_bed elf64_hppa_linux_bed`	`#define elf64_bed elf64_hppa_linux_bed`

`#include "elf64-target.h"`	`#include "elf64-target.h"`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [elf64-hppa.c] - Diff between revs 827 and 840