[BACK]Return to elf32-hppa.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / bfd

Annotation of src/external/gpl3/binutils.old/dist/bfd/elf32-hppa.c, Revision 1.1.1.5

1.1       christos    1: /* BFD back-end for HP PA-RISC ELF files.
1.1.1.5 ! christos    2:    Copyright (C) 1990-2020 Free Software Foundation, Inc.
1.1       christos    3:
                      4:    Original code by
                      5:        Center for Software Science
                      6:        Department of Computer Science
                      7:        University of Utah
                      8:    Largely rewritten by Alan Modra <alan@linuxcare.com.au>
                      9:    Naming cleanup by Carlos O'Donell <carlos@systemhalted.org>
                     10:    TLS support written by Randolph Chung <tausq@debian.org>
1.1.1.2   christos   11:
1.1       christos   12:    This file is part of BFD, the Binary File Descriptor library.
                     13:
                     14:    This program is free software; you can redistribute it and/or modify
                     15:    it under the terms of the GNU General Public License as published by
                     16:    the Free Software Foundation; either version 3 of the License, or
                     17:    (at your option) any later version.
                     18:
                     19:    This program is distributed in the hope that it will be useful,
                     20:    but WITHOUT ANY WARRANTY; without even the implied warranty of
                     21:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     22:    GNU General Public License for more details.
                     23:
                     24:    You should have received a copy of the GNU General Public License
                     25:    along with this program; if not, write to the Free Software
                     26:    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
                     27:    MA 02110-1301, USA.  */
                     28:
                     29: #include "sysdep.h"
                     30: #include "bfd.h"
                     31: #include "libbfd.h"
                     32: #include "elf-bfd.h"
                     33: #include "elf/hppa.h"
                     34: #include "libhppa.h"
                     35: #include "elf32-hppa.h"
                     36: #define ARCH_SIZE              32
                     37: #include "elf32-hppa.h"
                     38: #include "elf-hppa.h"
                     39:
                     40: /* In order to gain some understanding of code in this file without
                     41:    knowing all the intricate details of the linker, note the
                     42:    following:
                     43:
                     44:    Functions named elf32_hppa_* are called by external routines, other
                     45:    functions are only called locally.  elf32_hppa_* functions appear
                     46:    in this file more or less in the order in which they are called
                     47:    from external routines.  eg. elf32_hppa_check_relocs is called
                     48:    early in the link process, elf32_hppa_finish_dynamic_sections is
                     49:    one of the last functions.  */
                     50:
                     51: /* We use two hash tables to hold information for linking PA ELF objects.
                     52:
                     53:    The first is the elf32_hppa_link_hash_table which is derived
                     54:    from the standard ELF linker hash table.  We use this as a place to
                     55:    attach other hash tables and static information.
                     56:
                     57:    The second is the stub hash table which is derived from the
                     58:    base BFD hash table.  The stub hash table holds the information
                     59:    necessary to build the linker stubs during a link.
                     60:
                     61:    There are a number of different stubs generated by the linker.
                     62:
                     63:    Long branch stub:
                     64:    :           ldil LR'X,%r1
                     65:    :           be,n RR'X(%sr4,%r1)
                     66:
                     67:    PIC long branch stub:
                     68:    :           b,l .+8,%r1
                     69:    :           addil LR'X - ($PIC_pcrel$0 - 4),%r1
                     70:    :           be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
                     71:
                     72:    Import stub to call shared library routine from normal object file
                     73:    (single sub-space version)
1.1.1.5 ! christos   74:    :           addil LR'lt_ptr+ltoff,%dp       ; get PLT address
        !            75:    :           ldo RR'lt_ptr+ltoff(%r1),%r22   ;
        !            76:    :           ldw 0(%r22),%r21                ; get procedure entry point
1.1       christos   77:    :           bv %r0(%r21)
1.1.1.5 ! christos   78:    :           ldw 4(%r22),%r19                ; get new dlt value.
1.1       christos   79:
                     80:    Import stub to call shared library routine from shared library
                     81:    (single sub-space version)
1.1.1.5 ! christos   82:    :           addil LR'ltoff,%r19             ; get PLT address
        !            83:    :           ldo RR'ltoff(%r1),%r22
        !            84:    :           ldw 0(%r22),%r21                ; get procedure entry point
1.1       christos   85:    :           bv %r0(%r21)
1.1.1.5 ! christos   86:    :           ldw 4(%r22),%r19                ; get new dlt value.
1.1       christos   87:
                     88:    Import stub to call shared library routine from normal object file
                     89:    (multiple sub-space support)
1.1.1.5 ! christos   90:    :           addil LR'lt_ptr+ltoff,%dp       ; get PLT address
        !            91:    :           ldo RR'lt_ptr+ltoff(%r1),%r22   ;
        !            92:    :           ldw 0(%r22),%r21                ; get procedure entry point
        !            93:    :           ldsid (%r21),%r1                ; get target sid
        !            94:    :           ldw 4(%r22),%r19                ; get new dlt value.
1.1       christos   95:    :           mtsp %r1,%sr0
                     96:    :           be 0(%sr0,%r21)                 ; branch to target
                     97:    :           stw %rp,-24(%sp)                ; save rp
                     98:
                     99:    Import stub to call shared library routine from shared library
                    100:    (multiple sub-space support)
1.1.1.5 ! christos  101:    :           addil LR'ltoff,%r19             ; get PLT address
        !           102:    :           ldo RR'ltoff(%r1),%r22
        !           103:    :           ldw 0(%r22),%r21                ; get procedure entry point
        !           104:    :           ldsid (%r21),%r1                ; get target sid
        !           105:    :           ldw 4(%r22),%r19                ; get new dlt value.
1.1       christos  106:    :           mtsp %r1,%sr0
                    107:    :           be 0(%sr0,%r21)                 ; branch to target
                    108:    :           stw %rp,-24(%sp)                ; save rp
                    109:
                    110:    Export stub to return from shared lib routine (multiple sub-space support)
                    111:    One of these is created for each exported procedure in a shared
                    112:    library (and stored in the shared lib).  Shared lib routines are
                    113:    called via the first instruction in the export stub so that we can
                    114:    do an inter-space return.  Not required for single sub-space.
                    115:    :           bl,n X,%rp                      ; trap the return
                    116:    :           nop
                    117:    :           ldw -24(%sp),%rp                ; restore the original rp
                    118:    :           ldsid (%rp),%r1
                    119:    :           mtsp %r1,%sr0
                    120:    :           be,n 0(%sr0,%rp)                ; inter-space return.  */
                    121:
                    122:
                    123: /* Variable names follow a coding style.
                    124:    Please follow this (Apps Hungarian) style:
                    125:
1.1.1.4   christos  126:    Structure/Variable                  Prefix
1.1       christos  127:    elf_link_hash_table                 "etab"
                    128:    elf_link_hash_entry                 "eh"
1.1.1.2   christos  129:
1.1       christos  130:    elf32_hppa_link_hash_table          "htab"
                    131:    elf32_hppa_link_hash_entry          "hh"
                    132:
                    133:    bfd_hash_table                      "btab"
                    134:    bfd_hash_entry                      "bh"
1.1.1.2   christos  135:
1.1       christos  136:    bfd_hash_table containing stubs     "bstab"
                    137:    elf32_hppa_stub_hash_entry          "hsh"
                    138:
                    139:    Always remember to use GNU Coding Style. */
1.1.1.2   christos  140:
1.1       christos  141: #define PLT_ENTRY_SIZE 8
                    142: #define GOT_ENTRY_SIZE 4
1.1.1.5 ! christos  143: #define LONG_BRANCH_STUB_SIZE 8
        !           144: #define LONG_BRANCH_SHARED_STUB_SIZE 12
        !           145: #define IMPORT_STUB_SIZE 20
        !           146: #define IMPORT_SHARED_STUB_SIZE 32
        !           147: #define EXPORT_STUB_SIZE 24
1.1       christos  148: #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
                    149:
                    150: static const bfd_byte plt_stub[] =
                    151: {
1.1.1.5 ! christos  152:   0x0e, 0x80, 0x10, 0x95,  /* 1: ldw   0(%r20),%r21            */
        !           153:   0xea, 0xa0, 0xc0, 0x00,  /*    bv    %r0(%r21)               */
1.1       christos  154:   0x0e, 0x88, 0x10, 0x95,  /*    ldw   4(%r20),%r21            */
                    155: #define PLT_STUB_ENTRY (3*4)
                    156:   0xea, 0x9f, 0x1f, 0xdd,  /*    b,l   1b,%r20                 */
                    157:   0xd6, 0x80, 0x1c, 0x1e,  /*    depi  0,31,2,%r20             */
                    158:   0x00, 0xc0, 0xff, 0xee,  /* 9: .word fixup_func              */
                    159:   0xde, 0xad, 0xbe, 0xef   /*    .word fixup_ltp               */
                    160: };
                    161:
                    162: /* Section name for stubs is the associated section name plus this
                    163:    string.  */
                    164: #define STUB_SUFFIX ".stub"
                    165:
                    166: /* We don't need to copy certain PC- or GP-relative dynamic relocs
                    167:    into a shared object's dynamic section.  All the relocs of the
                    168:    limited class we are interested in, are absolute.  */
                    169: #ifndef RELATIVE_DYNRELOCS
                    170: #define RELATIVE_DYNRELOCS 0
                    171: #define IS_ABSOLUTE_RELOC(r_type) 1
1.1.1.4   christos  172: #define pc_dynrelocs(hh) 0
1.1       christos  173: #endif
                    174:
                    175: /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
                    176:    copying dynamic variables from a shared lib into an app's dynbss
                    177:    section, and instead use a dynamic relocation to point into the
                    178:    shared lib.  */
                    179: #define ELIMINATE_COPY_RELOCS 1
                    180:
                    181: enum elf32_hppa_stub_type
                    182: {
                    183:   hppa_stub_long_branch,
                    184:   hppa_stub_long_branch_shared,
                    185:   hppa_stub_import,
                    186:   hppa_stub_import_shared,
                    187:   hppa_stub_export,
                    188:   hppa_stub_none
                    189: };
                    190:
                    191: struct elf32_hppa_stub_hash_entry
                    192: {
                    193:   /* Base hash table entry structure.  */
                    194:   struct bfd_hash_entry bh_root;
                    195:
                    196:   /* The stub section.  */
                    197:   asection *stub_sec;
                    198:
                    199:   /* Offset within stub_sec of the beginning of this stub.  */
                    200:   bfd_vma stub_offset;
                    201:
                    202:   /* Given the symbol's value and its section we can determine its final
                    203:      value when building the stubs (so the stub knows where to jump.  */
                    204:   bfd_vma target_value;
                    205:   asection *target_section;
                    206:
                    207:   enum elf32_hppa_stub_type stub_type;
                    208:
                    209:   /* The symbol table entry, if any, that this was derived from.  */
                    210:   struct elf32_hppa_link_hash_entry *hh;
                    211:
                    212:   /* Where this stub is being called from, or, in the case of combined
                    213:      stub sections, the first input section in the group.  */
                    214:   asection *id_sec;
                    215: };
                    216:
1.1.1.4   christos  217: enum _tls_type
                    218:   {
                    219:     GOT_UNKNOWN = 0,
                    220:     GOT_NORMAL = 1,
                    221:     GOT_TLS_GD = 2,
                    222:     GOT_TLS_LDM = 4,
                    223:     GOT_TLS_IE = 8
                    224:   };
                    225:
1.1       christos  226: struct elf32_hppa_link_hash_entry
                    227: {
                    228:   struct elf_link_hash_entry eh;
                    229:
                    230:   /* A pointer to the most recently used stub hash entry against this
                    231:      symbol.  */
                    232:   struct elf32_hppa_stub_hash_entry *hsh_cache;
                    233:
                    234:   /* Used to count relocations for delayed sizing of relocation
                    235:      sections.  */
1.1.1.4   christos  236:   struct elf_dyn_relocs *dyn_relocs;
1.1       christos  237:
1.1.1.4   christos  238:   ENUM_BITFIELD (_tls_type) tls_type : 8;
1.1       christos  239:
                    240:   /* Set if this symbol is used by a plabel reloc.  */
                    241:   unsigned int plabel:1;
                    242: };
                    243:
                    244: struct elf32_hppa_link_hash_table
                    245: {
                    246:   /* The main hash table.  */
                    247:   struct elf_link_hash_table etab;
                    248:
                    249:   /* The stub hash table.  */
                    250:   struct bfd_hash_table bstab;
                    251:
                    252:   /* Linker stub bfd.  */
                    253:   bfd *stub_bfd;
                    254:
                    255:   /* Linker call-backs.  */
                    256:   asection * (*add_stub_section) (const char *, asection *);
                    257:   void (*layout_sections_again) (void);
                    258:
                    259:   /* Array to keep track of which stub sections have been created, and
                    260:      information on stub grouping.  */
                    261:   struct map_stub
                    262:   {
                    263:     /* This is the section to which stubs in the group will be
                    264:        attached.  */
                    265:     asection *link_sec;
                    266:     /* The stub section.  */
                    267:     asection *stub_sec;
                    268:   } *stub_group;
                    269:
                    270:   /* Assorted information used by elf32_hppa_size_stubs.  */
                    271:   unsigned int bfd_count;
1.1.1.2   christos  272:   unsigned int top_index;
1.1       christos  273:   asection **input_list;
                    274:   Elf_Internal_Sym **all_local_syms;
                    275:
                    276:   /* Used during a final link to store the base of the text and data
                    277:      segments so that we can perform SEGREL relocations.  */
                    278:   bfd_vma text_segment_base;
                    279:   bfd_vma data_segment_base;
                    280:
                    281:   /* Whether we support multiple sub-spaces for shared libs.  */
                    282:   unsigned int multi_subspace:1;
                    283:
                    284:   /* Flags set when various size branches are detected.  Used to
                    285:      select suitable defaults for the stub group size.  */
                    286:   unsigned int has_12bit_branch:1;
                    287:   unsigned int has_17bit_branch:1;
                    288:   unsigned int has_22bit_branch:1;
                    289:
                    290:   /* Set if we need a .plt stub to support lazy dynamic linking.  */
                    291:   unsigned int need_plt_stub:1;
                    292:
                    293:   /* Small local sym cache.  */
                    294:   struct sym_cache sym_cache;
                    295:
                    296:   /* Data for LDM relocations.  */
                    297:   union
                    298:   {
                    299:     bfd_signed_vma refcount;
                    300:     bfd_vma offset;
                    301:   } tls_ldm_got;
                    302: };
                    303:
                    304: /* Various hash macros and functions.  */
                    305: #define hppa_link_hash_table(p) \
                    306:   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
                    307:   == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
                    308:
                    309: #define hppa_elf_hash_entry(ent) \
                    310:   ((struct elf32_hppa_link_hash_entry *)(ent))
                    311:
                    312: #define hppa_stub_hash_entry(ent) \
                    313:   ((struct elf32_hppa_stub_hash_entry *)(ent))
                    314:
                    315: #define hppa_stub_hash_lookup(table, string, create, copy) \
                    316:   ((struct elf32_hppa_stub_hash_entry *) \
                    317:    bfd_hash_lookup ((table), (string), (create), (copy)))
                    318:
                    319: #define hppa_elf_local_got_tls_type(abfd) \
                    320:   ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
                    321:
                    322: #define hh_name(hh) \
                    323:   (hh ? hh->eh.root.root.string : "<undef>")
                    324:
                    325: #define eh_name(eh) \
                    326:   (eh ? eh->root.root.string : "<undef>")
                    327:
                    328: /* Assorted hash table functions.  */
                    329:
                    330: /* Initialize an entry in the stub hash table.  */
                    331:
                    332: static struct bfd_hash_entry *
                    333: stub_hash_newfunc (struct bfd_hash_entry *entry,
                    334:                   struct bfd_hash_table *table,
                    335:                   const char *string)
                    336: {
                    337:   /* Allocate the structure if it has not already been allocated by a
                    338:      subclass.  */
                    339:   if (entry == NULL)
                    340:     {
                    341:       entry = bfd_hash_allocate (table,
                    342:                                 sizeof (struct elf32_hppa_stub_hash_entry));
                    343:       if (entry == NULL)
                    344:        return entry;
                    345:     }
                    346:
                    347:   /* Call the allocation method of the superclass.  */
                    348:   entry = bfd_hash_newfunc (entry, table, string);
                    349:   if (entry != NULL)
                    350:     {
                    351:       struct elf32_hppa_stub_hash_entry *hsh;
                    352:
                    353:       /* Initialize the local fields.  */
                    354:       hsh = hppa_stub_hash_entry (entry);
                    355:       hsh->stub_sec = NULL;
                    356:       hsh->stub_offset = 0;
                    357:       hsh->target_value = 0;
                    358:       hsh->target_section = NULL;
                    359:       hsh->stub_type = hppa_stub_long_branch;
                    360:       hsh->hh = NULL;
                    361:       hsh->id_sec = NULL;
                    362:     }
                    363:
                    364:   return entry;
                    365: }
                    366:
                    367: /* Initialize an entry in the link hash table.  */
                    368:
                    369: static struct bfd_hash_entry *
                    370: hppa_link_hash_newfunc (struct bfd_hash_entry *entry,
                    371:                        struct bfd_hash_table *table,
                    372:                        const char *string)
                    373: {
                    374:   /* Allocate the structure if it has not already been allocated by a
                    375:      subclass.  */
                    376:   if (entry == NULL)
                    377:     {
                    378:       entry = bfd_hash_allocate (table,
                    379:                                 sizeof (struct elf32_hppa_link_hash_entry));
                    380:       if (entry == NULL)
                    381:        return entry;
                    382:     }
                    383:
                    384:   /* Call the allocation method of the superclass.  */
                    385:   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
                    386:   if (entry != NULL)
                    387:     {
                    388:       struct elf32_hppa_link_hash_entry *hh;
                    389:
                    390:       /* Initialize the local fields.  */
                    391:       hh = hppa_elf_hash_entry (entry);
                    392:       hh->hsh_cache = NULL;
                    393:       hh->dyn_relocs = NULL;
                    394:       hh->plabel = 0;
                    395:       hh->tls_type = GOT_UNKNOWN;
                    396:     }
                    397:
                    398:   return entry;
                    399: }
                    400:
1.1.1.2   christos  401: /* Free the derived linker hash table.  */
                    402:
                    403: static void
                    404: elf32_hppa_link_hash_table_free (bfd *obfd)
                    405: {
                    406:   struct elf32_hppa_link_hash_table *htab
                    407:     = (struct elf32_hppa_link_hash_table *) obfd->link.hash;
                    408:
                    409:   bfd_hash_table_free (&htab->bstab);
                    410:   _bfd_elf_link_hash_table_free (obfd);
                    411: }
                    412:
1.1       christos  413: /* Create the derived linker hash table.  The PA ELF port uses the derived
                    414:    hash table to keep information specific to the PA ELF linker (without
                    415:    using static variables).  */
                    416:
                    417: static struct bfd_link_hash_table *
                    418: elf32_hppa_link_hash_table_create (bfd *abfd)
                    419: {
                    420:   struct elf32_hppa_link_hash_table *htab;
                    421:   bfd_size_type amt = sizeof (*htab);
                    422:
1.1.1.2   christos  423:   htab = bfd_zmalloc (amt);
1.1       christos  424:   if (htab == NULL)
                    425:     return NULL;
                    426:
                    427:   if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, hppa_link_hash_newfunc,
                    428:                                      sizeof (struct elf32_hppa_link_hash_entry),
                    429:                                      HPPA32_ELF_DATA))
                    430:     {
                    431:       free (htab);
                    432:       return NULL;
                    433:     }
                    434:
                    435:   /* Init the stub hash table too.  */
                    436:   if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
                    437:                            sizeof (struct elf32_hppa_stub_hash_entry)))
1.1.1.2   christos  438:     {
                    439:       _bfd_elf_link_hash_table_free (abfd);
                    440:       return NULL;
                    441:     }
                    442:   htab->etab.root.hash_table_free = elf32_hppa_link_hash_table_free;
1.1       christos  443:
                    444:   htab->text_segment_base = (bfd_vma) -1;
                    445:   htab->data_segment_base = (bfd_vma) -1;
                    446:   return &htab->etab.root;
                    447: }
                    448:
1.1.1.3   christos  449: /* Initialize the linker stubs BFD so that we can use it for linker
                    450:    created dynamic sections.  */
                    451:
                    452: void
                    453: elf32_hppa_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
                    454: {
                    455:   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
                    456:
                    457:   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS32;
                    458:   htab->etab.dynobj = abfd;
                    459: }
                    460:
1.1       christos  461: /* Build a name for an entry in the stub hash table.  */
                    462:
                    463: static char *
                    464: hppa_stub_name (const asection *input_section,
                    465:                const asection *sym_sec,
                    466:                const struct elf32_hppa_link_hash_entry *hh,
                    467:                const Elf_Internal_Rela *rela)
                    468: {
                    469:   char *stub_name;
                    470:   bfd_size_type len;
                    471:
                    472:   if (hh)
                    473:     {
                    474:       len = 8 + 1 + strlen (hh_name (hh)) + 1 + 8 + 1;
                    475:       stub_name = bfd_malloc (len);
                    476:       if (stub_name != NULL)
                    477:        sprintf (stub_name, "%08x_%s+%x",
                    478:                 input_section->id & 0xffffffff,
                    479:                 hh_name (hh),
                    480:                 (int) rela->r_addend & 0xffffffff);
                    481:     }
                    482:   else
                    483:     {
                    484:       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
                    485:       stub_name = bfd_malloc (len);
                    486:       if (stub_name != NULL)
                    487:        sprintf (stub_name, "%08x_%x:%x+%x",
                    488:                 input_section->id & 0xffffffff,
                    489:                 sym_sec->id & 0xffffffff,
                    490:                 (int) ELF32_R_SYM (rela->r_info) & 0xffffffff,
                    491:                 (int) rela->r_addend & 0xffffffff);
                    492:     }
                    493:   return stub_name;
                    494: }
                    495:
                    496: /* Look up an entry in the stub hash.  Stub entries are cached because
                    497:    creating the stub name takes a bit of time.  */
                    498:
                    499: static struct elf32_hppa_stub_hash_entry *
                    500: hppa_get_stub_entry (const asection *input_section,
                    501:                     const asection *sym_sec,
                    502:                     struct elf32_hppa_link_hash_entry *hh,
                    503:                     const Elf_Internal_Rela *rela,
                    504:                     struct elf32_hppa_link_hash_table *htab)
                    505: {
                    506:   struct elf32_hppa_stub_hash_entry *hsh_entry;
                    507:   const asection *id_sec;
                    508:
                    509:   /* If this input section is part of a group of sections sharing one
                    510:      stub section, then use the id of the first section in the group.
                    511:      Stub names need to include a section id, as there may well be
                    512:      more than one stub used to reach say, printf, and we need to
                    513:      distinguish between them.  */
                    514:   id_sec = htab->stub_group[input_section->id].link_sec;
1.1.1.4   christos  515:   if (id_sec == NULL)
                    516:     return NULL;
1.1       christos  517:
                    518:   if (hh != NULL && hh->hsh_cache != NULL
                    519:       && hh->hsh_cache->hh == hh
                    520:       && hh->hsh_cache->id_sec == id_sec)
                    521:     {
                    522:       hsh_entry = hh->hsh_cache;
                    523:     }
                    524:   else
                    525:     {
                    526:       char *stub_name;
                    527:
                    528:       stub_name = hppa_stub_name (id_sec, sym_sec, hh, rela);
                    529:       if (stub_name == NULL)
                    530:        return NULL;
                    531:
                    532:       hsh_entry = hppa_stub_hash_lookup (&htab->bstab,
                    533:                                          stub_name, FALSE, FALSE);
                    534:       if (hh != NULL)
                    535:        hh->hsh_cache = hsh_entry;
                    536:
                    537:       free (stub_name);
                    538:     }
                    539:
                    540:   return hsh_entry;
                    541: }
                    542:
                    543: /* Add a new stub entry to the stub hash.  Not all fields of the new
                    544:    stub entry are initialised.  */
                    545:
                    546: static struct elf32_hppa_stub_hash_entry *
                    547: hppa_add_stub (const char *stub_name,
                    548:               asection *section,
                    549:               struct elf32_hppa_link_hash_table *htab)
                    550: {
                    551:   asection *link_sec;
                    552:   asection *stub_sec;
                    553:   struct elf32_hppa_stub_hash_entry *hsh;
                    554:
                    555:   link_sec = htab->stub_group[section->id].link_sec;
                    556:   stub_sec = htab->stub_group[section->id].stub_sec;
                    557:   if (stub_sec == NULL)
                    558:     {
                    559:       stub_sec = htab->stub_group[link_sec->id].stub_sec;
                    560:       if (stub_sec == NULL)
                    561:        {
                    562:          size_t namelen;
                    563:          bfd_size_type len;
                    564:          char *s_name;
                    565:
                    566:          namelen = strlen (link_sec->name);
                    567:          len = namelen + sizeof (STUB_SUFFIX);
                    568:          s_name = bfd_alloc (htab->stub_bfd, len);
                    569:          if (s_name == NULL)
                    570:            return NULL;
                    571:
                    572:          memcpy (s_name, link_sec->name, namelen);
                    573:          memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
                    574:          stub_sec = (*htab->add_stub_section) (s_name, link_sec);
                    575:          if (stub_sec == NULL)
                    576:            return NULL;
                    577:          htab->stub_group[link_sec->id].stub_sec = stub_sec;
                    578:        }
                    579:       htab->stub_group[section->id].stub_sec = stub_sec;
                    580:     }
                    581:
                    582:   /* Enter this entry into the linker stub hash table.  */
                    583:   hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,
                    584:                                      TRUE, FALSE);
                    585:   if (hsh == NULL)
                    586:     {
1.1.1.4   christos  587:       /* xgettext:c-format */
                    588:       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
                    589:                          section->owner, stub_name);
