Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/elf64-ia64-vms.c
Line
Count
Source (jump to first uncovered line)
1
/* IA-64 support for OpenVMS
2
   Copyright (C) 1998-2024 Free Software Foundation, Inc.
3
4
   This file is part of BFD, the Binary File Descriptor library.
5
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19
   MA 02110-1301, USA.  */
20
21
#include "sysdep.h"
22
#include "bfd.h"
23
#include "libbfd.h"
24
#include "elf-bfd.h"
25
#include "opcode/ia64.h"
26
#include "elf/ia64.h"
27
#include "objalloc.h"
28
#include "hashtab.h"
29
#include "elfxx-ia64.h"
30
#include "vms.h"
31
#include "bfdver.h"
32
33
/* THE RULES for all the stuff the linker creates --
34
35
  GOT   Entries created in response to LTOFF or LTOFF_FPTR
36
    relocations.  Dynamic relocs created for dynamic
37
    symbols in an application; REL relocs for locals
38
    in a shared library.
39
40
  FPTR    The canonical function descriptor.  Created for local
41
    symbols in applications.  Descriptors for dynamic symbols
42
    and local symbols in shared libraries are created by
43
    ld.so.  Thus there are no dynamic relocs against these
44
    objects.  The FPTR relocs for such _are_ passed through
45
    to the dynamic relocation tables.
46
47
  FULL_PLT  Created for a PCREL21B relocation against a dynamic symbol.
48
    Requires the creation of a PLTOFF entry.  This does not
49
    require any dynamic relocations.
50
51
  PLTOFF  Created by PLTOFF relocations.  For local symbols, this
52
    is an alternate function descriptor, and in shared libraries
53
    requires two REL relocations.  Note that this cannot be
54
    transformed into an FPTR relocation, since it must be in
55
    range of the GP.  For dynamic symbols, this is a function
56
    descriptor.  */
57
58
typedef struct bfd_hash_entry *(*new_hash_entry_func)
59
  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
60
61
/* In dynamically (linker-) created sections, we generally need to keep track
62
   of the place a symbol or expression got allocated to. This is done via hash
63
   tables that store entries of the following type.  */
64
65
struct elf64_ia64_dyn_sym_info
66
{
67
  /* The addend for which this entry is relevant.  */
68
  bfd_vma addend;
69
70
  bfd_vma got_offset;
71
  bfd_vma fptr_offset;
72
  bfd_vma pltoff_offset;
73
  bfd_vma plt_offset;
74
  bfd_vma plt2_offset;
75
76
  /* The symbol table entry, if any, that this was derived from.  */
77
  struct elf_link_hash_entry *h;
78
79
  /* Used to count non-got, non-plt relocations for delayed sizing
80
     of relocation sections.  */
81
  struct elf64_ia64_dyn_reloc_entry
82
  {
83
    struct elf64_ia64_dyn_reloc_entry *next;
84
    asection *srel;
85
    int type;
86
    int count;
87
  } *reloc_entries;
88
89
  /* TRUE when the section contents have been updated.  */
90
  unsigned got_done : 1;
91
  unsigned fptr_done : 1;
92
  unsigned pltoff_done : 1;
93
94
  /* TRUE for the different kinds of linker data we want created.  */
95
  unsigned want_got : 1;
96
  unsigned want_gotx : 1;
97
  unsigned want_fptr : 1;
98
  unsigned want_ltoff_fptr : 1;
99
  unsigned want_plt : 1;  /* A MIN_PLT entry.  */
100
  unsigned want_plt2 : 1; /* A FULL_PLT.  */
101
  unsigned want_pltoff : 1;
102
};
103
104
struct elf64_ia64_local_hash_entry
105
{
106
  int id;
107
  unsigned int r_sym;
108
  /* The number of elements in elf64_ia64_dyn_sym_info array.  */
109
  unsigned int count;
110
  /* The number of sorted elements in elf64_ia64_dyn_sym_info array.  */
111
  unsigned int sorted_count;
112
  /* The size of elf64_ia64_dyn_sym_info array.  */
113
  unsigned int size;
114
  /* The array of elf64_ia64_dyn_sym_info.  */
115
  struct elf64_ia64_dyn_sym_info *info;
116
117
  /* TRUE if this hash entry's addends was translated for
118
     SHF_MERGE optimization.  */
119
  unsigned sec_merge_done : 1;
120
};
121
122
struct elf64_ia64_link_hash_entry
123
{
124
  struct elf_link_hash_entry root;
125
126
  /* Set if this symbol is defined in a shared library.
127
     We can't use root.u.def.section->owner as the symbol is an absolute
128
     symbol.  */
129
  bfd *shl;
130
131
  /* The number of elements in elf64_ia64_dyn_sym_info array.  */
132
  unsigned int count;
133
  /* The number of sorted elements in elf64_ia64_dyn_sym_info array.  */
134
  unsigned int sorted_count;
135
  /* The size of elf64_ia64_dyn_sym_info array.  */
136
  unsigned int size;
137
  /* The array of elf64_ia64_dyn_sym_info.  */
138
  struct elf64_ia64_dyn_sym_info *info;
139
};
140
141
struct elf64_ia64_link_hash_table
142
{
143
  /* The main hash table.  */
144
  struct elf_link_hash_table root;
145
146
  asection *fptr_sec;   /* Function descriptor table (or NULL).  */
147
  asection *rel_fptr_sec; /* Dynamic relocation section for same.  */
148
  asection *pltoff_sec;   /* Private descriptors for plt (or NULL).  */
149
  asection *fixups_sec;   /* Fixups section.  */
150
  asection *transfer_sec; /* Transfer vector section.  */
151
  asection *note_sec;   /* .note section.  */
152
153
  /* There are maybe R_IA64_GPREL22 relocations, including those
154
     optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
155
     sections.  We need to record those sections so that we can choose
156
     a proper GP to cover all R_IA64_GPREL22 relocations.  */
157
  asection *max_short_sec;  /* Maximum short output section.  */
158
  bfd_vma max_short_offset; /* Maximum short offset.  */
159
  asection *min_short_sec;  /* Minimum short output section.  */
160
  bfd_vma min_short_offset; /* Minimum short offset.  */
161
162
  htab_t loc_hash_table;
163
  void *loc_hash_memory;
164
};
165
166
struct elf64_ia64_allocate_data
167
{
168
  struct bfd_link_info *info;
169
  bfd_size_type ofs;
170
};
171
172
#define elf64_ia64_hash_table(p) \
173
0
  ((is_elf_hash_table ((p)->hash)          \
174
0
    && elf_hash_table_id (elf_hash_table (p)) == IA64_ELF_DATA)   \
175
0
   ? (struct elf64_ia64_link_hash_table *) (p)->hash : NULL)
176
177
struct elf64_ia64_vms_obj_tdata
178
{
179
  struct elf_obj_tdata root;
180
181
  /* Ident for shared library.  */
182
  uint64_t ident;
183
184
  /* Used only during link: offset in the .fixups section for this bfd.  */
185
  bfd_vma fixups_off;
186
187
  /* Max number of shared libraries.  */
188
  unsigned int needed_count;
189
};
190
191
#define elf_ia64_vms_tdata(abfd) \
192
0
  ((struct elf64_ia64_vms_obj_tdata *)((abfd)->tdata.any))
193
0
#define elf_ia64_vms_ident(abfd) (elf_ia64_vms_tdata(abfd)->ident)
194
195
struct elf64_vms_transfer
196
{
197
  unsigned char size[4];
198
  unsigned char spare[4];
199
  unsigned char tfradr1[8];
200
  unsigned char tfradr2[8];
201
  unsigned char tfradr3[8];
202
  unsigned char tfradr4[8];
203
  unsigned char tfradr5[8];
204
205
  /* Local function descriptor for tfr3.  */
206
  unsigned char tfr3_func[8];
207
  unsigned char tfr3_gp[8];
208
};
209
210
typedef struct
211
{
212
  Elf64_External_Ehdr ehdr;
213
  unsigned char vms_needed_count[8];
214
} Elf64_External_VMS_Ehdr;
215
216
static struct elf64_ia64_dyn_sym_info * get_dyn_sym_info
217
  (struct elf64_ia64_link_hash_table *,
218
   struct elf_link_hash_entry *,
219
   bfd *, const Elf_Internal_Rela *, bool);
220
static bool elf64_ia64_dynamic_symbol_p
221
  (struct elf_link_hash_entry *);
222
static bool elf64_ia64_choose_gp
223
  (bfd *, struct bfd_link_info *, bool);
224
static void elf64_ia64_dyn_sym_traverse
225
  (struct elf64_ia64_link_hash_table *,
226
   bool (*) (struct elf64_ia64_dyn_sym_info *, void *),
227
   void *);
228
static bool allocate_global_data_got
229
  (struct elf64_ia64_dyn_sym_info *, void *);
230
static bool allocate_global_fptr_got
231
  (struct elf64_ia64_dyn_sym_info *, void *);
232
static bool allocate_local_got
233
  (struct elf64_ia64_dyn_sym_info *, void *);
234
static bool allocate_dynrel_entries
235
  (struct elf64_ia64_dyn_sym_info *, void *);
236
static asection *get_pltoff
237
  (bfd *, struct elf64_ia64_link_hash_table *);
238
static asection *get_got
239
  (bfd *, struct elf64_ia64_link_hash_table *);
240
241
242
/* Given a ELF reloc, return the matching HOWTO structure.  */
243
244
static bool
245
elf64_ia64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
246
        arelent *bfd_reloc,
247
        Elf_Internal_Rela *elf_reloc)
248
65
{
249
65
  unsigned int r_type = ELF32_R_TYPE (elf_reloc->r_info);
250
251
65
  bfd_reloc->howto = ia64_elf_lookup_howto (r_type);
252
65
  if (bfd_reloc->howto == NULL)
253
12
    {
254
      /* xgettext:c-format */
255
12
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
256
12
        abfd, r_type);
257
12
      bfd_set_error (bfd_error_bad_value);
258
12
      return false;
259
12
    }
260
261
53
  return true;
262
65
}
263
264
265
0
#define PLT_FULL_ENTRY_SIZE (2 * 16)
266
267
static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
268
{
269
  0x0b, 0x78, 0x00, 0x02, 0x00, 0x24,  /*   [MMI] addl r15=0,r1;;   */
270
  0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0,  /*   ld8.acq r16=[r15],8*/
271
  0x01, 0x08, 0x00, 0x84,        /*   mov r14=r1;;    */
272
  0x11, 0x08, 0x00, 0x1e, 0x18, 0x10,  /*   [MIB] ld8 r1=[r15]    */
273
  0x60, 0x80, 0x04, 0x80, 0x03, 0x00,  /*   mov b6=r16    */
274
  0x60, 0x00, 0x80, 0x00         /*   br.few b6;;   */
275
};
276
277
static const bfd_byte oor_brl[16] =
278
{
279
  0x05, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]  nop.m 0     */
280
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /*   brl.sptk.few tgt;;*/
281
  0x00, 0x00, 0x00, 0xc0
282
};
283
284
285
/* These functions do relaxation for IA-64 ELF.  */
286
287
/* Rename some of the generic section flags to better document how they
288
   are used here.  */
289
0
#define skip_relax_pass_0 sec_flg0
290
0
#define skip_relax_pass_1 sec_flg1
291
292
static void
293
elf64_ia64_update_short_info (asection *sec, bfd_vma offset,
294
            struct elf64_ia64_link_hash_table *ia64_info)
295
0
{
296
  /* Skip ABS and SHF_IA_64_SHORT sections.  */
297
0
  if (sec == bfd_abs_section_ptr
298
0
      || (sec->flags & SEC_SMALL_DATA) != 0)
299
0
    return;
300
301
0
  if (!ia64_info->min_short_sec)
302
0
    {
303
0
      ia64_info->max_short_sec = sec;
304
0
      ia64_info->max_short_offset = offset;
305
0
      ia64_info->min_short_sec = sec;
306
0
      ia64_info->min_short_offset = offset;
307
0
    }
308
0
  else if (sec == ia64_info->max_short_sec
309
0
     && offset > ia64_info->max_short_offset)
310
0
    ia64_info->max_short_offset = offset;
311
0
  else if (sec == ia64_info->min_short_sec
312
0
     && offset < ia64_info->min_short_offset)
313
0
    ia64_info->min_short_offset = offset;
314
0
  else if (sec->output_section->vma
315
0
     > ia64_info->max_short_sec->vma)
316
0
    {
317
0
      ia64_info->max_short_sec = sec;
318
0
      ia64_info->max_short_offset = offset;
319
0
    }
320
0
  else if (sec->output_section->vma
321
0
     < ia64_info->min_short_sec->vma)
322
0
    {
323
0
      ia64_info->min_short_sec = sec;
324
0
      ia64_info->min_short_offset = offset;
325
0
    }
326
0
}
327
328
/* Use a two passes algorithm.  In the first pass, branches are relaxed
329
   (which may increase the size of the section).  In the second pass,
330
   the other relaxations are done.
331
*/
332
333
static bool
334
elf64_ia64_relax_section (bfd *abfd, asection *sec,
335
        struct bfd_link_info *link_info,
336
        bool *again)
337
0
{
338
0
  struct one_fixup
339
0
    {
340
0
      struct one_fixup *next;
341
0
      asection *tsec;
342
0
      bfd_vma toff;
343
0
      bfd_vma trampoff;
344
0
    };
345
346
0
  Elf_Internal_Shdr *symtab_hdr;
347
0
  Elf_Internal_Rela *internal_relocs;
348
0
  Elf_Internal_Rela *irel, *irelend;
349
0
  bfd_byte *contents;
350
0
  Elf_Internal_Sym *isymbuf = NULL;
351
0
  struct elf64_ia64_link_hash_table *ia64_info;
352
0
  struct one_fixup *fixups = NULL;
353
0
  bool changed_contents = false;
354
0
  bool changed_relocs = false;
355
0
  bool skip_relax_pass_0 = true;
356
0
  bool skip_relax_pass_1 = true;
357
0
  bfd_vma gp = 0;
358
359
  /* Assume we're not going to change any sizes, and we'll only need
360
     one pass.  */
361
0
  *again = false;
362
363
0
  if (bfd_link_relocatable (link_info))
364
0
    (*link_info->callbacks->einfo)
365
0
      (_("%P%F: --relax and -r may not be used together\n"));
366
367
  /* Don't even try to relax for non-ELF outputs.  */
368
0
  if (!is_elf_hash_table (link_info->hash))
369
0
    return false;
370
371
  /* Nothing to do if there are no relocations or there is no need for
372
     the current pass.  */
373
0
  if (sec->reloc_count == 0
374
0
      || (sec->flags & SEC_RELOC) == 0
375
0
      || (sec->flags & SEC_HAS_CONTENTS) == 0
376
0
      || (link_info->relax_pass == 0 && sec->skip_relax_pass_0)
377
0
      || (link_info->relax_pass == 1 && sec->skip_relax_pass_1))
378
0
    return true;
379
380
0
  ia64_info = elf64_ia64_hash_table (link_info);
381
0
  if (ia64_info == NULL)
382
0
    return false;
383
384
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
385
386
  /* Load the relocations for this section.  */
387
0
  internal_relocs = (_bfd_elf_link_read_relocs
388
0
         (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
389
0
          link_info->keep_memory));
390
0
  if (internal_relocs == NULL)
391
0
    return false;
392
393
0
  irelend = internal_relocs + sec->reloc_count;
394
395
  /* Get the section contents.  */
396
0
  if (elf_section_data (sec)->this_hdr.contents != NULL)
397
0
    contents = elf_section_data (sec)->this_hdr.contents;
398
0
  else
399
0
    {
400
0
      if (!bfd_malloc_and_get_section (abfd, sec, &contents))
401
0
  goto error_return;
402
0
    }
403
404
0
  for (irel = internal_relocs; irel < irelend; irel++)
405
0
    {
406
0
      unsigned long r_type = ELF64_R_TYPE (irel->r_info);
407
0
      bfd_vma symaddr, reladdr, trampoff, toff, roff;
408
0
      asection *tsec;
409
0
      struct one_fixup *f;
410
0
      bfd_size_type amt;
411
0
      bool is_branch;
412
0
      struct elf64_ia64_dyn_sym_info *dyn_i;
413
414
0
      switch (r_type)
415
0
  {
416
0
  case R_IA64_PCREL21B:
417
0
  case R_IA64_PCREL21BI:
418
0
  case R_IA64_PCREL21M:
419
0
  case R_IA64_PCREL21F:
420
    /* In pass 1, all br relaxations are done. We can skip it. */
421
0
    if (link_info->relax_pass == 1)
422
0
      continue;
423
0
    skip_relax_pass_0 = false;
424
0
    is_branch = true;
425
0
    break;
426
427
0
  case R_IA64_PCREL60B:
428
    /* We can't optimize brl to br in pass 0 since br relaxations
429
       will increase the code size. Defer it to pass 1.  */
430
0
    if (link_info->relax_pass == 0)
431
0
      {
432
0
        skip_relax_pass_1 = false;
433
0
        continue;
434
0
      }
435
0
    is_branch = true;
436
0
    break;
437
438
0
  case R_IA64_GPREL22:
439
    /* Update max_short_sec/min_short_sec.  */
440
441
0
  case R_IA64_LTOFF22X:
442
0
  case R_IA64_LDXMOV:
443
    /* We can't relax ldx/mov in pass 0 since br relaxations will
444
       increase the code size. Defer it to pass 1.  */
445
0
    if (link_info->relax_pass == 0)
446
0
      {
447
0
        skip_relax_pass_1 = false;
448
0
        continue;
449
0
      }
450
0
    is_branch = false;
451
0
    break;
452
453
0
  default:
454
0
    continue;
455
0
  }
456
457
      /* Get the value of the symbol referred to by the reloc.  */
458
0
      if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
459
0
  {
460
    /* A local symbol.  */
461
0
    Elf_Internal_Sym *isym;
462
463
    /* Read this BFD's local symbols.  */
464
0
    if (isymbuf == NULL)
465
0
      {
466
0
        isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
467
0
        if (isymbuf == NULL)
468
0
    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
469
0
            symtab_hdr->sh_info, 0,
470
0
            NULL, NULL, NULL);
471
0
        if (isymbuf == 0)
472
0
    goto error_return;
473
0
      }
474
475
0
    isym = isymbuf + ELF64_R_SYM (irel->r_info);
476
0
    if (isym->st_shndx == SHN_UNDEF)
477
0
      continue; /* We can't do anything with undefined symbols.  */
478
0
    else if (isym->st_shndx == SHN_ABS)
479
0
      tsec = bfd_abs_section_ptr;
480
0
    else if (isym->st_shndx == SHN_COMMON)
481
0
      tsec = bfd_com_section_ptr;
482
0
    else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
483
0
      tsec = bfd_com_section_ptr;
484
0
    else
485
0
      tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
486
487
0
    toff = isym->st_value;
488
0
    dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, false);
489
0
  }
490
0
      else
491
0
  {
492
0
    unsigned long indx;
493
0
    struct elf_link_hash_entry *h;
494
495
0
    indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
496
0
    h = elf_sym_hashes (abfd)[indx];
497
0
    BFD_ASSERT (h != NULL);
498
499
0
    while (h->root.type == bfd_link_hash_indirect
500
0
     || h->root.type == bfd_link_hash_warning)
501
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
502
503
0
    dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, false);
504
505
    /* For branches to dynamic symbols, we're interested instead
506
       in a branch to the PLT entry.  */
507
0
    if (is_branch && dyn_i && dyn_i->want_plt2)
508
0
      {
509
        /* Internal branches shouldn't be sent to the PLT.
510
     Leave this for now and we'll give an error later.  */
511
0
        if (r_type != R_IA64_PCREL21B)
512
0
    continue;
513
514
0
        tsec = ia64_info->root.splt;
515
0
        toff = dyn_i->plt2_offset;
516
0
        BFD_ASSERT (irel->r_addend == 0);
517
0
      }
518
519
    /* Can't do anything else with dynamic symbols.  */
520
0
    else if (elf64_ia64_dynamic_symbol_p (h))
521
0
      continue;
522
523
0
    else
524
0
      {
525
        /* We can't do anything with undefined symbols.  */
526
0
        if (h->root.type == bfd_link_hash_undefined
527
0
      || h->root.type == bfd_link_hash_undefweak)
528
0
    continue;
529
530
0
        tsec = h->root.u.def.section;
531
0
        toff = h->root.u.def.value;
532
0
      }
533
0
  }
534
535
0
      toff += irel->r_addend;
536
537
0
      symaddr = tsec->output_section->vma + tsec->output_offset + toff;
538
539
0
      roff = irel->r_offset;
540
541
0
      if (is_branch)
542
0
  {
543
0
    bfd_signed_vma offset;
544
545
0
    reladdr = (sec->output_section->vma
546
0
         + sec->output_offset
547
0
         + roff) & (bfd_vma) -4;
548
549
    /* The .plt section is aligned at 32byte and the .text section
550
       is aligned at 64byte. The .text section is right after the
551
       .plt section.  After the first relaxation pass, linker may
552
       increase the gap between the .plt and .text sections up
553
       to 32byte.  We assume linker will always insert 32byte
554
       between the .plt and .text sections after the first
555
       relaxation pass.  */
556
0
    if (tsec == ia64_info->root.splt)
557
0
      offset = -0x1000000 + 32;
558
0
    else
559
0
      offset = -0x1000000;
560
561
    /* If the branch is in range, no need to do anything.  */
562
0
    if ((bfd_signed_vma) (symaddr - reladdr) >= offset
563
0
        && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
564
0
      {
565
        /* If the 60-bit branch is in 21-bit range, optimize it. */
566
0
        if (r_type == R_IA64_PCREL60B)
567
0
    {
568
0
      ia64_elf_relax_brl (contents, roff);
569
570
0
      irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
571
0
                 R_IA64_PCREL21B);
572
573
      /* If the original relocation offset points to slot
574
         1, change it to slot 2.  */
575
0
      if ((irel->r_offset & 3) == 1)
576
0
        irel->r_offset += 1;
577
0
    }
578
579
0
        continue;
580
0
      }
581
0
    else if (r_type == R_IA64_PCREL60B)
582
0
      continue;
583
0
    else if (ia64_elf_relax_br (contents, roff))
584
0
      {
585
0
        irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
586
0
             R_IA64_PCREL60B);
587
588
        /* Make the relocation offset point to slot 1.  */
589
0
        irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
590
0
        continue;
591
0
      }
592
593
    /* We can't put a trampoline in a .init/.fini section. Issue
594
       an error.  */
595
0
    if (strcmp (sec->output_section->name, ".init") == 0
596
0
        || strcmp (sec->output_section->name, ".fini") == 0)
597
0
      {
598
0
        _bfd_error_handler
599
    /* xgettext:c-format */
600
0
    (_("%pB: can't relax br at %#" PRIx64 " in section `%pA';"
601
0
       " please use brl or indirect branch"),
602
0
     sec->owner, (uint64_t) roff, sec);
603
0
        bfd_set_error (bfd_error_bad_value);
604
0
        goto error_return;
605
0
      }
606
607
    /* If the branch and target are in the same section, you've
608
       got one honking big section and we can't help you unless
609
       you are branching backwards.  You'll get an error message
610
       later.  */
611
0
    if (tsec == sec && toff > roff)
612
0
      continue;
613
614
    /* Look for an existing fixup to this address.  */
615
0
    for (f = fixups; f ; f = f->next)
616
0
      if (f->tsec == tsec && f->toff == toff)
617
0
        break;
618
619
0
    if (f == NULL)
620
0
      {
621
        /* Two alternatives: If it's a branch to a PLT entry, we can
622
     make a copy of the FULL_PLT entry.  Otherwise, we'll have
623
     to use a `brl' insn to get where we're going.  */
624
625
0
        size_t size;
626
627
0
        if (tsec == ia64_info->root.splt)
628
0
    size = sizeof (plt_full_entry);
629
0
        else
630
0
    size = sizeof (oor_brl);
631
632
        /* Resize the current section to make room for the new branch. */
633
0
        trampoff = (sec->size + 15) & (bfd_vma) -16;
634
635
        /* If trampoline is out of range, there is nothing we
636
     can do.  */
637
0
        offset = trampoff - (roff & (bfd_vma) -4);
638
0
        if (offset < -0x1000000 || offset > 0x0FFFFF0)
639
0
    continue;
640
641
0
        amt = trampoff + size;
642
0
        contents = (bfd_byte *) bfd_realloc (contents, amt);
643
0
        if (contents == NULL)
644
0
    goto error_return;
645
0
        sec->size = amt;
646
647
0
        if (tsec == ia64_info->root.splt)
648
0
    {
649
0
      memcpy (contents + trampoff, plt_full_entry, size);
650
651
      /* Hijack the old relocation for use as the PLTOFF reloc.  */
652
0
      irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
653
0
                 R_IA64_PLTOFF22);
654
0
      irel->r_offset = trampoff;
655
0
    }
656
0
        else
657
0
    {
658
0
      memcpy (contents + trampoff, oor_brl, size);
659
0
      irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
660
0
                 R_IA64_PCREL60B);
661
0
      irel->r_offset = trampoff + 2;
662
0
    }
663
664
        /* Record the fixup so we don't do it again this section.  */
665
0
        f = (struct one_fixup *)
666
0
    bfd_malloc ((bfd_size_type) sizeof (*f));
667
0
        f->next = fixups;
668
0
        f->tsec = tsec;
669
0
        f->toff = toff;
670
0
        f->trampoff = trampoff;
671
0
        fixups = f;
672
0
      }
673
0
    else
674
0
      {
675
        /* If trampoline is out of range, there is nothing we
676
     can do.  */
677
0
        offset = f->trampoff - (roff & (bfd_vma) -4);
678
0
        if (offset < -0x1000000 || offset > 0x0FFFFF0)
679
0
    continue;
680
681
        /* Nop out the reloc, since we're finalizing things here.  */
682
0
        irel->r_info = ELF64_R_INFO (0, R_IA64_NONE);
683
0
      }
684
685
    /* Fix up the existing branch to hit the trampoline.  */
686
0
    if (ia64_elf_install_value (contents + roff, offset, r_type)
687
0
        != bfd_reloc_ok)
688
0
      goto error_return;
689
690
0
    changed_contents = true;
691
0
    changed_relocs = true;
692
0
  }
693
0
      else
694
0
  {
695
    /* Fetch the gp.  */
696
0
    if (gp == 0)
697
0
      {
698
0
        bfd *obfd = sec->output_section->owner;
699
0
        gp = _bfd_get_gp_value (obfd);
700
0
        if (gp == 0)
701
0
    {
702
0
      if (!elf64_ia64_choose_gp (obfd, link_info, false))
703
0
        goto error_return;
704
0
      gp = _bfd_get_gp_value (obfd);
705
0
    }
706
0
      }
707
708
    /* If the data is out of range, do nothing.  */
709
0
    if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
710
0
        ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
711
0
      continue;
712
713
0
    if (r_type == R_IA64_GPREL22)
714
0
      elf64_ia64_update_short_info (tsec->output_section,
715
0
            tsec->output_offset + toff,
716
0
            ia64_info);
717
0
    else if (r_type == R_IA64_LTOFF22X)
718
0
      {
719
        /* Can't deal yet correctly with ABS symbols.  */
720
0
        if (bfd_is_abs_section (tsec))
721
0
    continue;
722
723
0
        irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
724
0
             R_IA64_GPREL22);
725
0
        changed_relocs = true;
726
727
0
        elf64_ia64_update_short_info (tsec->output_section,
728
0
              tsec->output_offset + toff,
729
0
              ia64_info);
730
0
      }