1.1       christos  590:       return NULL;
                    591:     }
                    592:
                    593:   hsh->stub_sec = stub_sec;
                    594:   hsh->stub_offset = 0;
                    595:   hsh->id_sec = link_sec;
                    596:   return hsh;
                    597: }
                    598:
                    599: /* Determine the type of stub needed, if any, for a call.  */
                    600:
                    601: static enum elf32_hppa_stub_type
                    602: hppa_type_of_stub (asection *input_sec,
                    603:                   const Elf_Internal_Rela *rela,
                    604:                   struct elf32_hppa_link_hash_entry *hh,
                    605:                   bfd_vma destination,
                    606:                   struct bfd_link_info *info)
                    607: {
                    608:   bfd_vma location;
                    609:   bfd_vma branch_offset;
                    610:   bfd_vma max_branch_offset;
                    611:   unsigned int r_type;
                    612:
                    613:   if (hh != NULL
                    614:       && hh->eh.plt.offset != (bfd_vma) -1
                    615:       && hh->eh.dynindx != -1
                    616:       && !hh->plabel
1.1.1.2   christos  617:       && (bfd_link_pic (info)
1.1       christos  618:          || !hh->eh.def_regular
                    619:          || hh->eh.root.type == bfd_link_hash_defweak))
                    620:     {
                    621:       /* We need an import stub.  Decide between hppa_stub_import
                    622:         and hppa_stub_import_shared later.  */
                    623:       return hppa_stub_import;
                    624:     }
                    625:
1.1.1.4   christos  626:   if (destination == (bfd_vma) -1)
                    627:     return hppa_stub_none;
                    628:
1.1       christos  629:   /* Determine where the call point is.  */
                    630:   location = (input_sec->output_offset
                    631:              + input_sec->output_section->vma
                    632:              + rela->r_offset);
                    633:
                    634:   branch_offset = destination - location - 8;
                    635:   r_type = ELF32_R_TYPE (rela->r_info);
                    636:
                    637:   /* Determine if a long branch stub is needed.  parisc branch offsets
                    638:      are relative to the second instruction past the branch, ie. +8
                    639:      bytes on from the branch instruction location.  The offset is
                    640:      signed and counts in units of 4 bytes.  */
                    641:   if (r_type == (unsigned int) R_PARISC_PCREL17F)
                    642:     max_branch_offset = (1 << (17 - 1)) << 2;
                    643:
                    644:   else if (r_type == (unsigned int) R_PARISC_PCREL12F)
                    645:     max_branch_offset = (1 << (12 - 1)) << 2;
                    646:
                    647:   else /* R_PARISC_PCREL22F.  */
                    648:     max_branch_offset = (1 << (22 - 1)) << 2;
                    649:
                    650:   if (branch_offset + max_branch_offset >= 2*max_branch_offset)
                    651:     return hppa_stub_long_branch;
                    652:
                    653:   return hppa_stub_none;
                    654: }
                    655:
                    656: /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
                    657:    IN_ARG contains the link info pointer.  */
                    658:
                    659: #define LDIL_R1                0x20200000      /* ldil  LR'XXX,%r1             */
                    660: #define BE_SR4_R1      0xe0202002      /* be,n  RR'XXX(%sr4,%r1)       */
                    661:
                    662: #define BL_R1          0xe8200000      /* b,l   .+8,%r1                */
                    663: #define ADDIL_R1       0x28200000      /* addil LR'XXX,%r1,%r1         */
                    664: #define DEPI_R1                0xd4201c1e      /* depi  0,31,2,%r1             */
                    665:
                    666: #define ADDIL_DP       0x2b600000      /* addil LR'XXX,%dp,%r1         */
                    667: #define LDW_R1_R21     0x48350000      /* ldw   RR'XXX(%sr0,%r1),%r21  */
                    668: #define BV_R0_R21      0xeaa0c000      /* bv    %r0(%r21)              */
                    669: #define LDW_R1_R19     0x48330000      /* ldw   RR'XXX(%sr0,%r1),%r19  */
                    670:
                    671: #define ADDIL_R19      0x2a600000      /* addil LR'XXX,%r19,%r1        */
                    672: #define LDW_R1_DP      0x483b0000      /* ldw   RR'XXX(%sr0,%r1),%dp   */
                    673:
1.1.1.5 ! christos  674: #define LDO_R1_R22     0x34360000      /* ldo   RR'XXX(%r1),%r22       */
        !           675: #define LDW_R22_R21    0x0ec01095      /* ldw   0(%r22),%r21           */
        !           676: #define LDW_R22_R19    0x0ec81093      /* ldw   4(%r22),%r19           */
        !           677:
1.1       christos  678: #define LDSID_R21_R1   0x02a010a1      /* ldsid (%sr0,%r21),%r1        */
                    679: #define MTSP_R1                0x00011820      /* mtsp  %r1,%sr0               */
                    680: #define BE_SR0_R21     0xe2a00000      /* be    0(%sr0,%r21)           */
                    681: #define STW_RP         0x6bc23fd1      /* stw   %rp,-24(%sr0,%sp)      */
                    682:
                    683: #define BL22_RP                0xe800a002      /* b,l,n XXX,%rp                */
                    684: #define BL_RP          0xe8400002      /* b,l,n XXX,%rp                */
                    685: #define NOP            0x08000240      /* nop                          */
                    686: #define LDW_RP         0x4bc23fd1      /* ldw   -24(%sr0,%sp),%rp      */
                    687: #define LDSID_RP_R1    0x004010a1      /* ldsid (%sr0,%rp),%r1         */
                    688: #define BE_SR0_RP      0xe0400002      /* be,n  0(%sr0,%rp)            */
                    689:
                    690: #ifndef R19_STUBS
                    691: #define R19_STUBS 1
                    692: #endif
                    693:
                    694: #if R19_STUBS
                    695: #define LDW_R1_DLT     LDW_R1_R19
                    696: #else
                    697: #define LDW_R1_DLT     LDW_R1_DP
                    698: #endif
                    699:
                    700: static bfd_boolean
                    701: hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
                    702: {
                    703:   struct elf32_hppa_stub_hash_entry *hsh;
                    704:   struct bfd_link_info *info;
                    705:   struct elf32_hppa_link_hash_table *htab;
                    706:   asection *stub_sec;
                    707:   bfd *stub_bfd;
                    708:   bfd_byte *loc;
                    709:   bfd_vma sym_value;
                    710:   bfd_vma insn;
                    711:   bfd_vma off;
                    712:   int val;
                    713:   int size;
                    714:
                    715:   /* Massage our args to the form they really have.  */
                    716:   hsh = hppa_stub_hash_entry (bh);
                    717:   info = (struct bfd_link_info *)in_arg;
                    718:
                    719:   htab = hppa_link_hash_table (info);
                    720:   if (htab == NULL)
                    721:     return FALSE;
                    722:
                    723:   stub_sec = hsh->stub_sec;
                    724:
                    725:   /* Make a note of the offset within the stubs for this entry.  */
                    726:   hsh->stub_offset = stub_sec->size;
                    727:   loc = stub_sec->contents + hsh->stub_offset;
                    728:
                    729:   stub_bfd = stub_sec->owner;
                    730:
                    731:   switch (hsh->stub_type)
                    732:     {
                    733:     case hppa_stub_long_branch:
                    734:       /* Create the long branch.  A long branch is formed with "ldil"
                    735:         loading the upper bits of the target address into a register,
                    736:         then branching with "be" which adds in the lower bits.
                    737:         The "be" has its delay slot nullified.  */
                    738:       sym_value = (hsh->target_value
                    739:                   + hsh->target_section->output_offset
                    740:                   + hsh->target_section->output_section->vma);
                    741:
                    742:       val = hppa_field_adjust (sym_value, 0, e_lrsel);
                    743:       insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
                    744:       bfd_put_32 (stub_bfd, insn, loc);
                    745:
                    746:       val = hppa_field_adjust (sym_value, 0, e_rrsel) >> 2;
                    747:       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
                    748:       bfd_put_32 (stub_bfd, insn, loc + 4);
                    749:
1.1.1.5 ! christos  750:       size = LONG_BRANCH_STUB_SIZE;
1.1       christos  751:       break;
                    752:
                    753:     case hppa_stub_long_branch_shared:
                    754:       /* Branches are relative.  This is where we are going to.  */
                    755:       sym_value = (hsh->target_value
                    756:                   + hsh->target_section->output_offset
                    757:                   + hsh->target_section->output_section->vma);
                    758:
                    759:       /* And this is where we are coming from, more or less.  */
                    760:       sym_value -= (hsh->stub_offset
                    761:                    + stub_sec->output_offset
                    762:                    + stub_sec->output_section->vma);
                    763:
                    764:       bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc);
                    765:       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel);
                    766:       insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21);
                    767:       bfd_put_32 (stub_bfd, insn, loc + 4);
                    768:
                    769:       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
                    770:       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
                    771:       bfd_put_32 (stub_bfd, insn, loc + 8);
1.1.1.5 ! christos  772:       size = LONG_BRANCH_SHARED_STUB_SIZE;
1.1       christos  773:       break;
                    774:
                    775:     case hppa_stub_import:
                    776:     case hppa_stub_import_shared:
                    777:       off = hsh->hh->eh.plt.offset;
                    778:       if (off >= (bfd_vma) -2)
                    779:        abort ();
                    780:
                    781:       off &= ~ (bfd_vma) 1;
                    782:       sym_value = (off
1.1.1.4   christos  783:                   + htab->etab.splt->output_offset
                    784:                   + htab->etab.splt->output_section->vma
                    785:                   - elf_gp (htab->etab.splt->output_section->owner));
1.1       christos  786:
                    787:       insn = ADDIL_DP;
                    788: #if R19_STUBS
                    789:       if (hsh->stub_type == hppa_stub_import_shared)
                    790:        insn = ADDIL_R19;
                    791: #endif
1.1.1.5 ! christos  792:
        !           793:       /* Load function descriptor address into register %r22.  It is
        !           794:         sometimes needed for lazy binding.  */
1.1       christos  795:       val = hppa_field_adjust (sym_value, 0, e_lrsel),
                    796:       insn = hppa_rebuild_insn ((int) insn, val, 21);
                    797:       bfd_put_32 (stub_bfd, insn, loc);
                    798:
                    799:       val = hppa_field_adjust (sym_value, 0, e_rrsel);
1.1.1.5 ! christos  800:       insn = hppa_rebuild_insn ((int) LDO_R1_R22, val, 14);
1.1       christos  801:       bfd_put_32 (stub_bfd, insn, loc + 4);
                    802:
1.1.1.5 ! christos  803:       bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R21, loc + 8);
        !           804:
1.1       christos  805:       if (htab->multi_subspace)
                    806:        {
                    807:          bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
1.1.1.5 ! christos  808:          bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R19,  loc + 16);
        !           809:          bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,      loc + 20);
        !           810:          bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21,   loc + 24);
        !           811:          bfd_put_32 (stub_bfd, (bfd_vma) STW_RP,       loc + 28);
1.1       christos  812:
1.1.1.5 ! christos  813:          size = IMPORT_SHARED_STUB_SIZE;
1.1       christos  814:        }
                    815:       else
                    816:        {
1.1.1.5 ! christos  817:          bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 12);
        !           818:          bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R19, loc + 16);
1.1       christos  819:
1.1.1.5 ! christos  820:          size = IMPORT_STUB_SIZE;
1.1       christos  821:        }
                    822:
                    823:       break;
                    824:
                    825:     case hppa_stub_export:
                    826:       /* Branches are relative.  This is where we are going to.  */
                    827:       sym_value = (hsh->target_value
                    828:                   + hsh->target_section->output_offset
                    829:                   + hsh->target_section->output_section->vma);
                    830:
                    831:       /* And this is where we are coming from.  */
                    832:       sym_value -= (hsh->stub_offset
                    833:                    + stub_sec->output_offset
                    834:                    + stub_sec->output_section->vma);
                    835:
                    836:       if (sym_value - 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
                    837:          && (!htab->has_22bit_branch
                    838:              || sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
                    839:        {
1.1.1.4   christos  840:          _bfd_error_handler
                    841:            /* xgettext:c-format */
                    842:            (_("%pB(%pA+%#" PRIx64 "): "
                    843:               "cannot reach %s, recompile with -ffunction-sections"),
1.1       christos  844:             hsh->target_section->owner,
                    845:             stub_sec,
1.1.1.4   christos  846:             (uint64_t) hsh->stub_offset,
1.1       christos  847:             hsh->bh_root.string);
                    848:          bfd_set_error (bfd_error_bad_value);
                    849:          return FALSE;
                    850:        }
                    851:
                    852:       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
                    853:       if (!htab->has_22bit_branch)
                    854:        insn = hppa_rebuild_insn ((int) BL_RP, val, 17);
                    855:       else
                    856:        insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
                    857:       bfd_put_32 (stub_bfd, insn, loc);
                    858:
1.1.1.4   christos  859:       bfd_put_32 (stub_bfd, (bfd_vma) NOP,        loc + 4);
1.1       christos  860:       bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP,      loc + 8);
                    861:       bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
                    862:       bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,     loc + 16);
                    863:       bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP,   loc + 20);
                    864:
                    865:       /* Point the function symbol at the stub.  */
                    866:       hsh->hh->eh.root.u.def.section = stub_sec;
                    867:       hsh->hh->eh.root.u.def.value = stub_sec->size;
                    868:
1.1.1.5 ! christos  869:       size = EXPORT_STUB_SIZE;
1.1       christos  870:       break;
                    871:
                    872:     default:
                    873:       BFD_FAIL ();
                    874:       return FALSE;
                    875:     }
                    876:
                    877:   stub_sec->size += size;
                    878:   return TRUE;
                    879: }
                    880:
                    881: #undef LDIL_R1
                    882: #undef BE_SR4_R1
                    883: #undef BL_R1
                    884: #undef ADDIL_R1
                    885: #undef DEPI_R1
                    886: #undef LDW_R1_R21
                    887: #undef LDW_R1_DLT
                    888: #undef LDW_R1_R19
                    889: #undef ADDIL_R19
                    890: #undef LDW_R1_DP
                    891: #undef LDSID_R21_R1
                    892: #undef MTSP_R1
                    893: #undef BE_SR0_R21
                    894: #undef STW_RP
                    895: #undef BV_R0_R21
                    896: #undef BL_RP
                    897: #undef NOP
                    898: #undef LDW_RP
                    899: #undef LDSID_RP_R1
                    900: #undef BE_SR0_RP
                    901:
                    902: /* As above, but don't actually build the stub.  Just bump offset so
                    903:    we know stub section sizes.  */
                    904:
                    905: static bfd_boolean
                    906: hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
                    907: {
                    908:   struct elf32_hppa_stub_hash_entry *hsh;
                    909:   struct elf32_hppa_link_hash_table *htab;
                    910:   int size;
                    911:
                    912:   /* Massage our args to the form they really have.  */
                    913:   hsh = hppa_stub_hash_entry (bh);
                    914:   htab = in_arg;
                    915:
                    916:   if (hsh->stub_type == hppa_stub_long_branch)
1.1.1.5 ! christos  917:     size = LONG_BRANCH_STUB_SIZE;
1.1       christos  918:   else if (hsh->stub_type == hppa_stub_long_branch_shared)
1.1.1.5 ! christos  919:     size = LONG_BRANCH_SHARED_STUB_SIZE;
1.1       christos  920:   else if (hsh->stub_type == hppa_stub_export)
1.1.1.5 ! christos  921:     size = EXPORT_STUB_SIZE;
1.1       christos  922:   else /* hppa_stub_import or hppa_stub_import_shared.  */
                    923:     {
                    924:       if (htab->multi_subspace)
1.1.1.5 ! christos  925:        size = IMPORT_SHARED_STUB_SIZE;
1.1       christos  926:       else
1.1.1.5 ! christos  927:        size = IMPORT_STUB_SIZE;
1.1       christos  928:     }
                    929:
                    930:   hsh->stub_sec->size += size;
                    931:   return TRUE;
                    932: }
                    933:
                    934: /* Return nonzero if ABFD represents an HPPA ELF32 file.
                    935:    Additionally we set the default architecture and machine.  */
                    936:
                    937: static bfd_boolean
                    938: elf32_hppa_object_p (bfd *abfd)
                    939: {
                    940:   Elf_Internal_Ehdr * i_ehdrp;
                    941:   unsigned int flags;
                    942:
                    943:   i_ehdrp = elf_elfheader (abfd);
                    944:   if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
                    945:     {
                    946:       /* GCC on hppa-linux produces binaries with OSABI=GNU,
                    947:         but the kernel produces corefiles with OSABI=SysV.  */
                    948:       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU &&
                    949:          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
                    950:        return FALSE;
                    951:     }
                    952:   else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
                    953:     {
                    954:       /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD,
                    955:         but the kernel produces corefiles with OSABI=SysV.  */
                    956:       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD &&
                    957:          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
                    958:        return FALSE;
                    959:     }
                    960:   else
                    961:     {
                    962:       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
                    963:        return FALSE;
                    964:     }
                    965:
                    966:   flags = i_ehdrp->e_flags;
                    967:   switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
                    968:     {
                    969:     case EFA_PARISC_1_0:
                    970:       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
                    971:     case EFA_PARISC_1_1:
                    972:       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
                    973:     case EFA_PARISC_2_0:
                    974:       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
                    975:     case EFA_PARISC_2_0 | EF_PARISC_WIDE:
                    976:       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
                    977:     }
                    978:   return TRUE;
                    979: }
                    980:
                    981: /* Create the .plt and .got sections, and set up our hash table
                    982:    short-cuts to various dynamic sections.  */
                    983:
                    984: static bfd_boolean
                    985: elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
                    986: {
                    987:   struct elf32_hppa_link_hash_table *htab;
                    988:   struct elf_link_hash_entry *eh;
                    989:
                    990:   /* Don't try to create the .plt and .got twice.  */
                    991:   htab = hppa_link_hash_table (info);
                    992:   if (htab == NULL)
                    993:     return FALSE;
1.1.1.4   christos  994:   if (htab->etab.splt != NULL)
1.1       christos  995:     return TRUE;
                    996:
                    997:   /* Call the generic code to do most of the work.  */
                    998:   if (! _bfd_elf_create_dynamic_sections (abfd, info))
                    999:     return FALSE;
                   1000:
                   1001:   /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
                   1002:      application, because __canonicalize_funcptr_for_compare needs it.  */
                   1003:   eh = elf_hash_table (info)->hgot;
                   1004:   eh->forced_local = 0;
                   1005:   eh->other = STV_DEFAULT;
                   1006:   return bfd_elf_link_record_dynamic_symbol (info, eh);
                   1007: }
                   1008:
                   1009: /* Copy the extra info we tack onto an elf_link_hash_entry.  */
                   1010:
                   1011: static void
                   1012: elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info,
                   1013:                                 struct elf_link_hash_entry *eh_dir,
                   1014:                                 struct elf_link_hash_entry *eh_ind)
                   1015: {
                   1016:   struct elf32_hppa_link_hash_entry *hh_dir, *hh_ind;
                   1017:
                   1018:   hh_dir = hppa_elf_hash_entry (eh_dir);
                   1019:   hh_ind = hppa_elf_hash_entry (eh_ind);
                   1020:
1.1.1.4   christos 1021:   if (hh_ind->dyn_relocs != NULL
                   1022:       && eh_ind->root.type == bfd_link_hash_indirect)
1.1       christos 1023:     {
                   1024:       if (hh_dir->dyn_relocs != NULL)
                   1025:        {
1.1.1.4   christos 1026:          struct elf_dyn_relocs **hdh_pp;
                   1027:          struct elf_dyn_relocs *hdh_p;
1.1       christos 1028:
                   1029:          /* Add reloc counts against the indirect sym to the direct sym
                   1030:             list.  Merge any entries against the same section.  */
                   1031:          for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
                   1032:            {
1.1.1.4   christos 1033:              struct elf_dyn_relocs *hdh_q;
1.1       christos 1034:
                   1035:              for (hdh_q = hh_dir->dyn_relocs;
                   1036:                   hdh_q != NULL;
1.1.1.4   christos 1037:                   hdh_q = hdh_q->next)
1.1       christos 1038:                if (hdh_q->sec == hdh_p->sec)
                   1039:                  {
                   1040: #if RELATIVE_DYNRELOCS
1.1.1.4   christos 1041:                    hdh_q->pc_count += hdh_p->pc_count;
1.1       christos 1042: #endif
                   1043:                    hdh_q->count += hdh_p->count;
1.1.1.4   christos 1044:                    *hdh_pp = hdh_p->next;
1.1       christos 1045:                    break;
                   1046:                  }
                   1047:              if (hdh_q == NULL)
1.1.1.4   christos 1048:                hdh_pp = &hdh_p->next;
1.1       christos 1049:            }
                   1050:          *hdh_pp = hh_dir->dyn_relocs;
                   1051:        }
                   1052:
                   1053:       hh_dir->dyn_relocs = hh_ind->dyn_relocs;
                   1054:       hh_ind->dyn_relocs = NULL;
                   1055:     }
                   1056:
1.1.1.4   christos 1057:   if (eh_ind->root.type == bfd_link_hash_indirect)
1.1       christos 1058:     {
1.1.1.4   christos 1059:       hh_dir->plabel |= hh_ind->plabel;
                   1060:       hh_dir->tls_type |= hh_ind->tls_type;
                   1061:       hh_ind->tls_type = GOT_UNKNOWN;
1.1       christos 1062:     }
                   1063:
1.1.1.4   christos 1064:   _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
1.1       christos 1065: }
                   1066:
                   1067: static int
                   1068: elf32_hppa_optimized_tls_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
                   1069:                                int r_type, int is_local ATTRIBUTE_UNUSED)
                   1070: {
                   1071:   /* For now we don't support linker optimizations.  */
                   1072:   return r_type;
                   1073: }
                   1074:
                   1075: /* Return a pointer to the local GOT, PLT and TLS reference counts
                   1076:    for ABFD.  Returns NULL if the storage allocation fails.  */
                   1077:
                   1078: static bfd_signed_vma *
                   1079: hppa32_elf_local_refcounts (bfd *abfd)
                   1080: {
                   1081:   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
                   1082:   bfd_signed_vma *local_refcounts;
1.1.1.2   christos 1083:
1.1       christos 1084:   local_refcounts = elf_local_got_refcounts (abfd);
                   1085:   if (local_refcounts == NULL)
                   1086:     {
                   1087:       bfd_size_type size;
                   1088:
                   1089:       /* Allocate space for local GOT and PLT reference
                   1090:         counts.  Done this way to save polluting elf_obj_tdata
                   1091:         with another target specific pointer.  */
                   1092:       size = symtab_hdr->sh_info;
                   1093:       size *= 2 * sizeof (bfd_signed_vma);
                   1094:       /* Add in space to store the local GOT TLS types.  */
                   1095:       size += symtab_hdr->sh_info;
                   1096:       local_refcounts = bfd_zalloc (abfd, size);
                   1097:       if (local_refcounts == NULL)
                   1098:        return NULL;
                   1099:       elf_local_got_refcounts (abfd) = local_refcounts;
                   1100:       memset (hppa_elf_local_got_tls_type (abfd), GOT_UNKNOWN,
                   1101:              symtab_hdr->sh_info);
                   1102:     }
                   1103:   return local_refcounts;
                   1104: }
                   1105:
                   1106:
                   1107: /* Look through the relocs for a section during the first phase, and
                   1108:    calculate needed space in the global offset table, procedure linkage
                   1109:    table, and dynamic reloc sections.  At this point we haven't
                   1110:    necessarily read all the input files.  */
                   1111:
                   1112: static bfd_boolean
                   1113: elf32_hppa_check_relocs (bfd *abfd,
                   1114:                         struct bfd_link_info *info,
                   1115:                         asection *sec,
                   1116:                         const Elf_Internal_Rela *relocs)
                   1117: {
                   1118:   Elf_Internal_Shdr *symtab_hdr;
                   1119:   struct elf_link_hash_entry **eh_syms;
                   1120:   const Elf_Internal_Rela *rela;
                   1121:   const Elf_Internal_Rela *rela_end;
                   1122:   struct elf32_hppa_link_hash_table *htab;
                   1123:   asection *sreloc;
                   1124:
1.1.1.2   christos 1125:   if (bfd_link_relocatable (info))
1.1       christos 1126:     return TRUE;
                   1127:
                   1128:   htab = hppa_link_hash_table (info);
                   1129:   if (htab == NULL)
                   1130:     return FALSE;
                   1131:   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
                   1132:   eh_syms = elf_sym_hashes (abfd);
                   1133:   sreloc = NULL;
                   1134:
                   1135:   rela_end = relocs + sec->reloc_count;
                   1136:   for (rela = relocs; rela < rela_end; rela++)
                   1137:     {
                   1138:       enum {
                   1139:        NEED_GOT = 1,
                   1140:        NEED_PLT = 2,
                   1141:        NEED_DYNREL = 4,
                   1142:        PLT_PLABEL = 8
                   1143:       };
                   1144:
                   1145:       unsigned int r_symndx, r_type;
                   1146:       struct elf32_hppa_link_hash_entry *hh;
                   1147:       int need_entry = 0;
                   1148:
                   1149:       r_symndx = ELF32_R_SYM (rela->r_info);
                   1150:
                   1151:       if (r_symndx < symtab_hdr->sh_info)
                   1152:        hh = NULL;
                   1153:       else
                   1154:        {
                   1155:          hh =  hppa_elf_hash_entry (eh_syms[r_symndx - symtab_hdr->sh_info]);
                   1156:          while (hh->eh.root.type == bfd_link_hash_indirect
                   1157:                 || hh->eh.root.type == bfd_link_hash_warning)
                   1158:            hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
                   1159:        }
                   1160:
                   1161:       r_type = ELF32_R_TYPE (rela->r_info);
                   1162:       r_type = elf32_hppa_optimized_tls_reloc (info, r_type, hh == NULL);
                   1163:
                   1164:       switch (r_type)
                   1165:        {
                   1166:        case R_PARISC_DLTIND14F:
                   1167:        case R_PARISC_DLTIND14R:
                   1168:        case R_PARISC_DLTIND21L:
                   1169:          /* This symbol requires a global offset table entry.  */
                   1170:          need_entry = NEED_GOT;
                   1171:          break;
                   1172:
                   1173:        case R_PARISC_PLABEL14R: /* "Official" procedure labels.  */
                   1174:        case R_PARISC_PLABEL21L:
                   1175:        case R_PARISC_PLABEL32:
                   1176:          /* If the addend is non-zero, we break badly.  */
                   1177:          if (rela->r_addend != 0)
                   1178:            abort ();
                   1179:
                   1180:          /* If we are creating a shared library, then we need to
                   1181:             create a PLT entry for all PLABELs, because PLABELs with
                   1182:             local symbols may be passed via a pointer to another
                   1183:             object.  Additionally, output a dynamic relocation
                   1184:             pointing to the PLT entry.
                   1185:
                   1186:             For executables, the original 32-bit ABI allowed two
                   1187:             different styles of PLABELs (function pointers):  For
                   1188:             global functions, the PLABEL word points into the .plt
                   1189:             two bytes past a (function address, gp) pair, and for
                   1190:             local functions the PLABEL points directly at the
                   1191:             function.  The magic +2 for the first type allows us to
                   1192:             differentiate between the two.  As you can imagine, this
                   1193:             is a real pain when it comes to generating code to call
                   1194:             functions indirectly or to compare function pointers.
                   1195:             We avoid the mess by always pointing a PLABEL into the
                   1196:             .plt, even for local functions.  */
1.1.1.4   christos 1197:          need_entry = PLT_PLABEL | NEED_PLT;
                   1198:          if (bfd_link_pic (info))
                   1199:            need_entry |= NEED_DYNREL;
1.1       christos 1200:          break;
                   1201:
                   1202:        case R_PARISC_PCREL12F:
                   1203:          htab->has_12bit_branch = 1;
                   1204:          goto branch_common;
                   1205:
                   1206:        case R_PARISC_PCREL17C:
                   1207:        case R_PARISC_PCREL17F:
                   1208:          htab->has_17bit_branch = 1;
                   1209:          goto branch_common;
                   1210:
                   1211:        case R_PARISC_PCREL22F:
                   1212:          htab->has_22bit_branch = 1;
                   1213:        branch_common:
                   1214:          /* Function calls might need to go through the .plt, and
                   1215:             might require long branch stubs.  */
                   1216:          if (hh == NULL)
                   1217:            {
                   1218:              /* We know local syms won't need a .plt entry, and if
                   1219:                 they need a long branch stub we can't guarantee that
                   1220:                 we can reach the stub.  So just flag an error later
                   1221:                 if we're doing a shared link and find we need a long
                   1222:                 branch stub.  */
                   1223:              continue;
                   1224:            }
                   1225:          else
                   1226:            {
                   1227:              /* Global symbols will need a .plt entry if they remain
                   1228:                 global, and in most cases won't need a long branch
                   1229:                 stub.  Unfortunately, we have to cater for the case
                   1230:                 where a symbol is forced local by versioning, or due
                   1231:                 to symbolic linking, and we lose the .plt entry.  */
                   1232:              need_entry = NEED_PLT;
                   1233:              if (hh->eh.type == STT_PARISC_MILLI)
                   1234:                need_entry = 0;
                   1235:            }
                   1236:          break;
                   1237:
                   1238:        case R_PARISC_SEGBASE:  /* Used to set segment base.  */
                   1239:        case R_PARISC_SEGREL32: /* Relative reloc, used for unwind.  */
                   1240:        case R_PARISC_PCREL14F: /* PC relative load/store.  */
                   1241:        case R_PARISC_PCREL14R:
                   1242:        case R_PARISC_PCREL17R: /* External branches.  */
                   1243:        case R_PARISC_PCREL21L: /* As above, and for load/store too.  */
                   1244:        case R_PARISC_PCREL32:
                   1245:          /* We don't need to propagate the relocation if linking a
                   1246:             shared object since these are section relative.  */
                   1247:          continue;
                   1248:
                   1249:        case R_PARISC_DPREL14F: /* Used for gp rel data load/store.  */
                   1250:        case R_PARISC_DPREL14R:
                   1251:        case R_PARISC_DPREL21L:
1.1.1.2   christos 1252:          if (bfd_link_pic (info))
1.1       christos 1253:            {
1.1.1.4   christos 1254:              _bfd_error_handler
                   1255:                /* xgettext:c-format */
                   1256:                (_("%pB: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1.1       christos 1257:                 abfd,
                   1258:                 elf_hppa_howto_table[r_type].name);
                   1259:              bfd_set_error (bfd_error_bad_value);
                   1260:              return FALSE;
                   1261:            }
                   1262:          /* Fall through.  */
                   1263:
                   1264:        case R_PARISC_DIR17F: /* Used for external branches.  */
                   1265:        case R_PARISC_DIR17R:
                   1266:        case R_PARISC_DIR14F: /* Used for load/store from absolute locn.  */
                   1267:        case R_PARISC_DIR14R:
                   1268:        case R_PARISC_DIR21L: /* As above, and for ext branches too.  */
                   1269:        case R_PARISC_DIR32: /* .word relocs.  */
                   1270:          /* We may want to output a dynamic relocation later.  */
                   1271:          need_entry = NEED_DYNREL;
                   1272:          break;
                   1273:
                   1274:          /* This relocation describes the C++ object vtable hierarchy.
                   1275:             Reconstruct it for later use during GC.  */
                   1276:        case R_PARISC_GNU_VTINHERIT:
                   1277:          if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))
                   1278:            return FALSE;
                   1279:          continue;
                   1280:
                   1281:          /* This relocation describes which C++ vtable entries are actually
                   1282:             used.  Record for later use during GC.  */
                   1283:        case R_PARISC_GNU_VTENTRY:
1.1.1.5 ! christos 1284:          if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
1.1       christos 1285:            return FALSE;
                   1286:          continue;
                   1287:
                   1288:        case R_PARISC_TLS_GD21L:
                   1289:        case R_PARISC_TLS_GD14R:
                   1290:        case R_PARISC_TLS_LDM21L:
                   1291:        case R_PARISC_TLS_LDM14R:
                   1292:          need_entry = NEED_GOT;
                   1293:          break;
                   1294:
                   1295:        case R_PARISC_TLS_IE21L:
                   1296:        case R_PARISC_TLS_IE14R:
1.1.1.4   christos 1297:          if (bfd_link_dll (info))
                   1298:            info->flags |= DF_STATIC_TLS;
1.1       christos 1299:          need_entry = NEED_GOT;
                   1300:          break;
                   1301:
                   1302:        default:
                   1303:          continue;
                   1304:        }
                   1305:
                   1306:       /* Now carry out our orders.  */
                   1307:       if (need_entry & NEED_GOT)
                   1308:        {
1.1.1.4   christos 1309:          int tls_type = GOT_NORMAL;
                   1310:
1.1       christos 1311:          switch (r_type)
                   1312:            {
                   1313:            default:
                   1314:              break;
                   1315:            case R_PARISC_TLS_GD21L:
                   1316:            case R_PARISC_TLS_GD14R:
1.1.1.4   christos 1317:              tls_type = GOT_TLS_GD;
1.1       christos 1318:              break;
                   1319:            case R_PARISC_TLS_LDM21L:
                   1320:            case R_PARISC_TLS_LDM14R:
1.1.1.4   christos 1321:              tls_type = GOT_TLS_LDM;
1.1       christos 1322:              break;
                   1323:            case R_PARISC_TLS_IE21L:
                   1324:            case R_PARISC_TLS_IE14R:
1.1.1.4   christos 1325:              tls_type = GOT_TLS_IE;
1.1       christos 1326:              break;
                   1327:            }
                   1328:
                   1329:          /* Allocate space for a GOT entry, as well as a dynamic
                   1330:             relocation for this entry.  */
1.1.1.4   christos 1331:          if (htab->etab.sgot == NULL)
1.1       christos 1332:            {
                   1333:              if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
                   1334:                return FALSE;
                   1335:            }
                   1336:
1.1.1.4   christos 1337:          if (hh != NULL)
1.1       christos 1338:            {
1.1.1.4   christos 1339:              if (tls_type == GOT_TLS_LDM)
                   1340:                htab->tls_ldm_got.refcount += 1;
1.1       christos 1341:              else
1.1.1.4   christos 1342:                hh->eh.got.refcount += 1;
                   1343:              hh->tls_type |= tls_type;
                   1344:            }
                   1345:          else
                   1346:            {
                   1347:              bfd_signed_vma *local_got_refcounts;
1.1       christos 1348:
1.1.1.4   christos 1349:              /* This is a global offset table entry for a local symbol.  */
                   1350:              local_got_refcounts = hppa32_elf_local_refcounts (abfd);
                   1351:              if (local_got_refcounts == NULL)
                   1352:                return FALSE;
                   1353:              if (tls_type == GOT_TLS_LDM)
                   1354:                htab->tls_ldm_got.refcount += 1;
                   1355:              else
                   1356:                local_got_refcounts[r_symndx] += 1;
1.1       christos 1357:
1.1.1.4   christos 1358:              hppa_elf_local_got_tls_type (abfd) [r_symndx] |= tls_type;
1.1       christos 1359:            }
                   1360:        }
                   1361:
                   1362:       if (need_entry & NEED_PLT)
                   1363:        {
                   1364:          /* If we are creating a shared library, and this is a reloc
                   1365:             against a weak symbol or a global symbol in a dynamic
                   1366:             object, then we will be creating an import stub and a
                   1367:             .plt entry for the symbol.  Similarly, on a normal link
                   1368:             to symbols defined in a dynamic object we'll need the
                   1369:             import stub and a .plt entry.  We don't know yet whether
                   1370:             the symbol is defined or not, so make an entry anyway and
                   1371:             clean up later in adjust_dynamic_symbol.  */
                   1372:          if ((sec->flags & SEC_ALLOC) != 0)
                   1373:            {
                   1374:              if (hh != NULL)
                   1375:                {
                   1376:                  hh->eh.needs_plt = 1;
                   1377:                  hh->eh.plt.refcount += 1;
                   1378:
                   1379:                  /* If this .plt entry is for a plabel, mark it so
                   1380:                     that adjust_dynamic_symbol will keep the entry
                   1381:                     even if it appears to be local.  */
                   1382:                  if (need_entry & PLT_PLABEL)
                   1383:                    hh->plabel = 1;
                   1384:                }
                   1385:              else if (need_entry & PLT_PLABEL)
                   1386:                {
                   1387:                  bfd_signed_vma *local_got_refcounts;
                   1388:                  bfd_signed_vma *local_plt_refcounts;
                   1389:
                   1390:                  local_got_refcounts = hppa32_elf_local_refcounts (abfd);
                   1391:                  if (local_got_refcounts == NULL)
                   1392:                    return FALSE;
                   1393:                  local_plt_refcounts = (local_got_refcounts
                   1394:                                         + symtab_hdr->sh_info);
                   1395:                  local_plt_refcounts[r_symndx] += 1;
                   1396:                }
                   1397:            }
                   1398:        }
                   1399:
1.1.1.4   christos 1400:       if ((need_entry & NEED_DYNREL) != 0
                   1401:          && (sec->flags & SEC_ALLOC) != 0)
1.1       christos 1402:        {
                   1403:          /* Flag this symbol as having a non-got, non-plt reference
                   1404:             so that we generate copy relocs if it turns out to be
                   1405:             dynamic.  */
1.1.1.4   christos 1406:          if (hh != NULL)
1.1       christos 1407:            hh->eh.non_got_ref = 1;
                   1408:
                   1409:          /* If we are creating a shared library then we need to copy
                   1410:             the reloc into the shared library.  However, if we are
                   1411:             linking with -Bsymbolic, we need only copy absolute
                   1412:             relocs or relocs against symbols that are not defined in
                   1413:             an object we are including in the link.  PC- or DP- or
                   1414:             DLT-relative relocs against any local sym or global sym
                   1415:             with DEF_REGULAR set, can be discarded.  At this point we
                   1416:             have not seen all the input files, so it is possible that
                   1417:             DEF_REGULAR is not set now but will be set later (it is
                   1418:             never cleared).  We account for that possibility below by
                   1419:             storing information in the dyn_relocs field of the
                   1420:             hash table entry.
                   1421:
                   1422:             A similar situation to the -Bsymbolic case occurs when
                   1423:             creating shared libraries and symbol visibility changes
                   1424:             render the symbol local.
                   1425:
                   1426:             As it turns out, all the relocs we will be creating here
                   1427:             are absolute, so we cannot remove them on -Bsymbolic
                   1428:             links or visibility changes anyway.  A STUB_REL reloc
                   1429:             is absolute too, as in that case it is the reloc in the
                   1430:             stub we will be creating, rather than copying the PCREL
                   1431:             reloc in the branch.
                   1432:
                   1433:             If on the other hand, we are creating an executable, we
                   1434:             may need to keep relocations for symbols satisfied by a
                   1435:             dynamic library if we manage to avoid copy relocs for the
                   1436:             symbol.  */
1.1.1.2   christos 1437:          if ((bfd_link_pic (info)
1.1       christos 1438:               && (IS_ABSOLUTE_RELOC (r_type)
                   1439:                   || (hh != NULL
1.1.1.2   christos 1440:                       && (!SYMBOLIC_BIND (info, &hh->eh)
1.1       christos 1441:                           || hh->eh.root.type == bfd_link_hash_defweak
                   1442:                           || !hh->eh.def_regular))))
                   1443:              || (ELIMINATE_COPY_RELOCS
1.1.1.2   christos 1444:                  && !bfd_link_pic (info)
1.1       christos 1445:                  && hh != NULL
                   1446:                  && (hh->eh.root.type == bfd_link_hash_defweak
                   1447:                      || !hh->eh.def_regular)))
                   1448:            {
1.1.1.4   christos 1449:              struct elf_dyn_relocs *hdh_p;
                   1450:              struct elf_dyn_relocs **hdh_head;
1.1       christos 1451:
                   1452:              /* Create a reloc section in dynobj and make room for
                   1453:                 this reloc.  */
                   1454:              if (sreloc == NULL)
                   1455:                {
                   1456:                  sreloc = _bfd_elf_make_dynamic_reloc_section
                   1457:                    (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
                   1458:
                   1459:                  if (sreloc == NULL)
                   1460:                    {
                   1461:                      bfd_set_error (bfd_error_bad_value);
                   1462:                      return FALSE;
                   1463:                    }
                   1464:                }
                   1465:
                   1466:              /* If this is a global symbol, we count the number of
                   1467:                 relocations we need for this symbol.  */
                   1468:              if (hh != NULL)
                   1469:                {
                   1470:                  hdh_head = &hh->dyn_relocs;
                   1471:                }
                   1472:              else
                   1473:                {
                   1474:                  /* Track dynamic relocs needed for local syms too.
                   1475:                     We really need local syms available to do this
                   1476:                     easily.  Oh well.  */
                   1477:                  asection *sr;
                   1478:                  void *vpp;
                   1479:                  Elf_Internal_Sym *isym;
                   1480:
                   1481:                  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
                   1482:                                                abfd, r_symndx);
                   1483:                  if (isym == NULL)
                   1484:                    return FALSE;
                   1485:
                   1486:                  sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
                   1487:                  if (sr == NULL)
                   1488:                    sr = sec;
                   1489:
                   1490:                  vpp = &elf_section_data (sr)->local_dynrel;
1.1.1.4   christos 1491:                  hdh_head = (struct elf_dyn_relocs **) vpp;
1.1       christos 1492:                }
                   1493:
                   1494:              hdh_p = *hdh_head;
                   1495:              if (hdh_p == NULL || hdh_p->sec != sec)
                   1496:                {
                   1497:                  hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
                   1498:                  if (hdh_p == NULL)
                   1499:                    return FALSE;
1.1.1.4   christos 1500:                  hdh_p->next = *hdh_head;
1.1       christos 1501:                  *hdh_head = hdh_p;
                   1502:                  hdh_p->sec = sec;
                   1503:                  hdh_p->count = 0;
                   1504: #if RELATIVE_DYNRELOCS
1.1.1.4   christos 1505:                  hdh_p->pc_count = 0;
1.1       christos 1506: #endif
                   1507:                }
                   1508:
                   1509:              hdh_p->count += 1;
                   1510: #if RELATIVE_DYNRELOCS
                   1511:              if (!IS_ABSOLUTE_RELOC (rtype))
1.1.1.4   christos 1512:                hdh_p->pc_count += 1;
1.1       christos 1513: #endif
                   1514:            }
                   1515:        }
                   1516:     }
                   1517:
                   1518:   return TRUE;
                   1519: }
                   1520:
                   1521: /* Return the section that should be marked against garbage collection
                   1522:    for a given relocation.  */
                   1523:
                   1524: static asection *
                   1525: elf32_hppa_gc_mark_hook (asection *sec,
                   1526:                         struct bfd_link_info *info,
                   1527:                         Elf_Internal_Rela *rela,
                   1528:                         struct elf_link_hash_entry *hh,
                   1529:                         Elf_Internal_Sym *sym)
                   1530: {
                   1531:   if (hh != NULL)
                   1532:     switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
                   1533:       {
                   1534:       case R_PARISC_GNU_VTINHERIT:
                   1535:       case R_PARISC_GNU_VTENTRY:
                   1536:        return NULL;
                   1537:       }
                   1538:
                   1539:   return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
                   1540: }
                   1541:
                   1542: /* Support for core dump NOTE sections.  */
                   1543:
                   1544: static bfd_boolean
                   1545: elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
                   1546: {
                   1547:   int offset;
                   1548:   size_t size;
                   1549:
                   1550:   switch (note->descsz)
                   1551:     {
                   1552:       default:
                   1553:        return FALSE;
                   1554:
                   1555:       case 396:                /* Linux/hppa */
                   1556:        /* pr_cursig */
1.1.1.2   christos 1557:        elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1.1       christos 1558:
                   1559:        /* pr_pid */
1.1.1.2   christos 1560:        elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
1.1       christos 1561:
                   1562:        /* pr_reg */
                   1563:        offset = 72;
                   1564:        size = 320;
                   1565:
                   1566:        break;
                   1567:     }
                   1568:
                   1569:   /* Make a ".reg/999" section.  */
                   1570:   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
                   1571:                                          size, note->descpos + offset);
                   1572: }
                   1573:
                   1574: static bfd_boolean
                   1575: elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
                   1576: {
                   1577:   switch (note->descsz)
                   1578:     {
                   1579:       default:
                   1580:        return FALSE;
                   1581:
                   1582:       case 124:                /* Linux/hppa elf_prpsinfo.  */
1.1.1.2   christos 1583:        elf_tdata (abfd)->core->program
1.1       christos 1584:          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1.1.1.2   christos 1585:        elf_tdata (abfd)->core->command
1.1       christos 1586:          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
                   1587:     }
                   1588:
                   1589:   /* Note that for some reason, a spurious space is tacked
                   1590:      onto the end of the args in some (at least one anyway)
                   1591:      implementations, so strip it off if it exists.  */
                   1592:   {
1.1.1.2   christos 1593:     char *command = elf_tdata (abfd)->core->command;
1.1       christos 1594:     int n = strlen (command);
                   1595:
                   1596:     if (0 < n && command[n - 1] == ' ')
                   1597:       command[n - 1] = '\0';
                   1598:   }
                   1599:
                   1600:   return TRUE;
                   1601: }
                   1602:
                   1603: /* Our own version of hide_symbol, so that we can keep plt entries for
                   1604:    plabels.  */
                   1605:
                   1606: static void
                   1607: elf32_hppa_hide_symbol (struct bfd_link_info *info,
                   1608:                        struct elf_link_hash_entry *eh,
                   1609:                        bfd_boolean force_local)
                   1610: {
                   1611:   if (force_local)
                   1612:     {
                   1613:       eh->forced_local = 1;
                   1614:       if (eh->dynindx != -1)
                   1615:        {
                   1616:          eh->dynindx = -1;
                   1617:          _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
                   1618:                                  eh->dynstr_index);
                   1619:        }
1.1.1.2   christos 1620:
                   1621:       /* PR 16082: Remove version information from hidden symbol.  */
                   1622:       eh->verinfo.verdef = NULL;
                   1623:       eh->verinfo.vertree = NULL;
1.1       christos 1624:     }
                   1625:
                   1626:   /* STT_GNU_IFUNC symbol must go through PLT.  */
                   1627:   if (! hppa_elf_hash_entry (eh)->plabel
                   1628:       && eh->type != STT_GNU_IFUNC)
                   1629:     {
                   1630:       eh->needs_plt = 0;
                   1631:       eh->plt = elf_hash_table (info)->init_plt_offset;
                   1632:     }
                   1633: }
                   1634:
1.1.1.4   christos 1635: /* Find any dynamic relocs that apply to read-only sections.  */
                   1636:
                   1637: static asection *
                   1638: readonly_dynrelocs (struct elf_link_hash_entry *eh)
                   1639: {
                   1640:   struct elf32_hppa_link_hash_entry *hh;
                   1641:   struct elf_dyn_relocs *hdh_p;
                   1642:
                   1643:   hh = hppa_elf_hash_entry (eh);
                   1644:   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
                   1645:     {
                   1646:       asection *sec = hdh_p->sec->output_section;
                   1647:
                   1648:       if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
                   1649:        return hdh_p->sec;
                   1650:     }
                   1651:   return NULL;
                   1652: }
                   1653:
                   1654: /* Return true if we have dynamic relocs against H or any of its weak
                   1655:    aliases, that apply to read-only sections.  Cannot be used after
                   1656:    size_dynamic_sections.  */
                   1657:
                   1658: static bfd_boolean
                   1659: alias_readonly_dynrelocs (struct elf_link_hash_entry *eh)
                   1660: {
                   1661:   struct elf32_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
                   1662:   do
                   1663:     {
                   1664:       if (readonly_dynrelocs (&hh->eh))
                   1665:        return TRUE;
                   1666:       hh = hppa_elf_hash_entry (hh->eh.u.alias);
                   1667:     } while (hh != NULL && &hh->eh != eh);
                   1668:
                   1669:   return FALSE;
                   1670: }
                   1671:
1.1       christos 1672: /* Adjust a symbol defined by a dynamic object and referenced by a
                   1673:    regular object.  The current definition is in some section of the
                   1674:    dynamic object, but we're not including those sections.  We have to
                   1675:    change the definition to something the rest of the link can
                   1676:    understand.  */
                   1677:
                   1678: static bfd_boolean
                   1679: elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
                   1680:                                  struct elf_link_hash_entry *eh)
                   1681: {
                   1682:   struct elf32_hppa_link_hash_table *htab;
1.1.1.4   christos 1683:   asection *sec, *srel;
1.1       christos 1684:
                   1685:   /* If this is a function, put it in the procedure linkage table.  We
                   1686:      will fill in the contents of the procedure linkage table later.  */
                   1687:   if (eh->type == STT_FUNC
                   1688:       || eh->needs_plt)
                   1689:     {
1.1.1.4   christos 1690:       bfd_boolean local = (SYMBOL_CALLS_LOCAL (info, eh)
                   1691:                           || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh));
                   1692:       /* Discard dyn_relocs when non-pic if we've decided that a
                   1693:         function symbol is local.  */
                   1694:       if (!bfd_link_pic (info) && local)
                   1695:        hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
                   1696:
1.1       christos 1697:       /* If the symbol is used by a plabel, we must allocate a PLT slot.
                   1698:         The refcounts are not reliable when it has been hidden since
                   1699:         hide_symbol can be called before the plabel flag is set.  */
1.1.1.4   christos 1700:       if (hppa_elf_hash_entry (eh)->plabel)
1.1       christos 1701:        eh->plt.refcount = 1;
                   1702:
1.1.1.4   christos 1703:       /* Note that unlike some other backends, the refcount is not
                   1704:         incremented for a non-call (and non-plabel) function reference.  */
                   1705:       else if (eh->plt.refcount <= 0
                   1706:               || local)
1.1       christos 1707:        {
                   1708:          /* The .plt entry is not needed when:
                   1709:             a) Garbage collection has removed all references to the
                   1710:             symbol, or
                   1711:             b) We know for certain the symbol is defined in this
                   1712:             object, and it's not a weak definition, nor is the symbol
                   1713:             used by a plabel relocation.  Either this object is the
                   1714:             application or we are doing a shared symbolic link.  */
                   1715:          eh->plt.offset = (bfd_vma) -1;
                   1716:          eh->needs_plt = 0;
                   1717:        }
                   1718:
1.1.1.4   christos 1719:       /* Unlike other targets, elf32-hppa.c does not define a function
                   1720:         symbol in a non-pic executable on PLT stub code, so we don't
                   1721:         have a local definition in that case.  ie. dyn_relocs can't
                   1722:         be discarded.  */
                   1723:
                   1724:       /* Function symbols can't have copy relocs.  */
1.1       christos 1725:       return TRUE;
                   1726:     }
                   1727:   else
                   1728:     eh->plt.offset = (bfd_vma) -1;
                   1729:
1.1.1.4   christos 1730:   htab = hppa_link_hash_table (info);
                   1731:   if (htab == NULL)
                   1732:     return FALSE;
                   1733:
1.1       christos 1734:   /* If this is a weak symbol, and there is a real definition, the
                   1735:      processor independent code will have arranged for us to see the
                   1736:      real definition first, and we can just use the same value.  */
1.1.1.4   christos 1737:   if (eh->is_weakalias)
1.1       christos 1738:     {
1.1.1.4   christos 1739:       struct elf_link_hash_entry *def = weakdef (eh);
                   1740:       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
                   1741:       eh->root.u.def.section = def->root.u.def.section;
                   1742:       eh->root.u.def.value = def->root.u.def.value;
                   1743:       if (def->root.u.def.section == htab->etab.sdynbss
                   1744:          || def->root.u.def.section == htab->etab.sdynrelro)
                   1745:        hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
1.1       christos 1746:       return TRUE;
                   1747:     }
                   1748:
                   1749:   /* This is a reference to a symbol defined by a dynamic object which
                   1750:      is not a function.  */
                   1751:
                   1752:   /* If we are creating a shared library, we must presume that the
                   1753:      only references to the symbol are via the global offset table.
                   1754:      For such cases we need not do anything here; the relocations will
                   1755:      be handled correctly by relocate_section.  */
1.1.1.2   christos 1756:   if (bfd_link_pic (info))
1.1       christos 1757:     return TRUE;
                   1758:
                   1759:   /* If there are no references to this symbol that do not use the
                   1760:      GOT, we don't need to generate a copy reloc.  */
                   1761:   if (!eh->non_got_ref)
                   1762:     return TRUE;
                   1763:
1.1.1.4   christos 1764:   /* If -z nocopyreloc was given, we won't generate them either.  */
                   1765:   if (info->nocopyreloc)
                   1766:     return TRUE;
1.1       christos 1767:
1.1.1.4   christos 1768:   /* If we don't find any dynamic relocs in read-only sections, then
                   1769:      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
                   1770:   if (ELIMINATE_COPY_RELOCS
                   1771:       && !alias_readonly_dynrelocs (eh))
                   1772:     return TRUE;
1.1       christos 1773:
                   1774:   /* We must allocate the symbol in our .dynbss section, which will
                   1775:      become part of the .bss section of the executable.  There will be
                   1776:      an entry for this symbol in the .dynsym section.  The dynamic
                   1777:      object will contain position independent code, so all references
                   1778:      from the dynamic object to this symbol will go through the global
                   1779:      offset table.  The dynamic linker will use the .dynsym entry to
                   1780:      determine the address it must put in the global offset table, so
                   1781:      both the dynamic object and the regular object will refer to the
                   1782:      same memory location for the variable.  */
1.1.1.4   christos 1783:   if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
                   1784:     {
                   1785:       sec = htab->etab.sdynrelro;
                   1786:       srel = htab->etab.sreldynrelro;
                   1787:     }
                   1788:   else
                   1789:     {
                   1790:       sec = htab->etab.sdynbss;
                   1791:       srel = htab->etab.srelbss;
                   1792:     }
1.1       christos 1793:   if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
                   1794:     {
1.1.1.4   christos 1795:       /* We must generate a COPY reloc to tell the dynamic linker to
                   1796:         copy the initial value out of the dynamic object and into the
                   1797:         runtime process image.  */
                   1798:       srel->size += sizeof (Elf32_External_Rela);
1.1       christos 1799:       eh->needs_copy = 1;
                   1800:     }
                   1801:
1.1.1.4   christos 1802:   /* We no longer want dyn_relocs.  */
                   1803:   hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
1.1.1.2   christos 1804:   return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
1.1       christos 1805: }
                   1806:
1.1.1.4   christos 1807: /* If EH is undefined, make it dynamic if that makes sense.  */
                   1808:
                   1809: static bfd_boolean
                   1810: ensure_undef_dynamic (struct bfd_link_info *info,
                   1811:                      struct elf_link_hash_entry *eh)
                   1812: {
                   1813:   struct elf_link_hash_table *htab = elf_hash_table (info);
                   1814:
                   1815:   if (htab->dynamic_sections_created
                   1816:       && (eh->root.type == bfd_link_hash_undefweak
                   1817:          || eh->root.type == bfd_link_hash_undefined)
                   1818:       && eh->dynindx == -1
                   1819:       && !eh->forced_local
                   1820:       && eh->type != STT_PARISC_MILLI
                   1821:       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh)
                   1822:       && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
                   1823:     return bfd_elf_link_record_dynamic_symbol (info, eh);
                   1824:   return TRUE;
                   1825: }
                   1826:
1.1       christos 1827: /* Allocate space in the .plt for entries that won't have relocations.
                   1828:    ie. plabel entries.  */
                   1829:
                   1830: static bfd_boolean
                   1831: allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
                   1832: {
                   1833:   struct bfd_link_info *info;
                   1834:   struct elf32_hppa_link_hash_table *htab;
                   1835:   struct elf32_hppa_link_hash_entry *hh;
                   1836:   asection *sec;
                   1837:
                   1838:   if (eh->root.type == bfd_link_hash_indirect)
                   1839:     return TRUE;
                   1840:
                   1841:   info = (struct bfd_link_info *) inf;
                   1842:   hh = hppa_elf_hash_entry (eh);
                   1843:   htab = hppa_link_hash_table (info);
                   1844:   if (htab == NULL)
                   1845:     return FALSE;
                   1846:
                   1847:   if (htab->etab.dynamic_sections_created
                   1848:       && eh->plt.refcount > 0)
                   1849:     {
1.1.1.4   christos 1850:       if (!ensure_undef_dynamic (info, eh))
                   1851:        return FALSE;
1.1       christos 1852:
1.1.1.2   christos 1853:       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
1.1       christos 1854:        {
                   1855:          /* Allocate these later.  From this point on, h->plabel
                   1856:             means that the plt entry is only used by a plabel.
                   1857:             We'll be using a normal plt entry for this symbol, so
                   1858:             clear the plabel indicator.  */
1.1.1.2   christos 1859:
1.1       christos 1860:          hh->plabel = 0;
                   1861:        }
                   1862:       else if (hh->plabel)
                   1863:        {
                   1864:          /* Make an entry in the .plt section for plabel references
                   1865:             that won't have a .plt entry for other reasons.  */
1.1.1.4   christos 1866:          sec = htab->etab.splt;
1.1       christos 1867:          eh->plt.offset = sec->size;
                   1868:          sec->size += PLT_ENTRY_SIZE;
1.1.1.4   christos 1869:          if (bfd_link_pic (info))
                   1870:            htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
1.1       christos 1871:        }
                   1872:       else
                   1873:        {
                   1874:          /* No .plt entry needed.  */
                   1875:          eh->plt.offset = (bfd_vma) -1;
                   1876:          eh->needs_plt = 0;
                   1877:        }
                   1878:     }
                   1879:   else
                   1880:     {
                   1881:       eh->plt.offset = (bfd_vma) -1;
                   1882:       eh->needs_plt = 0;
                   1883:     }
                   1884:
                   1885:   return TRUE;
                   1886: }
                   1887:
1.1.1.4   christos 1888: /* Calculate size of GOT entries for symbol given its TLS_TYPE.  */
                   1889:
                   1890: static inline unsigned int
                   1891: got_entries_needed (int tls_type)
                   1892: {
                   1893:   unsigned int need = 0;
                   1894:
                   1895:   if ((tls_type & GOT_NORMAL) != 0)
                   1896:     need += GOT_ENTRY_SIZE;
                   1897:   if ((tls_type & GOT_TLS_GD) != 0)
                   1898:     need += GOT_ENTRY_SIZE * 2;
                   1899:   if ((tls_type & GOT_TLS_IE) != 0)
                   1900:     need += GOT_ENTRY_SIZE;
                   1901:   return need;
                   1902: }
                   1903:
                   1904: /* Calculate size of relocs needed for symbol given its TLS_TYPE and
                   1905:    NEEDed GOT entries.  TPREL_KNOWN says a TPREL offset can be
                   1906:    calculated at link time.  DTPREL_KNOWN says the same for a DTPREL
                   1907:    offset.  */
                   1908:
                   1909: static inline unsigned int
                   1910: got_relocs_needed (int tls_type, unsigned int need,
                   1911:                   bfd_boolean dtprel_known, bfd_boolean tprel_known)
                   1912: {
                   1913:   /* All the entries we allocated need relocs.
                   1914:      Except for GD and IE with local symbols.  */
                   1915:   if ((tls_type & GOT_TLS_GD) != 0 && dtprel_known)
                   1916:     need -= GOT_ENTRY_SIZE;
                   1917:   if ((tls_type & GOT_TLS_IE) != 0 && tprel_known)
                   1918:     need -= GOT_ENTRY_SIZE;
                   1919:   return need * sizeof (Elf32_External_Rela) / GOT_ENTRY_SIZE;
                   1920: }
                   1921:
1.1       christos 1922: /* Allocate space in .plt, .got and associated reloc sections for
                   1923:    global syms.  */
                   1924:
                   1925: static bfd_boolean
                   1926: allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
                   1927: {
                   1928:   struct bfd_link_info *info;
                   1929:   struct elf32_hppa_link_hash_table *htab;
                   1930:   asection *sec;
                   1931:   struct elf32_hppa_link_hash_entry *hh;
1.1.1.4   christos 1932:   struct elf_dyn_relocs *hdh_p;
1.1       christos 1933:
                   1934:   if (eh->root.type == bfd_link_hash_indirect)
                   1935:     return TRUE;
                   1936:
                   1937:   info = inf;
                   1938:   htab = hppa_link_hash_table (info);
                   1939:   if (htab == NULL)
                   1940:     return FALSE;
                   1941:
                   1942:   hh = hppa_elf_hash_entry (eh);
1.1.1.2   christos 1943:
1.1       christos 1944:   if (htab->etab.dynamic_sections_created
                   1945:       && eh->plt.offset != (bfd_vma) -1
                   1946:       && !hh->plabel
                   1947:       && eh->plt.refcount > 0)
                   1948:     {
                   1949:       /* Make an entry in the .plt section.  */
1.1.1.4   christos 1950:       sec = htab->etab.splt;
1.1       christos 1951:       eh->plt.offset = sec->size;
                   1952:       sec->size += PLT_ENTRY_SIZE;
                   1953:
                   1954:       /* We also need to make an entry in the .rela.plt section.  */
1.1.1.4   christos 1955:       htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
1.1       christos 1956:       htab->need_plt_stub = 1;
                   1957:     }
                   1958:
                   1959:   if (eh->got.refcount > 0)
                   1960:     {
1.1.1.4   christos 1961:       unsigned int need;
                   1962:
                   1963:       if (!ensure_undef_dynamic (info, eh))
                   1964:        return FALSE;
1.1       christos 1965:
1.1.1.4   christos 1966:       sec = htab->etab.sgot;
1.1       christos 1967:       eh->got.offset = sec->size;
1.1.1.4   christos 1968:       need = got_entries_needed (hh->tls_type);
                   1969:       sec->size += need;
1.1       christos 1970:       if (htab->etab.dynamic_sections_created
1.1.1.4   christos 1971:          && (bfd_link_dll (info)
                   1972:              || (bfd_link_pic (info) && (hh->tls_type & GOT_NORMAL) != 0)
1.1       christos 1973:              || (eh->dynindx != -1
1.1.1.4   christos 1974:                  && !SYMBOL_REFERENCES_LOCAL (info, eh)))
                   1975:          && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
1.1       christos 1976:        {
1.1.1.4   christos 1977:          bfd_boolean local = SYMBOL_REFERENCES_LOCAL (info, eh);
                   1978:          htab->etab.srelgot->size
                   1979:            += got_relocs_needed (hh->tls_type, need, local,
                   1980:                                  local && bfd_link_executable (info));
1.1       christos 1981:        }
                   1982:     }
                   1983:   else
                   1984:     eh->got.offset = (bfd_vma) -1;
                   1985:
1.1.1.4   christos 1986:   /* If no dynamic sections we can't have dynamic relocs.  */
                   1987:   if (!htab->etab.dynamic_sections_created)
                   1988:     hh->dyn_relocs = NULL;
                   1989:
                   1990:   /* Discard relocs on undefined syms with non-default visibility.  */
                   1991:   else if ((eh->root.type == bfd_link_hash_undefined
                   1992:            && ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
                   1993:           || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
                   1994:     hh->dyn_relocs = NULL;
                   1995:
1.1       christos 1996:   if (hh->dyn_relocs == NULL)
                   1997:     return TRUE;
                   1998:
                   1999:   /* If this is a -Bsymbolic shared link, then we need to discard all
                   2000:      space allocated for dynamic pc-relative relocs against symbols
                   2001:      defined in a regular object.  For the normal shared case, discard
                   2002:      space for relocs that have become local due to symbol visibility
                   2003:      changes.  */
1.1.1.2   christos 2004:   if (bfd_link_pic (info))
1.1       christos 2005:     {
                   2006: #if RELATIVE_DYNRELOCS
                   2007:       if (SYMBOL_CALLS_LOCAL (info, eh))
                   2008:        {
1.1.1.4   christos 2009:          struct elf_dyn_relocs **hdh_pp;
1.1       christos 2010:
                   2011:          for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
                   2012:            {
1.1.1.4   christos 2013:              hdh_p->count -= hdh_p->pc_count;
                   2014:              hdh_p->pc_count = 0;
1.1       christos 2015:              if (hdh_p->count == 0)
1.1.1.4   christos 2016:                *hdh_pp = hdh_p->next;
1.1       christos 2017:              else
1.1.1.4   christos 2018:                hdh_pp = &hdh_p->next;
1.1       christos 2019:            }
                   2020:        }
                   2021: #endif
                   2022:
1.1.1.4   christos 2023:       if (hh->dyn_relocs != NULL)
1.1       christos 2024:        {
1.1.1.4   christos 2025:          if (!ensure_undef_dynamic (info, eh))
                   2026:            return FALSE;
1.1       christos 2027:        }
                   2028:     }
1.1.1.4   christos 2029:   else if (ELIMINATE_COPY_RELOCS)
1.1       christos 2030:     {
                   2031:       /* For the non-shared case, discard space for relocs against
                   2032:         symbols which turn out to need copy relocs or are not
                   2033:         dynamic.  */
1.1.1.2   christos 2034:
1.1.1.4   christos 2035:       if (eh->dynamic_adjusted
                   2036:          && !eh->def_regular
                   2037:          && !ELF_COMMON_DEF_P (eh))
                   2038:        {
                   2039:          if (!ensure_undef_dynamic (info, eh))
                   2040:            return FALSE;
1.1       christos 2041:
1.1.1.4   christos 2042:          if (eh->dynindx == -1)
                   2043:            hh->dyn_relocs = NULL;
1.1       christos 2044:        }
1.1.1.4   christos 2045:       else
                   2046:        hh->dyn_relocs = NULL;
1.1       christos 2047:     }
                   2048:
                   2049:   /* Finally, allocate space.  */
1.1.1.4   christos 2050:   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
1.1       christos 2051:     {
                   2052:       asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
                   2053:       sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
                   2054:     }
                   2055:
                   2056:   return TRUE;
                   2057: }
                   2058:
                   2059: /* This function is called via elf_link_hash_traverse to force
                   2060:    millicode symbols local so they do not end up as globals in the
                   2061:    dynamic symbol table.  We ought to be able to do this in
                   2062:    adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
                   2063:    for all dynamic symbols.  Arguably, this is a bug in
                   2064:    elf_adjust_dynamic_symbol.  */
                   2065:
                   2066: static bfd_boolean
                   2067: clobber_millicode_symbols (struct elf_link_hash_entry *eh,
                   2068:                           struct bfd_link_info *info)
                   2069: {
                   2070:   if (eh->type == STT_PARISC_MILLI
                   2071:       && !eh->forced_local)
                   2072:     {
                   2073:       elf32_hppa_hide_symbol (info, eh, TRUE);
                   2074:     }
                   2075:   return TRUE;
                   2076: }
                   2077:
1.1.1.4   christos 2078: /* Set DF_TEXTREL if we find any dynamic relocs that apply to
                   2079:    read-only sections.  */
1.1       christos 2080:
                   2081: static bfd_boolean
1.1.1.4   christos 2082: maybe_set_textrel (struct elf_link_hash_entry *eh, void *inf)
1.1       christos 2083: {
1.1.1.4   christos 2084:   asection *sec;
1.1       christos 2085:
1.1.1.4   christos 2086:   if (eh->root.type == bfd_link_hash_indirect)
                   2087:     return TRUE;
1.1       christos 2088:
1.1.1.4   christos 2089:   sec = readonly_dynrelocs (eh);
                   2090:   if (sec != NULL)
                   2091:     {
                   2092:       struct bfd_link_info *info = (struct bfd_link_info *) inf;
1.1       christos 2093:
1.1.1.4   christos 2094:       info->flags |= DF_TEXTREL;
                   2095:       info->callbacks->minfo
                   2096:        (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
                   2097:         sec->owner, eh->root.root.string, sec);
                   2098:       /* Not an error, just cut short the traversal.  */
                   2099:       return FALSE;
1.1       christos 2100:     }
                   2101:   return TRUE;
                   2102: }
                   2103:
                   2104: /* Set the sizes of the dynamic sections.  */
                   2105:
                   2106: static bfd_boolean
                   2107: elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
                   2108:                                  struct bfd_link_info *info)
                   2109: {
                   2110:   struct elf32_hppa_link_hash_table *htab;
                   2111:   bfd *dynobj;
                   2112:   bfd *ibfd;
                   2113:   asection *sec;
                   2114:   bfd_boolean relocs;
                   2115:
                   2116:   htab = hppa_link_hash_table (info);
                   2117:   if (htab == NULL)
                   2118:     return FALSE;
                   2119:
                   2120:   dynobj = htab->etab.dynobj;
                   2121:   if (dynobj == NULL)
                   2122:     abort ();
                   2123:
                   2124:   if (htab->etab.dynamic_sections_created)
                   2125:     {
                   2126:       /* Set the contents of the .interp section to the interpreter.  */
1.1.1.2   christos 2127:       if (bfd_link_executable (info) && !info->nointerp)
1.1       christos 2128:        {
                   2129:          sec = bfd_get_linker_section (dynobj, ".interp");
                   2130:          if (sec == NULL)
                   2131:            abort ();
                   2132:          sec->size = sizeof ELF_DYNAMIC_INTERPRETER;
                   2133:          sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
                   2134:        }
                   2135:
                   2136:       /* Force millicode symbols local.  */
                   2137:       elf_link_hash_traverse (&htab->etab,
                   2138:                              clobber_millicode_symbols,
                   2139:                              info);
                   2140:     }
                   2141:
                   2142:   /* Set up .got and .plt offsets for local syms, and space for local
                   2143:      dynamic relocs.  */
1.1.1.2   christos 2144:   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1.1       christos 2145:     {
                   2146:       bfd_signed_vma *local_got;
                   2147:       bfd_signed_vma *end_local_got;
                   2148:       bfd_signed_vma *local_plt;
                   2149:       bfd_signed_vma *end_local_plt;
                   2150:       bfd_size_type locsymcount;
                   2151:       Elf_Internal_Shdr *symtab_hdr;
                   2152:       asection *srel;
                   2153:       char *local_tls_type;
                   2154:
                   2155:       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
                   2156:        continue;
                   2157:
                   2158:       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
                   2159:        {
1.1.1.4   christos 2160:          struct elf_dyn_relocs *hdh_p;
1.1       christos 2161:
1.1.1.4   christos 2162:          for (hdh_p = ((struct elf_dyn_relocs *)
1.1       christos 2163:                    elf_section_data (sec)->local_dynrel);
                   2164:               hdh_p != NULL;
1.1.1.4   christos 2165:               hdh_p = hdh_p->next)
1.1       christos 2166:            {
                   2167:              if (!bfd_is_abs_section (hdh_p->sec)
                   2168:                  && bfd_is_abs_section (hdh_p->sec->output_section))
                   2169:                {
                   2170:                  /* Input section has been discarded, either because
                   2171:                     it is a copy of a linkonce section or due to
                   2172:                     linker script /DISCARD/, so we'll be discarding
                   2173:                     the relocs too.  */
                   2174:                }
                   2175:              else if (hdh_p->count != 0)
                   2176:                {
                   2177:                  srel = elf_section_data (hdh_p->sec)->sreloc;
                   2178:                  srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
                   2179:                  if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
                   2180:                    info->flags |= DF_TEXTREL;
                   2181:                }
                   2182:            }
                   2183:        }
                   2184:
                   2185:       local_got = elf_local_got_refcounts (ibfd);
                   2186:       if (!local_got)
                   2187:        continue;
                   2188:
                   2189:       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
                   2190:       locsymcount = symtab_hdr->sh_info;
                   2191:       end_local_got = local_got + locsymcount;
                   2192:       local_tls_type = hppa_elf_local_got_tls_type (ibfd);
1.1.1.4   christos 2193:       sec = htab->etab.sgot;
                   2194:       srel = htab->etab.srelgot;
1.1       christos 2195:       for (; local_got < end_local_got; ++local_got)
                   2196:        {
                   2197:          if (*local_got > 0)
                   2198:            {
1.1.1.4   christos 2199:              unsigned int need;
                   2200:
1.1       christos 2201:              *local_got = sec->size;
1.1.1.4   christos 2202:              need = got_entries_needed (*local_tls_type);
                   2203:              sec->size += need;
                   2204:              if (bfd_link_dll (info)
                   2205:                  || (bfd_link_pic (info)
                   2206:                      && (*local_tls_type & GOT_NORMAL) != 0))
                   2207:                htab->etab.srelgot->size
                   2208:                  += got_relocs_needed (*local_tls_type, need, TRUE,
                   2209:                                        bfd_link_executable (info));
1.1       christos 2210:            }
                   2211:          else
                   2212:            *local_got = (bfd_vma) -1;
                   2213:
                   2214:          ++local_tls_type;
                   2215:        }
                   2216:
                   2217:       local_plt = end_local_got;
                   2218:       end_local_plt = local_plt + locsymcount;
                   2219:       if (! htab->etab.dynamic_sections_created)
                   2220:        {
                   2221:          /* Won't be used, but be safe.  */
                   2222:          for (; local_plt < end_local_plt; ++local_plt)
                   2223:            *local_plt = (bfd_vma) -1;
                   2224:        }
                   2225:       else
                   2226:        {
1.1.1.4   christos 2227:          sec = htab->etab.splt;
                   2228:          srel = htab->etab.srelplt;
1.1       christos 2229:          for (; local_plt < end_local_plt; ++local_plt)
                   2230:            {
                   2231:              if (*local_plt > 0)
                   2232:                {
                   2233:                  *local_plt = sec->size;
                   2234:                  sec->size += PLT_ENTRY_SIZE;
1.1.1.2   christos 2235:                  if (bfd_link_pic (info))
1.1       christos 2236:                    srel->size += sizeof (Elf32_External_Rela);
                   2237:                }
                   2238:              else
                   2239:                *local_plt = (bfd_vma) -1;
                   2240:            }
                   2241:        }
                   2242:     }
1.1.1.2   christos 2243:
1.1       christos 2244:   if (htab->tls_ldm_got.refcount > 0)
                   2245:     {
1.1.1.2   christos 2246:       /* Allocate 2 got entries and 1 dynamic reloc for
1.1.1.4   christos 2247:         R_PARISC_TLS_DTPMOD32 relocs.  */
                   2248:       htab->tls_ldm_got.offset = htab->etab.sgot->size;
                   2249:       htab->etab.sgot->size += (GOT_ENTRY_SIZE * 2);
                   2250:       htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
1.1       christos 2251:     }
                   2252:   else
                   2253:     htab->tls_ldm_got.offset = -1;
                   2254:
                   2255:   /* Do all the .plt entries without relocs first.  The dynamic linker
                   2256:      uses the last .plt reloc to find the end of the .plt (and hence
                   2257:      the start of the .got) for lazy linking.  */
                   2258:   elf_link_hash_traverse (&htab->etab, allocate_plt_static, info);
                   2259:
                   2260:   /* Allocate global sym .plt and .got entries, and space for global
                   2261:      sym dynamic relocs.  */
                   2262:   elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
                   2263:
                   2264:   /* The check_relocs and adjust_dynamic_symbol entry points have
                   2265:      determined the sizes of the various dynamic sections.  Allocate
                   2266:      memory for them.  */
                   2267:   relocs = FALSE;
                   2268:   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
                   2269:     {
                   2270:       if ((sec->flags & SEC_LINKER_CREATED) == 0)
                   2271:        continue;
                   2272:
1.1.1.4   christos 2273:       if (sec == htab->etab.splt)
1.1       christos 2274:        {
                   2275:          if (htab->need_plt_stub)
                   2276:            {
                   2277:              /* Make space for the plt stub at the end of the .plt
                   2278:                 section.  We want this stub right at the end, up
                   2279:                 against the .got section.  */
1.1.1.5 ! christos 2280:              int gotalign = bfd_section_alignment (htab->etab.sgot);
        !          2281:              int pltalign = bfd_section_alignment (sec);
        !          2282:              int align = gotalign > 3 ? gotalign : 3;
1.1       christos 2283:              bfd_size_type mask;
                   2284:
1.1.1.5 ! christos 2285:              if (align > pltalign)
        !          2286:                bfd_set_section_alignment (sec, align);
1.1       christos 2287:              mask = ((bfd_size_type) 1 << gotalign) - 1;
                   2288:              sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
                   2289:            }
                   2290:        }
1.1.1.4   christos 2291:       else if (sec == htab->etab.sgot
                   2292:               || sec == htab->etab.sdynbss
                   2293:               || sec == htab->etab.sdynrelro)
1.1       christos 2294:        ;
1.1.1.5 ! christos 2295:       else if (CONST_STRNEQ (bfd_section_name (sec), ".rela"))
1.1       christos 2296:        {
                   2297:          if (sec->size != 0)
                   2298:            {
                   2299:              /* Remember whether there are any reloc sections other
                   2300:                 than .rela.plt.  */
1.1.1.4   christos 2301:              if (sec != htab->etab.srelplt)
1.1       christos 2302:                relocs = TRUE;
                   2303:
                   2304:              /* We use the reloc_count field as a counter if we need
                   2305:                 to copy relocs into the output file.  */
                   2306:              sec->reloc_count = 0;
                   2307:            }
                   2308:        }
                   2309:       else
                   2310:        {
                   2311:          /* It's not one of our sections, so don't allocate space.  */
                   2312:          continue;
                   2313:        }
                   2314:
                   2315:       if (sec->size == 0)
                   2316:        {
                   2317:          /* If we don't need this section, strip it from the
                   2318:             output file.  This is mostly to handle .rela.bss and
                   2319:             .rela.plt.  We must create both sections in
                   2320:             create_dynamic_sections, because they must be created
                   2321:             before the linker maps input sections to output
                   2322:             sections.  The linker does that before
                   2323:             adjust_dynamic_symbol is called, and it is that
                   2324:             function which decides whether anything needs to go
                   2325:             into these sections.  */
                   2326:          sec->flags |= SEC_EXCLUDE;
                   2327:          continue;
                   2328:        }
                   2329:
                   2330:       if ((sec->flags & SEC_HAS_CONTENTS) == 0)
                   2331:        continue;
                   2332:
                   2333:       /* Allocate memory for the section contents.  Zero it, because
                   2334:         we may not fill in all the reloc sections.  */
                   2335:       sec->contents = bfd_zalloc (dynobj, sec->size);
                   2336:       if (sec->contents == NULL)
                   2337:        return FALSE;
                   2338:     }
                   2339:
                   2340:   if (htab->etab.dynamic_sections_created)
                   2341:     {
                   2342:       /* Like IA-64 and HPPA64, always create a DT_PLTGOT.  It
                   2343:         actually has nothing to do with the PLT, it is how we
                   2344:         communicate the LTP value of a load module to the dynamic
                   2345:         linker.  */
                   2346: #define add_dynamic_entry(TAG, VAL) \
                   2347:   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
                   2348:
                   2349:       if (!add_dynamic_entry (DT_PLTGOT, 0))
                   2350:        return FALSE;
                   2351:
                   2352:       /* Add some entries to the .dynamic section.  We fill in the
                   2353:         values later, in elf32_hppa_finish_dynamic_sections, but we
                   2354:         must add the entries now so that we get the correct size for
                   2355:         the .dynamic section.  The DT_DEBUG entry is filled in by the
                   2356:         dynamic linker and used by the debugger.  */
1.1.1.2   christos 2357:       if (bfd_link_executable (info))
1.1       christos 2358:        {
                   2359:          if (!add_dynamic_entry (DT_DEBUG, 0))
                   2360:            return FALSE;
                   2361:        }
                   2362:
1.1.1.4   christos 2363:       if (htab->etab.srelplt->size != 0)
1.1       christos 2364:        {
                   2365:          if (!add_dynamic_entry (DT_PLTRELSZ, 0)
                   2366:              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
                   2367:              || !add_dynamic_entry (DT_JMPREL, 0))
                   2368:            return FALSE;
                   2369:        }
                   2370:
                   2371:       if (relocs)
                   2372:        {
                   2373:          if (!add_dynamic_entry (DT_RELA, 0)
                   2374:              || !add_dynamic_entry (DT_RELASZ, 0)
                   2375:              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
                   2376:            return FALSE;
                   2377:
                   2378:          /* If any dynamic relocs apply to a read-only section,
                   2379:             then we need a DT_TEXTREL entry.  */
                   2380:          if ((info->flags & DF_TEXTREL) == 0)
1.1.1.4   christos 2381:            elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
1.1       christos 2382:
                   2383:          if ((info->flags & DF_TEXTREL) != 0)
                   2384:            {
                   2385:              if (!add_dynamic_entry (DT_TEXTREL, 0))
                   2386:                return FALSE;
                   2387:            }
                   2388:        }
                   2389:     }
                   2390: #undef add_dynamic_entry
                   2391:
                   2392:   return TRUE;
                   2393: }
                   2394:
                   2395: /* External entry points for sizing and building linker stubs.  */
                   2396:
                   2397: /* Set up various things so that we can make a list of input sections
                   2398:    for each output section included in the link.  Returns -1 on error,
                   2399:    0 when no stubs will be needed, and 1 on success.  */
                   2400:
                   2401: int
                   2402: elf32_hppa_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
                   2403: {
                   2404:   bfd *input_bfd;
                   2405:   unsigned int bfd_count;
1.1.1.2   christos 2406:   unsigned int top_id, top_index;
1.1       christos 2407:   asection *section;
                   2408:   asection **input_list, **list;
                   2409:   bfd_size_type amt;
                   2410:   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
                   2411:
                   2412:   if (htab == NULL)
                   2413:     return -1;
                   2414:
                   2415:   /* Count the number of input BFDs and find the top input section id.  */
                   2416:   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
                   2417:        input_bfd != NULL;
1.1.1.2   christos 2418:        input_bfd = input_bfd->link.next)
1.1       christos 2419:     {
                   2420:       bfd_count += 1;
                   2421:       for (section = input_bfd->sections;
                   2422:           section != NULL;
                   2423:           section = section->next)
                   2424:        {
                   2425:          if (top_id < section->id)
                   2426:            top_id = section->id;
                   2427:        }
                   2428:     }
                   2429:   htab->bfd_count = bfd_count;
                   2430:
                   2431:   amt = sizeof (struct map_stub) * (top_id + 1);
                   2432:   htab->stub_group = bfd_zmalloc (amt);
                   2433:   if (htab->stub_group == NULL)
                   2434:     return -1;
                   2435:
                   2436:   /* We can't use output_bfd->section_count here to find the top output
                   2437:      section index as some sections may have been removed, and
                   2438:      strip_excluded_output_sections doesn't renumber the indices.  */
                   2439:   for (section = output_bfd->sections, top_index = 0;
                   2440:        section != NULL;
                   2441:        section = section->next)
                   2442:     {
                   2443:       if (top_index < section->index)
                   2444:        top_index = section->index;
                   2445:     }
                   2446:
                   2447:   htab->top_index = top_index;
                   2448:   amt = sizeof (asection *) * (top_index + 1);
                   2449:   input_list = bfd_malloc (amt);
                   2450:   htab->input_list = input_list;
                   2451:   if (input_list == NULL)
                   2452:     return -1;
                   2453:
                   2454:   /* For sections we aren't interested in, mark their entries with a
                   2455:      value we can check later.  */
                   2456:   list = input_list + top_index;
                   2457:   do
                   2458:     *list = bfd_abs_section_ptr;
                   2459:   while (list-- != input_list);
                   2460:
                   2461:   for (section = output_bfd->sections;
                   2462:        section != NULL;
                   2463:        section = section->next)
                   2464:     {
                   2465:       if ((section->flags & SEC_CODE) != 0)
                   2466:        input_list[section->index] = NULL;
                   2467:     }
                   2468:
                   2469:   return 1;
                   2470: }
                   2471:
                   2472: /* The linker repeatedly calls this function for each input section,
                   2473:    in the order that input sections are linked into output sections.
                   2474:    Build lists of input sections to determine groupings between which
                   2475:    we may insert linker stubs.  */
                   2476:
                   2477: void
                   2478: elf32_hppa_next_input_section (struct bfd_link_info *info, asection *isec)
                   2479: {
                   2480:   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
                   2481:
                   2482:   if (htab == NULL)
                   2483:     return;
                   2484:
                   2485:   if (isec->output_section->index <= htab->top_index)
                   2486:     {
                   2487:       asection **list = htab->input_list + isec->output_section->index;
                   2488:       if (*list != bfd_abs_section_ptr)
                   2489:        {
                   2490:          /* Steal the link_sec pointer for our list.  */
                   2491: #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
                   2492:          /* This happens to make the list in reverse order,
                   2493:             which is what we want.  */
                   2494:          PREV_SEC (isec) = *list;
                   2495:          *list = isec;
                   2496:        }
                   2497:     }
                   2498: }
                   2499:
                   2500: /* See whether we can group stub sections together.  Grouping stub
                   2501:    sections may result in fewer stubs.  More importantly, we need to
                   2502:    put all .init* and .fini* stubs at the beginning of the .init or
                   2503:    .fini output sections respectively, because glibc splits the
                   2504:    _init and _fini functions into multiple parts.  Putting a stub in
                   2505:    the middle of a function is not a good idea.  */
                   2506:
                   2507: static void
                   2508: group_sections (struct elf32_hppa_link_hash_table *htab,
                   2509:                bfd_size_type stub_group_size,
                   2510:                bfd_boolean stubs_always_before_branch)
                   2511: {
                   2512:   asection **list = htab->input_list + htab->top_index;
                   2513:   do
                   2514:     {
                   2515:       asection *tail = *list;
                   2516:       if (tail == bfd_abs_section_ptr)
                   2517:        continue;
                   2518:       while (tail != NULL)
                   2519:        {
                   2520:          asection *curr;
                   2521:          asection *prev;
                   2522:          bfd_size_type total;
                   2523:          bfd_boolean big_sec;
                   2524:
                   2525:          curr = tail;
                   2526:          total = tail->size;
                   2527:          big_sec = total >= stub_group_size;
                   2528:
                   2529:          while ((prev = PREV_SEC (curr)) != NULL
                   2530:                 && ((total += curr->output_offset - prev->output_offset)
                   2531:                     < stub_group_size))
                   2532:            curr = prev;
                   2533:
                   2534:          /* OK, the size from the start of CURR to the end is less
                   2535:             than 240000 bytes and thus can be handled by one stub
                   2536:             section.  (or the tail section is itself larger than
                   2537:             240000 bytes, in which case we may be toast.)
                   2538:             We should really be keeping track of the total size of
                   2539:             stubs added here, as stubs contribute to the final output
                   2540:             section size.  That's a little tricky, and this way will
                   2541:             only break if stubs added total more than 22144 bytes, or
                   2542:             2768 long branch stubs.  It seems unlikely for more than
                   2543:             2768 different functions to be called, especially from
                   2544:             code only 240000 bytes long.  This limit used to be
                   2545:             250000, but c++ code tends to generate lots of little
                   2546:             functions, and sometimes violated the assumption.  */
                   2547:          do
                   2548:            {
                   2549:              prev = PREV_SEC (tail);
                   2550:              /* Set up this stub group.  */
                   2551:              htab->stub_group[tail->id].link_sec = curr;
                   2552:            }
                   2553:          while (tail != curr && (tail = prev) != NULL);
                   2554:
                   2555:          /* But wait, there's more!  Input sections up to 240000
                   2556:             bytes before the stub section can be handled by it too.
                   2557:             Don't do this if we have a really large section after the
                   2558:             stubs, as adding more stubs increases the chance that
                   2559:             branches may not reach into the stub section.  */
                   2560:          if (!stubs_always_before_branch && !big_sec)
                   2561:            {
                   2562:              total = 0;
                   2563:              while (prev != NULL
                   2564:                     && ((total += tail->output_offset - prev->output_offset)
                   2565:                         < stub_group_size))
                   2566:                {
                   2567:                  tail = prev;
                   2568:                  prev = PREV_SEC (tail);
                   2569:                  htab->stub_group[tail->id].link_sec = curr;
                   2570:                }
                   2571:            }
                   2572:          tail = prev;
                   2573:        }
                   2574:     }
                   2575:   while (list-- != htab->input_list);
                   2576:   free (htab->input_list);
                   2577: #undef PREV_SEC
                   2578: }
                   2579:
                   2580: /* Read in all local syms for all input bfds, and create hash entries
                   2581:    for export stubs if we are building a multi-subspace shared lib.
                   2582:    Returns -1 on error, 1 if export stubs created, 0 otherwise.  */
                   2583:
                   2584: static int
                   2585: get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
                   2586: {
                   2587:   unsigned int bfd_indx;
                   2588:   Elf_Internal_Sym *local_syms, **all_local_syms;
                   2589:   int stub_changed = 0;
                   2590:   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
                   2591:
                   2592:   if (htab == NULL)
                   2593:     return -1;
                   2594:
                   2595:   /* We want to read in symbol extension records only once.  To do this
                   2596:      we need to read in the local symbols in parallel and save them for
                   2597:      later use; so hold pointers to the local symbols in an array.  */
                   2598:   bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
                   2599:   all_local_syms = bfd_zmalloc (amt);
                   2600:   htab->all_local_syms = all_local_syms;
                   2601:   if (all_local_syms == NULL)
                   2602:     return -1;
                   2603:
                   2604:   /* Walk over all the input BFDs, swapping in local symbols.
                   2605:      If we are creating a shared library, create hash entries for the
                   2606:      export stubs.  */
                   2607:   for (bfd_indx = 0;
                   2608:        input_bfd != NULL;
1.1.1.2   christos 2609:        input_bfd = input_bfd->link.next, bfd_indx++)
1.1       christos 2610:     {
                   2611:       Elf_Internal_Shdr *symtab_hdr;
                   2612:
                   2613:       /* We'll need the symbol table in a second.  */
                   2614:       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
                   2615:       if (symtab_hdr->sh_info == 0)
                   2616:        continue;
                   2617:
                   2618:       /* We need an array of the local symbols attached to the input bfd.  */
                   2619:       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
                   2620:       if (local_syms == NULL)
                   2621:        {
                   2622:          local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
                   2623:                                             symtab_hdr->sh_info, 0,
                   2624:                                             NULL, NULL, NULL);
                   2625:          /* Cache them for elf_link_input_bfd.  */
                   2626:          symtab_hdr->contents = (unsigned char *) local_syms;
                   2627:        }
                   2628:       if (local_syms == NULL)
                   2629:        return -1;
                   2630:
                   2631:       all_local_syms[bfd_indx] = local_syms;
                   2632:
1.1.1.2   christos 2633:       if (bfd_link_pic (info) && htab->multi_subspace)
1.1       christos 2634:        {
                   2635:          struct elf_link_hash_entry **eh_syms;
                   2636:          struct elf_link_hash_entry **eh_symend;
                   2637:          unsigned int symcount;
                   2638:
                   2639:          symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
                   2640:                      - symtab_hdr->sh_info);
                   2641:          eh_syms = (struct elf_link_hash_entry **) elf_sym_hashes (input_bfd);
                   2642:          eh_symend = (struct elf_link_hash_entry **) (eh_syms + symcount);
                   2643:
                   2644:          /* Look through the global syms for functions;  We need to
                   2645:             build export stubs for all globally visible functions.  */
                   2646:          for (; eh_syms < eh_symend; eh_syms++)
                   2647:            {
                   2648:              struct elf32_hppa_link_hash_entry *hh;
                   2649:
                   2650:              hh = hppa_elf_hash_entry (*eh_syms);
                   2651:
                   2652:              while (hh->eh.root.type == bfd_link_hash_indirect
                   2653:                     || hh->eh.root.type == bfd_link_hash_warning)
                   2654:                   hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
                   2655:
                   2656:              /* At this point in the link, undefined syms have been
                   2657:                 resolved, so we need to check that the symbol was
                   2658:                 defined in this BFD.  */
                   2659:              if ((hh->eh.root.type == bfd_link_hash_defined
                   2660:                   || hh->eh.root.type == bfd_link_hash_defweak)
                   2661:                  && hh->eh.type == STT_FUNC
                   2662:                  && hh->eh.root.u.def.section->output_section != NULL
                   2663:                  && (hh->eh.root.u.def.section->output_section->owner
                   2664:                      == output_bfd)
                   2665:                  && hh->eh.root.u.def.section->owner == input_bfd
                   2666:                  && hh->eh.def_regular
                   2667:                  && !hh->eh.forced_local
                   2668:                  && ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT)
                   2669:                {
                   2670:                  asection *sec;
                   2671:                  const char *stub_name;
                   2672:                  struct elf32_hppa_stub_hash_entry *hsh;
                   2673:
                   2674:                  sec = hh->eh.root.u.def.section;
                   2675:                  stub_name = hh_name (hh);
                   2676:                  hsh = hppa_stub_hash_lookup (&htab->bstab,
                   2677:                                                      stub_name,
                   2678:                                                      FALSE, FALSE);
                   2679:                  if (hsh == NULL)
                   2680:                    {
                   2681:                      hsh = hppa_add_stub (stub_name, sec, htab);
                   2682:                      if (!hsh)
                   2683:                        return -1;
                   2684:
                   2685:                      hsh->target_value = hh->eh.root.u.def.value;
                   2686:                      hsh->target_section = hh->eh.root.u.def.section;
                   2687:                      hsh->stub_type = hppa_stub_export;
                   2688:                      hsh->hh = hh;
                   2689:                      stub_changed = 1;
                   2690:                    }
                   2691:                  else
                   2692:                    {
1.1.1.4   christos 2693:                      /* xgettext:c-format */
                   2694:                      _bfd_error_handler (_("%pB: duplicate export stub %s"),
                   2695:                                          input_bfd, stub_name);
1.1       christos 2696:                    }
                   2697:                }
                   2698:            }
                   2699:        }
                   2700:     }
                   2701:
                   2702:   return stub_changed;
                   2703: }
                   2704:
                   2705: /* Determine and set the size of the stub section for a final link.
                   2706:
                   2707:    The basic idea here is to examine all the relocations looking for
                   2708:    PC-relative calls to a target that is unreachable with a "bl"
                   2709:    instruction.  */
                   2710:
                   2711: bfd_boolean
                   2712: elf32_hppa_size_stubs
                   2713:   (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info,
                   2714:    bfd_boolean multi_subspace, bfd_signed_vma group_size,
                   2715:    asection * (*add_stub_section) (const char *, asection *),
                   2716:    void (*layout_sections_again) (void))
                   2717: {
                   2718:   bfd_size_type stub_group_size;
                   2719:   bfd_boolean stubs_always_before_branch;
                   2720:   bfd_boolean stub_changed;
                   2721:   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
                   2722:
                   2723:   if (htab == NULL)
                   2724:     return FALSE;
                   2725:
                   2726:   /* Stash our params away.  */
                   2727:   htab->stub_bfd = stub_bfd;
                   2728:   htab->multi_subspace = multi_subspace;
                   2729:   htab->add_stub_section = add_stub_section;
                   2730:   htab->layout_sections_again = layout_sections_again;
                   2731:   stubs_always_before_branch = group_size < 0;
                   2732:   if (group_size < 0)
                   2733:     stub_group_size = -group_size;
                   2734:   else
                   2735:     stub_group_size = group_size;
                   2736:   if (stub_group_size == 1)
                   2737:     {
                   2738:       /* Default values.  */
                   2739:       if (stubs_always_before_branch)
                   2740:        {
                   2741:          stub_group_size = 7680000;
                   2742:          if (htab->has_17bit_branch || htab->multi_subspace)
                   2743:            stub_group_size = 240000;
                   2744:          if (htab->has_12bit_branch)
                   2745:            stub_group_size = 7500;
                   2746:        }
                   2747:       else
                   2748:        {
                   2749:          stub_group_size = 6971392;
                   2750:          if (htab->has_17bit_branch || htab->multi_subspace)
                   2751:            stub_group_size = 217856;
                   2752:          if (htab->has_12bit_branch)
                   2753:            stub_group_size = 6808;
                   2754:        }
                   2755:     }
                   2756:
                   2757:   group_sections (htab, stub_group_size, stubs_always_before_branch);
                   2758:
                   2759:   switch (get_local_syms (output_bfd, info->input_bfds, info))
                   2760:     {
                   2761:     default:
                   2762:       if (htab->all_local_syms)
                   2763:        goto error_ret_free_local;
                   2764:       return FALSE;
                   2765:
                   2766:     case 0:
                   2767:       stub_changed = FALSE;
                   2768:       break;
                   2769:
                   2770:     case 1:
                   2771:       stub_changed = TRUE;
                   2772:       break;
                   2773:     }
                   2774:
                   2775:   while (1)
                   2776:     {
                   2777:       bfd *input_bfd;
                   2778:       unsigned int bfd_indx;
                   2779:       asection *stub_sec;
                   2780:
                   2781:       for (input_bfd = info->input_bfds, bfd_indx = 0;
                   2782:           input_bfd != NULL;
1.1.1.2   christos 2783:           input_bfd = input_bfd->link.next, bfd_indx++)
1.1       christos 2784:        {
                   2785:          Elf_Internal_Shdr *symtab_hdr;
                   2786:          asection *section;
                   2787:          Elf_Internal_Sym *local_syms;
                   2788:
                   2789:          /* We'll need the symbol table in a second.  */
                   2790:          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
                   2791:          if (symtab_hdr->sh_info == 0)
                   2792:            continue;
                   2793:
                   2794:          local_syms = htab->all_local_syms[bfd_indx];
                   2795:
                   2796:          /* Walk over each section attached to the input bfd.  */
                   2797:          for (section = input_bfd->sections;
                   2798:               section != NULL;
                   2799:               section = section->next)
                   2800:            {
                   2801:              Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
                   2802:
                   2803:              /* If there aren't any relocs, then there's nothing more
                   2804:                 to do.  */
                   2805:              if ((section->flags & SEC_RELOC) == 0
1.1.1.4   christos 2806:                  || (section->flags & SEC_ALLOC) == 0
                   2807:                  || (section->flags & SEC_LOAD) == 0
                   2808:                  || (section->flags & SEC_CODE) == 0
1.1       christos 2809:                  || section->reloc_count == 0)
                   2810:                continue;
                   2811:
                   2812:              /* If this section is a link-once section that will be
                   2813:                 discarded, then don't create any stubs.  */
                   2814:              if (section->output_section == NULL
                   2815:                  || section->output_section->owner != output_bfd)
                   2816:                continue;
                   2817:
                   2818:              /* Get the relocs.  */
                   2819:              internal_relocs
                   2820:                = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
                   2821:                                             info->keep_memory);
                   2822:              if (internal_relocs == NULL)
                   2823:                goto error_ret_free_local;
                   2824:
                   2825:              /* Now examine each relocation.  */
                   2826:              irela = internal_relocs;
                   2827:              irelaend = irela + section->reloc_count;
                   2828:              for (; irela < irelaend; irela++)
                   2829:                {
                   2830:                  unsigned int r_type, r_indx;
                   2831:                  enum elf32_hppa_stub_type stub_type;
                   2832:                  struct elf32_hppa_stub_hash_entry *hsh;
                   2833:                  asection *sym_sec;
                   2834:                  bfd_vma sym_value;
                   2835:                  bfd_vma destination;
                   2836:                  struct elf32_hppa_link_hash_entry *hh;
                   2837:                  char *stub_name;
                   2838:                  const asection *id_sec;
                   2839:
                   2840:                  r_type = ELF32_R_TYPE (irela->r_info);
                   2841:                  r_indx = ELF32_R_SYM (irela->r_info);
                   2842:
                   2843:                  if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
                   2844:                    {
                   2845:                      bfd_set_error (bfd_error_bad_value);
                   2846:                    error_ret_free_internal:
                   2847:                      if (elf_section_data (section)->relocs == NULL)
                   2848:                        free (internal_relocs);
                   2849:                      goto error_ret_free_local;
                   2850:                    }
                   2851:
                   2852:                  /* Only look for stubs on call instructions.  */
                   2853:                  if (r_type != (unsigned int) R_PARISC_PCREL12F
                   2854:                      && r_type != (unsigned int) R_PARISC_PCREL17F
                   2855:                      && r_type != (unsigned int) R_PARISC_PCREL22F)
                   2856:                    continue;
                   2857:
                   2858:                  /* Now determine the call target, its name, value,
                   2859:                     section.  */
                   2860:                  sym_sec = NULL;
                   2861:                  sym_value = 0;
1.1.1.4   christos 2862:                  destination = -1;
1.1       christos 2863:                  hh = NULL;
                   2864:                  if (r_indx < symtab_hdr->sh_info)
                   2865:                    {
                   2866:                      /* It's a local symbol.  */
                   2867:                      Elf_Internal_Sym *sym;
                   2868:                      Elf_Internal_Shdr *hdr;
                   2869:                      unsigned int shndx;
                   2870:
                   2871:                      sym = local_syms + r_indx;
                   2872:                      if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
                   2873:                        sym_value = sym->st_value;
                   2874:                      shndx = sym->st_shndx;
                   2875:                      if (shndx < elf_numsections (input_bfd))
                   2876:                        {
                   2877:                          hdr = elf_elfsections (input_bfd)[shndx];
                   2878:                          sym_sec = hdr->bfd_section;
                   2879:                          destination = (sym_value + irela->r_addend
                   2880:                                         + sym_sec->output_offset
                   2881:                                         + sym_sec->output_section->vma);
                   2882:                        }
                   2883:                    }
                   2884:                  else
                   2885:                    {
                   2886:                      /* It's an external symbol.  */
                   2887:                      int e_indx;
                   2888:
                   2889:                      e_indx = r_indx - symtab_hdr->sh_info;
                   2890:                      hh = hppa_elf_hash_entry (elf_sym_hashes (input_bfd)[e_indx]);
                   2891:
                   2892:                      while (hh->eh.root.type == bfd_link_hash_indirect
                   2893:                             || hh->eh.root.type == bfd_link_hash_warning)
                   2894:                        hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
                   2895:
                   2896:                      if (hh->eh.root.type == bfd_link_hash_defined
                   2897:                          || hh->eh.root.type == bfd_link_hash_defweak)
                   2898:                        {
                   2899:                          sym_sec = hh->eh.root.u.def.section;
                   2900:                          sym_value = hh->eh.root.u.def.value;
                   2901:                          if (sym_sec->output_section != NULL)
                   2902:                            destination = (sym_value + irela->r_addend
                   2903:                                           + sym_sec->output_offset
                   2904:                                           + sym_sec->output_section->vma);
                   2905:                        }
                   2906:                      else if (hh->eh.root.type == bfd_link_hash_undefweak)
                   2907:                        {
1.1.1.2   christos 2908:                          if (! bfd_link_pic (info))
1.1       christos 2909:                            continue;
                   2910:                        }
                   2911:                      else if (hh->eh.root.type == bfd_link_hash_undefined)
                   2912:                        {
                   2913:                          if (! (info->unresolved_syms_in_objects == RM_IGNORE
                   2914:                                 && (ELF_ST_VISIBILITY (hh->eh.other)
                   2915:                                     == STV_DEFAULT)
                   2916:                                 && hh->eh.type != STT_PARISC_MILLI))
                   2917:                            continue;
                   2918:                        }
                   2919:                      else
                   2920:                        {
                   2921:                          bfd_set_error (bfd_error_bad_value);
                   2922:                          goto error_ret_free_internal;
                   2923:                        }
                   2924:                    }
                   2925:
                   2926:                  /* Determine what (if any) linker stub is needed.  */
                   2927:                  stub_type = hppa_type_of_stub (section, irela, hh,
                   2928:                                                 destination, info);
                   2929:                  if (stub_type == hppa_stub_none)
                   2930:                    continue;
                   2931:
                   2932:                  /* Support for grouping stub sections.  */
                   2933:                  id_sec = htab->stub_group[section->id].link_sec;
                   2934:
                   2935:                  /* Get the name of this stub.  */
                   2936:                  stub_name = hppa_stub_name (id_sec, sym_sec, hh, irela);
                   2937:                  if (!stub_name)
                   2938:                    goto error_ret_free_internal;
                   2939:
                   2940:                  hsh = hppa_stub_hash_lookup (&htab->bstab,
                   2941:                                                      stub_name,
                   2942:                                                      FALSE, FALSE);
                   2943:                  if (hsh != NULL)
                   2944:                    {
                   2945:                      /* The proper stub has already been created.  */
                   2946:                      free (stub_name);
                   2947:                      continue;
                   2948:                    }
                   2949:
                   2950:                  hsh = hppa_add_stub (stub_name, section, htab);
                   2951:                  if (hsh == NULL)
                   2952:                    {
                   2953:                      free (stub_name);
                   2954:                      goto error_ret_free_internal;
                   2955:                    }
                   2956:
                   2957:                  hsh->target_value = sym_value;
                   2958:                  hsh->target_section = sym_sec;
                   2959:                  hsh->stub_type = stub_type;
1.1.1.2   christos 2960:                  if (bfd_link_pic (info))
1.1       christos 2961:                    {
                   2962:                      if (stub_type == hppa_stub_import)
                   2963:                        hsh->stub_type = hppa_stub_import_shared;
                   2964:                      else if (stub_type == hppa_stub_long_branch)
                   2965:                        hsh->stub_type = hppa_stub_long_branch_shared;
                   2966:                    }
                   2967:                  hsh->hh = hh;
                   2968:                  stub_changed = TRUE;
                   2969:                }
                   2970:
                   2971:              /* We're done with the internal relocs, free them.  */
                   2972:              if (elf_section_data (section)->relocs == NULL)
                   2973:                free (internal_relocs);
                   2974:            }
                   2975:        }
                   2976:
                   2977:       if (!stub_changed)
                   2978:        break;
                   2979:
                   2980:       /* OK, we've added some stubs.  Find out the new size of the
                   2981:         stub sections.  */
                   2982:       for (stub_sec = htab->stub_bfd->sections;
                   2983:           stub_sec != NULL;
                   2984:           stub_sec = stub_sec->next)
1.1.1.3   christos 2985:        if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
                   2986:          stub_sec->size = 0;
1.1       christos 2987:
                   2988:       bfd_hash_traverse (&htab->bstab, hppa_size_one_stub, htab);
                   2989:
                   2990:       /* Ask the linker to do its stuff.  */
                   2991:       (*htab->layout_sections_again) ();
                   2992:       stub_changed = FALSE;
                   2993:     }
                   2994:
                   2995:   free (htab->all_local_syms);
                   2996:   return TRUE;
                   2997:
                   2998:  error_ret_free_local:
                   2999:   free (htab->all_local_syms);
                   3000:   return FALSE;
                   3001: }
                   3002:
                   3003: /* For a final link, this function is called after we have sized the
                   3004:    stubs to provide a value for __gp.  */
                   3005:
                   3006: bfd_boolean
                   3007: elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
                   3008: {
                   3009:   struct bfd_link_hash_entry *h;
                   3010:   asection *sec = NULL;
                   3011:   bfd_vma gp_val = 0;
                   3012:
1.1.1.4   christos 3013:   h = bfd_link_hash_lookup (info->hash, "$global$", FALSE, FALSE, FALSE);
1.1       christos 3014:
                   3015:   if (h != NULL
                   3016:       && (h->type == bfd_link_hash_defined
                   3017:          || h->type == bfd_link_hash_defweak))
                   3018:     {
                   3019:       gp_val = h->u.def.value;
                   3020:       sec = h->u.def.section;
                   3021:     }
                   3022:   else
                   3023:     {
                   3024:       asection *splt = bfd_get_section_by_name (abfd, ".plt");
                   3025:       asection *sgot = bfd_get_section_by_name (abfd, ".got");
                   3026:
                   3027:       /* Choose to point our LTP at, in this order, one of .plt, .got,
                   3028:         or .data, if these sections exist.  In the case of choosing
                   3029:         .plt try to make the LTP ideal for addressing anywhere in the
                   3030:         .plt or .got with a 14 bit signed offset.  Typically, the end
                   3031:         of the .plt is the start of the .got, so choose .plt + 0x2000
                   3032:         if either the .plt or .got is larger than 0x2000.  If both
                   3033:         the .plt and .got are smaller than 0x2000, choose the end of
                   3034:         the .plt section.  */
                   3035:       sec = strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0
                   3036:          ? NULL : splt;
                   3037:       if (sec != NULL)
                   3038:        {
                   3039:          gp_val = sec->size;
                   3040:          if (gp_val > 0x2000 || (sgot && sgot->size > 0x2000))
                   3041:            {
                   3042:              gp_val = 0x2000;
                   3043:            }
                   3044:        }
                   3045:       else
                   3046:        {
                   3047:          sec = sgot;
                   3048:          if (sec != NULL)
                   3049:            {
                   3050:              if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
                   3051:                {
1.1.1.4   christos 3052:                  /* We know we don't have a .plt.  If .got is large,
1.1       christos 3053:                     offset our LTP.  */
1.1.1.4   christos 3054:                  if (sec->size > 0x2000)
1.1       christos 3055:                    gp_val = 0x2000;
                   3056:                }
                   3057:            }
                   3058:          else
                   3059:            {
                   3060:              /* No .plt or .got.  Who cares what the LTP is?  */
                   3061:              sec = bfd_get_section_by_name (abfd, ".data");
                   3062:            }
                   3063:        }
                   3064:
                   3065:       if (h != NULL)
                   3066:        {
                   3067:          h->type = bfd_link_hash_defined;
                   3068:          h->u.def.value = gp_val;
                   3069:          if (sec != NULL)
                   3070:            h->u.def.section = sec;
                   3071:          else
                   3072:            h->u.def.section = bfd_abs_section_ptr;
                   3073:        }
                   3074:     }
                   3075:
1.1.1.4   christos 3076:   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
                   3077:     {
                   3078:       if (sec != NULL && sec->output_section != NULL)
                   3079:        gp_val += sec->output_section->vma + sec->output_offset;
1.1       christos 3080:
1.1.1.4   christos 3081:       elf_gp (abfd) = gp_val;
                   3082:     }
1.1       christos 3083:   return TRUE;
                   3084: }
                   3085:
                   3086: /* Build all the stubs associated with the current output file.  The
                   3087:    stubs are kept in a hash table attached to the main linker hash
                   3088:    table.  We also set up the .plt entries for statically linked PIC
                   3089:    functions here.  This function is called via hppaelf_finish in the
                   3090:    linker.  */
                   3091:
                   3092: bfd_boolean
                   3093: elf32_hppa_build_stubs (struct bfd_link_info *info)
                   3094: {
                   3095:   asection *stub_sec;
                   3096:   struct bfd_hash_table *table;
                   3097:   struct elf32_hppa_link_hash_table *htab;
                   3098:
                   3099:   htab = hppa_link_hash_table (info);
                   3100:   if (htab == NULL)
                   3101:     return FALSE;
                   3102:
                   3103:   for (stub_sec = htab->stub_bfd->sections;
                   3104:        stub_sec != NULL;
                   3105:        stub_sec = stub_sec->next)
1.1.1.3   christos 3106:     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
                   3107:        && stub_sec->size != 0)
                   3108:       {
                   3109:        /* Allocate memory to hold the linker stubs.  */
                   3110:        stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
                   3111:        if (stub_sec->contents == NULL)
                   3112:          return FALSE;
                   3113:        stub_sec->size = 0;
                   3114:       }