731
0
    else
732
0
      {
733
0
        ia64_elf_relax_ldxmov (contents, roff);
734
0
        irel->r_info = ELF64_R_INFO (0, R_IA64_NONE);
735
0
        changed_contents = true;
736
0
        changed_relocs = true;
737
0
      }
738
0
  }
739
0
    }
740
741
  /* ??? If we created fixups, this may push the code segment large
742
     enough that the data segment moves, which will change the GP.
743
     Reset the GP so that we re-calculate next round.  We need to
744
     do this at the _beginning_ of the next round; now will not do.  */
745
746
  /* Clean up and go home.  */
747
0
  while (fixups)
748
0
    {
749
0
      struct one_fixup *f = fixups;
750
0
      fixups = fixups->next;
751
0
      free (f);
752
0
    }
753
754
0
  if (isymbuf != NULL
755
0
      && symtab_hdr->contents != (unsigned char *) isymbuf)
756
0
    {
757
0
      if (! link_info->keep_memory)
758
0
  free (isymbuf);
759
0
      else
760
0
  {
761
    /* Cache the symbols for elf_link_input_bfd.  */
762
0
    symtab_hdr->contents = (unsigned char *) isymbuf;
763
0
  }
764
0
    }
765
766
0
  if (contents != NULL
767
0
      && elf_section_data (sec)->this_hdr.contents != contents)
768
0
    {
769
0
      if (!changed_contents && !link_info->keep_memory)
770
0
  free (contents);
771
0
      else
772
0
  {
773
    /* Cache the section contents for elf_link_input_bfd.  */
774
0
    elf_section_data (sec)->this_hdr.contents = contents;
775
0
  }
776
0
    }
777
778
0
  if (elf_section_data (sec)->relocs != internal_relocs)
779
0
    {
780
0
      if (!changed_relocs)
781
0
  free (internal_relocs);
782
0
      else
783
0
  elf_section_data (sec)->relocs = internal_relocs;
784
0
    }
785
786
0
  if (link_info->relax_pass == 0)
787
0
    {
788
      /* Pass 0 is only needed to relax br.  */
789
0
      sec->skip_relax_pass_0 = skip_relax_pass_0;
790
0
      sec->skip_relax_pass_1 = skip_relax_pass_1;
791
0
    }
792
793
0
  *again = changed_contents || changed_relocs;
794
0
  return true;
795
796
0
 error_return:
797
0
  if ((unsigned char *) isymbuf != symtab_hdr->contents)
798
0
    free (isymbuf);
799
0
  if (elf_section_data (sec)->this_hdr.contents != contents)
800
0
    free (contents);
801
0
  if (elf_section_data (sec)->relocs != internal_relocs)
802
0
    free (internal_relocs);
803
0
  return false;
804
0
}
805
#undef skip_relax_pass_0
806
#undef skip_relax_pass_1
807
808
/* Return TRUE if NAME is an unwind table section name.  */
809
810
static inline bool
811
is_unwind_section_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
812
0
{
813
0
  return ((startswith (name, ELF_STRING_ia64_unwind)
814
0
     && ! startswith (name, ELF_STRING_ia64_unwind_info))
815
0
    || startswith (name, ELF_STRING_ia64_unwind_once));
816
0
}
817
818
819
/* Convert IA-64 specific section flags to bfd internal section flags.  */
820
821
/* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
822
   flag.  */
823
824
static bool
825
elf64_ia64_section_flags (const Elf_Internal_Shdr *hdr)
826
29.8k
{
827
29.8k
  if (hdr->sh_flags & SHF_IA_64_SHORT)
828
9.99k
    hdr->bfd_section->flags |= SEC_SMALL_DATA;
829
830
29.8k
  return true;
831
29.8k
}
832
833
/* Set the correct type for an IA-64 ELF section.  We do this by the
834
   section name, which is a hack, but ought to work.  */
835
836
static bool
837
elf64_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr,
838
        asection *sec)
839
0
{
840
0
  const char *name;
841
842
0
  name = bfd_section_name (sec);
843
844
0
  if (is_unwind_section_name (abfd, name))
845
0
    {
846
      /* We don't have the sections numbered at this point, so sh_info
847
   is set later, in elf64_ia64_final_write_processing.  */
848
0
      hdr->sh_type = SHT_IA_64_UNWIND;
849
0
      hdr->sh_flags |= SHF_LINK_ORDER;
850
0
    }
851
0
  else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
852
0
    hdr->sh_type = SHT_IA_64_EXT;
853
854
0
  if (sec->flags & SEC_SMALL_DATA)
855
0
    hdr->sh_flags |= SHF_IA_64_SHORT;
856
857
0
  return true;
858
0
}
859
860
/* Hook called by the linker routine which adds symbols from an object
861
   file.  We use it to put .comm items in .sbss, and not .bss.  */
862
863
static bool
864
elf64_ia64_add_symbol_hook (bfd *abfd,
865
          struct bfd_link_info *info,
866
          Elf_Internal_Sym *sym,
867
          const char **namep ATTRIBUTE_UNUSED,
868
          flagword *flagsp ATTRIBUTE_UNUSED,
869
          asection **secp,
870
          bfd_vma *valp)
871
0
{
872
0
  if (sym->st_shndx == SHN_COMMON
873
0
      && !bfd_link_relocatable (info)
874
0
      && sym->st_size <= elf_gp_size (abfd))
875
0
    {
876
      /* Common symbols less than or equal to -G nn bytes are
877
   automatically put into .sbss.  */
878
879
0
      asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
880
881
0
      if (scomm == NULL)
882
0
  {
883
0
    scomm = bfd_make_section_with_flags (abfd, ".scommon",
884
0
                 (SEC_ALLOC
885
0
            | SEC_IS_COMMON
886
0
            | SEC_SMALL_DATA
887
0
            | SEC_LINKER_CREATED));
888
0
    if (scomm == NULL)
889
0
      return false;
890
0
  }
891
892
0
      *secp = scomm;
893
0
      *valp = sym->st_size;
894
0
    }
895
896
0
  return true;
897
0
}
898
899
/* According to the Tahoe assembler spec, all labels starting with a
900
   '.' are local.  */
901
902
static bool
903
elf64_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
904
        const char *name)
905
0
{
906
0
  return name[0] == '.';
907
0
}
908
909
/* Should we do dynamic things to this symbol?  */
910
911
static bool
912
elf64_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h)
913
0
{
914
0
  return h != NULL && h->def_dynamic;
915
0
}
916
917
static struct bfd_hash_entry*
918
elf64_ia64_new_elf_hash_entry (struct bfd_hash_entry *entry,
919
             struct bfd_hash_table *table,
920
             const char *string)
921
0
{
922
0
  struct elf64_ia64_link_hash_entry *ret;
923
0
  ret = (struct elf64_ia64_link_hash_entry *) entry;
924
925
  /* Allocate the structure if it has not already been allocated by a
926
     subclass.  */
927
0
  if (!ret)
928
0
    ret = bfd_hash_allocate (table, sizeof (*ret));
929
930
0
  if (!ret)
931
0
    return 0;
932
933
  /* Call the allocation method of the superclass.  */
934
0
  ret = ((struct elf64_ia64_link_hash_entry *)
935
0
   _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
936
0
             table, string));
937
938
0
  ret->info = NULL;
939
0
  ret->count = 0;
940
0
  ret->sorted_count = 0;
941
0
  ret->size = 0;
942
0
  return (struct bfd_hash_entry *) ret;
943
0
}
944
945
static void
946
elf64_ia64_hash_hide_symbol (struct bfd_link_info *info,
947
           struct elf_link_hash_entry *xh,
948
           bool force_local)
949
0
{
950
0
  struct elf64_ia64_link_hash_entry *h;
951
0
  struct elf64_ia64_dyn_sym_info *dyn_i;
952
0
  unsigned int count;
953
954
0
  h = (struct elf64_ia64_link_hash_entry *)xh;
955
956
0
  _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
957
958
0
  for (count = h->count, dyn_i = h->info;
959
0
       count != 0;
960
0
       count--, dyn_i++)
961
0
    {
962
0
      dyn_i->want_plt2 = 0;
963
0
      dyn_i->want_plt = 0;
964
0
    }
965
0
}
966
967
/* Compute a hash of a local hash entry.  */
968
969
static hashval_t
970
elf64_ia64_local_htab_hash (const void *ptr)
971
0
{
972
0
  struct elf64_ia64_local_hash_entry *entry
973
0
    = (struct elf64_ia64_local_hash_entry *) ptr;
974
975
0
  return ELF_LOCAL_SYMBOL_HASH (entry->id, entry->r_sym);
976
0
}
977
978
/* Compare local hash entries.  */
979
980
static int
981
elf64_ia64_local_htab_eq (const void *ptr1, const void *ptr2)
982
0
{
983
0
  struct elf64_ia64_local_hash_entry *entry1
984
0
    = (struct elf64_ia64_local_hash_entry *) ptr1;
985
0
  struct elf64_ia64_local_hash_entry *entry2
986
0
    = (struct elf64_ia64_local_hash_entry *) ptr2;
987
988
0
  return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
989
0
}
990
991
/* Free the global elf64_ia64_dyn_sym_info array.  */
992
993
static bool
994
elf64_ia64_global_dyn_info_free (struct elf_link_hash_entry *xentry,
995
         void * unused ATTRIBUTE_UNUSED)
996
0
{
997
0
  struct elf64_ia64_link_hash_entry *entry
998
0
    = (struct elf64_ia64_link_hash_entry *) xentry;
999
1000
0
  if (entry->root.root.type == bfd_link_hash_warning)
1001
0
    entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link;
1002
1003
0
  free (entry->info);
1004
0
  entry->info = NULL;
1005
0
  entry->count = 0;
1006
0
  entry->sorted_count = 0;
1007
0
  entry->size = 0;
1008
1009
0
  return true;
1010
0
}
1011
1012
/* Free the local elf64_ia64_dyn_sym_info array.  */
1013
1014
static int
1015
elf64_ia64_local_dyn_info_free (void **slot,
1016
        void * unused ATTRIBUTE_UNUSED)
1017
0
{
1018
0
  struct elf64_ia64_local_hash_entry *entry
1019
0
    = (struct elf64_ia64_local_hash_entry *) *slot;
1020
1021
0
  free (entry->info);
1022
0
  entry->info = NULL;
1023
0
  entry->count = 0;
1024
0
  entry->sorted_count = 0;
1025
0
  entry->size = 0;
1026
1027
0
  return true;
1028
0
}
1029
1030
/* Destroy IA-64 linker hash table.  */
1031
1032
static void
1033
elf64_ia64_link_hash_table_free (bfd *obfd)
1034
0
{
1035
0
  struct elf64_ia64_link_hash_table *ia64_info
1036
0
    = (struct elf64_ia64_link_hash_table *) obfd->link.hash;
1037
0
  if (ia64_info->loc_hash_table)
1038
0
    {
1039
0
      htab_traverse (ia64_info->loc_hash_table,
1040
0
         elf64_ia64_local_dyn_info_free, NULL);
1041
0
      htab_delete (ia64_info->loc_hash_table);
1042
0
    }
1043
0
  if (ia64_info->loc_hash_memory)
1044
0
    objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
1045
0
  elf_link_hash_traverse (&ia64_info->root,
1046
0
        elf64_ia64_global_dyn_info_free, NULL);
1047
0
  _bfd_elf_link_hash_table_free (obfd);
1048
0
}
1049
1050
/* Create the derived linker hash table.  The IA-64 ELF port uses this
1051
   derived hash table to keep information specific to the IA-64 ElF
1052
   linker (without using static variables).  */
1053
1054
static struct bfd_link_hash_table *
1055
elf64_ia64_hash_table_create (bfd *abfd)
1056
0
{
1057
0
  struct elf64_ia64_link_hash_table *ret;
1058
1059
0
  ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
1060
0
  if (!ret)
1061
0
    return NULL;
1062
1063
0
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1064
0
              elf64_ia64_new_elf_hash_entry,
1065
0
              sizeof (struct elf64_ia64_link_hash_entry),
1066
0
              IA64_ELF_DATA))
1067
0
    {
1068
0
      free (ret);
1069
0
      return NULL;
1070
0
    }
1071
1072
0
  ret->loc_hash_table = htab_try_create (1024, elf64_ia64_local_htab_hash,
1073
0
           elf64_ia64_local_htab_eq, NULL);
1074
0
  ret->loc_hash_memory = objalloc_create ();
1075
0
  if (!ret->loc_hash_table || !ret->loc_hash_memory)
1076
0
    {
1077
0
      elf64_ia64_link_hash_table_free (abfd);
1078
0
      return NULL;
1079
0
    }
1080
0
  ret->root.root.hash_table_free = elf64_ia64_link_hash_table_free;
1081
1082
0
  return &ret->root.root;
1083
0
}
1084
1085
/* Traverse both local and global hash tables.  */
1086
1087
struct elf64_ia64_dyn_sym_traverse_data
1088
{
1089
  bool (*func) (struct elf64_ia64_dyn_sym_info *, void *);
1090
  void * data;
1091
};
1092
1093
static bool
1094
elf64_ia64_global_dyn_sym_thunk (struct elf_link_hash_entry *xentry,
1095
         void * xdata)
1096
0
{
1097
0
  struct elf64_ia64_link_hash_entry *entry
1098
0
    = (struct elf64_ia64_link_hash_entry *) xentry;
1099
0
  struct elf64_ia64_dyn_sym_traverse_data *data
1100
0
    = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
1101
0
  struct elf64_ia64_dyn_sym_info *dyn_i;
1102
0
  unsigned int count;
1103
1104
0
  if (entry->root.root.type == bfd_link_hash_warning)
1105
0
    entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link;
1106
1107
0
  for (count = entry->count, dyn_i = entry->info;
1108
0
       count != 0;
1109
0
       count--, dyn_i++)
1110
0
    if (! (*data->func) (dyn_i, data->data))
1111
0
      return false;
1112
0
  return true;
1113
0
}
1114
1115
static int
1116
elf64_ia64_local_dyn_sym_thunk (void **slot, void * xdata)
1117
0
{
1118
0
  struct elf64_ia64_local_hash_entry *entry
1119
0
    = (struct elf64_ia64_local_hash_entry *) *slot;
1120
0
  struct elf64_ia64_dyn_sym_traverse_data *data
1121
0
    = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
1122
0
  struct elf64_ia64_dyn_sym_info *dyn_i;
1123
0
  unsigned int count;
1124
1125
0
  for (count = entry->count, dyn_i = entry->info;
1126
0
       count != 0;
1127
0
       count--, dyn_i++)
1128
0
    if (! (*data->func) (dyn_i, data->data))
1129
0
      return false;
1130
0
  return true;
1131
0
}
1132
1133
static void
1134
elf64_ia64_dyn_sym_traverse (struct elf64_ia64_link_hash_table *ia64_info,
1135
           bool (*func) (struct elf64_ia64_dyn_sym_info *, void *),
1136
           void * data)
1137
0
{
1138
0
  struct elf64_ia64_dyn_sym_traverse_data xdata;
1139
1140
0
  xdata.func = func;
1141
0
  xdata.data = data;
1142
1143
0
  elf_link_hash_traverse (&ia64_info->root,
1144
0
        elf64_ia64_global_dyn_sym_thunk, &xdata);
1145
0
  htab_traverse (ia64_info->loc_hash_table,
1146
0
     elf64_ia64_local_dyn_sym_thunk, &xdata);
1147
0
}
1148
1149
0
#define NOTE_NAME "IPF/VMS"
1150
1151
static bool
1152
create_ia64_vms_notes (bfd *abfd, struct bfd_link_info *info,
1153
           unsigned int time_hi, unsigned int time_lo)
1154
0
{
1155
0
#define NBR_NOTES 7
1156
0
  Elf_Internal_Note notes[NBR_NOTES];
1157
0
  char *module_name;
1158
0
  int module_name_len;
1159
0
  unsigned char cur_time[8];
1160
0
  Elf64_External_VMS_ORIG_DYN_Note *orig_dyn;
1161
0
  unsigned int orig_dyn_size;
1162
0
  unsigned int note_size;
1163
0
  int i;
1164
0
  unsigned char *noteptr;
1165
0
  unsigned char *note_contents;
1166
0
  struct elf64_ia64_link_hash_table *ia64_info;
1167
1168
0
  ia64_info = elf64_ia64_hash_table (info);
1169
1170
0
  module_name = vms_get_module_name (bfd_get_filename (abfd), true);
1171
0
  module_name_len = strlen (module_name) + 1;
1172
1173
0
  bfd_putl32 (time_lo, cur_time + 0);
1174
0
  bfd_putl32 (time_hi, cur_time + 4);
1175
1176
  /* Note 0: IMGNAM.  */
1177
0
  notes[0].type = NT_VMS_IMGNAM;
1178
0
  notes[0].descdata = module_name;
1179
0
  notes[0].descsz = module_name_len;
1180
1181
  /* Note 1: GSTNAM.  */
1182
0
  notes[1].type = NT_VMS_GSTNAM;
1183
0
  notes[1].descdata = module_name;
1184
0
  notes[1].descsz = module_name_len;
1185
1186
  /* Note 2: IMGID.  */
1187
0
#define IMG_ID "V1.0"
1188
0
  notes[2].type = NT_VMS_IMGID;
1189
0
  notes[2].descdata = IMG_ID;
1190
0
  notes[2].descsz = sizeof (IMG_ID);
1191
1192
  /* Note 3: Linktime.  */
1193
0
  notes[3].type = NT_VMS_LINKTIME;
1194
0
  notes[3].descdata = (char *)cur_time;
1195
0
  notes[3].descsz = sizeof (cur_time);
1196
1197
  /* Note 4: Linker id.  */
1198
0
  notes[4].type = NT_VMS_LINKID;
1199
0
  notes[4].descdata = "GNU ld " BFD_VERSION_STRING;
1200
0
  notes[4].descsz = strlen (notes[4].descdata) + 1;
1201
1202
  /* Note 5: Original dyn.  */
1203
0
  orig_dyn_size = (sizeof (*orig_dyn) + sizeof (IMG_ID) - 1 + 7) & ~7;
1204
0
  orig_dyn = bfd_zalloc (abfd, orig_dyn_size);
1205
0
  if (orig_dyn == NULL)
1206
0
    return false;
1207
0
  bfd_putl32 (1, orig_dyn->major_id);
1208
0
  bfd_putl32 (3, orig_dyn->minor_id);
1209
0
  memcpy (orig_dyn->manipulation_date, cur_time, sizeof (cur_time));
1210
0
  bfd_putl64 (VMS_LF_IMGSTA | VMS_LF_MAIN, orig_dyn->link_flags);
1211
0
  bfd_putl32 (EF_IA_64_ABI64, orig_dyn->elf_flags);
1212
0
  memcpy (orig_dyn->imgid, IMG_ID, sizeof (IMG_ID));
1213
0
  notes[5].type = NT_VMS_ORIG_DYN;
1214
0
  notes[5].descdata = (char *)orig_dyn;
1215
0
  notes[5].descsz = orig_dyn_size;
1216
1217
  /* Note 3: Patchtime.  */
1218
0
  notes[6].type = NT_VMS_PATCHTIME;
1219
0
  notes[6].descdata = (char *)cur_time;
1220
0
  notes[6].descsz = sizeof (cur_time);
1221
1222
  /* Compute notes size.  */
1223
0
  note_size = 0;
1224
0
  for (i = 0; i < NBR_NOTES; i++)
1225
0
    note_size += sizeof (Elf64_External_VMS_Note) - 1
1226
0
      + ((sizeof (NOTE_NAME) - 1 + 7) & ~7)
1227
0
      + ((notes[i].descsz + 7) & ~7);
1228
1229
  /* Malloc a temporary buffer large enough for most notes */
1230
0
  note_contents = (unsigned char *) bfd_zalloc (abfd, note_size);
1231
0
  if (note_contents == NULL)
1232
0
    return false;
1233
0
  noteptr = note_contents;
1234
1235
  /* Fill notes.  */
1236
0
  for (i = 0; i < NBR_NOTES; i++)
1237
0
    {
1238
0
      Elf64_External_VMS_Note *enote = (Elf64_External_VMS_Note *) noteptr;
1239
1240
0
      bfd_putl64 (sizeof (NOTE_NAME) - 1, enote->namesz);
1241
0
      bfd_putl64 (notes[i].descsz, enote->descsz);
1242
0
      bfd_putl64 (notes[i].type, enote->type);
1243
1244
0
      noteptr = (unsigned char *)enote->name;
1245
0
      memcpy (noteptr, NOTE_NAME, sizeof (NOTE_NAME) - 1);
1246
0
      noteptr += (sizeof (NOTE_NAME) - 1 + 7) & ~7;
1247
0
      memcpy (noteptr, notes[i].descdata, notes[i].descsz);
1248
0
      noteptr += (notes[i].descsz + 7) & ~7;
1249
0
    }
1250
1251
0
  ia64_info->note_sec->contents = note_contents;
1252
0
  ia64_info->note_sec->size = note_size;
1253
1254
0
  free (module_name);
1255
1256
0
  return true;
1257
0
}
1258
1259
static bool
1260
elf64_ia64_create_dynamic_sections (bfd *abfd,
1261
            struct bfd_link_info *info)
1262
0
{
1263
0
  struct elf64_ia64_link_hash_table *ia64_info;
1264
0
  asection *s;
1265
0
  flagword flags;
1266
0
  const struct elf_backend_data *bed;
1267
1268
0
  ia64_info = elf64_ia64_hash_table (info);
1269
0
  if (ia64_info == NULL)
1270
0
    return false;
1271
1272
0
  if (elf_hash_table (info)->dynamic_sections_created)
1273
0
    return true;
1274
1275
0
  abfd = elf_hash_table (info)->dynobj;
1276
0
  bed = get_elf_backend_data (abfd);
1277
1278
0
  flags = bed->dynamic_sec_flags;
1279
1280
0
  s = bfd_make_section_anyway_with_flags (abfd, ".dynamic",
1281
0
            flags | SEC_READONLY);
1282
0
  if (s == NULL
1283
0
      || !bfd_set_section_alignment (s, bed->s->log_file_align))
1284
0
    return false;
1285
1286
0
  s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags | SEC_READONLY);
1287
0
  if (s == NULL
1288
0
      || !bfd_set_section_alignment (s, bed->plt_alignment))
1289
0
    return false;
1290
0
  ia64_info->root.splt = s;
1291
1292
0
  if (!get_got (abfd, ia64_info))
1293
0
    return false;
1294
1295
0
  if (!get_pltoff (abfd, ia64_info))
1296
0
    return false;
1297
1298
0
  s = bfd_make_section_anyway_with_flags (abfd, ".vmsdynstr",
1299
0
            (SEC_ALLOC
1300
0
             | SEC_HAS_CONTENTS
1301
0
             | SEC_IN_MEMORY
1302
0
             | SEC_LINKER_CREATED));
1303
0
  if (s == NULL
1304
0
      || !bfd_set_section_alignment (s, 0))
1305
0
    return false;
1306
1307
  /* Create a fixup section.  */
1308
0
  s = bfd_make_section_anyway_with_flags (abfd, ".fixups",
1309
0
            (SEC_ALLOC
1310
0
             | SEC_HAS_CONTENTS
1311
0
             | SEC_IN_MEMORY
1312
0
             | SEC_LINKER_CREATED));
1313
0
  if (s == NULL
1314
0
      || !bfd_set_section_alignment (s, 3))
1315
0
    return false;
1316
0
  ia64_info->fixups_sec = s;
1317
1318
  /* Create the transfer fixup section.  */
1319
0
  s = bfd_make_section_anyway_with_flags (abfd, ".transfer",
1320
0
            (SEC_ALLOC
1321
0
             | SEC_HAS_CONTENTS
1322
0
             | SEC_IN_MEMORY
1323
0
             | SEC_LINKER_CREATED));
1324
0
  if (s == NULL
1325
0
      || !bfd_set_section_alignment (s, 3))
1326
0
    return false;
1327
0
  s->size = sizeof (struct elf64_vms_transfer);
1328
0
  ia64_info->transfer_sec = s;
1329
1330
  /* Create note section.  */
1331
0
  s = bfd_make_section_anyway_with_flags (abfd, ".vms.note",
1332
0
            (SEC_LINKER_CREATED
1333
0
             | SEC_HAS_CONTENTS
1334
0
             | SEC_IN_MEMORY
1335
0
             | SEC_READONLY));
1336
0
  if (s == NULL
1337
0
      || !bfd_set_section_alignment (s, 3))
1338
0
    return false;
1339
0
  ia64_info->note_sec = s;
1340
1341
0
  elf_hash_table (info)->dynamic_sections_created = true;
1342
0
  return true;
1343
0
}
1344
1345
/* Find and/or create a hash entry for local symbol.  */
1346
static struct elf64_ia64_local_hash_entry *
1347
get_local_sym_hash (struct elf64_ia64_link_hash_table *ia64_info,
1348
        bfd *abfd, const Elf_Internal_Rela *rel,
1349
        bool create)
1350
0
{
1351
0
  struct elf64_ia64_local_hash_entry e, *ret;
1352
0
  asection *sec = abfd->sections;
1353
0
  hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
1354
0
               ELF64_R_SYM (rel->r_info));
1355
0
  void **slot;
1356
1357
0
  e.id = sec->id;
1358
0
  e.r_sym = ELF64_R_SYM (rel->r_info);
1359
0
  slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
1360
0
           create ? INSERT : NO_INSERT);
1361
1362
0
  if (!slot)
1363
0
    return NULL;
1364
1365
0
  if (*slot)
1366
0
    return (struct elf64_ia64_local_hash_entry *) *slot;
1367
1368
0
  ret = (struct elf64_ia64_local_hash_entry *)
1369
0
  objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
1370
0
      sizeof (struct elf64_ia64_local_hash_entry));
1371
0
  if (ret)
1372
0
    {
1373
0
      memset (ret, 0, sizeof (*ret));
1374
0
      ret->id = sec->id;
1375
0
      ret->r_sym = ELF64_R_SYM (rel->r_info);
1376
0
      *slot = ret;
1377
0
    }
1378
0
  return ret;
1379
0
}
1380
1381
/* Used to sort elf64_ia64_dyn_sym_info array.  */
1382
1383
static int
1384
addend_compare (const void *xp, const void *yp)
1385
0
{
1386
0
  const struct elf64_ia64_dyn_sym_info *x
1387
0
    = (const struct elf64_ia64_dyn_sym_info *) xp;
1388
0
  const struct elf64_ia64_dyn_sym_info *y
1389
0
    = (const struct elf64_ia64_dyn_sym_info *) yp;
1390
1391
0
  return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0;
1392
0
}
1393
1394
/* Sort elf64_ia64_dyn_sym_info array and remove duplicates.  */
1395
1396
static unsigned int
1397
sort_dyn_sym_info (struct elf64_ia64_dyn_sym_info *info,
1398
       unsigned int count)
1399
0
{
1400
0
  bfd_vma curr, prev, got_offset;
1401
0
  unsigned int i, kept, dupes, diff, dest, src, len;
1402
1403
0
  qsort (info, count, sizeof (*info), addend_compare);
1404
1405
  /* Find the first duplicate.  */
1406
0
  prev = info [0].addend;
1407
0
  got_offset = info [0].got_offset;
1408
0
  for (i = 1; i < count; i++)
1409
0
    {
1410
0
      curr = info [i].addend;
1411
0
      if (curr == prev)
1412
0
  {
1413
    /* For duplicates, make sure that GOT_OFFSET is valid.  */
1414
0
    if (got_offset == (bfd_vma) -1)
1415
0
      got_offset = info [i].got_offset;
1416
0
    break;
1417
0
  }
1418
0
      got_offset = info [i].got_offset;
1419
0
      prev = curr;
1420
0
    }
1421
1422
  /* We may move a block of elements to here.  */
1423
0
  dest = i++;
1424
1425
  /* Remove duplicates.  */
1426
0
  if (i < count)
1427
0
    {
1428
0
      while (i < count)
1429
0
  {
1430
    /* For duplicates, make sure that the kept one has a valid
1431
       got_offset.  */
1432
0
    kept = dest - 1;
1433
0
    if (got_offset != (bfd_vma) -1)
1434
0
      info [kept].got_offset = got_offset;
1435
1436
0
    curr = info [i].addend;
1437
0
    got_offset = info [i].got_offset;
1438
1439
    /* Move a block of elements whose first one is different from
1440
       the previous.  */
1441
0
    if (curr == prev)
1442
0
      {
1443
0
        for (src = i + 1; src < count; src++)
1444
0
    {
1445
0
      if (info [src].addend != curr)
1446
0
        break;
1447
      /* For duplicates, make sure that GOT_OFFSET is
1448
         valid.  */
1449
0
      if (got_offset == (bfd_vma) -1)
1450
0
        got_offset = info [src].got_offset;
1451
0
    }
1452
1453
        /* Make sure that the kept one has a valid got_offset.  */
1454
0
        if (got_offset != (bfd_vma) -1)
1455
0
    info [kept].got_offset = got_offset;
1456
0
      }
1457
0
    else
1458
0
      src = i;
1459
1460
0
    if (src >= count)
1461
0
      break;
1462
1463
    /* Find the next duplicate.  SRC will be kept.  */
1464
0
    prev = info [src].addend;
1465
0
    got_offset = info [src].got_offset;
1466
0
    for (dupes = src + 1; dupes < count; dupes ++)
1467
0
      {
1468
0
        curr = info [dupes].addend;
1469
0
        if (curr == prev)
1470
0
    {
1471
      /* Make sure that got_offset is valid.  */
1472
0
      if (got_offset == (bfd_vma) -1)
1473
0
        got_offset = info [dupes].got_offset;
1474
1475
      /* For duplicates, make sure that the kept one has
1476
         a valid got_offset.  */
1477
0
      if (got_offset != (bfd_vma) -1)
1478
0
        info [dupes - 1].got_offset = got_offset;
1479
0
      break;
1480
0
    }
1481
0
        got_offset = info [dupes].got_offset;
1482
0
        prev = curr;
1483
0
      }
1484
1485
    /* How much to move.  */
1486
0
    len = dupes - src;
1487
0
    i = dupes + 1;
1488
1489
0
    if (len == 1 && dupes < count)
1490
0
      {
1491
        /* If we only move 1 element, we combine it with the next
1492
     one.  There must be at least a duplicate.  Find the
1493
     next different one.  */
1494
0
        for (diff = dupes + 1, src++; diff < count; diff++, src++)
1495
0
    {
1496
0
      if (info [diff].addend != curr)
1497
0
        break;
1498
      /* Make sure that got_offset is valid.  */
1499
0
      if (got_offset == (bfd_vma) -1)
1500
0
        got_offset = info [diff].got_offset;
1501
0
    }
1502
1503
        /* Makre sure that the last duplicated one has an valid
1504
     offset.  */
1505
0
        BFD_ASSERT (curr == prev);
1506
0
        if (got_offset != (bfd_vma) -1)
1507
0
    info [diff - 1].got_offset = got_offset;
1508
1509
0
        if (diff < count)
1510
0
    {
1511
      /* Find the next duplicate.  Track the current valid
1512
         offset.  */
1513
0
      prev = info [diff].addend;
1514
0
      got_offset = info [diff].got_offset;
1515
0
      for (dupes = diff + 1; dupes < count; dupes ++)
1516
0
        {
1517
0
          curr = info [dupes].addend;
1518
0
          if (curr == prev)
1519
0
      {
1520
        /* For duplicates, make sure that GOT_OFFSET
1521
           is valid.  */
1522
0
        if (got_offset == (bfd_vma) -1)
1523
0
          got_offset = info [dupes].got_offset;
1524
0
        break;
1525
0
      }
1526
0
          got_offset = info [dupes].got_offset;
1527
0
          prev = curr;
1528
0
          diff++;
1529
0
        }
1530
1531
0
      len = diff - src + 1;
1532
0
      i = diff + 1;
1533
0
    }
1534
0
      }
1535
1536
0
    memmove (&info [dest], &info [src], len * sizeof (*info));
1537
1538
0
    dest += len;
1539
0
  }
1540
1541
0
      count = dest;
1542
0
    }
1543
0
  else
1544
0
    {
1545
      /* When we get here, either there is no duplicate at all or
1546
   the only duplicate is the last element.  */
1547
0
      if (dest < count)
1548
0
  {
1549
    /* If the last element is a duplicate, make sure that the
1550
       kept one has a valid got_offset.  We also update count.  */
1551
0
    if (got_offset != (bfd_vma) -1)
1552
0
      info [dest - 1].got_offset = got_offset;
1553
0
    count = dest;
1554
0
  }
1555
0
    }
1556
1557
0
  return count;
1558
0
}
1559
1560
/* Find and/or create a descriptor for dynamic symbol info.  This will
1561
   vary based on global or local symbol, and the addend to the reloc.
1562
1563
   We don't sort when inserting.  Also, we sort and eliminate
1564
   duplicates if there is an unsorted section.  Typically, this will
1565
   only happen once, because we do all insertions before lookups.  We
1566
   then use bsearch to do a lookup.  This also allows lookups to be
1567
   fast.  So we have fast insertion (O(log N) due to duplicate check),
1568
   fast lookup (O(log N)) and one sort (O(N log N) expected time).
1569
   Previously, all lookups were O(N) because of the use of the linked
1570
   list and also all insertions were O(N) because of the check for
1571
   duplicates.  There are some complications here because the array
1572
   size grows occasionally, which may add an O(N) factor, but this
1573
   should be rare.  Also,  we free the excess array allocation, which
1574
   requires a copy which is O(N), but this only happens once.  */
1575
1576
static struct elf64_ia64_dyn_sym_info *
1577
get_dyn_sym_info (struct elf64_ia64_link_hash_table *ia64_info,
1578
      struct elf_link_hash_entry *h, bfd *abfd,
1579
      const Elf_Internal_Rela *rel, bool create)
1580
0
{
1581
0
  struct elf64_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
1582
0
  unsigned int *count_p, *sorted_count_p, *size_p;
1583
0
  unsigned int count, sorted_count, size;
1584
0
  bfd_vma addend = rel ? rel->r_addend : 0;
1585
0
  bfd_size_type amt;
1586
1587
0
  if (h)
1588
0
    {
1589
0
      struct elf64_ia64_link_hash_entry *global_h;
1590
1591
0
      global_h = (struct elf64_ia64_link_hash_entry *) h;
1592
0
      info_p = &global_h->info;
1593
0
      count_p = &global_h->count;
1594
0
      sorted_count_p = &global_h->sorted_count;
1595
0
      size_p = &global_h->size;
1596
0
    }
1597
0
  else
1598
0
    {
1599
0
      struct elf64_ia64_local_hash_entry *loc_h;
1600
1601
0
      loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
1602
0
      if (!loc_h)
1603
0
  {
1604
0
    BFD_ASSERT (!create);
1605
0
    return NULL;
1606
0
  }
1607
1608
0
      info_p = &loc_h->info;
1609
0
      count_p = &loc_h->count;
1610
0
      sorted_count_p = &loc_h->sorted_count;
1611
0
      size_p = &loc_h->size;
1612
0
    }
1613
1614
0
  count = *count_p;
1615
0
  sorted_count = *sorted_count_p;
1616
0
  size = *size_p;
1617
0
  info = *info_p;
1618
0
  if (create)
1619
0
    {
1620
      /* When we create the array, we don't check for duplicates,
1621
   except in the previously sorted section if one exists, and
1622
   against the last inserted entry.  This allows insertions to
1623
   be fast.  */
1624
0
      if (info)
1625
0
  {
1626
0
    if (sorted_count)
1627
0
      {
1628
        /* Try bsearch first on the sorted section.  */
1629
0
        key.addend = addend;
1630
0
        dyn_i = bsearch (&key, info, sorted_count,
1631
0
             sizeof (*info), addend_compare);
1632
1633
0
        if (dyn_i)
1634
0
    {
1635
0
      return dyn_i;
1636
0
    }
1637
0
      }
1638
1639
    /* Do a quick check for the last inserted entry.  */
1640
0
    dyn_i = info + count - 1;
1641
0
    if (dyn_i->addend == addend)
1642
0
      {
1643
0
        return dyn_i;
1644
0
      }
1645
0
  }
1646
1647
0
      if (size == 0)
1648
0
  {
1649
    /* It is the very first element. We create the array of size
1650
       1.  */
1651
0
    size = 1;
1652
0
    amt = size * sizeof (*info);
1653
0
    info = bfd_malloc (amt);
1654
0
  }
1655
0
      else if (size <= count)
1656
0
  {
1657
    /* We double the array size every time when we reach the
1658
       size limit.  */
1659
0
    size += size;
1660
0
    amt = size * sizeof (*info);
1661
0
    info = bfd_realloc (info, amt);
1662
0
  }
1663
0
      else
1664
0
  goto has_space;
1665
1666
0
      if (info == NULL)
1667
0
  return NULL;
1668
0
      *size_p = size;
1669
0
      *info_p = info;
1670
1671
0
    has_space:
1672
      /* Append the new one to the array.  */
1673
0
      dyn_i = info + count;
1674
0
      memset (dyn_i, 0, sizeof (*dyn_i));
1675
0
      dyn_i->got_offset = (bfd_vma) -1;
1676
0
      dyn_i->addend = addend;
1677
1678
      /* We increment count only since the new ones are unsorted and
1679
   may have duplicate.  */
1680
0
      (*count_p)++;
1681
0
    }
1682
0
  else
1683
0
    {
1684
      /* It is a lookup without insertion.  Sort array if part of the
1685
   array isn't sorted.  */
1686
0
      if (count != sorted_count)
1687
0
  {
1688
0
    count = sort_dyn_sym_info (info, count);
1689
0
    *count_p = count;
1690
0
    *sorted_count_p = count;
1691
0
  }
1692
1693
      /* Free unused memory.  */
1694
0
      if (size != count)
1695
0
  {
1696
0
    amt = count * sizeof (*info);
1697
0
    info = bfd_malloc (amt);
1698
0
    if (info != NULL)
1699
0
      {
1700
0
        memcpy (info, *info_p, amt);
1701
0
        free (*info_p);
1702
0
        *size_p = count;
1703
0
        *info_p = info;
1704
0
      }
1705
0
  }
1706
1707
0
      key.addend = addend;
1708
0
      dyn_i = bsearch (&key, info, count,
1709
0
           sizeof (*info), addend_compare);
1710
0
    }
1711
1712
0
  return dyn_i;
1713
0
}
1714
1715
static asection *
1716
get_got (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info)
1717
0
{
1718
0
  asection *got;
1719
0
  bfd *dynobj;
1720
1721
0
  got = ia64_info->root.sgot;
1722
0
  if (!got)
1723
0
    {
1724
0
      flagword flags;
1725
1726
0
      dynobj = ia64_info->root.dynobj;
1727
0
      if (!dynobj)
1728
0
  ia64_info->root.dynobj = dynobj = abfd;
1729
1730
      /* The .got section is always aligned at 8 bytes.  */
1731
0
      flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
1732
0
      got = bfd_make_section_anyway_with_flags (dynobj, ".got",
1733
0
            flags | SEC_SMALL_DATA);
1734
0
      if (got == NULL
1735
0
    || !bfd_set_section_alignment (got, 3))
1736
0
  return NULL;
1737
0
      ia64_info->root.sgot = got;
1738
0
    }
1739
1740
0
  return got;
1741
0
}
1742
1743
/* Create function descriptor section (.opd).  This section is called .opd
1744
   because it contains "official procedure descriptors".  The "official"
1745
   refers to the fact that these descriptors are used when taking the address
1746
   of a procedure, thus ensuring a unique address for each procedure.  */
1747
1748
static asection *
1749
get_fptr (bfd *abfd, struct bfd_link_info *info,
1750
    struct elf64_ia64_link_hash_table *ia64_info)
1751
0
{
1752
0
  asection *fptr;
1753
0
  bfd *dynobj;
1754
1755
0
  fptr = ia64_info->fptr_sec;
1756
0
  if (!fptr)
1757
0
    {
1758
0
      dynobj = ia64_info->root.dynobj;
1759
0
      if (!dynobj)
1760
0
  ia64_info->root.dynobj = dynobj = abfd;
1761
1762
0
      fptr = bfd_make_section_anyway_with_flags (dynobj, ".opd",
1763
0
             (SEC_ALLOC
1764
0
              | SEC_LOAD
1765
0
              | SEC_HAS_CONTENTS
1766
0
              | SEC_IN_MEMORY
1767
0
              | (bfd_link_pie (info) ? 0
1768
0
                 : SEC_READONLY)
1769
0
              | SEC_LINKER_CREATED));
1770
0
      if (!fptr
1771
0
    || !bfd_set_section_alignment (fptr, 4))
1772
0
  {
1773
0
    BFD_ASSERT (0);
1774
0
    return NULL;
1775
0
  }
1776
1777
0
      ia64_info->fptr_sec = fptr;
1778
1779
0
      if (bfd_link_pie (info))
1780
0
  {
1781
0
    asection *fptr_rel;
1782
0
    fptr_rel = bfd_make_section_anyway_with_flags (dynobj, ".rela.opd",
1783
0
               (SEC_ALLOC | SEC_LOAD
1784
0
                | SEC_HAS_CONTENTS
1785
0
                | SEC_IN_MEMORY
1786
0
                | SEC_LINKER_CREATED
1787
0
                | SEC_READONLY));
1788
0
    if (fptr_rel == NULL
1789
0
        || !bfd_set_section_alignment (fptr_rel, 3))
1790
0
      {
1791
0
        BFD_ASSERT (0);
1792
0
        return NULL;
1793
0
      }
1794
1795
0
    ia64_info->rel_fptr_sec = fptr_rel;
1796
0
  }
1797
0
    }
1798
1799
0
  return fptr;
1800
0
}
1801
1802
static asection *
1803
get_pltoff (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info)
1804
0
{
1805
0
  asection *pltoff;
1806
0
  bfd *dynobj;
1807
1808
0
  pltoff = ia64_info->pltoff_sec;
1809
0
  if (!pltoff)
1810
0
    {
1811
0
      dynobj = ia64_info->root.dynobj;
1812
0
      if (!dynobj)
1813
0
  ia64_info->root.dynobj = dynobj = abfd;
1814
1815
0
      pltoff = bfd_make_section_anyway_with_flags (dynobj,
1816
0
               ELF_STRING_ia64_pltoff,
1817
0
               (SEC_ALLOC
1818
0
                | SEC_LOAD
1819
0
                | SEC_HAS_CONTENTS
1820
0
                | SEC_IN_MEMORY
1821
0
                | SEC_SMALL_DATA
1822
0
                | SEC_LINKER_CREATED));
1823
0
      if (!pltoff
1824
0
    || !bfd_set_section_alignment (pltoff, 4))
1825
0
  {
1826
0
    BFD_ASSERT (0);
1827
0
    return NULL;
1828
0
  }
1829
1830
0
      ia64_info->pltoff_sec = pltoff;
1831
0
    }
1832
1833
0
  return pltoff;
1834
0
}
1835
1836
static asection *
1837
get_reloc_section (bfd *abfd,
1838
       struct elf64_ia64_link_hash_table *ia64_info,
1839
       asection *sec, bool create)
1840
0
{
1841
0
  const char *srel_name;
1842
0
  asection *srel;
1843
0
  bfd *dynobj;
1844
1845
0
  srel_name = (bfd_elf_string_from_elf_section
1846
0
         (abfd, elf_elfheader(abfd)->e_shstrndx,
1847
0
    _bfd_elf_single_rel_hdr (sec)->sh_name));
1848
0
  if (srel_name == NULL)
1849
0
    return NULL;
1850
1851
0
  BFD_ASSERT ((startswith (srel_name, ".rela")
1852
0
         && strcmp (bfd_section_name (sec), srel_name+5) == 0)
1853
0
        || (startswith (srel_name, ".rel")
1854
0
      && strcmp (bfd_section_name (sec), srel_name+4) == 0));
1855
1856
0
  dynobj = ia64_info->root.dynobj;
1857
0
  if (!dynobj)
1858
0
    ia64_info->root.dynobj = dynobj = abfd;
1859
1860
0
  srel = bfd_get_linker_section (dynobj, srel_name);
1861
0
  if (srel == NULL && create)
1862
0
    {
1863
0
      srel = bfd_make_section_anyway_with_flags (dynobj, srel_name,
1864
0
             (SEC_ALLOC | SEC_LOAD
1865
0
              | SEC_HAS_CONTENTS
1866
0
              | SEC_IN_MEMORY
1867
0
              | SEC_LINKER_CREATED
1868
0
              | SEC_READONLY));
1869
0
      if (srel == NULL
1870
0
    || !bfd_set_section_alignment (srel, 3))
1871
0
  return NULL;
1872
0
    }
1873
1874
0
  return srel;
1875
0
}
1876
1877
static bool
1878
count_dyn_reloc (bfd *abfd, struct elf64_ia64_dyn_sym_info *dyn_i,
1879
     asection *srel, int type)
1880
0
{
1881
0
  struct elf64_ia64_dyn_reloc_entry *rent;
1882
1883
0
  for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
1884
0
    if (rent->srel == srel && rent->type == type)
1885
0
      break;
1886
1887
0
  if (!rent)
1888
0
    {
1889
0
      rent = ((struct elf64_ia64_dyn_reloc_entry *)
1890
0
        bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
1891
0
      if (!rent)
1892
0
  return false;
1893
1894
0
      rent->next = dyn_i->reloc_entries;
1895
0
      rent->srel = srel;
1896
0
      rent->type = type;
1897
0
      rent->count = 0;
1898
0
      dyn_i->reloc_entries = rent;
1899
0
    }
1900
0
  rent->count++;
1901
1902
0
  return true;
1903
0
}
1904
1905
static bool
1906
elf64_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1907
       asection *sec,
1908
       const Elf_Internal_Rela *relocs)
1909
0
{
1910
0
  struct elf64_ia64_link_hash_table *ia64_info;
1911
0
  const Elf_Internal_Rela *relend;
1912
0
  Elf_Internal_Shdr *symtab_hdr;
1913
0
  const Elf_Internal_Rela *rel;
1914
0
  asection *got, *fptr, *srel, *pltoff;
1915
0
  enum {
1916
0
    NEED_GOT = 1,
1917
0
    NEED_GOTX = 2,
1918
0
    NEED_FPTR = 4,
1919
0
    NEED_PLTOFF = 8,
1920
0
    NEED_MIN_PLT = 16,
1921
0
    NEED_FULL_PLT = 32,
1922
0
    NEED_DYNREL = 64,
1923
0
    NEED_LTOFF_FPTR = 128
1924
0
  };
1925
0
  int need_entry;
1926
0
  struct elf_link_hash_entry *h;
1927
0
  unsigned long r_symndx;
1928
0
  bool maybe_dynamic;
1929
1930
0
  if (bfd_link_relocatable (info))
1931
0
    return true;
1932
1933
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1934
0
  ia64_info = elf64_ia64_hash_table (info);
1935
0
  if (ia64_info == NULL)
1936
0
    return false;
1937
1938
0
  got = fptr = srel = pltoff = NULL;
1939
1940
0
  relend = relocs + sec->reloc_count;
1941
1942
  /* We scan relocations first to create dynamic relocation arrays.  We
1943
     modified get_dyn_sym_info to allow fast insertion and support fast
1944
     lookup in the next loop.  */
1945
0
  for (rel = relocs; rel < relend; ++rel)
1946
0
    {
1947
0
      r_symndx = ELF64_R_SYM (rel->r_info);
1948
0
      if (r_symndx >= symtab_hdr->sh_info)
1949
0
  {
1950
0
    long indx = r_symndx - symtab_hdr->sh_info;
1951
0
    h = elf_sym_hashes (abfd)[indx];
1952
0
    while (h->root.type == bfd_link_hash_indirect
1953
0
     || h->root.type == bfd_link_hash_warning)
1954
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
1955
0
  }
1956
0
      else
1957
0
  h = NULL;
1958
1959
      /* We can only get preliminary data on whether a symbol is
1960
   locally or externally defined, as not all of the input files
1961
   have yet been processed.  Do something with what we know, as
1962
   this may help reduce memory usage and processing time later.  */
1963
0
      maybe_dynamic = (h && ((!bfd_link_executable (info)
1964
0
            && (!SYMBOLIC_BIND (info, h)
1965
0
          || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1966
0
           || !h->def_regular
1967
0
           || h->root.type == bfd_link_hash_defweak));
1968
1969
0
      need_entry = 0;
1970
0
      switch (ELF64_R_TYPE (rel->r_info))
1971
0
  {
1972
0
  case R_IA64_TPREL64MSB:
1973
0
  case R_IA64_TPREL64LSB:
1974
0
  case R_IA64_LTOFF_TPREL22:
1975
0
  case R_IA64_DTPREL32MSB:
1976
0
  case R_IA64_DTPREL32LSB:
1977
0
  case R_IA64_DTPREL64MSB:
1978
0
  case R_IA64_DTPREL64LSB:
1979
0
  case R_IA64_LTOFF_DTPREL22:
1980
0
  case R_IA64_DTPMOD64MSB:
1981
0
  case R_IA64_DTPMOD64LSB:
1982
0
  case R_IA64_LTOFF_DTPMOD22:
1983
0
    abort ();
1984
0
    break;
1985
1986
0
  case R_IA64_IPLTMSB:
1987
0
  case R_IA64_IPLTLSB:
1988
0
    break;
1989
1990
0
  case R_IA64_LTOFF_FPTR22:
1991
0
  case R_IA64_LTOFF_FPTR64I:
1992
0
  case R_IA64_LTOFF_FPTR32MSB:
1993
0
  case R_IA64_LTOFF_FPTR32LSB:
1994
0
  case R_IA64_LTOFF_FPTR64MSB:
1995
0
  case R_IA64_LTOFF_FPTR64LSB:
1996
0
    need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
1997
0
    break;
1998
1999
0
  case R_IA64_FPTR64I:
2000
0
  case R_IA64_FPTR32MSB:
2001
0
  case R_IA64_FPTR32LSB:
2002
0
  case R_IA64_FPTR64MSB:
2003
0
  case R_IA64_FPTR64LSB:
2004
0
    if (bfd_link_pic (info) || h)
2005
0
      need_entry = NEED_FPTR | NEED_DYNREL;
2006
0
    else
2007
0
      need_entry = NEED_FPTR;
2008
0
    break;
2009
2010
0
  case R_IA64_LTOFF22:
2011
0
  case R_IA64_LTOFF64I:
2012
0
    need_entry = NEED_GOT;
2013
0
    break;
2014
2015
0
  case R_IA64_LTOFF22X:
2016
0
    need_entry = NEED_GOTX;
2017
0
    break;
2018
2019
0
  case R_IA64_PLTOFF22:
2020
0
  case R_IA64_PLTOFF64I:
2021
0
  case R_IA64_PLTOFF64MSB:
2022
0
  case R_IA64_PLTOFF64LSB:
2023
0
    need_entry = NEED_PLTOFF;
2024
0
    if (h)
2025
0
      {
2026
0
        if (maybe_dynamic)
2027
0
    need_entry |= NEED_MIN_PLT;
2028
0
      }
2029
0
    else
2030
0
      {
2031
0
        (*info->callbacks->warning)
2032
0
    (info, _("@pltoff reloc against local symbol"), 0,
2033
0
     abfd, 0, (bfd_vma) 0);
2034
0
      }
2035
0
    break;
2036
2037
0
  case R_IA64_PCREL21B:
2038
0
  case R_IA64_PCREL60B:
2039
    /* Depending on where this symbol is defined, we may or may not
2040
       need a full plt entry.  Only skip if we know we'll not need
2041
       the entry -- static or symbolic, and the symbol definition
2042
       has already been seen.  */
2043
0
    if (maybe_dynamic && rel->r_addend == 0)
2044
0
      need_entry = NEED_FULL_PLT;
2045
0
    break;
2046
2047
0
  case R_IA64_IMM14:
2048
0
  case R_IA64_IMM22:
2049
0
  case R_IA64_IMM64:
2050
0
  case R_IA64_DIR32MSB:
2051
0
  case R_IA64_DIR32LSB:
2052
0
  case R_IA64_DIR64MSB:
2053
0
  case R_IA64_DIR64LSB:
2054
    /* Shared objects will always need at least a REL relocation.  */
2055
0
    if (bfd_link_pic (info) || maybe_dynamic)
2056
0
      need_entry = NEED_DYNREL;
2057
0
    break;
2058
2059
0
  case R_IA64_PCREL22:
2060
0
  case R_IA64_PCREL64I:
2061
0
  case R_IA64_PCREL32MSB:
2062
0
  case R_IA64_PCREL32LSB:
2063
0
  case R_IA64_PCREL64MSB:
2064
0
  case R_IA64_PCREL64LSB:
2065
0
    if (maybe_dynamic)
2066
0
      need_entry = NEED_DYNREL;
2067
0
    break;
2068
0
  }
2069
2070
0
      if (!need_entry)
2071
0
  continue;
2072
2073
0
      if ((need_entry & NEED_FPTR) != 0
2074
0
    && rel->r_addend)
2075
0
  {
2076
0
    (*info->callbacks->warning)
2077
0
      (info, _("non-zero addend in @fptr reloc"), 0,
2078
0
       abfd, 0, (bfd_vma) 0);
2079
0
  }
2080
2081
0
      if (get_dyn_sym_info (ia64_info, h, abfd, rel, true) == NULL)
2082
0
  return false;
2083
0
    }
2084
2085
  /* Now, we only do lookup without insertion, which is very fast
2086
     with the modified get_dyn_sym_info.  */
2087
0
  for (rel = relocs; rel < relend; ++rel)
2088
0
    {
2089
0
      struct elf64_ia64_dyn_sym_info *dyn_i;
2090
0
      int dynrel_type = R_IA64_NONE;
2091
2092
0
      r_symndx = ELF64_R_SYM (rel->r_info);
2093
0
      if (r_symndx >= symtab_hdr->sh_info)
2094
0
  {
2095
    /* We're dealing with a global symbol -- find its hash entry
2096
       and mark it as being referenced.  */
2097
0
    long indx = r_symndx - symtab_hdr->sh_info;
2098
0
    h = elf_sym_hashes (abfd)[indx];
2099
0
    while (h->root.type == bfd_link_hash_indirect
2100
0
     || h->root.type == bfd_link_hash_warning)
2101
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
2102
2103
    /* PR15323, ref flags aren't set for references in the same
2104
       object.  */
2105
0
    h->ref_regular = 1;
2106
0
  }
2107
0
      else
2108
0
  h = NULL;
2109
2110
      /* We can only get preliminary data on whether a symbol is
2111
   locally or externally defined, as not all of the input files
2112
   have yet been processed.  Do something with what we know, as
2113
   this may help reduce memory usage and processing time later.  */
2114
0
      maybe_dynamic = (h && ((!bfd_link_executable (info)
2115
0
            && (!SYMBOLIC_BIND (info, h)
2116
0
          || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2117
0
           || !h->def_regular
2118
0
           || h->root.type == bfd_link_hash_defweak));
2119
2120
0
      need_entry = 0;
2121
0
      switch (ELF64_R_TYPE (rel->r_info))
2122
0
  {
2123
0
  case R_IA64_TPREL64MSB:
2124
0
  case R_IA64_TPREL64LSB:
2125
0
  case R_IA64_LTOFF_TPREL22:
2126
0
  case R_IA64_DTPREL32MSB:
2127
0
  case R_IA64_DTPREL32LSB:
2128
0
  case R_IA64_DTPREL64MSB:
2129
0
  case R_IA64_DTPREL64LSB:
2130
0
  case R_IA64_LTOFF_DTPREL22:
2131
0
  case R_IA64_DTPMOD64MSB:
2132
0
  case R_IA64_DTPMOD64LSB:
2133
0
  case R_IA64_LTOFF_DTPMOD22:
2134
0
    abort ();
2135
0
    break;
2136
2137
0
  case R_IA64_LTOFF_FPTR22:
2138
0
  case R_IA64_LTOFF_FPTR64I:
2139
0
  case R_IA64_LTOFF_FPTR32MSB:
2140
0
  case R_IA64_LTOFF_FPTR32LSB:
2141
0
  case R_IA64_LTOFF_FPTR64MSB:
2142
0
  case R_IA64_LTOFF_FPTR64LSB:
2143
0
    need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2144
0
    break;
2145
2146
0
  case R_IA64_FPTR64I:
2147
0
  case R_IA64_FPTR32MSB:
2148
0
  case R_IA64_FPTR32LSB:
2149
0
  case R_IA64_FPTR64MSB:
2150
0
  case R_IA64_FPTR64LSB:
2151
0
    if (bfd_link_pic (info) || h)
2152
0
      need_entry = NEED_FPTR | NEED_DYNREL;
2153
0
    else
2154
0
      need_entry = NEED_FPTR;
2155
0
    dynrel_type = R_IA64_FPTR64LSB;
2156
0
    break;
2157
2158
0
  case R_IA64_LTOFF22:
2159
0
  case R_IA64_LTOFF64I:
2160
0
    need_entry = NEED_GOT;
2161
0
    break;
2162
2163
0
  case R_IA64_LTOFF22X:
2164
0
    need_entry = NEED_GOTX;
2165
0
    break;
2166
2167
0
  case R_IA64_PLTOFF22:
2168
0
  case R_IA64_PLTOFF64I:
2169
0
  case R_IA64_PLTOFF64MSB:
2170
0
  case R_IA64_PLTOFF64LSB:
2171
0
    need_entry = NEED_PLTOFF;
2172
0
    if (h)
2173
0
      {
2174
0
        if (maybe_dynamic)
2175
0
    need_entry |= NEED_MIN_PLT;
2176
0
      }
2177
0
    break;
2178
2179
0
  case R_IA64_PCREL21B:
2180
0
  case R_IA64_PCREL60B:
2181
    /* Depending on where this symbol is defined, we may or may not
2182
       need a full plt entry.  Only skip if we know we'll not need
2183
       the entry -- static or symbolic, and the symbol definition
2184
       has already been seen.  */
2185
0
    if (maybe_dynamic && rel->r_addend == 0)
2186
0
      need_entry = NEED_FULL_PLT;
2187
0
    break;
2188
2189
0
  case R_IA64_IMM14:
2190
0
  case R_IA64_IMM22:
2191
0
  case R_IA64_IMM64:
2192
0
  case R_IA64_DIR32MSB:
2193
0
  case R_IA64_DIR32LSB:
2194
0
  case R_IA64_DIR64MSB:
2195
0
  case R_IA64_DIR64LSB:
2196
    /* Shared objects will always need at least a REL relocation.  */
2197
0
    if (bfd_link_pic (info) || maybe_dynamic)
2198
0
      need_entry = NEED_DYNREL;
2199
0
    dynrel_type = R_IA64_DIR64LSB;
2200
0
    break;
2201
2202
0
  case R_IA64_IPLTMSB:
2203
0
  case R_IA64_IPLTLSB:
2204
0
    break;
2205
2206
0
  case R_IA64_PCREL22:
2207
0
  case R_IA64_PCREL64I:
2208
0
  case R_IA64_PCREL32MSB:
2209
0
  case R_IA64_PCREL32LSB:
2210
0
  case R_IA64_PCREL64MSB:
2211
0
  case R_IA64_PCREL64LSB:
2212
0
    if (maybe_dynamic)
2213
0
      need_entry = NEED_DYNREL;
2214
0
    dynrel_type = R_IA64_PCREL64LSB;
2215
0
    break;
2216
0
  }
2217
2218
0
      if (!need_entry)
2219
0
  continue;
2220
2221
0
      dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, false);
2222
2223
      /* Record whether or not this is a local symbol.  */
2224
0
      dyn_i->h = h;
2225
2226
      /* Create what's needed.  */
2227
0
      if (need_entry & (NEED_GOT | NEED_GOTX))
2228
0
  {
2229
0
    if (!got)
2230
0
      {
2231
0
        got = get_got (abfd, ia64_info);
2232
0
        if (!got)
2233
0
    return false;
2234
0
      }
2235
0
    if (need_entry & NEED_GOT)
2236
0
      dyn_i->want_got = 1;
2237
0
    if (need_entry & NEED_GOTX)
2238
0
      dyn_i->want_gotx = 1;
2239
0
  }
2240
0
      if (need_entry & NEED_FPTR)
2241
0
  {
2242
    /* Create the .opd section.  */
2243
0
    if (!fptr)
2244
0
      {
2245
0
        fptr = get_fptr (abfd, info, ia64_info);
2246
0
        if (!fptr)
2247
0
    return false;
2248
0
      }
2249
0
    dyn_i->want_fptr = 1;
2250
0
  }
2251
0
      if (need_entry & NEED_LTOFF_FPTR)
2252
0
  dyn_i->want_ltoff_fptr = 1;
2253
0
      if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2254
0
  {
2255
0
    if (!ia64_info->root.dynobj)
2256
0
      ia64_info->root.dynobj = abfd;
2257
0
    h->needs_plt = 1;
2258
0
    dyn_i->want_plt = 1;
2259
0
  }
2260
0
      if (need_entry & NEED_FULL_PLT)
2261
0
  dyn_i->want_plt2 = 1;
2262
0
      if (need_entry & NEED_PLTOFF)
2263
0
  {
2264
    /* This is needed here, in case @pltoff is used in a non-shared
2265
       link.  */
2266
0
    if (!pltoff)
2267
0
      {
2268
0
        pltoff = get_pltoff (abfd, ia64_info);
2269
0
        if (!pltoff)
2270
0
    return false;
2271
0
      }
2272
2273
0
    dyn_i->want_pltoff = 1;
2274
0
  }
2275
0
      if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2276
0
  {
2277
0
    if (!srel)
2278
0
      {
2279
0
        srel = get_reloc_section (abfd, ia64_info, sec, true);
2280
0
        if (!srel)
2281
0
    return false;
2282
0
      }
2283
0
    if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
2284
0
      return false;
2285
0
  }
2286
0
    }
2287
2288
0
  return true;
2289
0
}
2290
2291
/* For cleanliness, and potentially faster dynamic loading, allocate
2292
   external GOT entries first.  */
2293
2294
static bool
2295
allocate_global_data_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2296
        void * data)
2297
0
{
2298
0
  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2299
2300
0
  if ((dyn_i->want_got || dyn_i->want_gotx)
2301
0
      && ! dyn_i->want_fptr
2302
0
      && elf64_ia64_dynamic_symbol_p (dyn_i->h))
2303
0
     {
2304
       /* GOT entry with FPTR is done by allocate_global_fptr_got.  */
2305
0
       dyn_i->got_offset = x->ofs;
2306
0
       x->ofs += 8;
2307
0
     }
2308
0
  return true;
2309
0
}
2310
2311
/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs.  */
2312
2313
static bool
2314
allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2315
        void * data)
2316
0
{
2317
0
  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2318
2319
0
  if (dyn_i->want_got
2320
0
      && dyn_i->want_fptr
2321
0
      && elf64_ia64_dynamic_symbol_p (dyn_i->h))
2322
0
    {
2323
0
      dyn_i->got_offset = x->ofs;
2324
0
      x->ofs += 8;
2325
0
    }
2326
0
  return true;
2327
0
}
2328
2329
/* Lastly, allocate all the GOT entries for local data.  */
2330
2331
static bool
2332
allocate_local_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2333
        void * data)