1.1       christos 3115:
                   3116:   /* Build the stubs as directed by the stub hash table.  */
                   3117:   table = &htab->bstab;
                   3118:   bfd_hash_traverse (table, hppa_build_one_stub, info);
                   3119:
                   3120:   return TRUE;
                   3121: }
                   3122:
                   3123: /* Return the base vma address which should be subtracted from the real
1.1.1.2   christos 3124:    address when resolving a dtpoff relocation.
1.1       christos 3125:    This is PT_TLS segment p_vaddr.  */
                   3126:
                   3127: static bfd_vma
                   3128: dtpoff_base (struct bfd_link_info *info)
                   3129: {
                   3130:   /* If tls_sec is NULL, we should have signalled an error already.  */
                   3131:   if (elf_hash_table (info)->tls_sec == NULL)
                   3132:     return 0;
                   3133:   return elf_hash_table (info)->tls_sec->vma;
                   3134: }
                   3135:
                   3136: /* Return the relocation value for R_PARISC_TLS_TPOFF*..  */
                   3137:
                   3138: static bfd_vma
                   3139: tpoff (struct bfd_link_info *info, bfd_vma address)
                   3140: {
                   3141:   struct elf_link_hash_table *htab = elf_hash_table (info);
                   3142:
                   3143:   /* If tls_sec is NULL, we should have signalled an error already.  */
                   3144:   if (htab->tls_sec == NULL)
                   3145:     return 0;
1.1.1.2   christos 3146:   /* hppa TLS ABI is variant I and static TLS block start just after
1.1       christos 3147:      tcbhead structure which has 2 pointer fields.  */
1.1.1.2   christos 3148:   return (address - htab->tls_sec->vma
1.1       christos 3149:          + align_power ((bfd_vma) 8, htab->tls_sec->alignment_power));
                   3150: }
                   3151:
                   3152: /* Perform a final link.  */
                   3153:
                   3154: static bfd_boolean
                   3155: elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
                   3156: {
1.1.1.2   christos 3157:   struct stat buf;
                   3158:
1.1       christos 3159:   /* Invoke the regular ELF linker to do all the work.  */
                   3160:   if (!bfd_elf_final_link (abfd, info))
                   3161:     return FALSE;
                   3162:
                   3163:   /* If we're producing a final executable, sort the contents of the
                   3164:      unwind section.  */
1.1.1.2   christos 3165:   if (bfd_link_relocatable (info))
                   3166:     return TRUE;
                   3167:
                   3168:   /* Do not attempt to sort non-regular files.  This is here
                   3169:      especially for configure scripts and kernel builds which run
                   3170:      tests with "ld [...] -o /dev/null".  */
                   3171:   if (stat (abfd->filename, &buf) != 0
                   3172:       || !S_ISREG(buf.st_mode))
1.1       christos 3173:     return TRUE;
                   3174:
                   3175:   return elf_hppa_sort_unwind (abfd);
                   3176: }
                   3177:
                   3178: /* Record the lowest address for the data and text segments.  */
                   3179:
                   3180: static void
                   3181: hppa_record_segment_addr (bfd *abfd, asection *section, void *data)
                   3182: {
                   3183:   struct elf32_hppa_link_hash_table *htab;
                   3184:
                   3185:   htab = (struct elf32_hppa_link_hash_table*) data;
                   3186:   if (htab == NULL)
                   3187:     return;
                   3188:
                   3189:   if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
                   3190:     {
                   3191:       bfd_vma value;
                   3192:       Elf_Internal_Phdr *p;
                   3193:
                   3194:       p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
                   3195:       BFD_ASSERT (p != NULL);
                   3196:       value = p->p_vaddr;
                   3197:
                   3198:       if ((section->flags & SEC_READONLY) != 0)
                   3199:        {
                   3200:          if (value < htab->text_segment_base)
                   3201:            htab->text_segment_base = value;
                   3202:        }
                   3203:       else
                   3204:        {
                   3205:          if (value < htab->data_segment_base)
                   3206:            htab->data_segment_base = value;
                   3207:        }
                   3208:     }
                   3209: }
                   3210:
                   3211: /* Perform a relocation as part of a final link.  */
                   3212:
                   3213: static bfd_reloc_status_type
                   3214: final_link_relocate (asection *input_section,
                   3215:                     bfd_byte *contents,
                   3216:                     const Elf_Internal_Rela *rela,
                   3217:                     bfd_vma value,
                   3218:                     struct elf32_hppa_link_hash_table *htab,
                   3219:                     asection *sym_sec,
                   3220:                     struct elf32_hppa_link_hash_entry *hh,
                   3221:                     struct bfd_link_info *info)
                   3222: {
1.1.1.5 ! christos 3223:   unsigned int insn;
1.1       christos 3224:   unsigned int r_type = ELF32_R_TYPE (rela->r_info);
                   3225:   unsigned int orig_r_type = r_type;
                   3226:   reloc_howto_type *howto = elf_hppa_howto_table + r_type;
                   3227:   int r_format = howto->bitsize;
                   3228:   enum hppa_reloc_field_selector_type_alt r_field;
                   3229:   bfd *input_bfd = input_section->owner;
                   3230:   bfd_vma offset = rela->r_offset;
                   3231:   bfd_vma max_branch_offset = 0;
                   3232:   bfd_byte *hit_data = contents + offset;
                   3233:   bfd_signed_vma addend = rela->r_addend;
                   3234:   bfd_vma location;
                   3235:   struct elf32_hppa_stub_hash_entry *hsh = NULL;
1.1.1.2   christos 3236:   int val;
1.1       christos 3237:
                   3238:   if (r_type == R_PARISC_NONE)
                   3239:     return bfd_reloc_ok;
                   3240:
                   3241:   insn = bfd_get_32 (input_bfd, hit_data);
                   3242:
                   3243:   /* Find out where we are and where we're going.  */
                   3244:   location = (offset +
                   3245:              input_section->output_offset +
                   3246:              input_section->output_section->vma);
                   3247:
                   3248:   /* If we are not building a shared library, convert DLTIND relocs to
                   3249:      DPREL relocs.  */
1.1.1.2   christos 3250:   if (!bfd_link_pic (info))
1.1       christos 3251:     {
                   3252:       switch (r_type)
                   3253:        {
                   3254:          case R_PARISC_DLTIND21L:
                   3255:          case R_PARISC_TLS_GD21L:
                   3256:          case R_PARISC_TLS_LDM21L:
                   3257:          case R_PARISC_TLS_IE21L:
                   3258:            r_type = R_PARISC_DPREL21L;
                   3259:            break;
                   3260:
                   3261:          case R_PARISC_DLTIND14R:
                   3262:          case R_PARISC_TLS_GD14R:
                   3263:          case R_PARISC_TLS_LDM14R:
                   3264:          case R_PARISC_TLS_IE14R:
                   3265:            r_type = R_PARISC_DPREL14R;
                   3266:            break;
                   3267:
                   3268:          case R_PARISC_DLTIND14F:
                   3269:            r_type = R_PARISC_DPREL14F;
                   3270:            break;
                   3271:        }
                   3272:     }
                   3273:
                   3274:   switch (r_type)
                   3275:     {
                   3276:     case R_PARISC_PCREL12F:
                   3277:     case R_PARISC_PCREL17F:
                   3278:     case R_PARISC_PCREL22F:
                   3279:       /* If this call should go via the plt, find the import stub in
                   3280:         the stub hash.  */
                   3281:       if (sym_sec == NULL
                   3282:          || sym_sec->output_section == NULL
                   3283:          || (hh != NULL
                   3284:              && hh->eh.plt.offset != (bfd_vma) -1
                   3285:              && hh->eh.dynindx != -1
                   3286:              && !hh->plabel
1.1.1.2   christos 3287:              && (bfd_link_pic (info)
1.1       christos 3288:                  || !hh->eh.def_regular
                   3289:                  || hh->eh.root.type == bfd_link_hash_defweak)))
                   3290:        {
                   3291:          hsh = hppa_get_stub_entry (input_section, sym_sec,
1.1.1.4   christos 3292:                                     hh, rela, htab);
1.1       christos 3293:          if (hsh != NULL)
                   3294:            {
                   3295:              value = (hsh->stub_offset
                   3296:                       + hsh->stub_sec->output_offset
                   3297:                       + hsh->stub_sec->output_section->vma);
                   3298:              addend = 0;
                   3299:            }
                   3300:          else if (sym_sec == NULL && hh != NULL
                   3301:                   && hh->eh.root.type == bfd_link_hash_undefweak)
                   3302:            {
                   3303:              /* It's OK if undefined weak.  Calls to undefined weak
                   3304:                 symbols behave as if the "called" function
                   3305:                 immediately returns.  We can thus call to a weak
                   3306:                 function without first checking whether the function
                   3307:                 is defined.  */
                   3308:              value = location;
                   3309:              addend = 8;
                   3310:            }
                   3311:          else
                   3312:            return bfd_reloc_undefined;
                   3313:        }
                   3314:       /* Fall thru.  */
                   3315:
                   3316:     case R_PARISC_PCREL21L:
                   3317:     case R_PARISC_PCREL17C:
                   3318:     case R_PARISC_PCREL17R:
                   3319:     case R_PARISC_PCREL14R:
                   3320:     case R_PARISC_PCREL14F:
                   3321:     case R_PARISC_PCREL32:
                   3322:       /* Make it a pc relative offset.  */
                   3323:       value -= location;
                   3324:       addend -= 8;
                   3325:       break;
                   3326:
                   3327:     case R_PARISC_DPREL21L:
                   3328:     case R_PARISC_DPREL14R:
                   3329:     case R_PARISC_DPREL14F:
                   3330:       /* Convert instructions that use the linkage table pointer (r19) to
                   3331:         instructions that use the global data pointer (dp).  This is the
                   3332:         most efficient way of using PIC code in an incomplete executable,
                   3333:         but the user must follow the standard runtime conventions for
                   3334:         accessing data for this to work.  */
                   3335:       if (orig_r_type != r_type)
                   3336:        {
                   3337:          if (r_type == R_PARISC_DPREL21L)
                   3338:            {
                   3339:              /* GCC sometimes uses a register other than r19 for the
                   3340:                 operation, so we must convert any addil instruction
                   3341:                 that uses this relocation.  */
1.1.1.5 ! christos 3342:              if ((insn & 0xfc000000) == OP_ADDIL << 26)
1.1       christos 3343:                insn = ADDIL_DP;
                   3344:              else
                   3345:                /* We must have a ldil instruction.  It's too hard to find
                   3346:                   and convert the associated add instruction, so issue an
                   3347:                   error.  */
1.1.1.4   christos 3348:                _bfd_error_handler
                   3349:                  /* xgettext:c-format */
                   3350:                  (_("%pB(%pA+%#" PRIx64 "): %s fixup for insn %#x "
                   3351:                     "is not supported in a non-shared link"),
1.1       christos 3352:                   input_bfd,
                   3353:                   input_section,
1.1.1.4   christos 3354:                   (uint64_t) offset,
1.1       christos 3355:                   howto->name,
                   3356:                   insn);
                   3357:            }
                   3358:          else if (r_type == R_PARISC_DPREL14F)
                   3359:            {
                   3360:              /* This must be a format 1 load/store.  Change the base
                   3361:                 register to dp.  */
                   3362:              insn = (insn & 0xfc1ffff) | (27 << 21);
                   3363:            }
                   3364:        }
                   3365:
                   3366:       /* For all the DP relative relocations, we need to examine the symbol's
                   3367:         section.  If it has no section or if it's a code section, then
                   3368:         "data pointer relative" makes no sense.  In that case we don't
                   3369:         adjust the "value", and for 21 bit addil instructions, we change the
                   3370:         source addend register from %dp to %r0.  This situation commonly
                   3371:         arises for undefined weak symbols and when a variable's "constness"
                   3372:         is declared differently from the way the variable is defined.  For
                   3373:         instance: "extern int foo" with foo defined as "const int foo".  */
                   3374:       if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
                   3375:        {
1.1.1.5 ! christos 3376:          if ((insn & ((0x3fu << 26) | (0x1f << 21)))
        !          3377:              == ((OP_ADDIL << 26) | (27 << 21)))
1.1       christos 3378:            {
                   3379:              insn &= ~ (0x1f << 21);
                   3380:            }
                   3381:          /* Now try to make things easy for the dynamic linker.  */
                   3382:
                   3383:          break;
                   3384:        }
                   3385:       /* Fall thru.  */
                   3386:
                   3387:     case R_PARISC_DLTIND21L:
                   3388:     case R_PARISC_DLTIND14R:
                   3389:     case R_PARISC_DLTIND14F:
                   3390:     case R_PARISC_TLS_GD21L:
                   3391:     case R_PARISC_TLS_LDM21L:
                   3392:     case R_PARISC_TLS_IE21L:
                   3393:     case R_PARISC_TLS_GD14R:
                   3394:     case R_PARISC_TLS_LDM14R:
                   3395:     case R_PARISC_TLS_IE14R:
                   3396:       value -= elf_gp (input_section->output_section->owner);
                   3397:       break;
                   3398:
                   3399:     case R_PARISC_SEGREL32:
                   3400:       if ((sym_sec->flags & SEC_CODE) != 0)
                   3401:        value -= htab->text_segment_base;
                   3402:       else
                   3403:        value -= htab->data_segment_base;
                   3404:       break;
                   3405:
                   3406:     default:
                   3407:       break;
                   3408:     }
                   3409:
                   3410:   switch (r_type)
                   3411:     {
                   3412:     case R_PARISC_DIR32:
                   3413:     case R_PARISC_DIR14F:
                   3414:     case R_PARISC_DIR17F:
                   3415:     case R_PARISC_PCREL17C:
                   3416:     case R_PARISC_PCREL14F:
                   3417:     case R_PARISC_PCREL32:
                   3418:     case R_PARISC_DPREL14F:
                   3419:     case R_PARISC_PLABEL32:
                   3420:     case R_PARISC_DLTIND14F:
                   3421:     case R_PARISC_SEGBASE:
                   3422:     case R_PARISC_SEGREL32:
                   3423:     case R_PARISC_TLS_DTPMOD32:
                   3424:     case R_PARISC_TLS_DTPOFF32:
                   3425:     case R_PARISC_TLS_TPREL32:
                   3426:       r_field = e_fsel;
                   3427:       break;
                   3428:
                   3429:     case R_PARISC_DLTIND21L:
                   3430:     case R_PARISC_PCREL21L:
                   3431:     case R_PARISC_PLABEL21L:
                   3432:       r_field = e_lsel;
                   3433:       break;
                   3434:
                   3435:     case R_PARISC_DIR21L:
                   3436:     case R_PARISC_DPREL21L:
                   3437:     case R_PARISC_TLS_GD21L:
                   3438:     case R_PARISC_TLS_LDM21L:
                   3439:     case R_PARISC_TLS_LDO21L:
                   3440:     case R_PARISC_TLS_IE21L:
                   3441:     case R_PARISC_TLS_LE21L:
                   3442:       r_field = e_lrsel;
                   3443:       break;
                   3444:
                   3445:     case R_PARISC_PCREL17R:
                   3446:     case R_PARISC_PCREL14R:
                   3447:     case R_PARISC_PLABEL14R:
                   3448:     case R_PARISC_DLTIND14R:
                   3449:       r_field = e_rsel;
                   3450:       break;
                   3451:
                   3452:     case R_PARISC_DIR17R:
                   3453:     case R_PARISC_DIR14R:
                   3454:     case R_PARISC_DPREL14R:
                   3455:     case R_PARISC_TLS_GD14R:
                   3456:     case R_PARISC_TLS_LDM14R:
                   3457:     case R_PARISC_TLS_LDO14R:
                   3458:     case R_PARISC_TLS_IE14R:
                   3459:     case R_PARISC_TLS_LE14R:
                   3460:       r_field = e_rrsel;
                   3461:       break;
                   3462:
                   3463:     case R_PARISC_PCREL12F:
                   3464:     case R_PARISC_PCREL17F:
                   3465:     case R_PARISC_PCREL22F:
                   3466:       r_field = e_fsel;
                   3467:
                   3468:       if (r_type == (unsigned int) R_PARISC_PCREL17F)
                   3469:        {
                   3470:          max_branch_offset = (1 << (17-1)) << 2;
                   3471:        }
                   3472:       else if (r_type == (unsigned int) R_PARISC_PCREL12F)
                   3473:        {
                   3474:          max_branch_offset = (1 << (12-1)) << 2;
                   3475:        }
                   3476:       else
                   3477:        {
                   3478:          max_branch_offset = (1 << (22-1)) << 2;
                   3479:        }
                   3480:
                   3481:       /* sym_sec is NULL on undefined weak syms or when shared on
                   3482:         undefined syms.  We've already checked for a stub for the
                   3483:         shared undefined case.  */
                   3484:       if (sym_sec == NULL)
                   3485:        break;
                   3486:
                   3487:       /* If the branch is out of reach, then redirect the
                   3488:         call to the local stub for this function.  */
                   3489:       if (value + addend + max_branch_offset >= 2*max_branch_offset)
                   3490:        {
                   3491:          hsh = hppa_get_stub_entry (input_section, sym_sec,
1.1.1.4   christos 3492:                                     hh, rela, htab);
1.1       christos 3493:          if (hsh == NULL)
                   3494:            return bfd_reloc_undefined;
                   3495:
                   3496:          /* Munge up the value and addend so that we call the stub
                   3497:             rather than the procedure directly.  */
                   3498:          value = (hsh->stub_offset
                   3499:                   + hsh->stub_sec->output_offset
                   3500:                   + hsh->stub_sec->output_section->vma
                   3501:                   - location);
                   3502:          addend = -8;
                   3503:        }
                   3504:       break;
                   3505:
                   3506:     /* Something we don't know how to handle.  */
                   3507:     default:
                   3508:       return bfd_reloc_notsupported;
                   3509:     }
                   3510:
                   3511:   /* Make sure we can reach the stub.  */
                   3512:   if (max_branch_offset != 0
                   3513:       && value + addend + max_branch_offset >= 2*max_branch_offset)
                   3514:     {
1.1.1.4   christos 3515:       _bfd_error_handler
                   3516:        /* xgettext:c-format */
                   3517:        (_("%pB(%pA+%#" PRIx64 "): cannot reach %s, "
                   3518:           "recompile with -ffunction-sections"),
1.1       christos 3519:         input_bfd,
                   3520:         input_section,
1.1.1.4   christos 3521:         (uint64_t) offset,
1.1       christos 3522:         hsh->bh_root.string);
                   3523:       bfd_set_error (bfd_error_bad_value);
                   3524:       return bfd_reloc_notsupported;
                   3525:     }
                   3526:
                   3527:   val = hppa_field_adjust (value, addend, r_field);
                   3528:
                   3529:   switch (r_type)
                   3530:     {
                   3531:     case R_PARISC_PCREL12F:
                   3532:     case R_PARISC_PCREL17C:
                   3533:     case R_PARISC_PCREL17F:
                   3534:     case R_PARISC_PCREL17R:
                   3535:     case R_PARISC_PCREL22F:
                   3536:     case R_PARISC_DIR17F:
                   3537:     case R_PARISC_DIR17R:
                   3538:       /* This is a branch.  Divide the offset by four.
                   3539:         Note that we need to decide whether it's a branch or
                   3540:         otherwise by inspecting the reloc.  Inspecting insn won't
                   3541:         work as insn might be from a .word directive.  */
                   3542:       val >>= 2;
                   3543:       break;
                   3544:
                   3545:     default:
                   3546:       break;
                   3547:     }
                   3548:
                   3549:   insn = hppa_rebuild_insn (insn, val, r_format);
                   3550:
                   3551:   /* Update the instruction word.  */
                   3552:   bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
                   3553:   return bfd_reloc_ok;
                   3554: }
                   3555:
                   3556: /* Relocate an HPPA ELF section.  */
                   3557:
                   3558: static bfd_boolean
                   3559: elf32_hppa_relocate_section (bfd *output_bfd,
                   3560:                             struct bfd_link_info *info,
                   3561:                             bfd *input_bfd,
                   3562:                             asection *input_section,
                   3563:                             bfd_byte *contents,
                   3564:                             Elf_Internal_Rela *relocs,
                   3565:                             Elf_Internal_Sym *local_syms,
                   3566:                             asection **local_sections)
                   3567: {
                   3568:   bfd_vma *local_got_offsets;
                   3569:   struct elf32_hppa_link_hash_table *htab;
                   3570:   Elf_Internal_Shdr *symtab_hdr;
                   3571:   Elf_Internal_Rela *rela;
                   3572:   Elf_Internal_Rela *relend;
                   3573:
                   3574:   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
                   3575:
                   3576:   htab = hppa_link_hash_table (info);
                   3577:   if (htab == NULL)
                   3578:     return FALSE;
                   3579:
                   3580:   local_got_offsets = elf_local_got_offsets (input_bfd);
                   3581:
                   3582:   rela = relocs;
                   3583:   relend = relocs + input_section->reloc_count;
                   3584:   for (; rela < relend; rela++)
                   3585:     {
                   3586:       unsigned int r_type;
                   3587:       reloc_howto_type *howto;
                   3588:       unsigned int r_symndx;
                   3589:       struct elf32_hppa_link_hash_entry *hh;
                   3590:       Elf_Internal_Sym *sym;
                   3591:       asection *sym_sec;
                   3592:       bfd_vma relocation;
                   3593:       bfd_reloc_status_type rstatus;
                   3594:       const char *sym_name;
                   3595:       bfd_boolean plabel;
                   3596:       bfd_boolean warned_undef;
                   3597:
                   3598:       r_type = ELF32_R_TYPE (rela->r_info);
                   3599:       if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
                   3600:        {
                   3601:          bfd_set_error (bfd_error_bad_value);
                   3602:          return FALSE;
                   3603:        }
                   3604:       if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
                   3605:          || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
                   3606:        continue;
                   3607:
                   3608:       r_symndx = ELF32_R_SYM (rela->r_info);
                   3609:       hh = NULL;
                   3610:       sym = NULL;
                   3611:       sym_sec = NULL;
                   3612:       warned_undef = FALSE;
                   3613:       if (r_symndx < symtab_hdr->sh_info)
                   3614:        {
                   3615:          /* This is a local symbol, h defaults to NULL.  */
                   3616:          sym = local_syms + r_symndx;
                   3617:          sym_sec = local_sections[r_symndx];
                   3618:          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rela);
                   3619:        }
                   3620:       else
                   3621:        {
                   3622:          struct elf_link_hash_entry *eh;
1.1.1.2   christos 3623:          bfd_boolean unresolved_reloc, ignored;
1.1       christos 3624:          struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
                   3625:
                   3626:          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,
                   3627:                                   r_symndx, symtab_hdr, sym_hashes,
                   3628:                                   eh, sym_sec, relocation,
1.1.1.2   christos 3629:                                   unresolved_reloc, warned_undef,
                   3630:                                   ignored);
1.1       christos 3631:
1.1.1.2   christos 3632:          if (!bfd_link_relocatable (info)
1.1       christos 3633:              && relocation == 0
                   3634:              && eh->root.type != bfd_link_hash_defined
                   3635:              && eh->root.type != bfd_link_hash_defweak
                   3636:              && eh->root.type != bfd_link_hash_undefweak)
                   3637:            {
                   3638:              if (info->unresolved_syms_in_objects == RM_IGNORE
                   3639:                  && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
                   3640:                  && eh->type == STT_PARISC_MILLI)
                   3641:                {
1.1.1.3   christos 3642:                  (*info->callbacks->undefined_symbol)
                   3643:                    (info, eh_name (eh), input_bfd,
                   3644:                     input_section, rela->r_offset, FALSE);
1.1       christos 3645:                  warned_undef = TRUE;
                   3646:                }
                   3647:            }
                   3648:          hh = hppa_elf_hash_entry (eh);
                   3649:        }
                   3650:
                   3651:       if (sym_sec != NULL && discarded_section (sym_sec))
                   3652:        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
                   3653:                                         rela, 1, relend,
                   3654:                                         elf_hppa_howto_table + r_type, 0,
                   3655:                                         contents);
                   3656:
1.1.1.2   christos 3657:       if (bfd_link_relocatable (info))
1.1       christos 3658:        continue;
                   3659:
                   3660:       /* Do any required modifications to the relocation value, and
                   3661:         determine what types of dynamic info we need to output, if
                   3662:         any.  */
                   3663:       plabel = 0;
                   3664:       switch (r_type)
                   3665:        {
                   3666:        case R_PARISC_DLTIND14F:
                   3667:        case R_PARISC_DLTIND14R:
                   3668:        case R_PARISC_DLTIND21L:
                   3669:          {
                   3670:            bfd_vma off;
1.1.1.4   christos 3671:            bfd_boolean do_got = FALSE;
                   3672:            bfd_boolean reloc = bfd_link_pic (info);
1.1       christos 3673:
                   3674:            /* Relocation is to the entry for this symbol in the
                   3675:               global offset table.  */
                   3676:            if (hh != NULL)
                   3677:              {
                   3678:                bfd_boolean dyn;
                   3679:
                   3680:                off = hh->eh.got.offset;
                   3681:                dyn = htab->etab.dynamic_sections_created;
1.1.1.4   christos 3682:                reloc = (!UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh)
                   3683:                         && (reloc
                   3684:                             || (hh->eh.dynindx != -1
                   3685:                                 && !SYMBOL_REFERENCES_LOCAL (info, &hh->eh))));
                   3686:                if (!reloc
                   3687:                    || !WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
                   3688:                                                         bfd_link_pic (info),
                   3689:                                                         &hh->eh))
1.1       christos 3690:                  {
                   3691:                    /* If we aren't going to call finish_dynamic_symbol,
                   3692:                       then we need to handle initialisation of the .got
                   3693:                       entry and create needed relocs here.  Since the
                   3694:                       offset must always be a multiple of 4, we use the
                   3695:                       least significant bit to record whether we have
                   3696:                       initialised it already.  */
                   3697:                    if ((off & 1) != 0)
                   3698:                      off &= ~1;
                   3699:                    else
                   3700:                      {
                   3701:                        hh->eh.got.offset |= 1;
1.1.1.4   christos 3702:                        do_got = TRUE;
1.1       christos 3703:                      }
                   3704:                  }
                   3705:              }
                   3706:            else
                   3707:              {
                   3708:                /* Local symbol case.  */
                   3709:                if (local_got_offsets == NULL)
                   3710:                  abort ();
                   3711:
                   3712:                off = local_got_offsets[r_symndx];
                   3713:
                   3714:                /* The offset must always be a multiple of 4.  We use
                   3715:                   the least significant bit to record whether we have
                   3716:                   already generated the necessary reloc.  */
                   3717:                if ((off & 1) != 0)
                   3718:                  off &= ~1;
                   3719:                else
                   3720:                  {
                   3721:                    local_got_offsets[r_symndx] |= 1;
1.1.1.4   christos 3722:                    do_got = TRUE;
1.1       christos 3723:                  }
                   3724:              }
                   3725:
                   3726:            if (do_got)
                   3727:              {
1.1.1.4   christos 3728:                if (reloc)
1.1       christos 3729:                  {
                   3730:                    /* Output a dynamic relocation for this GOT entry.
                   3731:                       In this case it is relative to the base of the
                   3732:                       object because the symbol index is zero.  */
                   3733:                    Elf_Internal_Rela outrel;
                   3734:                    bfd_byte *loc;
1.1.1.4   christos 3735:                    asection *sec = htab->etab.srelgot;
1.1       christos 3736:
                   3737:                    outrel.r_offset = (off
1.1.1.4   christos 3738:                                       + htab->etab.sgot->output_offset
                   3739:                                       + htab->etab.sgot->output_section->vma);
1.1       christos 3740:                    outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
                   3741:                    outrel.r_addend = relocation;
                   3742:                    loc = sec->contents;
                   3743:                    loc += sec->reloc_count++ * sizeof (Elf32_External_Rela);
                   3744:                    bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                   3745:                  }
                   3746:                else
                   3747:                  bfd_put_32 (output_bfd, relocation,
1.1.1.4   christos 3748:                              htab->etab.sgot->contents + off);
1.1       christos 3749:              }
                   3750:
                   3751:            if (off >= (bfd_vma) -2)
                   3752:              abort ();
                   3753:
                   3754:            /* Add the base of the GOT to the relocation value.  */
                   3755:            relocation = (off
1.1.1.4   christos 3756:                          + htab->etab.sgot->output_offset
                   3757:                          + htab->etab.sgot->output_section->vma);
1.1       christos 3758:          }
                   3759:          break;
                   3760:
                   3761:        case R_PARISC_SEGREL32:
                   3762:          /* If this is the first SEGREL relocation, then initialize
                   3763:             the segment base values.  */
                   3764:          if (htab->text_segment_base == (bfd_vma) -1)
                   3765:            bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab);
                   3766:          break;
                   3767:
                   3768:        case R_PARISC_PLABEL14R:
                   3769:        case R_PARISC_PLABEL21L:
                   3770:        case R_PARISC_PLABEL32:
                   3771:          if (htab->etab.dynamic_sections_created)
                   3772:            {
                   3773:              bfd_vma off;
                   3774:              bfd_boolean do_plt = 0;
                   3775:              /* If we have a global symbol with a PLT slot, then
                   3776:                 redirect this relocation to it.  */
                   3777:              if (hh != NULL)
                   3778:                {
                   3779:                  off = hh->eh.plt.offset;
1.1.1.2   christos 3780:                  if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1,
                   3781:                                                         bfd_link_pic (info),
1.1       christos 3782:                                                         &hh->eh))
                   3783:                    {
1.1.1.4   christos 3784:                      /* In a non-shared link, adjust_dynamic_symbol
1.1       christos 3785:                         isn't called for symbols forced local.  We
                   3786:                         need to write out the plt entry here.  */
                   3787:                      if ((off & 1) != 0)
                   3788:                        off &= ~1;
                   3789:                      else
                   3790:                        {
                   3791:                          hh->eh.plt.offset |= 1;
                   3792:                          do_plt = 1;
                   3793:                        }
                   3794:                    }
                   3795:                }
                   3796:              else
                   3797:                {
                   3798:                  bfd_vma *local_plt_offsets;
                   3799:
                   3800:                  if (local_got_offsets == NULL)
                   3801:                    abort ();
                   3802:
                   3803:                  local_plt_offsets = local_got_offsets + symtab_hdr->sh_info;
                   3804:                  off = local_plt_offsets[r_symndx];
                   3805:
                   3806:                  /* As for the local .got entry case, we use the last
                   3807:                     bit to record whether we've already initialised
                   3808:                     this local .plt entry.  */
                   3809:                  if ((off & 1) != 0)
                   3810:                    off &= ~1;
                   3811:                  else
                   3812:                    {
                   3813:                      local_plt_offsets[r_symndx] |= 1;
                   3814:                      do_plt = 1;
                   3815:                    }
                   3816:                }
                   3817:
                   3818:              if (do_plt)
                   3819:                {
1.1.1.2   christos 3820:                  if (bfd_link_pic (info))
1.1       christos 3821:                    {
                   3822:                      /* Output a dynamic IPLT relocation for this
                   3823:                         PLT entry.  */
                   3824:                      Elf_Internal_Rela outrel;
                   3825:                      bfd_byte *loc;
1.1.1.4   christos 3826:                      asection *s = htab->etab.srelplt;
1.1       christos 3827:
                   3828:                      outrel.r_offset = (off
1.1.1.4   christos 3829:                                         + htab->etab.splt->output_offset
                   3830:                                         + htab->etab.splt->output_section->vma);
1.1       christos 3831:                      outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
                   3832:                      outrel.r_addend = relocation;
                   3833:                      loc = s->contents;
                   3834:                      loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
                   3835:                      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                   3836:                    }
                   3837:                  else
                   3838:                    {
                   3839:                      bfd_put_32 (output_bfd,
                   3840:                                  relocation,
1.1.1.4   christos 3841:                                  htab->etab.splt->contents + off);
1.1       christos 3842:                      bfd_put_32 (output_bfd,
1.1.1.4   christos 3843:                                  elf_gp (htab->etab.splt->output_section->owner),
                   3844:                                  htab->etab.splt->contents + off + 4);
1.1       christos 3845:                    }
                   3846:                }
                   3847:
                   3848:              if (off >= (bfd_vma) -2)
                   3849:                abort ();
                   3850:
                   3851:              /* PLABELs contain function pointers.  Relocation is to
                   3852:                 the entry for the function in the .plt.  The magic +2
                   3853:                 offset signals to $$dyncall that the function pointer
                   3854:                 is in the .plt and thus has a gp pointer too.
                   3855:                 Exception:  Undefined PLABELs should have a value of
                   3856:                 zero.  */
                   3857:              if (hh == NULL
                   3858:                  || (hh->eh.root.type != bfd_link_hash_undefweak
                   3859:                      && hh->eh.root.type != bfd_link_hash_undefined))
                   3860:                {
                   3861:                  relocation = (off
1.1.1.4   christos 3862:                                + htab->etab.splt->output_offset
                   3863:                                + htab->etab.splt->output_section->vma
1.1       christos 3864:                                + 2);
                   3865:                }
                   3866:              plabel = 1;
                   3867:            }
1.1.1.4   christos 3868:          /* Fall through.  */
1.1       christos 3869:
                   3870:        case R_PARISC_DIR17F:
                   3871:        case R_PARISC_DIR17R:
                   3872:        case R_PARISC_DIR14F:
                   3873:        case R_PARISC_DIR14R:
                   3874:        case R_PARISC_DIR21L:
                   3875:        case R_PARISC_DPREL14F:
                   3876:        case R_PARISC_DPREL14R:
                   3877:        case R_PARISC_DPREL21L:
                   3878:        case R_PARISC_DIR32:
                   3879:          if ((input_section->flags & SEC_ALLOC) == 0)
                   3880:            break;
                   3881:
1.1.1.4   christos 3882:          if (bfd_link_pic (info)
                   3883:              ? ((hh == NULL
                   3884:                  || hh->dyn_relocs != NULL)
                   3885:                 && ((hh != NULL && pc_dynrelocs (hh))
                   3886:                     || IS_ABSOLUTE_RELOC (r_type)))
                   3887:              : (hh != NULL
                   3888:                 && hh->dyn_relocs != NULL))
1.1       christos 3889:            {
                   3890:              Elf_Internal_Rela outrel;
                   3891:              bfd_boolean skip;
                   3892:              asection *sreloc;
                   3893:              bfd_byte *loc;
                   3894:
                   3895:              /* When generating a shared object, these relocations
                   3896:                 are copied into the output file to be resolved at run
                   3897:                 time.  */
                   3898:
                   3899:              outrel.r_addend = rela->r_addend;
                   3900:              outrel.r_offset =
                   3901:                _bfd_elf_section_offset (output_bfd, info, input_section,
                   3902:                                         rela->r_offset);
                   3903:              skip = (outrel.r_offset == (bfd_vma) -1
                   3904:                      || outrel.r_offset == (bfd_vma) -2);
                   3905:              outrel.r_offset += (input_section->output_offset
                   3906:                                  + input_section->output_section->vma);
1.1.1.2   christos 3907:
1.1       christos 3908:              if (skip)
                   3909:                {
                   3910:                  memset (&outrel, 0, sizeof (outrel));
                   3911:                }
                   3912:              else if (hh != NULL
                   3913:                       && hh->eh.dynindx != -1
                   3914:                       && (plabel
                   3915:                           || !IS_ABSOLUTE_RELOC (r_type)
1.1.1.2   christos 3916:                           || !bfd_link_pic (info)
                   3917:                           || !SYMBOLIC_BIND (info, &hh->eh)
1.1       christos 3918:                           || !hh->eh.def_regular))
                   3919:                {
                   3920:                  outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
                   3921:                }
                   3922:              else /* It's a local symbol, or one marked to become local.  */
                   3923:                {
                   3924:                  int indx = 0;
                   3925:
                   3926:                  /* Add the absolute offset of the symbol.  */
                   3927:                  outrel.r_addend += relocation;
                   3928:
                   3929:                  /* Global plabels need to be processed by the
                   3930:                     dynamic linker so that functions have at most one
                   3931:                     fptr.  For this reason, we need to differentiate
                   3932:                     between global and local plabels, which we do by
                   3933:                     providing the function symbol for a global plabel
                   3934:                     reloc, and no symbol for local plabels.  */
                   3935:                  if (! plabel
                   3936:                      && sym_sec != NULL
                   3937:                      && sym_sec->output_section != NULL
                   3938:                      && ! bfd_is_abs_section (sym_sec))
                   3939:                    {
                   3940:                      asection *osec;
                   3941:
                   3942:                      osec = sym_sec->output_section;
                   3943:                      indx = elf_section_data (osec)->dynindx;
                   3944:                      if (indx == 0)
                   3945:                        {
                   3946:                          osec = htab->etab.text_index_section;
                   3947:                          indx = elf_section_data (osec)->dynindx;
                   3948:                        }
                   3949:                      BFD_ASSERT (indx != 0);
                   3950:
                   3951:                      /* We are turning this relocation into one
                   3952:                         against a section symbol, so subtract out the
                   3953:                         output section's address but not the offset
                   3954:                         of the input section in the output section.  */
                   3955:                      outrel.r_addend -= osec->vma;
                   3956:                    }
                   3957:
                   3958:                  outrel.r_info = ELF32_R_INFO (indx, r_type);
                   3959:                }
                   3960:              sreloc = elf_section_data (input_section)->sreloc;
                   3961:              if (sreloc == NULL)
                   3962:                abort ();
                   3963:
                   3964:              loc = sreloc->contents;
                   3965:              loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
                   3966:              bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                   3967:            }
                   3968:          break;
1.1.1.2   christos 3969:
1.1       christos 3970:        case R_PARISC_TLS_LDM21L:
                   3971:        case R_PARISC_TLS_LDM14R:
                   3972:          {
                   3973:            bfd_vma off;
1.1.1.2   christos 3974:
1.1       christos 3975:            off = htab->tls_ldm_got.offset;
                   3976:            if (off & 1)
                   3977:              off &= ~1;
                   3978:            else
                   3979:              {
                   3980:                Elf_Internal_Rela outrel;
                   3981:                bfd_byte *loc;
                   3982:
1.1.1.2   christos 3983:                outrel.r_offset = (off
1.1.1.4   christos 3984:                                   + htab->etab.sgot->output_section->vma
                   3985:                                   + htab->etab.sgot->output_offset);
1.1       christos 3986:                outrel.r_addend = 0;
                   3987:                outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32);
1.1.1.4   christos 3988:                loc = htab->etab.srelgot->contents;
                   3989:                loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1.1       christos 3990:
                   3991:                bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                   3992:                htab->tls_ldm_got.offset |= 1;
                   3993:              }
                   3994:
                   3995:            /* Add the base of the GOT to the relocation value.  */
                   3996:            relocation = (off
1.1.1.4   christos 3997:                          + htab->etab.sgot->output_offset
                   3998:                          + htab->etab.sgot->output_section->vma);