2334
0
{
2335
0
  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
2336
2337
0
  if ((dyn_i->want_got || dyn_i->want_gotx)
2338
0
      && !elf64_ia64_dynamic_symbol_p (dyn_i->h))
2339
0
    {
2340
0
      dyn_i->got_offset = x->ofs;
2341
0
      x->ofs += 8;
2342
0
    }
2343
0
  return true;
2344
0
}
2345
2346
/* Allocate function descriptors.  We can do these for every function
2347
   in a main executable that is not exported.  */
2348
2349
static bool
2350
allocate_fptr (struct elf64_ia64_dyn_sym_info *dyn_i, void * data)
2351
0
{
2352
0
  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
2353
2354
0
  if (dyn_i->want_fptr)
2355
0
    {
2356
0
      struct elf_link_hash_entry *h = dyn_i->h;
2357
2358
0
      if (h)
2359
0
  while (h->root.type == bfd_link_hash_indirect
2360
0
         || h->root.type == bfd_link_hash_warning)
2361
0
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2362
2363
0
      if (h == NULL || !h->def_dynamic)
2364
0
  {
2365
    /*  A non dynamic symbol.  */
2366
0
    dyn_i->fptr_offset = x->ofs;
2367
0
    x->ofs += 16;
2368
0
  }
2369
0
      else
2370
0
  dyn_i->want_fptr = 0;
2371
0
    }
2372
0
  return true;
2373
0
}
2374
2375
/* Allocate all the minimal PLT entries.  */
2376
2377
static bool
2378
allocate_plt_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2379
          void * data ATTRIBUTE_UNUSED)
2380
0
{
2381
0
  if (dyn_i->want_plt)
2382
0
    {
2383
0
      struct elf_link_hash_entry *h = dyn_i->h;
2384
2385
0
      if (h)
2386
0
  while (h->root.type == bfd_link_hash_indirect
2387
0
         || h->root.type == bfd_link_hash_warning)
2388
0
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2389
2390
      /* ??? Versioned symbols seem to lose NEEDS_PLT.  */
2391
0
      if (elf64_ia64_dynamic_symbol_p (h))
2392
0
  {
2393
0
    dyn_i->want_pltoff = 1;
2394
0
  }
2395
0
      else
2396
0
  {
2397
0
    dyn_i->want_plt = 0;
2398
0
    dyn_i->want_plt2 = 0;
2399
0
  }
2400
0
    }
2401
0
  return true;
2402
0
}
2403
2404
/* Allocate all the full PLT entries.  */
2405
2406
static bool
2407
allocate_plt2_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2408
           void * data)
2409
0
{
2410
0
  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2411
2412
0
  if (dyn_i->want_plt2)
2413
0
    {
2414
0
      struct elf_link_hash_entry *h = dyn_i->h;
2415
0
      bfd_size_type ofs = x->ofs;
2416
2417
0
      dyn_i->plt2_offset = ofs;
2418
0
      x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2419
2420
0
      while (h->root.type == bfd_link_hash_indirect
2421
0
       || h->root.type == bfd_link_hash_warning)
2422
0
  h = (struct elf_link_hash_entry *) h->root.u.i.link;
2423
0
      dyn_i->h->plt.offset = ofs;
2424
0
    }
2425
0
  return true;
2426
0
}
2427
2428
/* Allocate all the PLTOFF entries requested by relocations and
2429
   plt entries.  We can't share space with allocated FPTR entries,
2430
   because the latter are not necessarily addressable by the GP.
2431
   ??? Relaxation might be able to determine that they are.  */
2432
2433
static bool
2434
allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2435
       void * data)
2436
0
{
2437
0
  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2438
2439
0
  if (dyn_i->want_pltoff)
2440
0
    {
2441
0
      dyn_i->pltoff_offset = x->ofs;
2442
0
      x->ofs += 16;
2443
0
    }
2444
0
  return true;
2445
0
}
2446
2447
/* Allocate dynamic relocations for those symbols that turned out
2448
   to be dynamic.  */
2449
2450
static bool
2451
allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2452
       void * data)
2453
0
{
2454
0
  struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2455
0
  struct elf64_ia64_link_hash_table *ia64_info;
2456
0
  struct elf64_ia64_dyn_reloc_entry *rent;
2457
0
  bool dynamic_symbol, shared, resolved_zero;
2458
0
  struct elf64_ia64_link_hash_entry *h_ia64;
2459
2460
0
  ia64_info = elf64_ia64_hash_table (x->info);
2461
0
  if (ia64_info == NULL)
2462
0
    return false;
2463
2464
  /* Note that this can't be used in relation to FPTR relocs below.  */
2465
0
  dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h);
2466
2467
0
  shared = bfd_link_pic (x->info);
2468
0
  resolved_zero = (dyn_i->h
2469
0
       && ELF_ST_VISIBILITY (dyn_i->h->other)
2470
0
       && dyn_i->h->root.type == bfd_link_hash_undefweak);
2471
2472
  /* Take care of the GOT and PLT relocations.  */
2473
2474
0
  if ((!resolved_zero
2475
0
       && (dynamic_symbol || shared)
2476
0
       && (dyn_i->want_got || dyn_i->want_gotx))
2477
0
      || (dyn_i->want_ltoff_fptr
2478
0
    && dyn_i->h
2479
0
    && dyn_i->h->def_dynamic))
2480
0
    {
2481
      /* VMS: FIX64.  */
2482
0
      if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
2483
0
  {
2484
0
    h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2485
0
    elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2486
0
      sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2487
0
    ia64_info->fixups_sec->size +=
2488
0
      sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2489
0
  }
2490
0
    }
2491
2492
0
  if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2493
0
    {
2494
      /* VMS: only image reloc.  */
2495
0
      if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2496
0
  ia64_info->rel_fptr_sec->size += sizeof (Elf64_External_Rela);
2497
0
    }
2498
2499
0
  if (!resolved_zero && dyn_i->want_pltoff)
2500
0
    {
2501
      /* VMS: FIXFD.  */
2502
0
      if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
2503
0
  {
2504
0
    h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2505
0
    elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2506
0
      sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2507
0
    ia64_info->fixups_sec->size +=
2508
0
      sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2509
0
  }
2510
0
    }
2511
2512
  /* Take care of the normal data relocations.  */
2513
2514
0
  for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2515
0
    {
2516
0
      switch (rent->type)
2517
0
  {
2518
0
  case R_IA64_FPTR32LSB:
2519
0
  case R_IA64_FPTR64LSB:
2520
    /* Allocate one iff !want_fptr and not PIE, which by this point
2521
       will be true only if we're actually allocating one statically
2522
       in the main executable.  Position independent executables
2523
       need a relative reloc.  */
2524
0
    if (dyn_i->want_fptr && !bfd_link_pie (x->info))
2525
0
      continue;
2526
0
    break;
2527
0
  case R_IA64_PCREL32LSB:
2528
0
  case R_IA64_PCREL64LSB:
2529
0
    if (!dynamic_symbol)
2530
0
      continue;
2531
0
    break;
2532
0
  case R_IA64_DIR32LSB:
2533
0
  case R_IA64_DIR64LSB:
2534
0
    if (!dynamic_symbol && !shared)
2535
0
      continue;
2536
0
    break;
2537
0
  case R_IA64_IPLTLSB:
2538
0
    if (!dynamic_symbol && !shared)
2539
0
      continue;
2540
0
    break;
2541
0
  case R_IA64_DTPREL32LSB:
2542
0
  case R_IA64_TPREL64LSB:
2543
0
  case R_IA64_DTPREL64LSB:
2544
0
  case R_IA64_DTPMOD64LSB:
2545
0
    break;
2546
0
  default:
2547
0
    abort ();
2548
0
  }
2549
2550
      /* Add a fixup.  */
2551
0
      if (!dynamic_symbol)
2552
0
  abort ();
2553
2554
0
      h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2555
0
      elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2556
0
  sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2557
0
      ia64_info->fixups_sec->size +=
2558
0
  sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2559
0
    }
2560
2561
0
  return true;
2562
0
}
2563
2564
static bool
2565
elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2566
          struct elf_link_hash_entry *h)
2567
0
{
2568
  /* ??? Undefined symbols with PLT entries should be re-defined
2569
     to be the PLT entry.  */
2570
2571
  /* If this is a weak symbol, and there is a real definition, the
2572
     processor independent code will have arranged for us to see the
2573
     real definition first, and we can just use the same value.  */
2574
0
  if (h->is_weakalias)
2575
0
    {
2576
0
      struct elf_link_hash_entry *def = weakdef (h);
2577
0
      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2578
0
      h->root.u.def.section = def->root.u.def.section;
2579
0
      h->root.u.def.value = def->root.u.def.value;
2580
0
      return true;
2581
0
    }
2582
2583
  /* If this is a reference to a symbol defined by a dynamic object which
2584
     is not a function, we might allocate the symbol in our .dynbss section
2585
     and allocate a COPY dynamic relocation.
2586
2587
     But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2588
     of hackery.  */
2589
2590
0
  return true;
2591
0
}
2592
2593
static bool
2594
elf64_ia64_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2595
             struct bfd_link_info *info)
2596
0
{
2597
0
  struct elf64_ia64_allocate_data data;
2598
0
  struct elf64_ia64_link_hash_table *ia64_info;
2599
0
  asection *sec;
2600
0
  bfd *dynobj;
2601
0
  struct elf_link_hash_table *hash_table;
2602
2603
0
  hash_table = elf_hash_table (info);
2604
0
  ia64_info = elf64_ia64_hash_table (info);
2605
0
  if (ia64_info == NULL)
2606
0
    return false;
2607
0
  dynobj = hash_table->dynobj;
2608
0
  if (dynobj == NULL)
2609
0
    return true;
2610
0
  data.info = info;
2611
2612
  /* Allocate the GOT entries.  */
2613
2614
0
  if (ia64_info->root.sgot)
2615
0
    {
2616
0
      data.ofs = 0;
2617
0
      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2618
0
      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2619
0
      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2620
0
      ia64_info->root.sgot->size = data.ofs;
2621
0
    }
2622
2623
  /* Allocate the FPTR entries.  */
2624
2625
0
  if (ia64_info->fptr_sec)
2626
0
    {
2627
0
      data.ofs = 0;
2628
0
      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2629
0
      ia64_info->fptr_sec->size = data.ofs;
2630
0
    }
2631
2632
  /* Now that we've seen all of the input files, we can decide which
2633
     symbols need plt entries.  Allocate the minimal PLT entries first.
2634
     We do this even though dynamic_sections_created may be FALSE, because
2635
     this has the side-effect of clearing want_plt and want_plt2.  */
2636
2637
0
  data.ofs = 0;
2638
0
  elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2639
2640
  /* Align the pointer for the plt2 entries.  */
2641
0
  data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2642
2643
0
  elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2644
0
  if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
2645
0
    {
2646
      /* FIXME: we always reserve the memory for dynamic linker even if
2647
   there are no PLT entries since dynamic linker may assume the
2648
   reserved memory always exists.  */
2649
2650
0
      BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2651
2652
0
      ia64_info->root.splt->size = data.ofs;
2653
0
    }
2654
2655
  /* Allocate the PLTOFF entries.  */
2656
2657
0
  if (ia64_info->pltoff_sec)
2658
0
    {
2659
0
      data.ofs = 0;
2660
0
      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2661
0
      ia64_info->pltoff_sec->size = data.ofs;
2662
0
    }
2663
2664
0
  if (ia64_info->root.dynamic_sections_created)
2665
0
    {
2666
      /* Allocate space for the dynamic relocations that turned out to be
2667
   required.  */
2668
0
      elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2669
0
    }
2670
2671
  /* We have now determined the sizes of the various dynamic sections.
2672
     Allocate memory for them.  */
2673
0
  for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2674
0
    {
2675
0
      bool strip;
2676
2677
0
      if (!(sec->flags & SEC_LINKER_CREATED))
2678
0
  continue;
2679
2680
      /* If we don't need this section, strip it from the output file.
2681
   There were several sections primarily related to dynamic
2682
   linking that must be create before the linker maps input
2683
   sections to output sections.  The linker does that before
2684
   bfd_elf_size_dynamic_sections is called, and it is that
2685
   function which decides whether anything needs to go into
2686
   these sections.  */
2687
2688
0
      strip = (sec->size == 0);
2689
2690
0
      if (sec == ia64_info->root.sgot)
2691
0
  strip = false;
2692
0
      else if (sec == ia64_info->root.srelgot)
2693
0
  {
2694
0
    if (strip)
2695
0
      ia64_info->root.srelgot = NULL;
2696
0
    else
2697
      /* We use the reloc_count field as a counter if we need to
2698
         copy relocs into the output file.  */
2699
0
      sec->reloc_count = 0;
2700
0
  }
2701
0
      else if (sec == ia64_info->fptr_sec)
2702
0
  {
2703
0
    if (strip)
2704
0
      ia64_info->fptr_sec = NULL;
2705
0
  }
2706
0
      else if (sec == ia64_info->rel_fptr_sec)
2707
0
  {
2708
0
    if (strip)
2709
0
      ia64_info->rel_fptr_sec = NULL;
2710
0
    else
2711
      /* We use the reloc_count field as a counter if we need to
2712
         copy relocs into the output file.  */
2713
0
      sec->reloc_count = 0;
2714
0
  }
2715
0
      else if (sec == ia64_info->root.splt)
2716
0
  {
2717
0
    if (strip)
2718
0
      ia64_info->root.splt = NULL;
2719
0
  }
2720
0
      else if (sec == ia64_info->pltoff_sec)
2721
0
  {
2722
0
    if (strip)
2723
0
      ia64_info->pltoff_sec = NULL;
2724
0
  }
2725
0
      else if (sec == ia64_info->fixups_sec)
2726
0
  {
2727
0
    if (strip)
2728
0
      ia64_info->fixups_sec = NULL;
2729
0
  }
2730
0
      else if (sec == ia64_info->transfer_sec)
2731
0
  {
2732
0
    ;
2733
0
  }
2734
0
      else
2735
0
  {
2736
0
    const char *name;
2737
2738
    /* It's OK to base decisions on the section name, because none
2739
       of the dynobj section names depend upon the input files.  */
2740
0
    name = bfd_section_name (sec);
2741
2742
0
    if (strcmp (name, ".got.plt") == 0)
2743
0
      strip = false;
2744
0
    else if (startswith (name, ".rel"))
2745
0
      {
2746
0
        if (!strip)
2747
0
    {
2748
      /* We use the reloc_count field as a counter if we need to
2749
         copy relocs into the output file.  */
2750
0
      sec->reloc_count = 0;
2751
0
    }
2752
0
      }
2753
0
    else
2754
0
      continue;
2755
0
  }
2756
2757
0
      if (strip)
2758
0
  sec->flags |= SEC_EXCLUDE;
2759
0
      else
2760
0
  {
2761
    /* Allocate memory for the section contents.  */
2762
0
    sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
2763
0
    if (sec->contents == NULL && sec->size != 0)
2764
0
      return false;
2765
0
  }
2766
0
    }
2767
2768
0
  if (elf_hash_table (info)->dynamic_sections_created)
2769
0
    {
2770
0
      bfd *abfd;
2771
0
      asection *dynsec;
2772
0
      asection *dynstrsec;
2773
0
      Elf_Internal_Dyn dyn;
2774
0
      const struct elf_backend_data *bed;
2775
0
      unsigned int shl_num = 0;
2776
0
      bfd_vma fixups_off = 0;
2777
0
      bfd_vma strdyn_off;
2778
0
      unsigned int time_hi, time_lo;
2779
2780
      /* The .dynamic section must exist and be empty.  */
2781
0
      dynsec = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
2782
0
      BFD_ASSERT (dynsec != NULL);
2783
0
      BFD_ASSERT (dynsec->size == 0);
2784
2785
0
      dynstrsec = bfd_get_linker_section (hash_table->dynobj, ".vmsdynstr");
2786
0
      BFD_ASSERT (dynstrsec != NULL);
2787
0
      BFD_ASSERT (dynstrsec->size == 0);
2788
0
      dynstrsec->size = 1;  /* Initial blank.  */
2789
2790
      /* Ident + link time.  */
2791
0
      vms_get_time (&time_hi, &time_lo);
2792
2793
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_IDENT, 0))
2794
0
  return false;
2795
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LINKTIME,
2796
0
               ((uint64_t) time_hi << 32)
2797
0
               + time_lo))
2798
0
  return false;
2799
2800
      /* Strtab.  */
2801
0
      strdyn_off = dynsec->size;
2802
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_STRTAB_OFFSET, 0))
2803
0
  return false;
2804
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_STRSZ, 0))
2805
0
  return false;
2806
2807
      /* PLTGOT  */
2808
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_SEG, 0))
2809
0
  return false;
2810
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_OFFSET, 0))
2811
0
  return false;
2812
2813
      /* Misc.  */
2814
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FPMODE, 0x9800000))
2815
0
  return false;
2816
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LNKFLAGS,
2817
0
               VMS_LF_IMGSTA | VMS_LF_MAIN))
2818
0
  return false;
2819
2820
      /* Add entries for shared libraries.  */
2821
0
      for (abfd = info->input_bfds; abfd; abfd = abfd->link.next)
2822
0
  {
2823
0
    char *soname;
2824
0
    size_t soname_len;
2825
0
    bfd_size_type strindex;
2826
0
    bfd_byte *newcontents;
2827
0
    bfd_vma fixups_shl_off;
2828
2829
0
    if (!(abfd->flags & DYNAMIC))
2830
0
      continue;
2831
0
    BFD_ASSERT (abfd->xvec == output_bfd->xvec);
2832
2833
0
    if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_NEEDED_IDENT,
2834
0
             elf_ia64_vms_ident (abfd)))
2835
0
      return false;
2836
2837
0
    soname = vms_get_module_name (bfd_get_filename (abfd), true);
2838
0
    if (soname == NULL)
2839
0
      return false;
2840
0
    strindex = dynstrsec->size;
2841
0
    soname_len = strlen (soname) + 1;
2842
0
    newcontents = (bfd_byte *) bfd_realloc (dynstrsec->contents,
2843
0
              strindex + soname_len);
2844
0
    if (newcontents == NULL)
2845
0
      return false;
2846
0
    memcpy (newcontents + strindex, soname, soname_len);
2847
0
    dynstrsec->size += soname_len;
2848
0
    dynstrsec->contents = newcontents;
2849
2850
0
    if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
2851
0
      return false;
2852
2853
0
    if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_NEEDED,
2854
0
             shl_num))
2855
0
      return false;
2856
0
    shl_num++;
2857
2858
    /* The fixups_off was in fact containing the size of the fixup
2859
       section.  Remap into the offset.  */
2860
0
    fixups_shl_off = elf_ia64_vms_tdata (abfd)->fixups_off;
2861
0
    elf_ia64_vms_tdata (abfd)->fixups_off = fixups_off;
2862
2863
0
    if (!_bfd_elf_add_dynamic_entry
2864
0
        (info, DT_IA_64_VMS_FIXUP_RELA_CNT,
2865
0
         fixups_shl_off / sizeof (Elf64_External_VMS_IMAGE_FIXUP)))
2866
0
      return false;
2867
0
    if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_RELA_OFF,
2868
0
             fixups_off))
2869
0
      return false;
2870
0
    fixups_off += fixups_shl_off;
2871
0
  }
2872
2873
      /* Unwind.  */
2874
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWINDSZ, 0))
2875
0
  return false;
2876
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_CODSEG, 0))
2877
0
  return false;
2878
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_INFOSEG, 0))
2879
0
  return false;
2880
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_OFFSET, 0))
2881
0
  return false;
2882
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_SEG, 0))
2883
0
  return false;
2884
2885
0
      if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0xdead))
2886
0
      return false;
2887
2888
      /* Fix the strtab entries.  */
2889
0
      bed = get_elf_backend_data (hash_table->dynobj);
2890
2891
0
      if (dynstrsec->size > 1)
2892
0
  dynstrsec->contents[0] = 0;
2893
0
      else
2894
0
  dynstrsec->size = 0;
2895
2896
      /* Note: one 'spare' (ie DT_NULL) entry is added by
2897
   bfd_elf_size_dynsym_hash_dynstr.  */
2898
0
      dyn.d_tag = DT_IA_64_VMS_STRTAB_OFFSET;
2899
0
      dyn.d_un.d_val = dynsec->size /* + sizeof (Elf64_External_Dyn) */;
2900
0
      bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
2901
0
          dynsec->contents + strdyn_off);
2902
2903
0
      dyn.d_tag = DT_STRSZ;
2904
0
      dyn.d_un.d_val = dynstrsec->size;
2905
0
      bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
2906
0
          dynsec->contents + strdyn_off + bed->s->sizeof_dyn);
2907
2908
0
      elf_ia64_vms_tdata (output_bfd)->needed_count = shl_num;
2909
2910
      /* Note section.  */
2911
0
      if (!create_ia64_vms_notes (output_bfd, info, time_hi, time_lo))
2912
0
  return false;
2913
0
    }
2914
2915
  /* ??? Perhaps force __gp local.  */
2916
2917
0
  return true;
2918
0
}
2919
2920
static void
2921
elf64_ia64_install_fixup (bfd *output_bfd,
2922
        struct elf64_ia64_link_hash_table *ia64_info,
2923
        struct elf_link_hash_entry *h,
2924
        unsigned int type, asection *sec, bfd_vma offset,
2925
        bfd_vma addend)
2926
0
{
2927
0
  asection *relsec;
2928
0
  Elf64_External_VMS_IMAGE_FIXUP *fixup;
2929
0
  struct elf64_ia64_link_hash_entry *h_ia64;
2930
0
  bfd_vma fixoff;
2931
0
  Elf_Internal_Phdr *phdr;
2932
2933
0
  if (h == NULL || !h->def_dynamic)
2934
0
    abort ();
2935
2936
0
  h_ia64 = (struct elf64_ia64_link_hash_entry *) h;
2937
0
  fixoff = elf_ia64_vms_tdata (h_ia64->shl)->fixups_off;
2938
0
  elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2939
0
    sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2940
0
  relsec = ia64_info->fixups_sec;
2941
2942
0
  fixup = (Elf64_External_VMS_IMAGE_FIXUP *)(relsec->contents + fixoff);
2943
0
  offset += sec->output_section->vma + sec->output_offset;
2944
2945
  /* FIXME: this is slow.  We should cache the last one used, or create a
2946
     map.  */
2947
0
  phdr = _bfd_elf_find_segment_containing_section
2948
0
    (output_bfd, sec->output_section);
2949
0
  BFD_ASSERT (phdr != NULL);
2950
2951
0
  bfd_putl64 (offset - phdr->p_vaddr, fixup->fixup_offset);
2952
0
  bfd_putl32 (type, fixup->type);
2953
0
  bfd_putl32 (phdr - elf_tdata (output_bfd)->phdr, fixup->fixup_seg);
2954
0
  bfd_putl64 (addend, fixup->addend);
2955
0
  bfd_putl32 (h->root.u.def.value, fixup->symvec_index);
2956
0
  bfd_putl32 (2, fixup->data_type);
2957
0
}
2958
2959
/* Store an entry for target address TARGET_ADDR in the linkage table
2960
   and return the gp-relative address of the linkage table entry.  */
2961
2962
static bfd_vma
2963
set_got_entry (bfd *abfd, struct bfd_link_info *info,
2964
         struct elf64_ia64_dyn_sym_info *dyn_i,
2965
         bfd_vma addend, bfd_vma value, unsigned int dyn_r_type)
2966
0
{
2967
0
  struct elf64_ia64_link_hash_table *ia64_info;
2968
0
  asection *got_sec;
2969
0
  bool done;
2970
0
  bfd_vma got_offset;
2971
2972
0
  ia64_info = elf64_ia64_hash_table (info);
2973
0
  if (ia64_info == NULL)
2974
0
    return 0;
2975
2976
0
  got_sec = ia64_info->root.sgot;
2977
2978
0
  switch (dyn_r_type)
2979
0
    {
2980
0
    case R_IA64_TPREL64LSB:
2981
0
    case R_IA64_DTPMOD64LSB:
2982
0
    case R_IA64_DTPREL32LSB:
2983
0
    case R_IA64_DTPREL64LSB:
2984
0
      abort ();
2985
0
      break;
2986
0
    default:
2987
0
      done = dyn_i->got_done;
2988
0
      dyn_i->got_done = true;
2989
0
      got_offset = dyn_i->got_offset;
2990
0
      break;
2991
0
    }
2992
2993
0
  BFD_ASSERT ((got_offset & 7) == 0);
2994
2995
0
  if (! done)
2996
0
    {
2997
      /* Store the target address in the linkage table entry.  */
2998
0
      bfd_put_64 (abfd, value, got_sec->contents + got_offset);
2999
3000
      /* Install a dynamic relocation if needed.  */
3001
0
      if (((bfd_link_pic (info)
3002
0
      && (!dyn_i->h
3003
0
    || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3004
0
    || dyn_i->h->root.type != bfd_link_hash_undefweak))
3005
0
     || elf64_ia64_dynamic_symbol_p (dyn_i->h))
3006
0
    && (!dyn_i->want_ltoff_fptr
3007
0
        || !bfd_link_pie (info)
3008
0
        || !dyn_i->h
3009
0
        || dyn_i->h->root.type != bfd_link_hash_undefweak))
3010
0
  {
3011
0
    if (!dyn_i->h || !dyn_i->h->def_dynamic)
3012
0
      {
3013
0
        dyn_r_type = R_IA64_REL64LSB;
3014
0
        addend = value;
3015
0
      }
3016
3017
    /* VMS: install a FIX32 or FIX64.  */
3018
0
    switch (dyn_r_type)
3019
0
      {
3020
0
      case R_IA64_DIR32LSB:
3021
0
      case R_IA64_FPTR32LSB:
3022
0
        dyn_r_type = R_IA64_VMS_FIX32;
3023
0
        break;
3024
0
      case R_IA64_DIR64LSB:
3025
0
      case R_IA64_FPTR64LSB:
3026
0
        dyn_r_type = R_IA64_VMS_FIX64;
3027
0
        break;
3028
0
      default:
3029
0
        BFD_ASSERT (false);
3030
0
        break;
3031
0
      }
3032
0
    elf64_ia64_install_fixup
3033
0
      (info->output_bfd, ia64_info, dyn_i->h,
3034
0
       dyn_r_type, got_sec, got_offset, addend);
3035
0
  }
3036
0
    }
3037
3038
  /* Return the address of the linkage table entry.  */
3039
0
  value = (got_sec->output_section->vma
3040
0
     + got_sec->output_offset
3041
0
     + got_offset);
3042
3043
0
  return value;
3044
0
}
3045
3046
/* Fill in a function descriptor consisting of the function's code
3047
   address and its global pointer.  Return the descriptor's address.  */
3048
3049
static bfd_vma
3050
set_fptr_entry (bfd *abfd, struct bfd_link_info *info,
3051
    struct elf64_ia64_dyn_sym_info *dyn_i,
3052
    bfd_vma value)
3053
0
{
3054
0
  struct elf64_ia64_link_hash_table *ia64_info;
3055
0
  asection *fptr_sec;
3056
3057
0
  ia64_info = elf64_ia64_hash_table (info);
3058
0
  if (ia64_info == NULL)
3059
0
    return 0;
3060
3061
0
  fptr_sec = ia64_info->fptr_sec;
3062
3063
0
  if (!dyn_i->fptr_done)
3064
0
    {
3065
0
      dyn_i->fptr_done = 1;
3066
3067
      /* Fill in the function descriptor.  */
3068
0
      bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3069
0
      bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3070
0
      fptr_sec->contents + dyn_i->fptr_offset + 8);
3071
0
    }
3072
3073
  /* Return the descriptor's address.  */
3074
0
  value = (fptr_sec->output_section->vma
3075
0
     + fptr_sec->output_offset
3076
0
     + dyn_i->fptr_offset);
3077
3078
0
  return value;
3079
0
}
3080
3081
/* Fill in a PLTOFF entry consisting of the function's code address
3082
   and its global pointer.  Return the descriptor's address.  */
3083
3084
static bfd_vma
3085
set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
3086
      struct elf64_ia64_dyn_sym_info *dyn_i,
3087
      bfd_vma value, bool is_plt)
3088
0
{
3089
0
  struct elf64_ia64_link_hash_table *ia64_info;
3090
0
  asection *pltoff_sec;
3091
3092
0
  ia64_info = elf64_ia64_hash_table (info);
3093
0
  if (ia64_info == NULL)
3094
0
    return 0;
3095
3096
0
  pltoff_sec = ia64_info->pltoff_sec;
3097
3098
  /* Don't do anything if this symbol uses a real PLT entry.  In
3099
     that case, we'll fill this in during finish_dynamic_symbol.  */
3100
0
  if ((! dyn_i->want_plt || is_plt)
3101
0
      && !dyn_i->pltoff_done)
3102
0
    {
3103
0
      bfd_vma gp = _bfd_get_gp_value (abfd);
3104
3105
      /* Fill in the function descriptor.  */
3106
0
      bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3107
0
      bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3108
3109
      /* Install dynamic relocations if needed.  */
3110
0
      if (!is_plt
3111
0
    && bfd_link_pic (info)
3112
0
    && (!dyn_i->h
3113
0
        || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3114
0
        || dyn_i->h->root.type != bfd_link_hash_undefweak))
3115
0
  {
3116
    /* VMS:  */
3117
0
    abort ();
3118
0
  }
3119
3120
0
      dyn_i->pltoff_done = 1;
3121
0
    }
3122
3123
  /* Return the descriptor's address.  */
3124
0
  value = (pltoff_sec->output_section->vma
3125
0
     + pltoff_sec->output_offset
3126
0
     + dyn_i->pltoff_offset);
3127
3128
0
  return value;
3129
0
}
3130
3131
/* Called through qsort to sort the .IA_64.unwind section during a
3132
   non-relocatable link.  Set elf64_ia64_unwind_entry_compare_bfd
3133
   to the output bfd so we can do proper endianness frobbing.  */
3134
3135
static bfd *elf64_ia64_unwind_entry_compare_bfd;
3136
3137
static int
3138
elf64_ia64_unwind_entry_compare (const void * a, const void * b)
3139
0
{
3140
0
  bfd_vma av, bv;
3141
3142
0
  av = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, a);
3143
0
  bv = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, b);
3144
3145
0
  return (av < bv ? -1 : av > bv ? 1 : 0);
3146
0
}
3147
3148
/* Make sure we've got ourselves a nice fat __gp value.  */
3149
static bool
3150
elf64_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bool final)
3151
0
{
3152
0
  bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3153
0
  bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3154
0
  struct elf_link_hash_entry *gp;
3155
0
  bfd_vma gp_val;
3156
0
  asection *os;
3157
0
  struct elf64_ia64_link_hash_table *ia64_info;
3158
3159
0
  ia64_info = elf64_ia64_hash_table (info);
3160
0
  if (ia64_info == NULL)
3161
0
    return false;
3162
3163
  /* Find the min and max vma of all sections marked short.  Also collect
3164
     min and max vma of any type, for use in selecting a nice gp.  */
3165
0
  for (os = abfd->sections; os ; os = os->next)
3166
0
    {
3167
0
      bfd_vma lo, hi;
3168
3169
0
      if ((os->flags & SEC_ALLOC) == 0)
3170
0
  continue;
3171
3172
0
      lo = os->vma;
3173
      /* When this function is called from elfNN_ia64_final_link
3174
   the correct value to use is os->size.  When called from
3175
   elfNN_ia64_relax_section we are in the middle of section
3176
   sizing; some sections will already have os->size set, others
3177
   will have os->size zero and os->rawsize the previous size.  */
3178
0
      hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size);
3179
0
      if (hi < lo)
3180
0
  hi = (bfd_vma) -1;
3181
3182
0
      if (min_vma > lo)
3183
0
  min_vma = lo;
3184
0
      if (max_vma < hi)
3185
0
  max_vma = hi;
3186
0
      if (os->flags & SEC_SMALL_DATA)
3187
0
  {
3188
0
    if (min_short_vma > lo)
3189
0
      min_short_vma = lo;
3190
0
    if (max_short_vma < hi)
3191
0
      max_short_vma = hi;
3192
0
  }
3193
0
    }
3194
3195
0
  if (ia64_info->min_short_sec)
3196
0
    {
3197
0
      if (min_short_vma
3198
0
    > (ia64_info->min_short_sec->vma
3199
0
       + ia64_info->min_short_offset))
3200
0
  min_short_vma = (ia64_info->min_short_sec->vma
3201
0
       + ia64_info->min_short_offset);
3202
0
      if (max_short_vma
3203
0
    < (ia64_info->max_short_sec->vma
3204
0
       + ia64_info->max_short_offset))
3205
0
  max_short_vma = (ia64_info->max_short_sec->vma
3206
0
       + ia64_info->max_short_offset);
3207
0
    }
3208
3209
  /* See if the user wants to force a value.  */
3210
0
  gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
3211
0
           false, false);
3212
3213
0
  if (gp
3214
0
      && (gp->root.type == bfd_link_hash_defined
3215
0
    || gp->root.type == bfd_link_hash_defweak))
3216
0
    {
3217
0
      asection *gp_sec = gp->root.u.def.section;
3218
0
      gp_val = (gp->root.u.def.value
3219
0
    + gp_sec->output_section->vma
3220
0
    + gp_sec->output_offset);
3221
0
    }
3222
0
  else
3223
0
    {
3224
      /* Pick a sensible value.  */
3225
3226
0
      if (ia64_info->min_short_sec)
3227
0
  {
3228
0
    bfd_vma short_range = max_short_vma - min_short_vma;
3229
3230
    /* If min_short_sec is set, pick one in the middle bewteen
3231
       min_short_vma and max_short_vma.  */
3232
0
    if (short_range >= 0x400000)
3233
0
      goto overflow;
3234
0
    gp_val = min_short_vma + short_range / 2;
3235
0
  }
3236
0
      else
3237
0
  {
3238
0
    asection *got_sec = ia64_info->root.sgot;
3239
3240
    /* Start with just the address of the .got.  */
3241
0
    if (got_sec)
3242
0
      gp_val = got_sec->output_section->vma;
3243
0
    else if (max_short_vma != 0)
3244
0
      gp_val = min_short_vma;
3245
0
    else if (max_vma - min_vma < 0x200000)
3246
0
      gp_val = min_vma;
3247
0
    else
3248
0
      gp_val = max_vma - 0x200000 + 8;
3249
0
  }
3250
3251
      /* If it is possible to address the entire image, but we
3252
   don't with the choice above, adjust.  */
3253
0
      if (max_vma - min_vma < 0x400000
3254
0
    && (max_vma - gp_val >= 0x200000
3255
0
        || gp_val - min_vma > 0x200000))
3256
0
  gp_val = min_vma + 0x200000;
3257
0
      else if (max_short_vma != 0)
3258
0
  {
3259
    /* If we don't cover all the short data, adjust.  */
3260
0
    if (max_short_vma - gp_val >= 0x200000)
3261
0
      gp_val = min_short_vma + 0x200000;
3262
3263
    /* If we're addressing stuff past the end, adjust back.  */
3264
0
    if (gp_val > max_vma)
3265
0
      gp_val = max_vma - 0x200000 + 8;
3266
0
  }
3267
0
    }
3268
3269
  /* Validate whether all SHF_IA_64_SHORT sections are within
3270
     range of the chosen GP.  */
3271
3272
0
  if (max_short_vma != 0)
3273
0
    {
3274
0
      if (max_short_vma - min_short_vma >= 0x400000)
3275
0
  {
3276
0
  overflow:
3277
0
    _bfd_error_handler
3278
      /* xgettext:c-format */
3279
0
      (_("%pB: short data segment overflowed (%#" PRIx64 " >= 0x400000)"),
3280
0
       abfd, (uint64_t) (max_short_vma - min_short_vma));
3281
0
    return false;
3282
0
  }
3283
0
      else if ((gp_val > min_short_vma
3284
0
    && gp_val - min_short_vma > 0x200000)
3285
0
         || (gp_val < max_short_vma
3286
0
       && max_short_vma - gp_val >= 0x200000))
3287
0
  {
3288
0
    _bfd_error_handler
3289
0
      (_("%pB: __gp does not cover short data segment"), abfd);
3290
0
    return false;
3291
0
  }
3292
0
    }
3293
3294
0
  _bfd_set_gp_value (abfd, gp_val);
3295
3296
0
  return true;
3297
0
}
3298
3299
static bool
3300
elf64_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
3301
0
{
3302
0
  struct elf64_ia64_link_hash_table *ia64_info;
3303
0
  asection *unwind_output_sec;
3304
3305
0
  ia64_info = elf64_ia64_hash_table (info);
3306
0
  if (ia64_info == NULL)
3307
0
    return false;
3308
3309
  /* Make sure we've got ourselves a nice fat __gp value.  */
3310
0
  if (!bfd_link_relocatable (info))
3311
0
    {
3312
0
      bfd_vma gp_val;
3313
0
      struct elf_link_hash_entry *gp;
3314
3315
      /* We assume after gp is set, section size will only decrease. We
3316
   need to adjust gp for it.  */
3317
0
      _bfd_set_gp_value (abfd, 0);
3318
0
      if (! elf64_ia64_choose_gp (abfd, info, true))
3319
0
  return false;
3320
0
      gp_val = _bfd_get_gp_value (abfd);
3321
3322
0
      gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
3323
0
         false, false);
3324
0
      if (gp)
3325
0
  {
3326
0
    gp->root.type = bfd_link_hash_defined;
3327
0
    gp->root.u.def.value = gp_val;
3328
0
    gp->root.u.def.section = bfd_abs_section_ptr;
3329
0
  }
3330
0
    }
3331
3332
  /* If we're producing a final executable, we need to sort the contents
3333
     of the .IA_64.unwind section.  Force this section to be relocated
3334
     into memory rather than written immediately to the output file.  */
3335
0
  unwind_output_sec = NULL;
3336
0
  if (!bfd_link_relocatable (info))
3337
0
    {
3338
0
      asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3339
0
      if (s)
3340
0
  {
3341
0
    unwind_output_sec = s->output_section;
3342
0
    unwind_output_sec->contents
3343
0
      = bfd_malloc (unwind_output_sec->size);
3344
0
    if (unwind_output_sec->contents == NULL)
3345
0
      return false;
3346
0
  }
3347
0
    }
3348
3349
  /* Invoke the regular ELF backend linker to do all the work.  */
3350
0
  if (!bfd_elf_final_link (abfd, info))
3351
0
    return false;
3352
3353
0
  if (unwind_output_sec)
3354
0
    {
3355
0
      elf64_ia64_unwind_entry_compare_bfd = abfd;
3356
0
      qsort (unwind_output_sec->contents,
3357
0
       (size_t) (unwind_output_sec->size / 24),
3358
0
       24,
3359
0
       elf64_ia64_unwind_entry_compare);
3360
3361
0
      if (! bfd_set_section_contents (abfd, unwind_output_sec,
3362
0
              unwind_output_sec->contents, (bfd_vma) 0,
3363
0
              unwind_output_sec->size))
3364
0
  return false;
3365
0
    }
3366
3367
0
  return true;
3368
0
}
3369
3370
static int
3371
elf64_ia64_relocate_section (bfd *output_bfd,
3372
           struct bfd_link_info *info,
3373
           bfd *input_bfd,
3374
           asection *input_section,
3375
           bfd_byte *contents,
3376
           Elf_Internal_Rela *relocs,
3377
           Elf_Internal_Sym *local_syms,
3378
           asection **local_sections)
3379
0
{
3380
0
  struct elf64_ia64_link_hash_table *ia64_info;
3381
0
  Elf_Internal_Shdr *symtab_hdr;
3382
0
  Elf_Internal_Rela *rel;
3383
0
  Elf_Internal_Rela *relend;
3384
0
  bool ret_val = true;  /* for non-fatal errors */
3385
0
  bfd_vma gp_val;
3386
3387
0
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3388
0
  ia64_info = elf64_ia64_hash_table (info);
3389
0
  if (ia64_info == NULL)
3390
0
    return false;
3391
3392
  /* Infect various flags from the input section to the output section.  */
3393
0
  if (bfd_link_relocatable (info))
3394
0
    {
3395
0
      bfd_vma flags;
3396
3397
0
      flags = elf_section_data(input_section)->this_hdr.sh_flags;
3398
0
      flags &= SHF_IA_64_NORECOV;
3399
3400
0
      elf_section_data(input_section->output_section)
3401
0
  ->this_hdr.sh_flags |= flags;
3402
0
    }
3403
3404
0
  gp_val = _bfd_get_gp_value (output_bfd);
3405
3406
0
  rel = relocs;
3407
0
  relend = relocs + input_section->reloc_count;
3408
0
  for (; rel < relend; ++rel)
3409
0
    {
3410
0
      struct elf_link_hash_entry *h;
3411
0
      struct elf64_ia64_dyn_sym_info *dyn_i;
3412
0
      bfd_reloc_status_type r;
3413
0
      reloc_howto_type *howto;
3414
0
      unsigned long r_symndx;
3415
0
      Elf_Internal_Sym *sym;
3416
0
      unsigned int r_type;
3417
0
      bfd_vma value;
3418
0
      asection *sym_sec;
3419
0
      bfd_byte *hit_addr;
3420
0
      bool dynamic_symbol_p;
3421
0
      bool undef_weak_ref;
3422
3423
0
      r_type = ELF64_R_TYPE (rel->r_info);
3424
0
      if (r_type > R_IA64_MAX_RELOC_CODE)
3425
0
  {
3426
    /* xgettext:c-format */
3427
0
    _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3428
0
            input_bfd, (int) r_type);
3429
0
    bfd_set_error (bfd_error_bad_value);
3430
0
    ret_val = false;
3431
0
    continue;
3432
0
  }
3433
3434
0
      howto = ia64_elf_lookup_howto (r_type);
3435
0
      if (howto == NULL)
3436
0
  {
3437
0
    ret_val = false;
3438
0
    continue;
3439
0
  }
3440
0
      r_symndx = ELF64_R_SYM (rel->r_info);
3441
0
      h = NULL;
3442
0
      sym = NULL;
3443
0
      sym_sec = NULL;
3444
0
      undef_weak_ref = false;
3445
3446
0
      if (r_symndx < symtab_hdr->sh_info)
3447
0
  {
3448
    /* Reloc against local symbol.  */
3449
0
    asection *msec;
3450
0
    sym = local_syms + r_symndx;
3451
0
    sym_sec = local_sections[r_symndx];
3452
0
    msec = sym_sec;
3453
0
    value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
3454
0
    if (!bfd_link_relocatable (info)
3455
0
        && (sym_sec->flags & SEC_MERGE) != 0
3456
0
        && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3457
0
        && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
3458
0
      {
3459
0
        struct elf64_ia64_local_hash_entry *loc_h;
3460
3461
0
        loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, false);
3462
0
        if (loc_h && ! loc_h->sec_merge_done)
3463
0
    {
3464
0
      struct elf64_ia64_dyn_sym_info *dynent;
3465
0
      unsigned int count;
3466
3467
0
      for (count = loc_h->count, dynent = loc_h->info;
3468
0
           count != 0;
3469
0
           count--, dynent++)
3470
0
        {
3471
0
          msec = sym_sec;
3472
0
          dynent->addend =
3473
0
      _bfd_merged_section_offset (output_bfd, &msec,
3474
0
                elf_section_data (msec)->
3475
0
                sec_info,
3476
0
                sym->st_value
3477
0
                + dynent->addend);
3478
0
          dynent->addend -= sym->st_value;
3479
0
          dynent->addend += msec->output_section->vma
3480
0
          + msec->output_offset
3481
0
          - sym_sec->output_section->vma
3482
0
          - sym_sec->output_offset;
3483
0
        }
3484
3485
      /* We may have introduced duplicated entries. We need
3486
         to remove them properly.  */
3487
0
      count = sort_dyn_sym_info (loc_h->info, loc_h->count);
3488
0
      if (count != loc_h->count)
3489
0
        {
3490
0
          loc_h->count = count;
3491
0
          loc_h->sorted_count = count;
3492
0
        }
3493
3494
0
      loc_h->sec_merge_done = 1;
3495
0
    }
3496
0
      }
3497
0
  }
3498
0
      else
3499
0
  {
3500
0
    bool unresolved_reloc;
3501
0
    bool warned, ignored;
3502
0
    struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3503
3504
0
    RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3505
0
           r_symndx, symtab_hdr, sym_hashes,
3506
0
           h, sym_sec, value,
3507
0
           unresolved_reloc, warned, ignored);
3508
3509
0
    if (h->root.type == bfd_link_hash_undefweak)
3510
0
      undef_weak_ref = true;
3511
0
    else if (warned)
3512
0
      continue;
3513
0
  }
3514
3515
      /* For relocs against symbols from removed linkonce sections,
3516
   or sections discarded by a linker script, we just want the
3517
   section contents zeroed.  Avoid any special processing.  */
3518
0
      if (sym_sec != NULL && discarded_section (sym_sec))
3519
0
  RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3520
0
           rel, 1, relend, howto, 0, contents);
3521
3522
0
      if (bfd_link_relocatable (info))
3523
0
  continue;
3524
3525
0
      hit_addr = contents + rel->r_offset;
3526
0
      value += rel->r_addend;
3527
0
      dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h);
3528
3529
0
      switch (r_type)