1.1       christos 3999:
                   4000:            break;
                   4001:          }
                   4002:
                   4003:        case R_PARISC_TLS_LDO21L:
                   4004:        case R_PARISC_TLS_LDO14R:
                   4005:          relocation -= dtpoff_base (info);
                   4006:          break;
                   4007:
                   4008:        case R_PARISC_TLS_GD21L:
                   4009:        case R_PARISC_TLS_GD14R:
                   4010:        case R_PARISC_TLS_IE21L:
                   4011:        case R_PARISC_TLS_IE14R:
                   4012:          {
                   4013:            bfd_vma off;
                   4014:            int indx;
                   4015:            char tls_type;
                   4016:
                   4017:            indx = 0;
                   4018:            if (hh != NULL)
                   4019:              {
1.1.1.4   christos 4020:                if (!htab->etab.dynamic_sections_created
                   4021:                    || hh->eh.dynindx == -1
                   4022:                    || SYMBOL_REFERENCES_LOCAL (info, &hh->eh)
                   4023:                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))
                   4024:                  /* This is actually a static link, or it is a
                   4025:                     -Bsymbolic link and the symbol is defined
                   4026:                     locally, or the symbol was forced to be local
                   4027:                     because of a version file.  */
                   4028:                  ;
                   4029:                else
                   4030:                  indx = hh->eh.dynindx;
1.1       christos 4031:                off = hh->eh.got.offset;
                   4032:                tls_type = hh->tls_type;
                   4033:              }
                   4034:            else
                   4035:              {
                   4036:                off = local_got_offsets[r_symndx];
                   4037:                tls_type = hppa_elf_local_got_tls_type (input_bfd)[r_symndx];
                   4038:              }
                   4039:
                   4040:            if (tls_type == GOT_UNKNOWN)
                   4041:              abort ();
                   4042:
                   4043:            if ((off & 1) != 0)
                   4044:              off &= ~1;
                   4045:            else
                   4046:              {
                   4047:                bfd_boolean need_relocs = FALSE;
                   4048:                Elf_Internal_Rela outrel;
                   4049:                bfd_byte *loc = NULL;
                   4050:                int cur_off = off;
                   4051:
1.1.1.4   christos 4052:                /* The GOT entries have not been initialized yet.  Do it
                   4053:                   now, and emit any relocations.  If both an IE GOT and a
                   4054:                   GD GOT are necessary, we emit the GD first.  */
                   4055:
                   4056:                if (indx != 0
                   4057:                    || (bfd_link_dll (info)
                   4058:                        && (hh == NULL
                   4059:                            || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
1.1       christos 4060:                  {
                   4061:                    need_relocs = TRUE;
1.1.1.4   christos 4062:                    loc = htab->etab.srelgot->contents;
                   4063:                    loc += (htab->etab.srelgot->reloc_count
                   4064:                            * sizeof (Elf32_External_Rela));
1.1       christos 4065:                  }
                   4066:
                   4067:                if (tls_type & GOT_TLS_GD)
                   4068:                  {
                   4069:                    if (need_relocs)
                   4070:                      {
1.1.1.4   christos 4071:                        outrel.r_offset
                   4072:                          = (cur_off
                   4073:                             + htab->etab.sgot->output_section->vma
                   4074:                             + htab->etab.sgot->output_offset);
                   4075:                        outrel.r_info
                   4076:                          = ELF32_R_INFO (indx, R_PARISC_TLS_DTPMOD32);
1.1       christos 4077:                        outrel.r_addend = 0;
                   4078:                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1.1.1.4   christos 4079:                        htab->etab.srelgot->reloc_count++;
1.1       christos 4080:                        loc += sizeof (Elf32_External_Rela);
1.1.1.4   christos 4081:                        bfd_put_32 (output_bfd, 0,
                   4082:                                    htab->etab.sgot->contents + cur_off);
1.1       christos 4083:                      }
                   4084:                    else
1.1.1.4   christos 4085:                      /* If we are not emitting relocations for a
                   4086:                         general dynamic reference, then we must be in a
                   4087:                         static link or an executable link with the
                   4088:                         symbol binding locally.  Mark it as belonging
                   4089:                         to module 1, the executable.  */
                   4090:                      bfd_put_32 (output_bfd, 1,
                   4091:                                  htab->etab.sgot->contents + cur_off);
                   4092:
                   4093:                    if (indx != 0)
1.1       christos 4094:                      {
1.1.1.4   christos 4095:                        outrel.r_info
                   4096:                          = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
                   4097:                        outrel.r_offset += 4;
                   4098:                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                   4099:                        htab->etab.srelgot->reloc_count++;
                   4100:                        loc += sizeof (Elf32_External_Rela);
                   4101:                        bfd_put_32 (output_bfd, 0,
                   4102:                                    htab->etab.sgot->contents + cur_off + 4);
1.1       christos 4103:                      }
1.1.1.4   christos 4104:                    else
                   4105:                      bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
                   4106:                                  htab->etab.sgot->contents + cur_off + 4);
1.1       christos 4107:                    cur_off += 8;
                   4108:                  }
                   4109:
                   4110:                if (tls_type & GOT_TLS_IE)
                   4111:                  {
1.1.1.4   christos 4112:                    if (need_relocs
                   4113:                        && !(bfd_link_executable (info)
                   4114:                             && SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
1.1       christos 4115:                      {
1.1.1.4   christos 4116:                        outrel.r_offset
                   4117:                          = (cur_off
                   4118:                             + htab->etab.sgot->output_section->vma
                   4119:                             + htab->etab.sgot->output_offset);
                   4120:                        outrel.r_info = ELF32_R_INFO (indx,
                   4121:                                                      R_PARISC_TLS_TPREL32);
1.1       christos 4122:                        if (indx == 0)
                   4123:                          outrel.r_addend = relocation - dtpoff_base (info);
                   4124:                        else
                   4125:                          outrel.r_addend = 0;
                   4126:                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1.1.1.4   christos 4127:                        htab->etab.srelgot->reloc_count++;
1.1       christos 4128:                        loc += sizeof (Elf32_External_Rela);
                   4129:                      }
                   4130:                    else
                   4131:                      bfd_put_32 (output_bfd, tpoff (info, relocation),
1.1.1.4   christos 4132:                                  htab->etab.sgot->contents + cur_off);
1.1       christos 4133:                    cur_off += 4;
                   4134:                  }
                   4135:
                   4136:                if (hh != NULL)
                   4137:                  hh->eh.got.offset |= 1;
                   4138:                else
                   4139:                  local_got_offsets[r_symndx] |= 1;
                   4140:              }
                   4141:
1.1.1.4   christos 4142:            if ((tls_type & GOT_NORMAL) != 0
                   4143:                && (tls_type & (GOT_TLS_GD | GOT_TLS_LDM | GOT_TLS_IE)) != 0)
                   4144:              {
                   4145:                if (hh != NULL)
                   4146:                  _bfd_error_handler (_("%s has both normal and TLS relocs"),
                   4147:                                      hh_name (hh));
                   4148:                else
                   4149:                  {
                   4150:                    Elf_Internal_Sym *isym
                   4151:                      = bfd_sym_from_r_symndx (&htab->sym_cache,
                   4152:                                               input_bfd, r_symndx);
                   4153:                    if (isym == NULL)
                   4154:                      return FALSE;
                   4155:                    sym_name
                   4156:                      = bfd_elf_string_from_elf_section (input_bfd,
                   4157:                                                         symtab_hdr->sh_link,
                   4158:                                                         isym->st_name);
                   4159:                    if (sym_name == NULL)
                   4160:                      return FALSE;
                   4161:                    if (*sym_name == '\0')
1.1.1.5 ! christos 4162:                      sym_name = bfd_section_name (sym_sec);
1.1.1.4   christos 4163:                    _bfd_error_handler
                   4164:                      (_("%pB:%s has both normal and TLS relocs"),
                   4165:                       input_bfd, sym_name);
                   4166:                  }
                   4167:                bfd_set_error (bfd_error_bad_value);
                   4168:                return FALSE;
                   4169:              }
                   4170:
1.1       christos 4171:            if ((tls_type & GOT_TLS_GD)
1.1.1.4   christos 4172:                && r_type != R_PARISC_TLS_GD21L
                   4173:                && r_type != R_PARISC_TLS_GD14R)
1.1       christos 4174:              off += 2 * GOT_ENTRY_SIZE;
                   4175:
                   4176:            /* Add the base of the GOT to the relocation value.  */
                   4177:            relocation = (off
1.1.1.4   christos 4178:                          + htab->etab.sgot->output_offset
                   4179:                          + htab->etab.sgot->output_section->vma);
1.1       christos 4180:
                   4181:            break;
                   4182:          }
                   4183:
                   4184:        case R_PARISC_TLS_LE21L:
                   4185:        case R_PARISC_TLS_LE14R:
                   4186:          {
                   4187:            relocation = tpoff (info, relocation);
                   4188:            break;
                   4189:          }
                   4190:          break;
                   4191:
                   4192:        default:
                   4193:          break;
                   4194:        }
                   4195:
                   4196:       rstatus = final_link_relocate (input_section, contents, rela, relocation,
                   4197:                               htab, sym_sec, hh, info);
                   4198:
                   4199:       if (rstatus == bfd_reloc_ok)
                   4200:        continue;
                   4201:
                   4202:       if (hh != NULL)
                   4203:        sym_name = hh_name (hh);
                   4204:       else
                   4205:        {
                   4206:          sym_name = bfd_elf_string_from_elf_section (input_bfd,
                   4207:                                                      symtab_hdr->sh_link,
                   4208:                                                      sym->st_name);
                   4209:          if (sym_name == NULL)
                   4210:            return FALSE;
                   4211:          if (*sym_name == '\0')
1.1.1.5 ! christos 4212:            sym_name = bfd_section_name (sym_sec);
1.1       christos 4213:        }
                   4214:
                   4215:       howto = elf_hppa_howto_table + r_type;
                   4216:
                   4217:       if (rstatus == bfd_reloc_undefined || rstatus == bfd_reloc_notsupported)
                   4218:        {
                   4219:          if (rstatus == bfd_reloc_notsupported || !warned_undef)
                   4220:            {
1.1.1.4   christos 4221:              _bfd_error_handler
                   4222:                /* xgettext:c-format */
                   4223:                (_("%pB(%pA+%#" PRIx64 "): cannot handle %s for %s"),
1.1       christos 4224:                 input_bfd,
                   4225:                 input_section,
1.1.1.4   christos 4226:                 (uint64_t) rela->r_offset,
1.1       christos 4227:                 howto->name,
                   4228:                 sym_name);
                   4229:              bfd_set_error (bfd_error_bad_value);
                   4230:              return FALSE;
                   4231:            }
                   4232:        }
                   4233:       else
1.1.1.3   christos 4234:        (*info->callbacks->reloc_overflow)
                   4235:          (info, (hh ? &hh->eh.root : NULL), sym_name, howto->name,
                   4236:           (bfd_vma) 0, input_bfd, input_section, rela->r_offset);
1.1       christos 4237:     }
                   4238:
                   4239:   return TRUE;
                   4240: }
                   4241:
                   4242: /* Finish up dynamic symbol handling.  We set the contents of various
                   4243:    dynamic sections here.  */
                   4244:
                   4245: static bfd_boolean
                   4246: elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
                   4247:                                  struct bfd_link_info *info,
                   4248:                                  struct elf_link_hash_entry *eh,
                   4249:                                  Elf_Internal_Sym *sym)
                   4250: {
                   4251:   struct elf32_hppa_link_hash_table *htab;
                   4252:   Elf_Internal_Rela rela;
                   4253:   bfd_byte *loc;
                   4254:
                   4255:   htab = hppa_link_hash_table (info);
                   4256:   if (htab == NULL)
                   4257:     return FALSE;
                   4258:
                   4259:   if (eh->plt.offset != (bfd_vma) -1)
                   4260:     {
                   4261:       bfd_vma value;
                   4262:
                   4263:       if (eh->plt.offset & 1)
                   4264:        abort ();
                   4265:
                   4266:       /* This symbol has an entry in the procedure linkage table.  Set
                   4267:         it up.
                   4268:
                   4269:         The format of a plt entry is
                   4270:         <funcaddr>
                   4271:         <__gp>
                   4272:       */
                   4273:       value = 0;
                   4274:       if (eh->root.type == bfd_link_hash_defined
                   4275:          || eh->root.type == bfd_link_hash_defweak)
                   4276:        {
                   4277:          value = eh->root.u.def.value;
                   4278:          if (eh->root.u.def.section->output_section != NULL)
                   4279:            value += (eh->root.u.def.section->output_offset
                   4280:                      + eh->root.u.def.section->output_section->vma);
                   4281:        }
                   4282:
                   4283:       /* Create a dynamic IPLT relocation for this entry.  */
                   4284:       rela.r_offset = (eh->plt.offset
1.1.1.4   christos 4285:                      + htab->etab.splt->output_offset
                   4286:                      + htab->etab.splt->output_section->vma);
1.1       christos 4287:       if (eh->dynindx != -1)
                   4288:        {
                   4289:          rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT);
                   4290:          rela.r_addend = 0;
                   4291:        }
                   4292:       else
                   4293:        {
                   4294:          /* This symbol has been marked to become local, and is
                   4295:             used by a plabel so must be kept in the .plt.  */
                   4296:          rela.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
                   4297:          rela.r_addend = value;
                   4298:        }
                   4299:
1.1.1.4   christos 4300:       loc = htab->etab.srelplt->contents;
                   4301:       loc += htab->etab.srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
                   4302:       bfd_elf32_swap_reloca_out (htab->etab.splt->output_section->owner, &rela, loc);
1.1       christos 4303:
                   4304:       if (!eh->def_regular)
                   4305:        {
                   4306:          /* Mark the symbol as undefined, rather than as defined in
                   4307:             the .plt section.  Leave the value alone.  */
                   4308:          sym->st_shndx = SHN_UNDEF;
                   4309:        }
                   4310:     }
                   4311:
                   4312:   if (eh->got.offset != (bfd_vma) -1
1.1.1.4   christos 4313:       && (hppa_elf_hash_entry (eh)->tls_type & GOT_NORMAL) != 0
                   4314:       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
1.1       christos 4315:     {
1.1.1.4   christos 4316:       bfd_boolean is_dyn = (eh->dynindx != -1
                   4317:                            && !SYMBOL_REFERENCES_LOCAL (info, eh));
1.1       christos 4318:
1.1.1.4   christos 4319:       if (is_dyn || bfd_link_pic (info))
1.1       christos 4320:        {
1.1.1.4   christos 4321:          /* This symbol has an entry in the global offset table.  Set
                   4322:             it up.  */
                   4323:
                   4324:          rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
                   4325:                           + htab->etab.sgot->output_offset
                   4326:                           + htab->etab.sgot->output_section->vma);
                   4327:
                   4328:          /* If this is a -Bsymbolic link and the symbol is defined
                   4329:             locally or was forced to be local because of a version
                   4330:             file, we just want to emit a RELATIVE reloc.  The entry
                   4331:             in the global offset table will already have been
                   4332:             initialized in the relocate_section function.  */
                   4333:          if (!is_dyn)
                   4334:            {
                   4335:              rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
                   4336:              rela.r_addend = (eh->root.u.def.value
                   4337:                               + eh->root.u.def.section->output_offset
                   4338:                               + eh->root.u.def.section->output_section->vma);
                   4339:            }
                   4340:          else
                   4341:            {
                   4342:              if ((eh->got.offset & 1) != 0)
                   4343:                abort ();
1.1       christos 4344:
1.1.1.4   christos 4345:              bfd_put_32 (output_bfd, 0,
                   4346:                          htab->etab.sgot->contents + (eh->got.offset & ~1));
                   4347:              rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
                   4348:              rela.r_addend = 0;
                   4349:            }
1.1       christos 4350:
1.1.1.4   christos 4351:          loc = htab->etab.srelgot->contents;
                   4352:          loc += (htab->etab.srelgot->reloc_count++
                   4353:                  * sizeof (Elf32_External_Rela));
                   4354:          bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
                   4355:        }
1.1       christos 4356:     }
                   4357:
                   4358:   if (eh->needs_copy)
                   4359:     {
                   4360:       asection *sec;
                   4361:
                   4362:       /* This symbol needs a copy reloc.  Set it up.  */
                   4363:
                   4364:       if (! (eh->dynindx != -1
                   4365:             && (eh->root.type == bfd_link_hash_defined
                   4366:                 || eh->root.type == bfd_link_hash_defweak)))
                   4367:        abort ();
                   4368:
                   4369:       rela.r_offset = (eh->root.u.def.value
                   4370:                      + eh->root.u.def.section->output_offset
                   4371:                      + eh->root.u.def.section->output_section->vma);
                   4372:       rela.r_addend = 0;
                   4373:       rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY);
1.1.1.4   christos 4374:       if (eh->root.u.def.section == htab->etab.sdynrelro)
                   4375:        sec = htab->etab.sreldynrelro;
                   4376:       else
                   4377:        sec = htab->etab.srelbss;
1.1       christos 4378:       loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela);
                   4379:       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
                   4380:     }
                   4381:
                   4382:   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
1.1.1.2   christos 4383:   if (eh == htab->etab.hdynamic || eh == htab->etab.hgot)
1.1       christos 4384:     {
                   4385:       sym->st_shndx = SHN_ABS;
                   4386:     }
                   4387:
                   4388:   return TRUE;
                   4389: }
                   4390:
                   4391: /* Used to decide how to sort relocs in an optimal manner for the
                   4392:    dynamic linker, before writing them out.  */
                   4393:
                   4394: static enum elf_reloc_type_class
1.1.1.2   christos 4395: elf32_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
                   4396:                             const asection *rel_sec ATTRIBUTE_UNUSED,
                   4397:                             const Elf_Internal_Rela *rela)
1.1       christos 4398: {
                   4399:   /* Handle TLS relocs first; we don't want them to be marked
                   4400:      relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)"
                   4401:      check below.  */
                   4402:   switch ((int) ELF32_R_TYPE (rela->r_info))
                   4403:     {
                   4404:       case R_PARISC_TLS_DTPMOD32:
                   4405:       case R_PARISC_TLS_DTPOFF32:
                   4406:       case R_PARISC_TLS_TPREL32:
1.1.1.4   christos 4407:        return reloc_class_normal;
1.1       christos 4408:     }
                   4409:
                   4410:   if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)
                   4411:     return reloc_class_relative;
                   4412:
                   4413:   switch ((int) ELF32_R_TYPE (rela->r_info))
                   4414:     {
                   4415:     case R_PARISC_IPLT:
                   4416:       return reloc_class_plt;
                   4417:     case R_PARISC_COPY:
                   4418:       return reloc_class_copy;
                   4419:     default:
                   4420:       return reloc_class_normal;
                   4421:     }
                   4422: }
                   4423:
                   4424: /* Finish up the dynamic sections.  */
                   4425:
                   4426: static bfd_boolean
                   4427: elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
                   4428:                                    struct bfd_link_info *info)
                   4429: {
                   4430:   bfd *dynobj;
                   4431:   struct elf32_hppa_link_hash_table *htab;
                   4432:   asection *sdyn;
                   4433:   asection * sgot;
                   4434:
                   4435:   htab = hppa_link_hash_table (info);
                   4436:   if (htab == NULL)
                   4437:     return FALSE;
                   4438:
                   4439:   dynobj = htab->etab.dynobj;
                   4440:
1.1.1.4   christos 4441:   sgot = htab->etab.sgot;
1.1       christos 4442:   /* A broken linker script might have discarded the dynamic sections.
                   4443:      Catch this here so that we do not seg-fault later on.  */
                   4444:   if (sgot != NULL && bfd_is_abs_section (sgot->output_section))
                   4445:     return FALSE;
                   4446:
                   4447:   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
                   4448:
                   4449:   if (htab->etab.dynamic_sections_created)
                   4450:     {
                   4451:       Elf32_External_Dyn *dyncon, *dynconend;
                   4452:
                   4453:       if (sdyn == NULL)
                   4454:        abort ();
                   4455:
                   4456:       dyncon = (Elf32_External_Dyn *) sdyn->contents;
                   4457:       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
                   4458:       for (; dyncon < dynconend; dyncon++)
                   4459:        {
                   4460:          Elf_Internal_Dyn dyn;
                   4461:          asection *s;
                   4462:
                   4463:          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
                   4464:
                   4465:          switch (dyn.d_tag)
                   4466:            {
                   4467:            default:
                   4468:              continue;
                   4469:
                   4470:            case DT_PLTGOT:
                   4471:              /* Use PLTGOT to set the GOT register.  */
                   4472:              dyn.d_un.d_ptr = elf_gp (output_bfd);
                   4473:              break;
                   4474:
                   4475:            case DT_JMPREL:
1.1.1.4   christos 4476:              s = htab->etab.srelplt;
1.1       christos 4477:              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
                   4478:              break;
                   4479:
                   4480:            case DT_PLTRELSZ:
1.1.1.4   christos 4481:              s = htab->etab.srelplt;
1.1       christos 4482:              dyn.d_un.d_val = s->size;
                   4483:              break;
                   4484:            }
                   4485:
                   4486:          bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
                   4487:        }
                   4488:     }
                   4489:
                   4490:   if (sgot != NULL && sgot->size != 0)
                   4491:     {
                   4492:       /* Fill in the first entry in the global offset table.
                   4493:         We use it to point to our dynamic section, if we have one.  */
                   4494:       bfd_put_32 (output_bfd,
                   4495:                  sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
                   4496:                  sgot->contents);
                   4497:
                   4498:       /* The second entry is reserved for use by the dynamic linker.  */
                   4499:       memset (sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
                   4500:
                   4501:       /* Set .got entry size.  */
                   4502:       elf_section_data (sgot->output_section)
                   4503:        ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
                   4504:     }
                   4505:
1.1.1.4   christos 4506:   if (htab->etab.splt != NULL && htab->etab.splt->size != 0)
1.1       christos 4507:     {
1.1.1.2   christos 4508:       /* Set plt entry size to 0 instead of PLT_ENTRY_SIZE, since we add the
                   4509:         plt stubs and as such the section does not hold a table of fixed-size
                   4510:         entries.  */
1.1.1.4   christos 4511:       elf_section_data (htab->etab.splt->output_section)->this_hdr.sh_entsize = 0;
1.1       christos 4512:
                   4513:       if (htab->need_plt_stub)
                   4514:        {
                   4515:          /* Set up the .plt stub.  */
1.1.1.4   christos 4516:          memcpy (htab->etab.splt->contents
                   4517:                  + htab->etab.splt->size - sizeof (plt_stub),
1.1       christos 4518:                  plt_stub, sizeof (plt_stub));
                   4519:
1.1.1.4   christos 4520:          if ((htab->etab.splt->output_offset
                   4521:               + htab->etab.splt->output_section->vma
                   4522:               + htab->etab.splt->size)
1.1       christos 4523:              != (sgot->output_offset
                   4524:                  + sgot->output_section->vma))
                   4525:            {
1.1.1.4   christos 4526:              _bfd_error_handler
1.1       christos 4527:                (_(".got section not immediately after .plt section"));
                   4528:              return FALSE;
                   4529:            }
                   4530:        }
                   4531:     }
                   4532:
                   4533:   return TRUE;
                   4534: }
                   4535:
                   4536: /* Called when writing out an object file to decide the type of a
                   4537:    symbol.  */
                   4538: static int
                   4539: elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
                   4540: {
                   4541:   if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
                   4542:     return STT_PARISC_MILLI;
                   4543:   else
                   4544:     return type;
                   4545: }
                   4546:
                   4547: /* Misc BFD support code.  */
                   4548: #define bfd_elf32_bfd_is_local_label_name    elf_hppa_is_local_label_name
                   4549: #define bfd_elf32_bfd_reloc_type_lookup             elf_hppa_reloc_type_lookup
                   4550: #define bfd_elf32_bfd_reloc_name_lookup      elf_hppa_reloc_name_lookup
                   4551: #define elf_info_to_howto                   elf_hppa_info_to_howto
                   4552: #define elf_info_to_howto_rel               elf_hppa_info_to_howto_rel
                   4553:
                   4554: /* Stuff for the BFD linker.  */
                   4555: #define bfd_elf32_bfd_final_link            elf32_hppa_final_link
                   4556: #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
                   4557: #define elf_backend_adjust_dynamic_symbol    elf32_hppa_adjust_dynamic_symbol
                   4558: #define elf_backend_copy_indirect_symbol     elf32_hppa_copy_indirect_symbol
                   4559: #define elf_backend_check_relocs            elf32_hppa_check_relocs
1.1.1.4   christos 4560: #define elf_backend_relocs_compatible       _bfd_elf_relocs_compatible
1.1       christos 4561: #define elf_backend_create_dynamic_sections  elf32_hppa_create_dynamic_sections
                   4562: #define elf_backend_fake_sections           elf_hppa_fake_sections
                   4563: #define elf_backend_relocate_section        elf32_hppa_relocate_section
                   4564: #define elf_backend_hide_symbol                     elf32_hppa_hide_symbol
                   4565: #define elf_backend_finish_dynamic_symbol    elf32_hppa_finish_dynamic_symbol
                   4566: #define elf_backend_finish_dynamic_sections  elf32_hppa_finish_dynamic_sections
                   4567: #define elf_backend_size_dynamic_sections    elf32_hppa_size_dynamic_sections
                   4568: #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
                   4569: #define elf_backend_gc_mark_hook            elf32_hppa_gc_mark_hook
                   4570: #define elf_backend_grok_prstatus           elf32_hppa_grok_prstatus
                   4571: #define elf_backend_grok_psinfo                     elf32_hppa_grok_psinfo
                   4572: #define elf_backend_object_p                elf32_hppa_object_p
                   4573: #define elf_backend_final_write_processing   elf_hppa_final_write_processing
                   4574: #define elf_backend_get_symbol_type         elf32_hppa_elf_get_symbol_type
                   4575: #define elf_backend_reloc_type_class        elf32_hppa_reloc_type_class
                   4576: #define elf_backend_action_discarded        elf_hppa_action_discarded
                   4577:
                   4578: #define elf_backend_can_gc_sections         1
                   4579: #define elf_backend_can_refcount            1
                   4580: #define elf_backend_plt_alignment           2
                   4581: #define elf_backend_want_got_plt            0
                   4582: #define elf_backend_plt_readonly            0
                   4583: #define elf_backend_want_plt_sym            0
                   4584: #define elf_backend_got_header_size         8
1.1.1.4   christos 4585: #define elf_backend_want_dynrelro           1
1.1       christos 4586: #define elf_backend_rela_normal                     1
1.1.1.4   christos 4587: #define elf_backend_dtrel_excludes_plt      1
                   4588: #define elf_backend_no_page_alias           1
1.1       christos 4589:
1.1.1.2   christos 4590: #define TARGET_BIG_SYM         hppa_elf32_vec
1.1       christos 4591: #define TARGET_BIG_NAME                "elf32-hppa"
                   4592: #define ELF_ARCH               bfd_arch_hppa
                   4593: #define ELF_TARGET_ID          HPPA32_ELF_DATA
                   4594: #define ELF_MACHINE_CODE       EM_PARISC
                   4595: #define ELF_MAXPAGESIZE                0x1000
                   4596: #define ELF_OSABI              ELFOSABI_HPUX
                   4597: #define elf32_bed              elf32_hppa_hpux_bed
                   4598:
                   4599: #include "elf32-target.h"
                   4600:
                   4601: #undef TARGET_BIG_SYM
1.1.1.2   christos 4602: #define TARGET_BIG_SYM         hppa_elf32_linux_vec
1.1       christos 4603: #undef TARGET_BIG_NAME
                   4604: #define TARGET_BIG_NAME                "elf32-hppa-linux"
                   4605: #undef ELF_OSABI
                   4606: #define ELF_OSABI              ELFOSABI_GNU
                   4607: #undef elf32_bed
                   4608: #define elf32_bed              elf32_hppa_linux_bed
                   4609:
                   4610: #include "elf32-target.h"
                   4611:
                   4612: #undef TARGET_BIG_SYM
1.1.1.2   christos 4613: #define TARGET_BIG_SYM         hppa_elf32_nbsd_vec
1.1       christos 4614: #undef TARGET_BIG_NAME
                   4615: #define TARGET_BIG_NAME                "elf32-hppa-netbsd"
                   4616: #undef ELF_OSABI
                   4617: #define ELF_OSABI              ELFOSABI_NETBSD
                   4618: #undef elf32_bed
                   4619: #define elf32_bed              elf32_hppa_netbsd_bed
                   4620:
                   4621: #include "elf32-target.h"

CVSweb <webmaster@jp.NetBSD.org>