3530
0
  {
3531
0
  case R_IA64_NONE:
3532
0
  case R_IA64_LDXMOV:
3533
0
    continue;
3534
3535
0
  case R_IA64_IMM14:
3536
0
  case R_IA64_IMM22:
3537
0
  case R_IA64_IMM64:
3538
0
  case R_IA64_DIR32MSB:
3539
0
  case R_IA64_DIR32LSB:
3540
0
  case R_IA64_DIR64MSB:
3541
0
  case R_IA64_DIR64LSB:
3542
    /* Install a dynamic relocation for this reloc.  */
3543
0
    if ((dynamic_symbol_p || bfd_link_pic (info))
3544
0
        && r_symndx != 0
3545
0
        && (input_section->flags & SEC_ALLOC) != 0)
3546
0
      {
3547
0
        unsigned int dyn_r_type;
3548
0
        bfd_vma addend;
3549
3550
0
        switch (r_type)
3551
0
    {
3552
0
    case R_IA64_IMM14:
3553
0
    case R_IA64_IMM22:
3554
0
    case R_IA64_IMM64:
3555
      /* ??? People shouldn't be doing non-pic code in
3556
         shared libraries nor dynamic executables.  */
3557
0
      _bfd_error_handler
3558
        /* xgettext:c-format */
3559
0
        (_("%pB: non-pic code with imm relocation against"
3560
0
           " dynamic symbol `%s'"),
3561
0
         input_bfd,
3562
0
         h ? h->root.root.string
3563
0
           : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3564
0
             sym_sec));
3565
0
      ret_val = false;
3566
0
      continue;
3567
3568
0
    default:
3569
0
      break;
3570
0
    }
3571
3572
        /* If we don't need dynamic symbol lookup, find a
3573
     matching RELATIVE relocation.  */
3574
0
        dyn_r_type = r_type;
3575
0
        if (dynamic_symbol_p)
3576
0
    {
3577
0
      addend = rel->r_addend;
3578
0
      value = 0;
3579
0
    }
3580
0
        else
3581
0
    {
3582
0
      addend = value;
3583
0
    }
3584
3585
        /* VMS: install a FIX64.  */
3586
0
        switch (dyn_r_type)
3587
0
    {
3588
0
    case R_IA64_DIR32LSB:
3589
0
      dyn_r_type = R_IA64_VMS_FIX32;
3590
0
      break;
3591
0
    case R_IA64_DIR64LSB:
3592
0
      dyn_r_type = R_IA64_VMS_FIX64;
3593
0
      break;
3594
0
    default:
3595
0
      BFD_ASSERT (false);
3596
0
      break;
3597
0
    }
3598
0
        elf64_ia64_install_fixup
3599
0
    (output_bfd, ia64_info, h,
3600
0
     dyn_r_type, input_section, rel->r_offset, addend);
3601
0
        r = bfd_reloc_ok;
3602
0
        break;
3603
0
      }
3604
    /* Fall through.  */
3605
3606
0
  case R_IA64_LTV32MSB:
3607
0
  case R_IA64_LTV32LSB:
3608
0
  case R_IA64_LTV64MSB:
3609
0
  case R_IA64_LTV64LSB:
3610
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3611
0
    break;
3612
3613
0
  case R_IA64_GPREL22:
3614
0
  case R_IA64_GPREL64I:
3615
0
  case R_IA64_GPREL32MSB:
3616
0
  case R_IA64_GPREL32LSB:
3617
0
  case R_IA64_GPREL64MSB:
3618
0
  case R_IA64_GPREL64LSB:
3619
0
    if (dynamic_symbol_p)
3620
0
      {
3621
0
        _bfd_error_handler
3622
    /* xgettext:c-format */
3623
0
    (_("%pB: @gprel relocation against dynamic symbol %s"),
3624
0
     input_bfd,
3625
0
     h ? h->root.root.string
3626
0
       : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3627
0
               sym_sec));
3628
0
        ret_val = false;
3629
0
        continue;
3630
0
      }
3631
0
    value -= gp_val;
3632
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3633
0
    break;
3634
3635
0
  case R_IA64_LTOFF22:
3636
0
  case R_IA64_LTOFF22X:
3637
0
  case R_IA64_LTOFF64I:
3638
0
    dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3639
0
    value = set_got_entry (input_bfd, info, dyn_i,
3640
0
         rel->r_addend, value, R_IA64_DIR64LSB);
3641
0
    value -= gp_val;
3642
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3643
0
    break;
3644
3645
0
  case R_IA64_PLTOFF22:
3646
0
  case R_IA64_PLTOFF64I:
3647
0
  case R_IA64_PLTOFF64MSB:
3648
0
  case R_IA64_PLTOFF64LSB:
3649
0
    dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3650
0
    value = set_pltoff_entry (output_bfd, info, dyn_i, value, false);
3651
0
    value -= gp_val;
3652
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3653
0
    break;
3654
3655
0
  case R_IA64_FPTR64I:
3656
0
  case R_IA64_FPTR32MSB:
3657
0
  case R_IA64_FPTR32LSB:
3658
0
  case R_IA64_FPTR64MSB:
3659
0
  case R_IA64_FPTR64LSB:
3660
0
    dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3661
0
    if (dyn_i->want_fptr)
3662
0
      {
3663
0
        if (!undef_weak_ref)
3664
0
    value = set_fptr_entry (output_bfd, info, dyn_i, value);
3665
0
      }
3666
0
    if (!dyn_i->want_fptr || bfd_link_pie (info))
3667
0
      {
3668
        /* Otherwise, we expect the dynamic linker to create
3669
     the entry.  */
3670
3671
0
        if (dyn_i->want_fptr)
3672
0
    {
3673
0
      if (r_type == R_IA64_FPTR64I)
3674
0
        {
3675
          /* We can't represent this without a dynamic symbol.
3676
       Adjust the relocation to be against an output
3677
       section symbol, which are always present in the
3678
       dynamic symbol table.  */
3679
          /* ??? People shouldn't be doing non-pic code in
3680
       shared libraries.  Hork.  */
3681
0
          _bfd_error_handler
3682
0
      (_("%pB: linking non-pic code in a position independent executable"),
3683
0
       input_bfd);
3684
0
          ret_val = false;
3685
0
          continue;
3686
0
        }
3687
0
    }
3688
0
        else
3689
0
    {
3690
0
      value = 0;
3691
0
    }
3692
3693
        /* VMS: FIXFD.  */
3694
0
        elf64_ia64_install_fixup
3695
0
    (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD,
3696
0
     input_section, rel->r_offset, 0);
3697
0
        r = bfd_reloc_ok;
3698
0
        break;
3699
0
      }
3700
3701
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3702
0
    break;
3703
3704
0
  case R_IA64_LTOFF_FPTR22:
3705
0
  case R_IA64_LTOFF_FPTR64I:
3706
0
  case R_IA64_LTOFF_FPTR32MSB:
3707
0
  case R_IA64_LTOFF_FPTR32LSB:
3708
0
  case R_IA64_LTOFF_FPTR64MSB:
3709
0
  case R_IA64_LTOFF_FPTR64LSB:
3710
0
    dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3711
0
    if (dyn_i->want_fptr)
3712
0
      {
3713
0
        BFD_ASSERT (h == NULL || !h->def_dynamic);
3714
0
        if (!undef_weak_ref)
3715
0
    value = set_fptr_entry (output_bfd, info, dyn_i, value);
3716
0
      }
3717
0
    else
3718
0
      value = 0;
3719
3720
0
    value = set_got_entry (output_bfd, info, dyn_i,
3721
0
         rel->r_addend, value, R_IA64_FPTR64LSB);
3722
0
    value -= gp_val;
3723
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3724
0
    break;
3725
3726
0
  case R_IA64_PCREL32MSB:
3727
0
  case R_IA64_PCREL32LSB:
3728
0
  case R_IA64_PCREL64MSB:
3729
0
  case R_IA64_PCREL64LSB:
3730
    /* Install a dynamic relocation for this reloc.  */
3731
0
    if (dynamic_symbol_p && r_symndx != 0)
3732
0
      {
3733
        /* VMS: doesn't exist ???  */
3734
0
        abort ();
3735
0
      }
3736
0
    goto finish_pcrel;
3737
3738
0
  case R_IA64_PCREL21B:
3739
0
  case R_IA64_PCREL60B:
3740
    /* We should have created a PLT entry for any dynamic symbol.  */
3741
0
    dyn_i = NULL;
3742
0
    if (h)
3743
0
      dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3744
3745
0
    if (dyn_i && dyn_i->want_plt2)
3746
0
      {
3747
        /* Should have caught this earlier.  */
3748
0
        BFD_ASSERT (rel->r_addend == 0);
3749
3750
0
        value = (ia64_info->root.splt->output_section->vma
3751
0
           + ia64_info->root.splt->output_offset
3752
0
           + dyn_i->plt2_offset);
3753
0
      }
3754
0
    else
3755
0
      {
3756
        /* Since there's no PLT entry, Validate that this is
3757
     locally defined.  */
3758
0
        BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
3759
3760
        /* If the symbol is undef_weak, we shouldn't be trying
3761
     to call it.  There's every chance that we'd wind up
3762
     with an out-of-range fixup here.  Don't bother setting
3763
     any value at all.  */
3764
0
        if (undef_weak_ref)
3765
0
    continue;
3766
0
      }
3767
0
    goto finish_pcrel;
3768
3769
0
  case R_IA64_PCREL21BI:
3770
0
  case R_IA64_PCREL21F:
3771
0
  case R_IA64_PCREL21M:
3772
0
  case R_IA64_PCREL22:
3773
0
  case R_IA64_PCREL64I:
3774
    /* The PCREL21BI reloc is specifically not intended for use with
3775
       dynamic relocs.  PCREL21F and PCREL21M are used for speculation
3776
       fixup code, and thus probably ought not be dynamic.  The
3777
       PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs.  */
3778
0
    if (dynamic_symbol_p)
3779
0
      {
3780
0
        const char *msg;
3781
3782
0
        if (r_type == R_IA64_PCREL21BI)
3783
    /* xgettext:c-format */
3784
0
    msg = _("%pB: @internal branch to dynamic symbol %s");
3785
0
        else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
3786
    /* xgettext:c-format */
3787
0
    msg = _("%pB: speculation fixup to dynamic symbol %s");
3788
0
        else
3789
    /* xgettext:c-format */
3790
0
    msg = _("%pB: @pcrel relocation against dynamic symbol %s");
3791
0
        _bfd_error_handler (msg, input_bfd,
3792
0
          h ? h->root.root.string
3793
0
          : bfd_elf_sym_name (input_bfd,
3794
0
                  symtab_hdr,
3795
0
                  sym,
3796
0
                  sym_sec));
3797
0
        ret_val = false;
3798
0
        continue;
3799
0
      }
3800
0
    goto finish_pcrel;
3801
3802
0
  finish_pcrel:
3803
    /* Make pc-relative.  */
3804
0
    value -= (input_section->output_section->vma
3805
0
        + input_section->output_offset
3806
0
        + rel->r_offset) & ~ (bfd_vma) 0x3;
3807
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3808
0
    break;
3809
3810
0
  case R_IA64_SEGREL32MSB:
3811
0
  case R_IA64_SEGREL32LSB:
3812
0
  case R_IA64_SEGREL64MSB:
3813
0
  case R_IA64_SEGREL64LSB:
3814
0
      {
3815
        /* Find the segment that contains the output_section.  */
3816
0
        Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section
3817
0
    (output_bfd, sym_sec->output_section);
3818
3819
0
        if (p == NULL)
3820
0
    {
3821
0
      r = bfd_reloc_notsupported;
3822
0
    }
3823
0
        else
3824
0
    {
3825
      /* The VMA of the segment is the vaddr of the associated
3826
         program header.  */
3827
0
      if (value > p->p_vaddr)
3828
0
        value -= p->p_vaddr;
3829
0
      else
3830
0
        value = 0;
3831
0
      r = ia64_elf_install_value (hit_addr, value, r_type);
3832
0
    }
3833
0
        break;
3834
0
      }
3835
3836
0
  case R_IA64_SECREL32MSB:
3837
0
  case R_IA64_SECREL32LSB:
3838
0
  case R_IA64_SECREL64MSB:
3839
0
  case R_IA64_SECREL64LSB:
3840
    /* Make output-section relative to section where the symbol
3841
       is defined. PR 475  */
3842
0
    if (sym_sec)
3843
0
      value -= sym_sec->output_section->vma;
3844
0
    r = ia64_elf_install_value (hit_addr, value, r_type);
3845
0
    break;
3846
3847
0
  case R_IA64_IPLTMSB:
3848
0
  case R_IA64_IPLTLSB:
3849
    /* Install a dynamic relocation for this reloc.  */
3850
0
    if ((dynamic_symbol_p || bfd_link_pic (info))
3851
0
        && (input_section->flags & SEC_ALLOC) != 0)
3852
0
      {
3853
        /* VMS: FIXFD ??  */
3854
0
        abort ();
3855
0
      }
3856
3857
0
    if (r_type == R_IA64_IPLTMSB)
3858
0
      r_type = R_IA64_DIR64MSB;
3859
0
    else
3860
0
      r_type = R_IA64_DIR64LSB;
3861
0
    ia64_elf_install_value (hit_addr, value, r_type);
3862
0
    r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type);
3863
0
    break;
3864
3865
0
  case R_IA64_TPREL14:
3866
0
  case R_IA64_TPREL22:
3867
0
  case R_IA64_TPREL64I:
3868
0
    r = bfd_reloc_notsupported;
3869
0
    break;
3870
3871
0
  case R_IA64_DTPREL14:
3872
0
  case R_IA64_DTPREL22:
3873
0
  case R_IA64_DTPREL64I:
3874
0
  case R_IA64_DTPREL32LSB:
3875
0
  case R_IA64_DTPREL32MSB:
3876
0
  case R_IA64_DTPREL64LSB:
3877
0
  case R_IA64_DTPREL64MSB:
3878
0
    r = bfd_reloc_notsupported;
3879
0
    break;
3880
3881
0
  case R_IA64_LTOFF_TPREL22:
3882
0
  case R_IA64_LTOFF_DTPMOD22:
3883
0
  case R_IA64_LTOFF_DTPREL22:
3884
0
    r = bfd_reloc_notsupported;
3885
0
    break;
3886
3887
0
  default:
3888
0
    r = bfd_reloc_notsupported;
3889
0
    break;
3890
0
  }
3891
3892
0
      switch (r)
3893
0
  {
3894
0
  case bfd_reloc_ok:
3895
0
    break;
3896
3897
0
  case bfd_reloc_undefined:
3898
    /* This can happen for global table relative relocs if
3899
       __gp is undefined.  This is a panic situation so we
3900
       don't try to continue.  */
3901
0
    (*info->callbacks->undefined_symbol)
3902
0
      (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
3903
0
    return false;
3904
3905
0
  case bfd_reloc_notsupported:
3906
0
    {
3907
0
      const char *name;
3908
3909
0
      if (h)
3910
0
        name = h->root.root.string;
3911
0
      else
3912
0
        name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3913
0
               sym_sec);
3914
0
      (*info->callbacks->warning) (info, _("unsupported reloc"),
3915
0
           name, input_bfd,
3916
0
           input_section, rel->r_offset);
3917
0
      ret_val = false;
3918
0
    }
3919
0
    break;
3920
3921
0
  case bfd_reloc_dangerous:
3922
0
  case bfd_reloc_outofrange:
3923
0
  case bfd_reloc_overflow:
3924
0
  default:
3925
0
    {
3926
0
      const char *name;
3927
3928
0
      if (h)
3929
0
        name = h->root.root.string;
3930
0
      else
3931
0
        name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3932
0
               sym_sec);
3933
3934
0
      switch (r_type)
3935
0
        {
3936
0
        case R_IA64_TPREL14:
3937
0
        case R_IA64_TPREL22:
3938
0
        case R_IA64_TPREL64I:
3939
0
        case R_IA64_DTPREL14:
3940
0
        case R_IA64_DTPREL22:
3941
0
        case R_IA64_DTPREL64I:
3942
0
        case R_IA64_DTPREL32LSB:
3943
0
        case R_IA64_DTPREL32MSB:
3944
0
        case R_IA64_DTPREL64LSB:
3945
0
        case R_IA64_DTPREL64MSB:
3946
0
        case R_IA64_LTOFF_TPREL22:
3947
0
        case R_IA64_LTOFF_DTPMOD22:
3948
0
        case R_IA64_LTOFF_DTPREL22:
3949
0
    _bfd_error_handler
3950
      /* xgettext:c-format */
3951
0
      (_("%pB: missing TLS section for relocation %s against `%s'"
3952
0
         " at %#" PRIx64 " in section `%pA'."),
3953
0
       input_bfd, howto->name, name,
3954
0
       (uint64_t) rel->r_offset, input_section);
3955
0
    break;
3956
3957
0
        case R_IA64_PCREL21B:
3958
0
        case R_IA64_PCREL21BI:
3959
0
        case R_IA64_PCREL21M:
3960
0
        case R_IA64_PCREL21F:
3961
0
    if (is_elf_hash_table (info->hash))
3962
0
      {
3963
        /* Relaxtion is always performed for ELF output.
3964
           Overflow failures for those relocations mean
3965
           that the section is too big to relax.  */
3966
0
        _bfd_error_handler
3967
          /* xgettext:c-format */
3968
0
          (_("%pB: Can't relax br (%s) to `%s' "
3969
0
       "at %#" PRIx64 " in section `%pA' "
3970
0
       "with size %#" PRIx64 " (> 0x1000000)."),
3971
0
           input_bfd, howto->name, name, (uint64_t) rel->r_offset,
3972
0
           input_section, (uint64_t) input_section->size);
3973
0
        break;
3974
0
      }
3975
    /* Fall through.  */
3976
0
        default:
3977
0
    (*info->callbacks->reloc_overflow) (info,
3978
0
                &h->root,
3979
0
                name,
3980
0
                howto->name,
3981
0
                (bfd_vma) 0,
3982
0
                input_bfd,
3983
0
                input_section,
3984
0
                rel->r_offset);
3985
0
    break;
3986
0
        }
3987
3988
0
      ret_val = false;
3989
0
    }
3990
0
    break;
3991
0
  }
3992
0
    }
3993
3994
0
  return ret_val;
3995
0
}
3996
3997
static bool
3998
elf64_ia64_finish_dynamic_symbol (bfd *output_bfd,
3999
          struct bfd_link_info *info,
4000
          struct elf_link_hash_entry *h,
4001
          Elf_Internal_Sym *sym)
4002
0
{
4003
0
  struct elf64_ia64_link_hash_table *ia64_info;
4004
0
  struct elf64_ia64_dyn_sym_info *dyn_i;
4005
4006
0
  ia64_info = elf64_ia64_hash_table (info);
4007
4008
0
  dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
4009
4010
  /* Fill in the PLT data, if required.  */
4011
0
  if (dyn_i && dyn_i->want_plt)
4012
0
    {
4013
0
      bfd_byte *loc;
4014
0
      asection *plt_sec;
4015
0
      bfd_vma plt_addr, pltoff_addr, gp_val;
4016
4017
0
      gp_val = _bfd_get_gp_value (output_bfd);
4018
4019
0
      plt_sec = ia64_info->root.splt;
4020
0
      plt_addr = 0;  /* Not used as overriden by FIXUPs.  */
4021
0
      pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true);
4022
4023
      /* Initialize the FULL PLT entry, if needed.  */
4024
0
      if (dyn_i->want_plt2)
4025
0
  {
4026
0
    loc = plt_sec->contents + dyn_i->plt2_offset;
4027
4028
0
    memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4029
0
    ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
4030
4031
    /* Mark the symbol as undefined, rather than as defined in the
4032
       plt section.  Leave the value alone.  */
4033
    /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4034
       first place.  But perhaps elflink.c did some for us.  */
4035
0
    if (!h->def_regular)
4036
0
      sym->st_shndx = SHN_UNDEF;
4037
0
  }
4038
4039
      /* VMS: FIXFD.  */
4040
0
      elf64_ia64_install_fixup
4041
0
  (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD, ia64_info->pltoff_sec,
4042
0
   pltoff_addr - (ia64_info->pltoff_sec->output_section->vma
4043
0
      + ia64_info->pltoff_sec->output_offset), 0);
4044
0
    }
4045
4046
  /* Mark some specially defined symbols as absolute.  */
4047
0
  if (h == ia64_info->root.hdynamic
4048
0
      || h == ia64_info->root.hgot
4049
0
      || h == ia64_info->root.hplt)
4050
0
    sym->st_shndx = SHN_ABS;
4051
4052
0
  return true;
4053
0
}
4054
4055
static bool
4056
elf64_ia64_finish_dynamic_sections (bfd *abfd,
4057
            struct bfd_link_info *info)
4058
0
{
4059
0
  struct elf64_ia64_link_hash_table *ia64_info;
4060
0
  bfd *dynobj;
4061
4062
0
  ia64_info = elf64_ia64_hash_table (info);
4063
0
  if (ia64_info == NULL)
4064
0
    return false;
4065
4066
0
  dynobj = ia64_info->root.dynobj;
4067
4068
0
  if (elf_hash_table (info)->dynamic_sections_created)
4069
0
    {
4070
0
      Elf64_External_Dyn *dyncon, *dynconend;
4071
0
      asection *sdyn;
4072
0
      asection *unwind_sec;
4073
0
      bfd_vma gp_val;
4074
0
      unsigned int gp_seg;
4075
0
      bfd_vma gp_off;
4076
0
      Elf_Internal_Phdr *phdr;
4077
0
      Elf_Internal_Phdr *base_phdr;
4078
0
      unsigned int unwind_seg = 0;
4079
0
      unsigned int code_seg = 0;
4080
4081
0
      sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4082
0
      BFD_ASSERT (sdyn != NULL);
4083
0
      dyncon = (Elf64_External_Dyn *) sdyn->contents;
4084
0
      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
4085
4086
0
      gp_val = _bfd_get_gp_value (abfd);
4087
0
      phdr = _bfd_elf_find_segment_containing_section
4088
0
  (info->output_bfd, ia64_info->pltoff_sec->output_section);
4089
0
      BFD_ASSERT (phdr != NULL);
4090
0
      base_phdr = elf_tdata (info->output_bfd)->phdr;
4091
0
      gp_seg = phdr - base_phdr;
4092
0
      gp_off = gp_val - phdr->p_vaddr;
4093
4094
0
      unwind_sec = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
4095
0
      if (unwind_sec != NULL)
4096
0
  {
4097
0
    asection *code_sec;
4098
4099
0
    phdr = _bfd_elf_find_segment_containing_section (abfd, unwind_sec);
4100
0
    BFD_ASSERT (phdr != NULL);
4101
0
    unwind_seg = phdr - base_phdr;
4102
4103
0
    code_sec = bfd_get_section_by_name (abfd, "$CODE$");
4104
0
    phdr = _bfd_elf_find_segment_containing_section (abfd, code_sec);
4105
0
    BFD_ASSERT (phdr != NULL);
4106
0
    code_seg = phdr - base_phdr;
4107
0
  }
4108
4109
0
      for (; dyncon < dynconend; dyncon++)
4110
0
  {
4111
0
    Elf_Internal_Dyn dyn;
4112
4113
0
    bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4114
4115
0
    switch (dyn.d_tag)
4116
0
      {
4117
0
      case DT_IA_64_VMS_FIXUP_RELA_OFF:
4118
0
        dyn.d_un.d_val +=
4119
0
    (ia64_info->fixups_sec->output_section->vma
4120
0
     + ia64_info->fixups_sec->output_offset)
4121
0
    - (sdyn->output_section->vma + sdyn->output_offset);
4122
0
        break;
4123
4124
0
      case DT_IA_64_VMS_PLTGOT_OFFSET:
4125
0
        dyn.d_un.d_val = gp_off;
4126
0
        break;
4127
4128
0
      case DT_IA_64_VMS_PLTGOT_SEG:
4129
0
        dyn.d_un.d_val = gp_seg;
4130
0
        break;
4131
4132
0
      case DT_IA_64_VMS_UNWINDSZ:
4133
0
        if (unwind_sec == NULL)
4134
0
    {
4135
0
      dyn.d_tag = DT_NULL;
4136
0
      dyn.d_un.d_val = 0xdead;
4137
0
    }
4138
0
        else
4139
0
    dyn.d_un.d_val = unwind_sec->size;
4140
0
        break;
4141
4142
0
      case DT_IA_64_VMS_UNWIND_CODSEG:
4143
0
        dyn.d_un.d_val = code_seg;
4144
0
        break;
4145
4146
0
      case DT_IA_64_VMS_UNWIND_INFOSEG:
4147
0
      case DT_IA_64_VMS_UNWIND_SEG:
4148
0
        dyn.d_un.d_val = unwind_seg;
4149
0
        break;
4150
4151
0
      case DT_IA_64_VMS_UNWIND_OFFSET:
4152
0
        break;
4153
4154
0
      default:
4155
        /* No need to rewrite the entry.  */
4156
0
        continue;
4157
0
      }
4158
4159
0
    bfd_elf64_swap_dyn_out (abfd, &dyn, dyncon);
4160
0
  }
4161
0
    }
4162
4163
  /* Handle transfer addresses.  */
4164
0
  {
4165
0
    asection *tfr_sec = ia64_info->transfer_sec;
4166
0
    struct elf64_vms_transfer *tfr;
4167
0
    struct elf_link_hash_entry *tfr3;
4168
4169
0
    tfr = (struct elf64_vms_transfer *)tfr_sec->contents;
4170
0
    bfd_putl32 (6 * 8, tfr->size);
4171
0
    bfd_putl64 (tfr_sec->output_section->vma
4172
0
    + tfr_sec->output_offset
4173
0
    + 6 * 8, tfr->tfradr3);
4174
4175
0
    tfr3 = elf_link_hash_lookup (elf_hash_table (info), "ELF$TFRADR", false,
4176
0
         false, false);
4177
4178
0
    if (tfr3
4179
0
  && (tfr3->root.type == bfd_link_hash_defined
4180
0
      || tfr3->root.type == bfd_link_hash_defweak))
4181
0
      {
4182
0
  asection *tfr3_sec = tfr3->root.u.def.section;
4183
0
  bfd_vma tfr3_val;
4184
4185
0
  tfr3_val = (tfr3->root.u.def.value
4186
0
        + tfr3_sec->output_section->vma
4187
0
        + tfr3_sec->output_offset);
4188
4189
0
  bfd_putl64 (tfr3_val, tfr->tfr3_func);
4190
0
  bfd_putl64 (_bfd_get_gp_value (info->output_bfd), tfr->tfr3_gp);
4191
0
      }
4192
4193
    /* FIXME: set linker flags,
4194
       handle lib$initialize.  */
4195
0
  }
4196
4197
0
  return true;
4198
0
}
4199
4200
/* ELF file flag handling:  */
4201
4202
/* Function to keep IA-64 specific file flags.  */
4203
static bool
4204
elf64_ia64_set_private_flags (bfd *abfd, flagword flags)
4205
0
{
4206
0
  BFD_ASSERT (!elf_flags_init (abfd)
4207
0
        || elf_elfheader (abfd)->e_flags == flags);
4208
4209
0
  elf_elfheader (abfd)->e_flags = flags;
4210
0
  elf_flags_init (abfd) = true;
4211
0
  return true;
4212
0
}
4213
4214
/* Merge backend specific data from an object file to the output
4215
   object file when linking.  */
4216
static bool
4217
elf64_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4218
0
{
4219
0
  bfd *obfd = info->output_bfd;
4220
0
  flagword out_flags;
4221
0
  flagword in_flags;
4222
0
  bool ok = true;
4223
4224
  /* FIXME: What should be checked when linking shared libraries?  */
4225
0
  if ((ibfd->flags & DYNAMIC) != 0)
4226
0
    return true;
4227
4228
  /* Don't even pretend to support mixed-format linking.  */
4229
0
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4230
0
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4231
0
    return false;
4232
4233
0
  in_flags  = elf_elfheader (ibfd)->e_flags;
4234
0
  out_flags = elf_elfheader (obfd)->e_flags;
4235
4236
0
  if (! elf_flags_init (obfd))
4237
0
    {
4238
0
      elf_flags_init (obfd) = true;
4239
0
      elf_elfheader (obfd)->e_flags = in_flags;
4240
4241
0
      if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4242
0
    && bfd_get_arch_info (obfd)->the_default)
4243
0
  {
4244
0
    return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4245
0
            bfd_get_mach (ibfd));
4246
0
  }
4247
4248
0
      return true;
4249
0
    }
4250
4251
  /* Check flag compatibility.  */
4252
0
  if (in_flags == out_flags)
4253
0
    return true;
4254
4255
  /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set.  */
4256
0
  if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4257
0
    elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4258
4259
0
  if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4260
0
    {
4261
0
      _bfd_error_handler
4262
0
  (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4263
0
   ibfd);
4264
4265
0
      bfd_set_error (bfd_error_bad_value);
4266
0
      ok = false;
4267
0
    }
4268
0
  if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4269
0
    {
4270
0
      _bfd_error_handler
4271
0
  (_("%pB: linking big-endian files with little-endian files"),
4272
0
   ibfd);
4273
4274
0
      bfd_set_error (bfd_error_bad_value);
4275
0
      ok = false;
4276
0
    }
4277
0
  if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4278
0
    {
4279
0
      _bfd_error_handler
4280
0
  (_("%pB: linking 64-bit files with 32-bit files"),
4281
0
   ibfd);
4282
4283
0
      bfd_set_error (bfd_error_bad_value);
4284
0
      ok = false;
4285
0
    }
4286
0
  if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4287
0
    {
4288
0
      _bfd_error_handler
4289
0
  (_("%pB: linking constant-gp files with non-constant-gp files"),
4290
0
   ibfd);
4291
4292
0
      bfd_set_error (bfd_error_bad_value);
4293
0
      ok = false;
4294
0
    }
4295
0
  if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4296
0
      != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4297
0
    {
4298
0
      _bfd_error_handler
4299
0
  (_("%pB: linking auto-pic files with non-auto-pic files"),
4300
0
   ibfd);
4301
4302
0
      bfd_set_error (bfd_error_bad_value);
4303
0
      ok = false;
4304
0
    }
4305
4306
0
  return ok;
4307
0
}
4308
4309
static bool
4310
elf64_ia64_print_private_bfd_data (bfd *abfd, void * ptr)
4311
43
{
4312
43
  FILE *file = (FILE *) ptr;
4313
43
  flagword flags = elf_elfheader (abfd)->e_flags;
4314
4315
43
  BFD_ASSERT (abfd != NULL && ptr != NULL);
4316
4317
43
  fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4318
43
     (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4319
43
     (flags & EF_IA_64_EXT) ? "EXT, " : "",
4320
43
     (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4321
43
     (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4322
43
     (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4323
43
     (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4324
43
     (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4325
43
     (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4326
4327
43
  _bfd_elf_print_private_bfd_data (abfd, ptr);
4328
43
  return true;
4329
43
}
4330
4331
static enum elf_reloc_type_class
4332
elf64_ia64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4333
           const asection *rel_sec ATTRIBUTE_UNUSED,
4334
           const Elf_Internal_Rela *rela)
4335
0
{
4336
0
  switch ((int) ELF64_R_TYPE (rela->r_info))
4337
0
    {
4338
0
    case R_IA64_REL32MSB:
4339
0
    case R_IA64_REL32LSB:
4340
0
    case R_IA64_REL64MSB:
4341
0
    case R_IA64_REL64LSB:
4342
0
      return reloc_class_relative;
4343
0
    case R_IA64_IPLTMSB:
4344
0
    case R_IA64_IPLTLSB:
4345
0
      return reloc_class_plt;
4346
0
    case R_IA64_COPY:
4347
0
      return reloc_class_copy;
4348
0
    default:
4349
0
      return reloc_class_normal;
4350
0
    }
4351
0
}
4352
4353
static const struct bfd_elf_special_section elf64_ia64_special_sections[] =
4354
{
4355
  { STRING_COMMA_LEN (".sbss"),  -1, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4356
  { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4357
  { NULL,        0,   0, 0,      0 }
4358
};
4359
4360
static bool
4361
elf64_ia64_object_p (bfd *abfd)
4362
51.5k
{
4363
51.5k
  asection *sec;
4364
51.5k
  asection *group, *unwi, *unw;
4365
51.5k
  flagword flags;
4366
51.5k
  const char *name;
4367
51.5k
  char *unwi_name, *unw_name;
4368
51.5k
  size_t amt;
4369
4370
51.5k
  if (abfd->flags & DYNAMIC)
4371
12.2k
    return true;
4372
4373
  /* Flags for fake group section.  */
4374
39.3k
  flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
4375
39.3k
     | SEC_EXCLUDE);
4376
4377
  /* We add a fake section group for each .gnu.linkonce.t.* section,
4378
     which isn't in a section group, and its unwind sections.  */
4379
59.9k
  for (sec = abfd->sections; sec != NULL; sec = sec->next)
4380
20.6k
    {
4381
20.6k
      if (elf_sec_group (sec) == NULL
4382
20.6k
    && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
4383
20.6k
        == (SEC_LINK_ONCE | SEC_CODE))
4384
20.6k
    && startswith (sec->name, ".gnu.linkonce.t."))
4385
2
  {
4386
2
    name = sec->name + 16;
4387
4388
2
    amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
4389
2
    unwi_name = bfd_alloc (abfd, amt);
4390
2
    if (!unwi_name)
4391
0
      return false;
4392
4393
2
    strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
4394
2
    unwi = bfd_get_section_by_name (abfd, unwi_name);
4395
4396
2
    amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
4397
2
    unw_name = bfd_alloc (abfd, amt);
4398
2
    if (!unw_name)
4399
0
      return false;
4400
4401
2
    strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
4402
2
    unw = bfd_get_section_by_name (abfd, unw_name);
4403
4404
    /* We need to create a fake group section for it and its
4405
       unwind sections.  */
4406
2
    group = bfd_make_section_anyway_with_flags (abfd, name,
4407
2
                  flags);
4408
2
    if (group == NULL)
4409
0
      return false;
4410
4411
    /* Move the fake group section to the beginning.  */
4412
2
    bfd_section_list_remove (abfd, group);
4413
2
    bfd_section_list_prepend (abfd, group);
4414
4415
2
    elf_next_in_group (group) = sec;
4416
4417
2
    elf_group_name (sec) = name;
4418
2
    elf_next_in_group (sec) = sec;
4419
2
    elf_sec_group (sec) = group;
4420
4421
2
    if (unwi)
4422
0
      {
4423
0
        elf_group_name (unwi) = name;
4424
0
        elf_next_in_group (unwi) = sec;
4425
0
        elf_next_in_group (sec) = unwi;
4426
0
        elf_sec_group (unwi) = group;
4427
0
      }
4428
4429
2
     if (unw)
4430
0
       {
4431
0
         elf_group_name (unw) = name;
4432
0
         if (unwi)
4433
0
     {
4434
0
       elf_next_in_group (unw) = elf_next_in_group (unwi);
4435
0
       elf_next_in_group (unwi) = unw;
4436
0
     }
4437
0
         else
4438
0
     {
4439
0
       elf_next_in_group (unw) = sec;
4440
0
       elf_next_in_group (sec) = unw;
4441
0
     }
4442
0
         elf_sec_group (unw) = group;
4443
0
       }
4444
4445
     /* Fake SHT_GROUP section header.  */
4446
2
    elf_section_data (group)->this_hdr.bfd_section = group;
4447
2
    elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
4448
2
  }
4449
20.6k
    }
4450
39.3k
  return true;
4451
39.3k
}
4452
4453
/* Handle an IA-64 specific section when reading an object file.  This
4454
   is called when bfd_section_from_shdr finds a section with an unknown
4455
   type.  */
4456
4457
static bool
4458
elf64_vms_section_from_shdr (bfd *abfd,
4459
           Elf_Internal_Shdr *hdr,
4460
           const char *name,
4461
           int shindex)
4462
15.1k
{
4463
15.1k
  flagword secflags = 0;
4464
4465
15.1k
  switch (hdr->sh_type)
4466
15.1k
    {
4467
2
    case SHT_IA_64_VMS_TRACE:
4468
15
    case SHT_IA_64_VMS_DEBUG:
4469
20
    case SHT_IA_64_VMS_DEBUG_STR:
4470
20
      secflags = SEC_DEBUGGING;
4471
20
      break;
4472
4473
7
    case SHT_IA_64_UNWIND:
4474
14
    case SHT_IA_64_HP_OPT_ANOT:
4475
14
      break;
4476
4477
0
    case SHT_IA_64_EXT:
4478
0
      if (strcmp (name, ELF_STRING_ia64_archext) != 0)
4479
0
  return false;
4480
0
      break;
4481
4482
15.1k
    default:
4483
15.1k
      return false;
4484
15.1k
    }
4485
4486
34
  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4487
0
    return false;
4488
4489
34
  if (secflags != 0)
4490
20
    {
4491
20
      asection *newsect = hdr->bfd_section;
4492
4493
20
      if (!bfd_set_section_flags (newsect,
4494
20
          bfd_section_flags (newsect) | secflags))
4495
0
  return false;
4496
20
    }
4497
4498
34
  return true;
4499
34
}
4500
4501
static bool
4502
elf64_vms_object_p (bfd *abfd)
4503
51.5k
{
4504
51.5k
  Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4505
51.5k
  Elf_Internal_Phdr *i_phdr = elf_tdata (abfd)->phdr;
4506
51.5k
  unsigned int i;
4507
51.5k
  unsigned int num_text = 0;
4508
51.5k
  unsigned int num_data = 0;
4509
51.5k
  unsigned int num_rodata = 0;
4510
51.5k
  char name[16];
4511
4512
51.5k
  if (!elf64_ia64_object_p (abfd))
4513
0
    return false;
4514
4515
  /* Many VMS compilers do not generate sections for the corresponding
4516
     segment.  This is boring as binutils tools won't be able to disassemble
4517
     the code.  So we simply create all the missing sections.  */
4518
1.85M
  for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
4519
1.80M
    {
4520
      /* Is there a section for this segment?  */
4521
1.80M
      bfd_vma base_vma = i_phdr->p_vaddr;
4522
1.80M
      bfd_vma limit_vma = base_vma + i_phdr->p_filesz;
4523
4524
1.80M
      if (i_phdr->p_type != PT_LOAD)
4525
1.68M
  continue;
4526
4527
      /* We need to cover from base_vms to limit_vma.  */
4528
179k
    again:
4529
301k
      while (base_vma < limit_vma)
4530
180k
  {
4531
180k
    bfd_vma next_vma = limit_vma;
4532
180k
    asection *nsec;
4533
180k
    asection *sec;
4534
180k
    flagword flags;
4535
180k
    char *nname = NULL;
4536
4537
    /* Find a section covering [base_vma;limit_vma)  */
4538
469k
    for (sec = abfd->sections; sec != NULL; sec = sec->next)
4539
347k
      {
4540
        /* Skip uninteresting sections (either not in memory or
4541
     below base_vma.  */
4542
347k
        if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == 0
4543
347k
      || sec->vma + sec->size <= base_vma)
4544
154k
    continue;
4545
192k
        if (sec->vma <= base_vma)
4546
57.8k
    {
4547
      /* This section covers (maybe partially) the beginning
4548
         of the range.  */
4549
57.8k
      base_vma = sec->vma + sec->size;
4550
57.8k
      goto again;
4551
57.8k
    }
4552
134k
        if (sec->vma < next_vma)
4553
51.9k
    {
4554
      /* This section partially covers the end of the range.
4555
         Used to compute the size of the hole.  */
4556
51.9k
      next_vma = sec->vma;
4557
51.9k
    }
4558
134k
      }
4559
4560
    /* No section covering [base_vma; next_vma).  Create a fake one.  */
4561
122k
    flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
4562
122k
    if (i_phdr->p_flags & PF_X)
4563
7.56k
      {
4564
7.56k
        flags |= SEC_CODE;
4565
7.56k
        if (num_text++ == 0)
4566
6.27k
    nname = ".text";
4567
1.29k
        else
4568
1.29k
    sprintf (name, ".text$%u", num_text);
4569
7.56k
      }
4570
114k
    else if ((i_phdr->p_flags & (PF_R | PF_W)) == PF_R)
4571
49.0k
      {
4572
49.0k
        flags |= SEC_READONLY;
4573
49.0k
        sprintf (name, ".rodata$%u", num_rodata++);
4574
49.0k
      }
4575
65.8k
    else
4576
65.8k
      {
4577
65.8k
        flags |= SEC_DATA;
4578
65.8k
        sprintf (name, ".data$%u", num_data++);
4579
65.8k
      }
4580
4581
    /* Allocate name.  */
4582
122k
    if (nname == NULL)
4583
116k
      {
4584
116k
        size_t name_len = strlen (name) + 1;
4585
116k
        nname = bfd_alloc (abfd, name_len);
4586
116k
        if (nname == NULL)
4587
0
    return false;
4588
116k
        memcpy (nname, name, name_len);
4589
116k
      }
4590
4591
    /* Create and fill new section.  */
4592
122k
    nsec = bfd_make_section_anyway_with_flags (abfd, nname, flags);
4593
122k
    if (nsec == NULL)
4594
0
      return false;
4595
122k
    nsec->vma = base_vma;
4596
122k
    nsec->size = next_vma - base_vma;
4597
122k
    nsec->filepos = i_phdr->p_offset + (base_vma - i_phdr->p_vaddr);
4598
4599
122k
    base_vma = next_vma;
4600
122k
  }
4601
179k
    }
4602
51.5k
  return true;
4603
51.5k
}
4604
4605
static bool
4606
elf64_vms_init_file_header (bfd *abfd, struct bfd_link_info *info)
4607
0
{
4608
0
  Elf_Internal_Ehdr *i_ehdrp;
4609
4610
0
  if (!_bfd_elf_init_file_header (abfd, info))
4611
0
    return false;
4612
4613
0
  i_ehdrp = elf_elfheader (abfd);
4614
0
  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_OPENVMS;
4615
0
  i_ehdrp->e_ident[EI_ABIVERSION] = 2;
4616
0
  return true;
4617
0
}
4618
4619
static bool
4620
elf64_vms_section_processing (bfd *abfd ATTRIBUTE_UNUSED,
4621
            Elf_Internal_Shdr *hdr)
4622
0
{
4623
0
  if (hdr->bfd_section != NULL)
4624
0
    {
4625
0
      const char *name = bfd_section_name (hdr->bfd_section);
4626
4627
0
      if (strcmp (name, ".text") == 0)
4628
0
  hdr->sh_flags |= SHF_IA_64_VMS_SHARED;
4629
0
      else if ((strcmp (name, ".debug") == 0)
4630
0
      || (strcmp (name, ".debug_abbrev") == 0)
4631
0
      || (strcmp (name, ".debug_aranges") == 0)
4632
0
      || (strcmp (name, ".debug_frame") == 0)
4633
0
      || (strcmp (name, ".debug_info") == 0)
4634
0
      || (strcmp (name, ".debug_loc") == 0)
4635
0
      || (strcmp (name, ".debug_macinfo") == 0)
4636
0
      || (strcmp (name, ".debug_pubnames") == 0)
4637
0
      || (strcmp (name, ".debug_pubtypes") == 0))
4638
0
  hdr->sh_type = SHT_IA_64_VMS_DEBUG;
4639
0
      else if ((strcmp (name, ".debug_line") == 0)
4640
0
      || (strcmp (name, ".debug_ranges") == 0)
4641
0
      || (strcmp (name, ".trace_info") == 0)
4642
0
      || (strcmp (name, ".trace_abbrev") == 0)
4643
0
      || (strcmp (name, ".trace_aranges") == 0))
4644
0
  hdr->sh_type = SHT_IA_64_VMS_TRACE;
4645
0
      else if (strcmp (name, ".debug_str") == 0)
4646
0
  hdr->sh_type = SHT_IA_64_VMS_DEBUG_STR;
4647
0
    }
4648
4649
0
  return true;
4650
0
}
4651
4652
/* The final processing done just before writing out a VMS IA-64 ELF
4653
   object file.  */
4654
4655
static bool
4656
elf64_vms_final_write_processing (bfd *abfd)
4657
0
{
4658
0
  Elf_Internal_Shdr *hdr;
4659
0
  asection *s;
4660
0
  int unwind_info_sect_idx = 0;
4661
4662
0
  for (s = abfd->sections; s; s = s->next)
4663
0
    {
4664
0
      hdr = &elf_section_data (s)->this_hdr;
4665
4666
0
      if (strcmp (bfd_section_name (hdr->bfd_section),
4667
0
      ".IA_64.unwind_info") == 0)
4668
0
  unwind_info_sect_idx = elf_section_data (s)->this_idx;
4669
4670
0
      switch (hdr->sh_type)
4671
0
  {
4672
0
  case SHT_IA_64_UNWIND:
4673
    /* VMS requires sh_info to point to the unwind info section.  */
4674
0
    hdr->sh_info = unwind_info_sect_idx;
4675
0
    break;
4676
0
  }
4677
0
    }
4678
4679
0
  if (! elf_flags_init (abfd))
4680
0
    {
4681
0
      unsigned long flags = 0;
4682
4683
0
      if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
4684
0
  flags |= EF_IA_64_BE;
4685
0
      if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
4686
0
  flags |= EF_IA_64_ABI64;
4687
4688
0
      elf_elfheader (abfd)->e_flags = flags;
4689
0
      elf_flags_init (abfd) = true;
4690
0
    }
4691
0
  return _bfd_elf_final_write_processing (abfd);
4692
0
}
4693
4694
static bool
4695
elf64_vms_write_shdrs_and_ehdr (bfd *abfd)
4696
0
{
4697
0
  unsigned char needed_count[8];
4698
4699
0
  if (!bfd_elf64_write_shdrs_and_ehdr (abfd))
4700
0
    return false;
4701
4702
0
  bfd_putl64 (elf_ia64_vms_tdata (abfd)->needed_count, needed_count);
4703
4704
0
  if (bfd_seek (abfd, sizeof (Elf64_External_Ehdr), SEEK_SET) != 0
4705
0
      || bfd_write (needed_count, 8, abfd) != 8)
4706
0
    return false;
4707
4708
0
  return true;
4709
0
}
4710
4711
static bool
4712
elf64_vms_close_and_cleanup (bfd *abfd)
4713
25.7k
{
4714
25.7k
  bool ret = true;
4715
25.7k
  if (bfd_get_format (abfd) == bfd_object
4716
25.7k
      && bfd_write_p (abfd))
4717
0
    {
4718
0
      long isize;
4719
4720
      /* Pad to 8 byte boundary for IPF/VMS.  */
4721
0
      isize = bfd_get_size (abfd);
4722
0
      if ((isize & 7) != 0)
4723
0
  {
4724
0
    unsigned int ishort = 8 - (isize & 7);
4725
0
    uint64_t pad = 0;
4726
4727
0
    if (bfd_seek (abfd, isize, SEEK_SET) != 0
4728
0
        || bfd_write (&pad, ishort, abfd) != ishort)
4729
0
      ret = false;
4730
0
  }
4731
0
    }
4732
4733
25.7k
  return _bfd_generic_close_and_cleanup (abfd) && ret;
4734
25.7k
}
4735
4736
/* Add symbols from an ELF object file to the linker hash table.  */
4737
4738
static bool
4739
elf64_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
4740
0
{
4741
0
  Elf_Internal_Shdr *hdr;
4742
0
  bfd_size_type symcount;
4743
0
  bfd_size_type extsymcount;
4744
0
  bfd_size_type extsymoff;
4745
0
  struct elf_link_hash_entry **sym_hash;
4746
0
  bool dynamic;
4747
0
  Elf_Internal_Sym *isymbuf = NULL;
4748
0
  Elf_Internal_Sym *isym;
4749
0
  Elf_Internal_Sym *isymend;
4750
0
  const struct elf_backend_data *bed;
4751
0
  struct elf_link_hash_table *htab;
4752
0
  bfd_size_type amt;
4753
4754
0
  htab = elf_hash_table (info);
4755
0
  bed = get_elf_backend_data (abfd);
4756
4757
0
  if ((abfd->flags & DYNAMIC) == 0)
4758
0
    dynamic = false;
4759
0
  else
4760
0
    {
4761
0
      dynamic = true;
4762
4763
      /* You can't use -r against a dynamic object.  Also, there's no
4764
   hope of using a dynamic object which does not exactly match
4765
   the format of the output file.  */
4766
0
      if (bfd_link_relocatable (info)
4767
0
    || !is_elf_hash_table (&htab->root)
4768
0
    || info->output_bfd->xvec != abfd->xvec)
4769
0
  {
4770
0
    if (bfd_link_relocatable (info))
4771
0
      bfd_set_error (bfd_error_invalid_operation);
4772
0
    else
4773
0
      bfd_set_error (bfd_error_wrong_format);
4774
0
    goto error_return;
4775
0
  }
4776
0
    }
4777
4778
0
  if (! dynamic)
4779
0
    {
4780
      /* If we are creating a shared library, create all the dynamic
4781
   sections immediately.  We need to attach them to something,
4782
   so we attach them to this BFD, provided it is the right
4783
   format.  FIXME: If there are no input BFD's of the same
4784
   format as the output, we can't make a shared library.  */
4785
0
      if (bfd_link_pic (info)
4786
0
    && is_elf_hash_table (&htab->root)
4787
0
    && info->output_bfd->xvec == abfd->xvec
4788
0
    && !htab->dynamic_sections_created)
4789
0
  {
4790
0
    if (! elf64_ia64_create_dynamic_sections (abfd, info))
4791
0
      goto error_return;
4792
0
  }
4793
0
    }
4794
0
  else if (!is_elf_hash_table (&htab->root))
4795
0
    goto error_return;
4796
0
  else
4797
0
    {
4798
0
      asection *s;
4799
0
      bfd_byte *dynbuf;
4800
0
      bfd_byte *extdyn;
4801
4802
      /* ld --just-symbols and dynamic objects don't mix very well.
4803
   ld shouldn't allow it.  */
4804
0
      if ((s = abfd->sections) != NULL
4805
0
    && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4806
0
  abort ();
4807
4808
      /* Be sure there are dynamic sections.  */
4809
0
      if (! elf64_ia64_create_dynamic_sections (htab->dynobj, info))
4810
0
  goto error_return;
4811
4812
0
      s = bfd_get_section_by_name (abfd, ".dynamic");
4813
0
      if (s == NULL)
4814
0
  {
4815
    /* VMS libraries do not have dynamic sections.  Create one from
4816
       the segment.  */
4817
0
    Elf_Internal_Phdr *phdr;
4818
0
    unsigned int i, phnum;
4819
4820
0
    phdr = elf_tdata (abfd)->phdr;
4821
0
    if (phdr == NULL)
4822
0
      goto error_return;
4823
0
    phnum = elf_elfheader (abfd)->e_phnum;
4824
0
    for (i = 0; i < phnum; phdr++)
4825
0
      if (phdr->p_type == PT_DYNAMIC)
4826
0
        {
4827
0
    s = bfd_make_section (abfd, ".dynamic");
4828
0
    if (s == NULL)
4829
0
      goto error_return;
4830
0
    s->vma = phdr->p_vaddr;
4831
0
    s->lma = phdr->p_paddr;
4832
0
    s->size = phdr->p_filesz;
4833
0
    s->filepos = phdr->p_offset;
4834
0
    s->flags |= SEC_HAS_CONTENTS;
4835
0
    s->alignment_power = bfd_log2 (phdr->p_align);
4836
0
    break;
4837
0
        }
4838
0
    if (s == NULL)
4839
0
      goto error_return;
4840
0
  }
4841
4842
      /* Extract IDENT.  */
4843
0
      if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
4844
0
  {
4845
0
  error_free_dyn:
4846
0
    free (dynbuf);
4847
0
    goto error_return;
4848
0
  }
4849
4850
0
      for (extdyn = dynbuf;
4851
0
     (size_t) (dynbuf + s->size - extdyn) >= bed->s->sizeof_dyn;
4852
0
     extdyn += bed->s->sizeof_dyn)
4853
0
  {
4854
0
    Elf_Internal_Dyn dyn;
4855
4856
0
    bed->s->swap_dyn_in (abfd, extdyn, &dyn);
4857
0
    if (dyn.d_tag == DT_IA_64_VMS_IDENT)
4858
0
      {
4859
0
        uint64_t tagv = dyn.d_un.d_val;
4860
0
        elf_ia64_vms_ident (abfd) = tagv;
4861
0
        break;
4862
0
      }
4863
0
  }
4864
0
      if (extdyn >= dynbuf + s->size)
4865
0
  {
4866
    /* Ident not found.  */
4867
0
    goto error_free_dyn;
4868
0
  }
4869
0
      free (dynbuf);
4870
4871
      /* We do not want to include any of the sections in a dynamic
4872
   object in the output file.  We hack by simply clobbering the
4873
   list of sections in the BFD.  This could be handled more
4874
   cleanly by, say, a new section flag; the existing
4875
   SEC_NEVER_LOAD flag is not the one we want, because that one
4876
   still implies that the section takes up space in the output
4877
   file.  */
4878
0
      bfd_section_list_clear (abfd);
4879
4880
      /* FIXME: should we detect if this library is already included ?
4881
   This should be harmless and shouldn't happen in practice.  */
4882
0
    }
4883
4884
0
  hdr = &elf_tdata (abfd)->symtab_hdr;
4885
0
  symcount = hdr->sh_size / bed->s->sizeof_sym;
4886
4887
  /* The sh_info field of the symtab header tells us where the
4888
     external symbols start.  We don't care about the local symbols at
4889
     this point.  */
4890
0
  extsymcount = symcount - hdr->sh_info;
4891
0
  extsymoff = hdr->sh_info;
4892
4893
0
  sym_hash = NULL;
4894
0
  if (extsymcount != 0)
4895
0
    {
4896
0
      isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
4897
0
              NULL, NULL, NULL);
4898
0
      if (isymbuf == NULL)
4899
0
  goto error_return;
4900
4901
      /* We store a pointer to the hash table entry for each external
4902
   symbol.  */
4903
0
      amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4904
0
      sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
4905
0
      if (sym_hash == NULL)
4906
0
  goto error_free_sym;
4907
0
      elf_sym_hashes (abfd) = sym_hash;
4908
0
    }
4909
4910
0
  for (isym = isymbuf, isymend = isymbuf + extsymcount;
4911
0
       isym < isymend;
4912
0
       isym++, sym_hash++)
4913
0
    {
4914
0
      int bind;
4915
0
      bfd_vma value;
4916
0
      asection *sec, *new_sec;
4917
0
      flagword flags;
4918
0
      const char *name;
4919
0
      struct elf_link_hash_entry *h;
4920
0
      bool definition;
4921
0
      bool size_change_ok;
4922
0
      bool type_change_ok;
4923
0
      bool common;
4924
0
      unsigned int old_alignment;
4925
0
      bfd *old_bfd;
4926
4927
0
      flags = BSF_NO_FLAGS;
4928
0
      sec = NULL;
4929
0
      value = isym->st_value;
4930
0
      *sym_hash = NULL;
4931
0
      common = bed->common_definition (isym);
4932
4933
0
      bind = ELF_ST_BIND (isym->st_info);
4934
0
      switch (bind)
4935
0
  {
4936
0
  case STB_LOCAL:
4937
    /* This should be impossible, since ELF requires that all
4938
       global symbols follow all local symbols, and that sh_info
4939
       point to the first global symbol.  Unfortunately, Irix 5
4940
       screws this up.  */
4941
0
    continue;
4942
4943
0
  case STB_GLOBAL:
4944
0
    if (isym->st_shndx != SHN_UNDEF && !common)
4945
0
      flags = BSF_GLOBAL;
4946
0
    break;
4947
4948
0
  case STB_WEAK:
4949
0
    flags = BSF_WEAK;
4950
0
    break;
4951
4952
0
  case STB_GNU_UNIQUE:
4953
0
    flags = BSF_GNU_UNIQUE;
4954
0
    break;
4955
4956
0
  default:
4957
    /* Leave it up to the processor backend.  */
4958
0
    break;
4959
0
  }
4960
4961
0
      if (isym->st_shndx == SHN_UNDEF)
4962
0
  sec = bfd_und_section_ptr;
4963
0
      else if (isym->st_shndx == SHN_ABS)
4964
0
  sec = bfd_abs_section_ptr;
4965
0
      else if (isym->st_shndx == SHN_COMMON)
4966
0
  {
4967
0
    sec = bfd_com_section_ptr;
4968
    /* What ELF calls the size we call the value.  What ELF
4969
       calls the value we call the alignment.  */
4970
0
    value = isym->st_size;
4971
0
  }
4972
0
      else
4973
0
  {
4974
0
    sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4975
0
    if (sec == NULL)
4976
0
      sec = bfd_abs_section_ptr;
4977
0
    else if (sec->kept_section)
4978
0
      {
4979
        /* Symbols from discarded section are undefined.  We keep
4980
     its visibility.  */
4981
0
        sec = bfd_und_section_ptr;
4982
0
        isym->st_shndx = SHN_UNDEF;
4983
0
      }
4984
0
    else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
4985
0
      value -= sec->vma;
4986
0
  }
4987
4988
0
      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4989
0
                isym->st_name);
4990
0
      if (name == NULL)
4991
0
  goto error_free_vers;
4992
4993
0
      if (bed->elf_add_symbol_hook)
4994
0
  {
4995
0
    if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
4996
0
               &sec, &value))
4997
0
      goto error_free_vers;
4998
4999
    /* The hook function sets the name to NULL if this symbol
5000
       should be skipped for some reason.  */
5001
0
    if (name == NULL)
5002
0
      continue;
5003
0
  }
5004
5005
      /* Sanity check that all possibilities were handled.  */
5006
0
      if (sec == NULL)
5007
0
  {
5008
0
    bfd_set_error (bfd_error_bad_value);
5009
0
    goto error_free_vers;
5010
0
  }
5011
5012
0
      if (bfd_is_und_section (sec)
5013
0
    || bfd_is_com_section (sec))
5014
0
  definition = false;
5015
0
      else
5016
0
  definition = true;
5017
5018
0
      size_change_ok = false;
5019
0
      type_change_ok = bed->type_change_ok;
5020
0
      old_alignment = 0;
5021
0
      old_bfd = NULL;
5022
0
      new_sec = sec;
5023
5024
0
      if (! bfd_is_und_section (sec))
5025
0
  h = elf_link_hash_lookup (htab, name, true, false, false);
5026
0
      else
5027
0
  h = ((struct elf_link_hash_entry *) bfd_wrapped_link_hash_lookup
5028
0
       (abfd, info, name, true, false, false));
5029
0
      if (h == NULL)
5030
0
  goto error_free_sym;
5031
5032
0
      *sym_hash = h;
5033
5034
0
      if (is_elf_hash_table (&htab->root))
5035
0
  {
5036
0
    while (h->root.type == bfd_link_hash_indirect
5037
0
     || h->root.type == bfd_link_hash_warning)
5038
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
5039
5040
    /* Remember the old alignment if this is a common symbol, so
5041
       that we don't reduce the alignment later on.  We can't
5042
       check later, because _bfd_generic_link_add_one_symbol
5043
       will set a default for the alignment which we want to
5044
       override. We also remember the old bfd where the existing
5045
       definition comes from.  */
5046
0
    switch (h->root.type)
5047
0
      {
5048
0
      default:
5049
0
        break;
5050
5051
0
      case bfd_link_hash_defined:
5052
0
        if (abfd->selective_search)
5053
0
    continue;
5054
        /* Fall-through.  */
5055
0
      case bfd_link_hash_defweak:
5056
0
        old_bfd = h->root.u.def.section->owner;
5057
0
        break;
5058
5059
0
      case bfd_link_hash_common:
5060
0
        old_bfd = h->root.u.c.p->section->owner;
5061
0
        old_alignment = h->root.u.c.p->alignment_power;
5062
0
        break;
5063
0
      }
5064
0
  }
5065
5066
0
      if (! (_bfd_generic_link_add_one_symbol
5067
0
       (info, abfd, name, flags, sec, value, NULL, false, bed->collect,
5068
0
        (struct bfd_link_hash_entry **) sym_hash)))
5069
0
  goto error_free_vers;
5070
5071
0
      h = *sym_hash;
5072
0
      while (h->root.type == bfd_link_hash_indirect
5073
0
       || h->root.type == bfd_link_hash_warning)
5074
0
  h = (struct elf_link_hash_entry *) h->root.u.i.link;
5075
5076
0
      *sym_hash = h;
5077
0
      if (definition)
5078
0
  h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
5079
5080
      /* Set the alignment of a common symbol.  */
5081
0
      if ((common || bfd_is_com_section (sec))
5082
0
    && h->root.type == bfd_link_hash_common)
5083
0
  {
5084
0
    unsigned int align;
5085
5086
0
    if (common)
5087
0
      align = bfd_log2 (isym->st_value);
5088
0
    else
5089
0
      {
5090
        /* The new symbol is a common symbol in a shared object.
5091
     We need to get the alignment from the section.  */
5092
0
        align = new_sec->alignment_power;
5093
0
      }
5094
0
    if (align > old_alignment
5095
        /* Permit an alignment power of zero if an alignment of one
5096
     is specified and no other alignments have been specified.  */
5097
0
        || (isym->st_value == 1 && old_alignment == 0))
5098
0
      h->root.u.c.p->alignment_power = align;
5099
0
    else
5100
0
      h->root.u.c.p->alignment_power = old_alignment;
5101
0
  }
5102
5103
0
      if (is_elf_hash_table (&htab->root))
5104
0
  {
5105
    /* Check the alignment when a common symbol is involved. This
5106
       can change when a common symbol is overridden by a normal
5107
       definition or a common symbol is ignored due to the old
5108
       normal definition. We need to make sure the maximum
5109
       alignment is maintained.  */
5110
0
    if ((old_alignment || common)
5111
0
        && h->root.type != bfd_link_hash_common)
5112
0
      {
5113
0
        unsigned int common_align;
5114
0
        unsigned int normal_align;
5115
0
        unsigned int symbol_align;
5116
0
        bfd *normal_bfd;
5117
0
        bfd *common_bfd;
5118
5119
0
        symbol_align = ffs (h->root.u.def.value) - 1;
5120
0
        if (h->root.u.def.section->owner != NULL
5121
0
      && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
5122
0
    {
5123
0
      normal_align = h->root.u.def.section->alignment_power;
5124
0
      if (normal_align > symbol_align)
5125
0
        normal_align = symbol_align;
5126
0
    }
5127
0
        else
5128
0
    normal_align = symbol_align;
5129
5130
0
        if (old_alignment)
5131
0
    {
5132
0
      common_align = old_alignment;
5133
0
      common_bfd = old_bfd;
5134
0
      normal_bfd = abfd;
5135
0
    }
5136
0
        else
5137
0
    {
5138
0
      common_align = bfd_log2 (isym->st_value);
5139
0
      common_bfd = abfd;
5140
0
      normal_bfd = old_bfd;
5141
0
    }
5142
5143
0
        if (normal_align < common_align)
5144
0
    {
5145
      /* PR binutils/2735 */
5146
0
      if (normal_bfd == NULL)
5147
0
        _bfd_error_handler
5148
          /* xgettext:c-format */
5149
0
          (_("warning: alignment %u of common symbol `%s' in %pB"
5150
0
       " is greater than the alignment (%u) of its section %pA"),
5151
0
           1 << common_align, name, common_bfd,
5152
0
           1 << normal_align, h->root.u.def.section);
5153
0
      else
5154
0
        _bfd_error_handler
5155
          /* xgettext:c-format */
5156
0
          (_("warning: alignment %u of symbol `%s' in %pB"
5157
0
       " is smaller than %u in %pB"),
5158
0
           1 << normal_align, name, normal_bfd,
5159
0
           1 << common_align, common_bfd);
5160
0
    }
5161
0
      }
5162
5163
    /* Remember the symbol size if it isn't undefined.  */
5164
0
    if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF)
5165
0
        && (definition || h->size == 0))
5166
0
      {
5167
0
        if (h->size != 0
5168
0
      && h->size != isym->st_size
5169
0
      && ! size_change_ok)
5170
0
    _bfd_error_handler
5171
      /* xgettext:c-format */
5172
0
      (_("warning: size of symbol `%s' changed"
5173
0
         " from %" PRIu64 " in %pB to %" PRIu64 " in %pB"),
5174
0
       name, (uint64_t) h->size, old_bfd,
5175
0
       (uint64_t) isym->st_size, abfd);
5176
5177
0
        h->size = isym->st_size;
5178
0
      }
5179
5180
    /* If this is a common symbol, then we always want H->SIZE
5181
       to be the size of the common symbol.  The code just above
5182
       won't fix the size if a common symbol becomes larger.  We
5183
       don't warn about a size change here, because that is
5184
       covered by --warn-common.  Allow changed between different
5185
       function types.  */
5186
0
    if (h->root.type == bfd_link_hash_common)
5187
0
      h->size = h->root.u.c.size;
5188
5189
0
    if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
5190
0
        && (definition || h->type == STT_NOTYPE))
5191
0
      {
5192
0
        unsigned int type = ELF_ST_TYPE (isym->st_info);
5193
5194
0
        if (h->type != type)
5195
0
    {
5196
0
      if (h->type != STT_NOTYPE && ! type_change_ok)
5197
0
        _bfd_error_handler
5198
          /* xgettext:c-format */
5199
0
          (_("warning: type of symbol `%s' changed"
5200
0
       " from %d to %d in %pB"),
5201
0
           name, h->type, type, abfd);
5202
5203
0
      h->type = type;
5204
0
    }
5205
0
      }
5206
5207
    /* Set a flag in the hash table entry indicating the type of
5208
       reference or definition we just found.  Keep a count of
5209
       the number of dynamic symbols we find.  A dynamic symbol
5210
       is one which is referenced or defined by both a regular
5211
       object and a shared object.  */
5212
0
    if (! dynamic)
5213
0
      {
5214
0
        if (! definition)
5215
0
    {
5216
0
      h->ref_regular = 1;
5217
0
      if (bind != STB_WEAK)
5218
0
        h->ref_regular_nonweak = 1;
5219
0
    }
5220
0
        else
5221
0
    {
5222
0
      BFD_ASSERT (!h->def_dynamic);
5223
0
      h->def_regular = 1;
5224
0
    }
5225
0
      }
5226
0
    else
5227
0
      {
5228
0
        BFD_ASSERT (definition);
5229
0
        h->def_dynamic = 1;
5230
0
        h->dynindx = -2;
5231
0
        ((struct elf64_ia64_link_hash_entry *)h)->shl = abfd;
5232
0
      }
5233
0
  }
5234
0
    }
5235
5236
0
  free (isymbuf);
5237
0
  isymbuf = NULL;
5238
5239
  /* If this object is the same format as the output object, and it is
5240
     not a shared library, then let the backend look through the
5241
     relocs.
5242
5243
     This is required to build global offset table entries and to
5244
     arrange for dynamic relocs.  It is not required for the
5245
     particular common case of linking non PIC code, even when linking
5246
     against shared libraries, but unfortunately there is no way of
5247
     knowing whether an object file has been compiled PIC or not.
5248
     Looking through the relocs is not particularly time consuming.
5249
     The problem is that we must either (1) keep the relocs in memory,
5250
     which causes the linker to require additional runtime memory or
5251
     (2) read the relocs twice from the input file, which wastes time.
5252
     This would be a good case for using mmap.
5253
5254
     I have no idea how to handle linking PIC code into a file of a
5255
     different format.  It probably can't be done.  */
5256
0
  if (! dynamic
5257
0
      && is_elf_hash_table (&htab->root)
5258
0
      && bed->check_relocs != NULL
5259
0
      && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
5260
0
    {
5261
0
      asection *o;
5262
5263
0
      for (o = abfd->sections; o != NULL; o = o->next)
5264
0
  {
5265
0
    Elf_Internal_Rela *internal_relocs;
5266
0
    bool ok;
5267
5268
0
    if ((o->flags & SEC_RELOC) == 0
5269
0
        || o->reloc_count == 0
5270
0
        || ((info->strip == strip_all || info->strip == strip_debugger)
5271
0
      && (o->flags & SEC_DEBUGGING) != 0)
5272
0
        || bfd_is_abs_section (o->output_section))
5273
0
      continue;
5274
5275
0
    internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
5276
0
                   info->keep_memory);
5277
0
    if (internal_relocs == NULL)
5278
0
      goto error_return;
5279
5280
0
    ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
5281
5282
0
    if (elf_section_data (o)->relocs != internal_relocs)
5283
0
      free (internal_relocs);
5284
5285
0
    if (! ok)
5286
0
      goto error_return;
5287
0
  }
5288
0
    }
5289
5290
0
  return true;
5291
5292
0
 error_free_vers:
5293
0
 error_free_sym:
5294
0
  free (isymbuf);
5295
0
 error_return:
5296
0
  return false;
5297
0
}
5298
5299
static bool
5300
elf64_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
5301
0
{
5302
0
  int pass;
5303
0
  struct bfd_link_hash_entry **pundef;
5304
0
  struct bfd_link_hash_entry **next_pundef;
5305
5306
  /* We only accept VMS libraries.  */
5307
0
  if (info->output_bfd->xvec != abfd->xvec)
5308
0
    {
5309
0
      bfd_set_error (bfd_error_wrong_format);
5310
0
      return false;
5311
0
    }
5312
5313
  /* The archive_pass field in the archive itself is used to
5314
     initialize PASS, since we may search the same archive multiple
5315
     times.  */
5316
0
  pass = ++abfd->archive_pass;
5317
5318
  /* Look through the list of undefined symbols.  */
5319
0
  for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
5320
0
    {
5321
0
      struct bfd_link_hash_entry *h;
5322
0
      symindex symidx;
5323
0
      bfd *element;
5324
0
      bfd *orig_element;
5325
5326
0
      h = *pundef;
5327
0
      next_pundef = &(*pundef)->u.undef.next;
5328
5329
      /* When a symbol is defined, it is not necessarily removed from
5330
   the list.  */
5331
0
      if (h->type != bfd_link_hash_undefined
5332
0
    && h->type != bfd_link_hash_common)
5333
0
  {
5334
    /* Remove this entry from the list, for general cleanliness
5335
       and because we are going to look through the list again
5336
       if we search any more libraries.  We can't remove the
5337
       entry if it is the tail, because that would lose any
5338
       entries we add to the list later on.  */
5339
0
    if (*pundef != info->hash->undefs_tail)
5340
0
      {
5341
0
        *pundef = *next_pundef;
5342
0
        next_pundef = pundef;
5343
0
      }
5344
0
    continue;
5345
0
  }
5346
5347
      /* Look for this symbol in the archive hash table.  */
5348
0
      symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
5349
0
      if (symidx == BFD_NO_MORE_SYMBOLS)
5350
0
  {
5351
    /* Nothing in this slot.  */
5352
0
    continue;
5353
0
  }
5354
5355
0
      element = bfd_get_elt_at_index (abfd, symidx);
5356
0
      if (element == NULL)
5357
0
  return false;
5358
5359
0
      if (element->archive_pass == -1 || element->archive_pass == pass)
5360
0
  {
5361
    /* Next symbol if this archive is wrong or already handled.  */
5362
0
    continue;
5363
0
  }
5364
5365
0
      orig_element = element;
5366
0
      if (bfd_is_thin_archive (abfd))
5367
0
  {
5368
0
    element = _bfd_vms_lib_get_imagelib_file (element);
5369
0
    if (element == NULL || !bfd_check_format (element, bfd_object))
5370
0
      {
5371
0
        orig_element->archive_pass = -1;
5372
0
        return false;
5373
0
      }
5374
0
  }
5375
0
      else if (! bfd_check_format (element, bfd_object))
5376
0
  {
5377
0
    element->archive_pass = -1;
5378
0
    return false;
5379
0
  }
5380
5381
      /* Unlike the generic linker, we know that this element provides
5382
   a definition for an undefined symbol and we know that we want
5383
   to include it.  We don't need to check anything.  */
5384
0
      if (! (*info->callbacks->add_archive_element) (info, element,
5385
0
                 h->root.string, &element))
5386
0
  continue;
5387
0
      if (! elf64_vms_link_add_object_symbols (element, info))
5388
0
  return false;
5389
5390
0
      orig_element->archive_pass = pass;
5391
0
    }
5392
5393
0
  return true;
5394
0
}
5395
5396
static bool
5397
elf64_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5398
0
{
5399
0
  switch (bfd_get_format (abfd))
5400
0
    {
5401
0
    case bfd_object:
5402
0
      return elf64_vms_link_add_object_symbols (abfd, info);
5403
0
      break;
5404
0
    case bfd_archive:
5405
0
      return elf64_vms_link_add_archive_symbols (abfd, info);
5406
0
      break;
5407
0
    default:
5408
0
      bfd_set_error (bfd_error_wrong_format);
5409
0
      return false;
5410
0
    }
5411
0
}
5412
5413
static bool
5414
elf64_ia64_vms_mkobject (bfd *abfd)
5415
148k
{
5416
148k
  return bfd_elf_allocate_object
5417
148k
    (abfd, sizeof (struct elf64_ia64_vms_obj_tdata), IA64_ELF_DATA);
5418
148k
}
5419
5420
5421
/* Size-dependent data and functions.  */
5422
static const struct elf_size_info elf64_ia64_vms_size_info = {
5423
  sizeof (Elf64_External_VMS_Ehdr),
5424
  sizeof (Elf64_External_Phdr),
5425
  sizeof (Elf64_External_Shdr),
5426
  sizeof (Elf64_External_Rel),
5427
  sizeof (Elf64_External_Rela),
5428
  sizeof (Elf64_External_Sym),
5429
  sizeof (Elf64_External_Dyn),
5430
  sizeof (Elf_External_Note),
5431
  4,
5432
  1,
5433
  64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */
5434
  ELFCLASS64, EV_CURRENT,
5435
  bfd_elf64_write_out_phdrs,
5436
  elf64_vms_write_shdrs_and_ehdr,
5437
  bfd_elf64_checksum_contents,
5438
  bfd_elf64_write_relocs,
5439
  bfd_elf64_swap_symbol_in,
5440
  bfd_elf64_swap_symbol_out,
5441
  bfd_elf64_slurp_reloc_table,
5442
  bfd_elf64_slurp_symbol_table,
5443
  bfd_elf64_swap_dyn_in,
5444
  bfd_elf64_swap_dyn_out,
5445
  bfd_elf64_swap_reloc_in,
5446
  bfd_elf64_swap_reloc_out,
5447
  bfd_elf64_swap_reloca_in,
5448
  bfd_elf64_swap_reloca_out
5449
};
5450
5451
#define ELF_ARCH      bfd_arch_ia64
5452
#define ELF_MACHINE_CODE    EM_IA_64
5453
#define ELF_MAXPAGESIZE     0x10000 /* 64KB */
5454
#define ELF_COMMONPAGESIZE    0x200 /* 16KB */
5455
5456
#define elf_backend_section_from_shdr \
5457
  elf64_ia64_section_from_shdr
5458
#define elf_backend_section_flags \
5459
  elf64_ia64_section_flags
5460
#define elf_backend_fake_sections \
5461
  elf64_ia64_fake_sections
5462
#define elf_backend_final_write_processing \
5463
  elf64_ia64_final_write_processing
5464
#define elf_backend_add_symbol_hook \
5465
  elf64_ia64_add_symbol_hook
5466
#define elf_info_to_howto \
5467
  elf64_ia64_info_to_howto
5468
5469
#define bfd_elf64_bfd_reloc_type_lookup \
5470
  ia64_elf_reloc_type_lookup
5471
#define bfd_elf64_bfd_reloc_name_lookup \
5472
  ia64_elf_reloc_name_lookup
5473
#define bfd_elf64_bfd_is_local_label_name \
5474
  elf64_ia64_is_local_label_name
5475
#define bfd_elf64_bfd_relax_section \
5476
  elf64_ia64_relax_section
5477
5478
#define elf_backend_object_p \
5479
  elf64_ia64_object_p
5480
5481
/* Stuff for the BFD linker: */
5482
#define bfd_elf64_bfd_link_hash_table_create \
5483
  elf64_ia64_hash_table_create
5484
#define elf_backend_create_dynamic_sections \
5485
  elf64_ia64_create_dynamic_sections
5486
#define elf_backend_check_relocs \
5487
  elf64_ia64_check_relocs
5488
#define elf_backend_adjust_dynamic_symbol \
5489
  elf64_ia64_adjust_dynamic_symbol
5490
#define elf_backend_late_size_sections \
5491
  elf64_ia64_late_size_sections
5492
#define elf_backend_omit_section_dynsym \
5493
  _bfd_elf_omit_section_dynsym_all
5494
#define elf_backend_relocate_section \
5495
  elf64_ia64_relocate_section
5496
#define elf_backend_finish_dynamic_symbol \
5497
  elf64_ia64_finish_dynamic_symbol
5498
#define elf_backend_finish_dynamic_sections \
5499
  elf64_ia64_finish_dynamic_sections
5500
#define bfd_elf64_bfd_final_link \
5501
  elf64_ia64_final_link
5502
5503
#define bfd_elf64_bfd_merge_private_bfd_data \
5504
  elf64_ia64_merge_private_bfd_data
5505
#define bfd_elf64_bfd_set_private_flags \
5506
  elf64_ia64_set_private_flags
5507
#define bfd_elf64_bfd_print_private_bfd_data \
5508
  elf64_ia64_print_private_bfd_data
5509
5510
#define elf_backend_plt_readonly  1
5511
#define elf_backend_want_plt_sym  0
5512
#define elf_backend_plt_alignment 5
5513
#define elf_backend_got_header_size 0
5514
#define elf_backend_want_got_plt  1
5515
#define elf_backend_may_use_rel_p 1
5516
#define elf_backend_may_use_rela_p  1
5517
#define elf_backend_default_use_rela_p  1
5518
#define elf_backend_want_dynbss   0
5519
#define elf_backend_hide_symbol   elf64_ia64_hash_hide_symbol
5520
#define elf_backend_fixup_symbol  _bfd_elf_link_hash_fixup_symbol
5521
#define elf_backend_reloc_type_class  elf64_ia64_reloc_type_class
5522
#define elf_backend_rela_normal   1
5523
#define elf_backend_special_sections  elf64_ia64_special_sections
5524
#define elf_backend_default_execstack 0
5525
5526
/* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5527
   SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5528
   We don't want to flood users with so many error messages. We turn
5529
   off the warning for now. It will be turned on later when the Intel
5530
   compiler is fixed.   */
5531
#define elf_backend_link_order_error_handler NULL
5532
5533
/* VMS-specific vectors.  */
5534
5535
#undef  TARGET_LITTLE_SYM
5536
#define TARGET_LITTLE_SYM   ia64_elf64_vms_vec
5537
#undef  TARGET_LITTLE_NAME
5538
#define TARGET_LITTLE_NAME    "elf64-ia64-vms"
5539
#undef  TARGET_BIG_SYM
5540
#undef  TARGET_BIG_NAME
5541
5542
/* These are VMS specific functions.  */
5543
5544
#undef  elf_backend_object_p
5545
#define elf_backend_object_p elf64_vms_object_p
5546
5547
#undef  elf_backend_section_from_shdr
5548
#define elf_backend_section_from_shdr elf64_vms_section_from_shdr
5549
5550
#undef  elf_backend_init_file_header
5551
#define elf_backend_init_file_header elf64_vms_init_file_header
5552
5553
#undef  elf_backend_section_processing
5554
#define elf_backend_section_processing elf64_vms_section_processing
5555
5556
#undef  elf_backend_final_write_processing
5557
#define elf_backend_final_write_processing elf64_vms_final_write_processing
5558
5559
#undef  bfd_elf64_close_and_cleanup
5560
#define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup
5561
5562
#undef  elf_backend_section_from_bfd_section
5563
5564
#undef  elf_backend_symbol_processing
5565
5566
#undef  elf_backend_want_p_paddr_set_to_zero
5567
5568
#undef  ELF_OSABI
5569
#define ELF_OSABI     ELFOSABI_OPENVMS
5570
5571
#undef  ELF_MAXPAGESIZE
5572
#define ELF_MAXPAGESIZE     0x10000 /* 64KB */
5573
5574
#undef  elf64_bed
5575
#define elf64_bed elf64_ia64_vms_bed
5576
5577
#define elf_backend_size_info elf64_ia64_vms_size_info
5578
5579
/* Use VMS-style archives (in particular, don't use the standard coff
5580
   archive format).  */
5581
#define bfd_elf64_archive_functions
5582
5583
#undef bfd_elf64_archive_p
5584
#define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p
5585
#undef bfd_elf64_write_archive_contents
5586
#define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents
5587
#undef bfd_elf64_mkarchive
5588
#define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive
5589
5590
#define bfd_elf64_archive_slurp_armap \
5591
  _bfd_vms_lib_slurp_armap
5592
#define bfd_elf64_archive_slurp_extended_name_table \
5593
  _bfd_vms_lib_slurp_extended_name_table
5594
#define bfd_elf64_archive_construct_extended_name_table \
5595
  _bfd_vms_lib_construct_extended_name_table
5596
#define bfd_elf64_archive_truncate_arname \
5597
  _bfd_vms_lib_truncate_arname
5598
#define bfd_elf64_archive_write_armap \
5599
  _bfd_vms_lib_write_armap
5600
#define bfd_elf64_archive_read_ar_hdr \
5601
  _bfd_vms_lib_read_ar_hdr
5602
#define bfd_elf64_archive_write_ar_hdr \
5603
  _bfd_vms_lib_write_ar_hdr
5604
#define bfd_elf64_archive_openr_next_archived_file \
5605
  _bfd_vms_lib_openr_next_archived_file
5606
#define bfd_elf64_archive_get_elt_at_index \
5607
  _bfd_vms_lib_get_elt_at_index
5608
#define bfd_elf64_archive_generic_stat_arch_elt \
5609
  _bfd_vms_lib_generic_stat_arch_elt
5610
#define bfd_elf64_archive_update_armap_timestamp \
5611
  _bfd_vms_lib_update_armap_timestamp
5612
5613
/* VMS link methods.  */
5614
#undef  bfd_elf64_bfd_link_add_symbols
5615
#define bfd_elf64_bfd_link_add_symbols  elf64_vms_bfd_link_add_symbols
5616
5617
#undef  elf_backend_want_got_sym
5618
#define elf_backend_want_got_sym  0
5619
5620
#undef  bfd_elf64_mkobject
5621
#define bfd_elf64_mkobject    elf64_ia64_vms_mkobject
5622
5623
/* Redefine to align segments on block size.  */
5624
#undef  ELF_MAXPAGESIZE
5625
#define ELF_MAXPAGESIZE     0x200 /* 512B  */
5626
5627
#undef  elf_backend_want_got_plt
5628
#define elf_backend_want_got_plt  0
5629
5630
#include "elf64-target.h"