OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elf32-i370.c] - Blame information for rev 157

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* i370-specific support for 32-bit ELF
2
   Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004,
3
   2005, 2006, 2007 Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor, Cygnus Support.
5
   Hacked by Linas Vepstas for i370 linas@linas.org
6
 
7
   This file is part of BFD, the Binary File Descriptor library.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
/* This file is based on a preliminary PowerPC ELF ABI.
25
   But its been hacked on for the IBM 360/370 architectures.
26
   Basically, the 31bit relocation works, and just about everything
27
   else is a wild card.  In particular, don't expect shared libs or
28
   dynamic loading to work ...  its never been tested.  */
29
 
30
#include "sysdep.h"
31
#include "bfd.h"
32
#include "bfdlink.h"
33
#include "libbfd.h"
34
#include "elf-bfd.h"
35
#include "elf/i370.h"
36
 
37
static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
38
 
39
static reloc_howto_type i370_elf_howto_raw[] =
40
{
41
  /* This reloc does nothing.  */
42
  HOWTO (R_I370_NONE,           /* type */
43
         0,                      /* rightshift */
44
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
45
         32,                    /* bitsize */
46
         FALSE,                 /* pc_relative */
47
         0,                      /* bitpos */
48
         complain_overflow_bitfield, /* complain_on_overflow */
49
         bfd_elf_generic_reloc, /* special_function */
50
         "R_I370_NONE",         /* name */
51
         FALSE,                 /* partial_inplace */
52
         0,                      /* src_mask */
53
         0,                      /* dst_mask */
54
         FALSE),                /* pcrel_offset */
55
 
56
  /* A standard 31 bit relocation.  */
57
  HOWTO (R_I370_ADDR31,         /* type */
58
         0,                      /* rightshift */
59
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
60
         31,                    /* bitsize */
61
         FALSE,                 /* pc_relative */
62
         0,                      /* bitpos */
63
         complain_overflow_bitfield, /* complain_on_overflow */
64
         bfd_elf_generic_reloc, /* special_function */
65
         "R_I370_ADDR31",       /* name */
66
         FALSE,                 /* partial_inplace */
67
         0,                      /* src_mask */
68
         0x7fffffff,            /* dst_mask */
69
         FALSE),                /* pcrel_offset */
70
 
71
  /* A standard 32 bit relocation.  */
72
  HOWTO (R_I370_ADDR32,         /* type */
73
         0,                      /* rightshift */
74
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
75
         32,                    /* bitsize */
76
         FALSE,                 /* pc_relative */
77
         0,                      /* bitpos */
78
         complain_overflow_bitfield, /* complain_on_overflow */
79
         bfd_elf_generic_reloc, /* special_function */
80
         "R_I370_ADDR32",       /* name */
81
         FALSE,                 /* partial_inplace */
82
         0,                      /* src_mask */
83
         0xffffffff,            /* dst_mask */
84
         FALSE),                /* pcrel_offset */
85
 
86
  /* A standard 16 bit relocation.  */
87
  HOWTO (R_I370_ADDR16,         /* type */
88
         0,                      /* rightshift */
89
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
90
         16,                    /* bitsize */
91
         FALSE,                 /* pc_relative */
92
         0,                      /* bitpos */
93
         complain_overflow_bitfield, /* complain_on_overflow */
94
         bfd_elf_generic_reloc, /* special_function */
95
         "R_I370_ADDR16",       /* name */
96
         FALSE,                 /* partial_inplace */
97
         0,                      /* src_mask */
98
         0xffff,                /* dst_mask */
99
         FALSE),                /* pcrel_offset */
100
 
101
  /* 31-bit PC relative.  */
102
  HOWTO (R_I370_REL31,          /* type */
103
         0,                      /* rightshift */
104
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
105
         31,                    /* bitsize */
106
         TRUE,                  /* pc_relative */
107
         0,                      /* bitpos */
108
         complain_overflow_bitfield, /* complain_on_overflow */
109
         bfd_elf_generic_reloc, /* special_function */
110
         "R_I370_REL31",        /* name */
111
         FALSE,                 /* partial_inplace */
112
         0,                      /* src_mask */
113
         0x7fffffff,            /* dst_mask */
114
         TRUE),                 /* pcrel_offset */
115
 
116
  /* 32-bit PC relative.  */
117
  HOWTO (R_I370_REL32,          /* type */
118
         0,                      /* rightshift */
119
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
120
         32,                    /* bitsize */
121
         TRUE,                  /* pc_relative */
122
         0,                      /* bitpos */
123
         complain_overflow_bitfield, /* complain_on_overflow */
124
         bfd_elf_generic_reloc, /* special_function */
125
         "R_I370_REL32",        /* name */
126
         FALSE,                 /* partial_inplace */
127
         0,                      /* src_mask */
128
         0xffffffff,            /* dst_mask */
129
         TRUE),                 /* pcrel_offset */
130
 
131
  /* A standard 12 bit relocation.  */
132
  HOWTO (R_I370_ADDR12,         /* type */
133
         0,                      /* rightshift */
134
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
135
         12,                    /* bitsize */
136
         FALSE,                 /* pc_relative */
137
         0,                      /* bitpos */
138
         complain_overflow_bitfield, /* complain_on_overflow */
139
         bfd_elf_generic_reloc, /* special_function */
140
         "R_I370_ADDR12",       /* name */
141
         FALSE,                 /* partial_inplace */
142
         0,                      /* src_mask */
143
         0xfff,                 /* dst_mask */
144
         FALSE),                /* pcrel_offset */
145
 
146
  /* 12-bit PC relative.  */
147
  HOWTO (R_I370_REL12,          /* type */
148
         0,                      /* rightshift */
149
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
150
         12,                    /* bitsize */
151
         TRUE,                  /* pc_relative */
152
         0,                      /* bitpos */
153
         complain_overflow_bitfield, /* complain_on_overflow */
154
         bfd_elf_generic_reloc, /* special_function */
155
         "R_I370_REL12",        /* name */
156
         FALSE,                 /* partial_inplace */
157
         0,                      /* src_mask */
158
         0xfff,                 /* dst_mask */
159
         TRUE),                 /* pcrel_offset */
160
 
161
  /* A standard 8 bit relocation.  */
162
  HOWTO (R_I370_ADDR8,          /* type */
163
         0,                      /* rightshift */
164
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
165
         8,                     /* bitsize */
166
         FALSE,                 /* pc_relative */
167
         0,                      /* bitpos */
168
         complain_overflow_bitfield, /* complain_on_overflow */
169
         bfd_elf_generic_reloc, /* special_function */
170
         "R_I370_ADDR8",        /* name */
171
         FALSE,                 /* partial_inplace */
172
         0,                      /* src_mask */
173
         0xff,                  /* dst_mask */
174
         FALSE),                /* pcrel_offset */
175
 
176
  /* 8-bit PC relative.  */
177
  HOWTO (R_I370_REL8,           /* type */
178
         0,                      /* rightshift */
179
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
180
         8,                     /* bitsize */
181
         TRUE,                  /* pc_relative */
182
         0,                      /* bitpos */
183
         complain_overflow_bitfield, /* complain_on_overflow */
184
         bfd_elf_generic_reloc, /* special_function */
185
         "R_I370_REL8",         /* name */
186
         FALSE,                 /* partial_inplace */
187
         0,                      /* src_mask */
188
         0xff,                  /* dst_mask */
189
         TRUE),                 /* pcrel_offset */
190
 
191
  /* This is used only by the dynamic linker.  The symbol should exist
192
     both in the object being run and in some shared library.  The
193
     dynamic linker copies the data addressed by the symbol from the
194
     shared library into the object, because the object being
195
     run has to have the data at some particular address.  */
196
  HOWTO (R_I370_COPY,           /* type */
197
         0,                      /* rightshift */
198
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
199
         32,                    /* bitsize */
200
         FALSE,                 /* pc_relative */
201
         0,                      /* bitpos */
202
         complain_overflow_bitfield, /* complain_on_overflow */
203
         bfd_elf_generic_reloc,  /* special_function */
204
         "R_I370_COPY",         /* name */
205
         FALSE,                 /* partial_inplace */
206
         0,                      /* src_mask */
207
         0,                      /* dst_mask */
208
         FALSE),                /* pcrel_offset */
209
 
210
  /* Used only by the dynamic linker.  When the object is run, this
211
     longword is set to the load address of the object, plus the
212
     addend.  */
213
  HOWTO (R_I370_RELATIVE,       /* type */
214
         0,                      /* rightshift */
215
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
216
         32,                    /* bitsize */
217
         FALSE,                 /* pc_relative */
218
         0,                      /* bitpos */
219
         complain_overflow_bitfield, /* complain_on_overflow */
220
         bfd_elf_generic_reloc,  /* special_function */
221
         "R_I370_RELATIVE",     /* name */
222
         FALSE,                 /* partial_inplace */
223
         0,                      /* src_mask */
224
         0xffffffff,            /* dst_mask */
225
         FALSE),                /* pcrel_offset */
226
 
227
};
228
 
229
/* Initialize the i370_elf_howto_table, so that linear accesses can be done.  */
230
 
231
static void
232
i370_elf_howto_init (void)
233
{
234
  unsigned int i, type;
235
 
236
  for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
237
    {
238
      type = i370_elf_howto_raw[i].type;
239
      BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
240
      i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
241
    }
242
}
243
 
244
static reloc_howto_type *
245
i370_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
246
                            bfd_reloc_code_real_type code)
247
{
248
  enum i370_reloc_type i370_reloc = R_I370_NONE;
249
 
250
  if (!i370_elf_howto_table[ R_I370_ADDR31 ])
251
    /* Initialize howto table if needed.  */
252
    i370_elf_howto_init ();
253
 
254
  switch ((int) code)
255
    {
256
    default:
257
      return NULL;
258
 
259
    case BFD_RELOC_NONE:        i370_reloc = R_I370_NONE;       break;
260
    case BFD_RELOC_32:          i370_reloc = R_I370_ADDR31;     break;
261
    case BFD_RELOC_16:          i370_reloc = R_I370_ADDR16;     break;
262
    case BFD_RELOC_32_PCREL:    i370_reloc = R_I370_REL31;      break;
263
    case BFD_RELOC_CTOR:        i370_reloc = R_I370_ADDR31;     break;
264
    case BFD_RELOC_I370_D12:    i370_reloc = R_I370_ADDR12;     break;
265
    }
266
 
267
  return i370_elf_howto_table[ (int)i370_reloc ];
268
};
269
 
270
static reloc_howto_type *
271
i370_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
272
                            const char *r_name)
273
{
274
  unsigned int i;
275
 
276
  for (i = 0;
277
       i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]);
278
       i++)
279
    if (i370_elf_howto_raw[i].name != NULL
280
        && strcasecmp (i370_elf_howto_raw[i].name, r_name) == 0)
281
      return &i370_elf_howto_raw[i];
282
 
283
  return NULL;
284
}
285
 
286
/* The name of the dynamic interpreter.  This is put in the .interp
287
    section.  */
288
 
289
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
290
 
291
/* Set the howto pointer for an i370 ELF reloc.  */
292
 
293
static void
294
i370_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
295
                        arelent *cache_ptr,
296
                        Elf_Internal_Rela *dst)
297
{
298
  if (!i370_elf_howto_table[ R_I370_ADDR31 ])
299
    /* Initialize howto table.  */
300
    i370_elf_howto_init ();
301
 
302
  BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
303
  cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
304
}
305
 
306
/* Hack alert --  the following several routines look generic to me ...
307
   why are we bothering with them ?  */
308
/* Function to set whether a module needs the -mrelocatable bit set.  */
309
 
310
static bfd_boolean
311
i370_elf_set_private_flags (bfd *abfd, flagword flags)
312
{
313
  BFD_ASSERT (!elf_flags_init (abfd)
314
              || elf_elfheader (abfd)->e_flags == flags);
315
 
316
  elf_elfheader (abfd)->e_flags = flags;
317
  elf_flags_init (abfd) = TRUE;
318
  return TRUE;
319
}
320
 
321
/* Merge backend specific data from an object file to the output
322
   object file when linking.  */
323
 
324
static bfd_boolean
325
i370_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
326
{
327
  flagword old_flags;
328
  flagword new_flags;
329
 
330
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
331
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
332
    return TRUE;
333
 
334
  new_flags = elf_elfheader (ibfd)->e_flags;
335
  old_flags = elf_elfheader (obfd)->e_flags;
336
  if (!elf_flags_init (obfd))   /* First call, no flags set.  */
337
    {
338
      elf_flags_init (obfd) = TRUE;
339
      elf_elfheader (obfd)->e_flags = new_flags;
340
    }
341
 
342
  else if (new_flags == old_flags)      /* Compatible flags are ok.  */
343
    ;
344
 
345
  else                                  /* Incompatible flags.  */
346
    {
347
      (*_bfd_error_handler)
348
        ("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
349
         ibfd, (long) new_flags, (long) old_flags);
350
 
351
      bfd_set_error (bfd_error_bad_value);
352
      return FALSE;
353
    }
354
 
355
  return TRUE;
356
}
357
 
358
/* Handle an i370 specific section when reading an object file.  This
359
   is called when elfcode.h finds a section with an unknown type.  */
360
/* XXX hack alert bogus This routine is mostly all junk and almost
361
   certainly does the wrong thing.  Its here simply because it does
362
   just enough to allow glibc-2.1 ld.so to compile & link.  */
363
 
364
static bfd_boolean
365
i370_elf_section_from_shdr (bfd *abfd,
366
                            Elf_Internal_Shdr *hdr,
367
                            const char *name,
368
                            int shindex)
369
{
370
  asection *newsect;
371
  flagword flags;
372
 
373
  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
374
    return FALSE;
375
 
376
  newsect = hdr->bfd_section;
377
  flags = bfd_get_section_flags (abfd, newsect);
378
  if (hdr->sh_flags & SHF_EXCLUDE)
379
    flags |= SEC_EXCLUDE;
380
 
381
  if (hdr->sh_type == SHT_ORDERED)
382
    flags |= SEC_SORT_ENTRIES;
383
 
384
  bfd_set_section_flags (abfd, newsect, flags);
385
  return TRUE;
386
}
387
 
388
/* Set up any other section flags and such that may be necessary.  */
389
/* XXX hack alert bogus This routine is mostly all junk and almost
390
   certainly does the wrong thing.  Its here simply because it does
391
   just enough to allow glibc-2.1 ld.so to compile & link.  */
392
 
393
static bfd_boolean
394
i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
395
                        Elf_Internal_Shdr *shdr,
396
                        asection *asect)
397
{
398
  if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
399
    shdr->sh_flags |= SHF_EXCLUDE;
400
 
401
  if ((asect->flags & SEC_SORT_ENTRIES) != 0)
402
    shdr->sh_type = SHT_ORDERED;
403
 
404
  return TRUE;
405
}
406
 
407
/* We have to create .dynsbss and .rela.sbss here so that they get mapped
408
   to output sections (just like _bfd_elf_create_dynamic_sections has
409
   to create .dynbss and .rela.bss).  */
410
/* XXX hack alert bogus This routine is mostly all junk and almost
411
   certainly does the wrong thing.  Its here simply because it does
412
   just enough to allow glibc-2.1 ld.so to compile & link.  */
413
 
414
static bfd_boolean
415
i370_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
416
{
417
  asection *s;
418
  flagword flags;
419
 
420
  if (!_bfd_elf_create_dynamic_sections(abfd, info))
421
    return FALSE;
422
 
423
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
424
           | SEC_LINKER_CREATED);
425
 
426
  s = bfd_make_section_with_flags (abfd, ".dynsbss",
427
                                   SEC_ALLOC | SEC_LINKER_CREATED);
428
  if (s == NULL)
429
    return FALSE;
430
 
431
  if (! info->shared)
432
    {
433
      s = bfd_make_section_with_flags (abfd, ".rela.sbss",
434
                                       flags | SEC_READONLY);
435
      if (s == NULL
436
          || ! bfd_set_section_alignment (abfd, s, 2))
437
        return FALSE;
438
    }
439
 
440
   /* XXX beats me, seem to need a rela.text ...  */
441
   s = bfd_make_section_with_flags (abfd, ".rela.text",
442
                                    flags | SEC_READONLY);
443
   if (s == NULL
444
      || ! bfd_set_section_alignment (abfd, s, 2))
445
    return FALSE;
446
  return TRUE;
447
}
448
 
449
/* Adjust a symbol defined by a dynamic object and referenced by a
450
   regular object.  The current definition is in some section of the
451
   dynamic object, but we're not including those sections.  We have to
452
   change the definition to something the rest of the link can
453
   understand.  */
454
/* XXX hack alert bogus This routine is mostly all junk and almost
455
   certainly does the wrong thing.  Its here simply because it does
456
   just enough to allow glibc-2.1 ld.so to compile & link.  */
457
 
458
static bfd_boolean
459
i370_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
460
                                struct elf_link_hash_entry *h)
461
{
462
  bfd *dynobj = elf_hash_table (info)->dynobj;
463
  asection *s;
464
 
465
#ifdef DEBUG
466
  fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
467
           h->root.root.string);
468
#endif
469
 
470
  /* Make sure we know what is going on here.  */
471
  BFD_ASSERT (dynobj != NULL
472
              && (h->needs_plt
473
                  || h->u.weakdef != NULL
474
                  || (h->def_dynamic
475
                      && h->ref_regular
476
                      && !h->def_regular)));
477
 
478
  s = bfd_get_section_by_name (dynobj, ".rela.text");
479
  BFD_ASSERT (s != NULL);
480
  s->size += sizeof (Elf32_External_Rela);
481
 
482
  /* If this is a weak symbol, and there is a real definition, the
483
     processor independent code will have arranged for us to see the
484
     real definition first, and we can just use the same value.  */
485
  if (h->u.weakdef != NULL)
486
    {
487
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
488
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
489
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
490
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
491
      return TRUE;
492
    }
493
 
494
  /* This is a reference to a symbol defined by a dynamic object which
495
     is not a function.  */
496
 
497
  /* If we are creating a shared library, we must presume that the
498
     only references to the symbol are via the global offset table.
499
     For such cases we need not do anything here; the relocations will
500
     be handled correctly by relocate_section.  */
501
  if (info->shared)
502
    return TRUE;
503
 
504
  if (h->size == 0)
505
    {
506
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
507
                             h->root.root.string);
508
      return TRUE;
509
    }
510
 
511
  /* We must allocate the symbol in our .dynbss section, which will
512
     become part of the .bss section of the executable.  There will be
513
     an entry for this symbol in the .dynsym section.  The dynamic
514
     object will contain position independent code, so all references
515
     from the dynamic object to this symbol will go through the global
516
     offset table.  The dynamic linker will use the .dynsym entry to
517
     determine the address it must put in the global offset table, so
518
     both the dynamic object and the regular object will refer to the
519
     same memory location for the variable.
520
 
521
     Of course, if the symbol is sufficiently small, we must instead
522
     allocate it in .sbss.  FIXME: It would be better to do this if and
523
     only if there were actually SDAREL relocs for that symbol.  */
524
 
525
  if (h->size <= elf_gp_size (dynobj))
526
    s = bfd_get_section_by_name (dynobj, ".dynsbss");
527
  else
528
    s = bfd_get_section_by_name (dynobj, ".dynbss");
529
  BFD_ASSERT (s != NULL);
530
 
531
  /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
532
     copy the initial value out of the dynamic object and into the
533
     runtime process image.  We need to remember the offset into the
534
     .rela.bss section we are going to use.  */
535
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
536
    {
537
      asection *srel;
538
 
539
      if (h->size <= elf_gp_size (dynobj))
540
        srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
541
      else
542
        srel = bfd_get_section_by_name (dynobj, ".rela.bss");
543
      BFD_ASSERT (srel != NULL);
544
      srel->size += sizeof (Elf32_External_Rela);
545
      h->needs_copy = 1;
546
    }
547
 
548
  return _bfd_elf_adjust_dynamic_copy (h, s);
549
}
550
 
551
/* Increment the index of a dynamic symbol by a given amount.  Called
552
   via elf_link_hash_traverse.  */
553
/* XXX hack alert bogus This routine is mostly all junk and almost
554
   certainly does the wrong thing.  Its here simply because it does
555
   just enough to allow glibc-2.1 ld.so to compile & link.  */
556
 
557
static bfd_boolean
558
i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg)
559
{
560
  int *cp = (int *) cparg;
561
 
562
#ifdef DEBUG
563
  fprintf (stderr,
564
           "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
565
           h->dynindx, *cp);
566
#endif
567
 
568
  if (h->root.type == bfd_link_hash_warning)
569
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
570
 
571
  if (h->dynindx != -1)
572
    h->dynindx += *cp;
573
 
574
  return TRUE;
575
}
576
 
577
/* Set the sizes of the dynamic sections.  */
578
/* XXX hack alert bogus This routine is mostly all junk and almost
579
   certainly does the wrong thing.  Its here simply because it does
580
   just enough to allow glibc-2.1 ld.so to compile & link.  */
581
 
582
static bfd_boolean
583
i370_elf_size_dynamic_sections (bfd *output_bfd,
584
                                struct bfd_link_info *info)
585
{
586
  bfd *dynobj;
587
  asection *s;
588
  bfd_boolean plt;
589
  bfd_boolean relocs;
590
  bfd_boolean reltext;
591
 
592
#ifdef DEBUG
593
  fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
594
#endif
595
 
596
  dynobj = elf_hash_table (info)->dynobj;
597
  BFD_ASSERT (dynobj != NULL);
598
 
599
  if (elf_hash_table (info)->dynamic_sections_created)
600
    {
601
      /* Set the contents of the .interp section to the interpreter.  */
602
      if (info->executable)
603
        {
604
          s = bfd_get_section_by_name (dynobj, ".interp");
605
          BFD_ASSERT (s != NULL);
606
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
607
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
608
        }
609
    }
610
  else
611
    {
612
      /* We may have created entries in the .rela.got, .rela.sdata, and
613
         .rela.sdata2 sections.  However, if we are not creating the
614
         dynamic sections, we will not actually use these entries.  Reset
615
         the size of .rela.got, et al, which will cause it to get
616
         stripped from the output file below.  */
617
      static char *rela_sections[] = { ".rela.got", ".rela.sdata",
618
                                       ".rela.sdata2", ".rela.sbss",
619
                                       NULL };
620
      char **p;
621
 
622
      for (p = rela_sections; *p != NULL; p++)
623
        {
624
          s = bfd_get_section_by_name (dynobj, *p);
625
          if (s != NULL)
626
            s->size = 0;
627
        }
628
    }
629
 
630
  /* The check_relocs and adjust_dynamic_symbol entry points have
631
     determined the sizes of the various dynamic sections.  Allocate
632
     memory for them.  */
633
  plt = FALSE;
634
  relocs = FALSE;
635
  reltext = FALSE;
636
  for (s = dynobj->sections; s != NULL; s = s->next)
637
    {
638
      const char *name;
639
 
640
      if ((s->flags & SEC_LINKER_CREATED) == 0)
641
        continue;
642
 
643
      /* It's OK to base decisions on the section name, because none
644
         of the dynobj section names depend upon the input files.  */
645
      name = bfd_get_section_name (dynobj, s);
646
 
647
      if (strcmp (name, ".plt") == 0)
648
        {
649
          /* Remember whether there is a PLT.  */
650
          plt = s->size != 0;
651
        }
652
      else if (CONST_STRNEQ (name, ".rela"))
653
        {
654
          if (s->size != 0)
655
            {
656
              asection *target;
657
              const char *outname;
658
 
659
              /* Remember whether there are any relocation sections.  */
660
              relocs = TRUE;
661
 
662
              /* If this relocation section applies to a read only
663
                 section, then we probably need a DT_TEXTREL entry.  */
664
              outname = bfd_get_section_name (output_bfd,
665
                                              s->output_section);
666
              target = bfd_get_section_by_name (output_bfd, outname + 5);
667
              if (target != NULL
668
                  && (target->flags & SEC_READONLY) != 0
669
                  && (target->flags & SEC_ALLOC) != 0)
670
                reltext = TRUE;
671
 
672
              /* We use the reloc_count field as a counter if we need
673
                 to copy relocs into the output file.  */
674
              s->reloc_count = 0;
675
            }
676
        }
677
      else if (strcmp (name, ".got") != 0
678
               && strcmp (name, ".sdata") != 0
679
               && strcmp (name, ".sdata2") != 0
680
               && strcmp (name, ".dynbss") != 0
681
               && strcmp (name, ".dynsbss") != 0)
682
        {
683
          /* It's not one of our sections, so don't allocate space.  */
684
          continue;
685
        }
686
 
687
      if (s->size == 0)
688
        {
689
          /* If we don't need this section, strip it from the
690
             output file.  This is mostly to handle .rela.bss and
691
             .rela.plt.  We must create both sections in
692
             create_dynamic_sections, because they must be created
693
             before the linker maps input sections to output
694
             sections.  The linker does that before
695
             adjust_dynamic_symbol is called, and it is that
696
             function which decides whether anything needs to go
697
             into these sections.  */
698
          s->flags |= SEC_EXCLUDE;
699
          continue;
700
        }
701
 
702
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
703
        continue;
704
 
705
      /* Allocate memory for the section contents.  */
706
      s->contents = bfd_zalloc (dynobj, s->size);
707
      if (s->contents == NULL)
708
        return FALSE;
709
    }
710
 
711
  if (elf_hash_table (info)->dynamic_sections_created)
712
    {
713
      /* Add some entries to the .dynamic section.  We fill in the
714
         values later, in i370_elf_finish_dynamic_sections, but we
715
         must add the entries now so that we get the correct size for
716
         the .dynamic section.  The DT_DEBUG entry is filled in by the
717
         dynamic linker and used by the debugger.  */
718
#define add_dynamic_entry(TAG, VAL) \
719
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
720
 
721
      if (!info->shared)
722
        {
723
          if (!add_dynamic_entry (DT_DEBUG, 0))
724
            return FALSE;
725
        }
726
 
727
      if (plt)
728
        {
729
          if (!add_dynamic_entry (DT_PLTGOT, 0)
730
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
731
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
732
              || !add_dynamic_entry (DT_JMPREL, 0))
733
            return FALSE;
734
        }
735
 
736
      if (relocs)
737
        {
738
          if (!add_dynamic_entry (DT_RELA, 0)
739
              || !add_dynamic_entry (DT_RELASZ, 0)
740
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
741
            return FALSE;
742
        }
743
 
744
      if (reltext)
745
        {
746
          if (!add_dynamic_entry (DT_TEXTREL, 0))
747
            return FALSE;
748
          info->flags |= DF_TEXTREL;
749
        }
750
    }
751
#undef add_dynamic_entry
752
 
753
  /* If we are generating a shared library, we generate a section
754
     symbol for each output section.  These are local symbols, which
755
     means that they must come first in the dynamic symbol table.
756
     That means we must increment the dynamic symbol index of every
757
     other dynamic symbol.
758
 
759
     FIXME: We assume that there will never be relocations to
760
     locations in linker-created sections that do not have
761
     externally-visible names. Instead, we should work out precisely
762
     which sections relocations are targeted at.  */
763
  if (info->shared)
764
    {
765
      int c;
766
 
767
      for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
768
        {
769
          if ((s->flags & SEC_LINKER_CREATED) != 0
770
              || (s->flags & SEC_ALLOC) == 0)
771
            {
772
              elf_section_data (s)->dynindx = -1;
773
              continue;
774
            }
775
 
776
          /* These symbols will have no names, so we don't need to
777
             fiddle with dynstr_index.  */
778
 
779
          elf_section_data (s)->dynindx = c + 1;
780
 
781
          c++;
782
        }
783
 
784
      elf_link_hash_traverse (elf_hash_table (info),
785
                              i370_elf_adjust_dynindx, & c);
786
      elf_hash_table (info)->dynsymcount += c;
787
    }
788
 
789
  return TRUE;
790
}
791
 
792
/* Look through the relocs for a section during the first phase, and
793
   allocate space in the global offset table or procedure linkage
794
   table.  */
795
/* XXX hack alert bogus This routine is mostly all junk and almost
796
   certainly does the wrong thing.  Its here simply because it does
797
   just enough to allow glibc-2.1 ld.so to compile & link.  */
798
 
799
static bfd_boolean
800
i370_elf_check_relocs (bfd *abfd,
801
                       struct bfd_link_info *info,
802
                       asection *sec,
803
                       const Elf_Internal_Rela *relocs)
804
{
805
  bfd *dynobj;
806
  Elf_Internal_Shdr *symtab_hdr;
807
  struct elf_link_hash_entry **sym_hashes;
808
  const Elf_Internal_Rela *rel;
809
  const Elf_Internal_Rela *rel_end;
810
  bfd_vma *local_got_offsets;
811
  asection *sreloc;
812
 
813
  if (info->relocatable)
814
    return TRUE;
815
 
816
#ifdef DEBUG
817
  _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
818
                      sec, abfd);
819
#endif
820
 
821
  dynobj = elf_hash_table (info)->dynobj;
822
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
823
  sym_hashes = elf_sym_hashes (abfd);
824
  local_got_offsets = elf_local_got_offsets (abfd);
825
 
826
  sreloc = NULL;
827
 
828
  rel_end = relocs + sec->reloc_count;
829
  for (rel = relocs; rel < rel_end; rel++)
830
    {
831
      unsigned long r_symndx;
832
      struct elf_link_hash_entry *h;
833
 
834
      r_symndx = ELF32_R_SYM (rel->r_info);
835
      if (r_symndx < symtab_hdr->sh_info)
836
        h = NULL;
837
      else
838
        {
839
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
840
          while (h->root.type == bfd_link_hash_indirect
841
                 || h->root.type == bfd_link_hash_warning)
842
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
843
        }
844
 
845
      if (info->shared)
846
        {
847
#ifdef DEBUG
848
          fprintf (stderr,
849
                   "i370_elf_check_relocs needs to create relocation for %s\n",
850
                   (h && h->root.root.string)
851
                   ? h->root.root.string : "<unknown>");
852
#endif
853
          if (sreloc == NULL)
854
            {
855
              const char *name;
856
 
857
              name = (bfd_elf_string_from_elf_section
858
                      (abfd,
859
                       elf_elfheader (abfd)->e_shstrndx,
860
                       elf_section_data (sec)->rel_hdr.sh_name));
861
              if (name == NULL)
862
                return FALSE;
863
 
864
              BFD_ASSERT (CONST_STRNEQ (name, ".rela")
865
                          && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);
866
 
867
              sreloc = bfd_get_section_by_name (dynobj, name);
868
              if (sreloc == NULL)
869
                {
870
                  flagword flags;
871
 
872
                  flags = (SEC_HAS_CONTENTS | SEC_READONLY
873
                           | SEC_IN_MEMORY | SEC_LINKER_CREATED);
874
                  if ((sec->flags & SEC_ALLOC) != 0)
875
                    flags |= SEC_ALLOC | SEC_LOAD;
876
                  sreloc = bfd_make_section_with_flags (dynobj, name,
877
                                                        flags);
878
                  if (sreloc == NULL
879
                      || ! bfd_set_section_alignment (dynobj, sreloc, 2))
880
                    return FALSE;
881
                }
882
            }
883
 
884
          sreloc->size += sizeof (Elf32_External_Rela);
885
 
886
          /* FIXME: We should here do what the m68k and i386
887
             backends do: if the reloc is pc-relative, record it
888
             in case it turns out that the reloc is unnecessary
889
             because the symbol is forced local by versioning or
890
             we are linking with -Bdynamic.  Fortunately this
891
             case is not frequent.  */
892
        }
893
    }
894
 
895
  return TRUE;
896
}
897
 
898
/* Finish up the dynamic sections.  */
899
/* XXX hack alert bogus This routine is mostly all junk and almost
900
   certainly does the wrong thing.  Its here simply because it does
901
   just enough to allow glibc-2.1 ld.so to compile & link.  */
902
 
903
static bfd_boolean
904
i370_elf_finish_dynamic_sections (bfd *output_bfd,
905
                                  struct bfd_link_info *info)
906
{
907
  asection *sdyn;
908
  bfd *dynobj = elf_hash_table (info)->dynobj;
909
  asection *sgot = bfd_get_section_by_name (dynobj, ".got");
910
 
911
#ifdef DEBUG
912
  fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
913
#endif
914
 
915
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
916
 
917
  if (elf_hash_table (info)->dynamic_sections_created)
918
    {
919
      asection *splt;
920
      Elf32_External_Dyn *dyncon, *dynconend;
921
 
922
      splt = bfd_get_section_by_name (dynobj, ".plt");
923
      BFD_ASSERT (splt != NULL && sdyn != NULL);
924
 
925
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
926
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
927
      for (; dyncon < dynconend; dyncon++)
928
        {
929
          Elf_Internal_Dyn dyn;
930
          const char *name;
931
          bfd_boolean size;
932
 
933
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
934
 
935
          switch (dyn.d_tag)
936
            {
937
            case DT_PLTGOT:   name = ".plt";      size = FALSE; break;
938
            case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE;  break;
939
            case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
940
            default:          name = NULL;        size = FALSE; break;
941
            }
942
 
943
          if (name != NULL)
944
            {
945
              asection *s;
946
 
947
              s = bfd_get_section_by_name (output_bfd, name);
948
              if (s == NULL)
949
                dyn.d_un.d_val = 0;
950
              else
951
                {
952
                  if (! size)
953
                    dyn.d_un.d_ptr = s->vma;
954
                  else
955
                    dyn.d_un.d_val = s->size;
956
                }
957
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
958
            }
959
        }
960
    }
961
 
962
  if (sgot && sgot->size != 0)
963
    {
964
      unsigned char *contents = sgot->contents;
965
 
966
      if (sdyn == NULL)
967
        bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
968
      else
969
        bfd_put_32 (output_bfd,
970
                    sdyn->output_section->vma + sdyn->output_offset,
971
                    contents);
972
 
973
      elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
974
    }
975
 
976
  if (info->shared)
977
    {
978
      asection *sdynsym;
979
      asection *s;
980
      Elf_Internal_Sym sym;
981
      int maxdindx = 0;
982
 
983
      /* Set up the section symbols for the output sections.  */
984
 
985
      sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
986
      BFD_ASSERT (sdynsym != NULL);
987
 
988
      sym.st_size = 0;
989
      sym.st_name = 0;
990
      sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
991
      sym.st_other = 0;
992
 
993
      for (s = output_bfd->sections; s != NULL; s = s->next)
994
        {
995
          int indx, dindx;
996
          Elf32_External_Sym *esym;
997
 
998
          sym.st_value = s->vma;
999
 
1000
          indx = elf_section_data (s)->this_idx;
1001
          dindx = elf_section_data (s)->dynindx;
1002
          if (dindx != -1)
1003
            {
1004
              BFD_ASSERT(indx > 0);
1005
              BFD_ASSERT(dindx > 0);
1006
 
1007
              if (dindx > maxdindx)
1008
                maxdindx = dindx;
1009
 
1010
              sym.st_shndx = indx;
1011
 
1012
              esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
1013
              bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
1014
            }
1015
        }
1016
 
1017
      /* Set the sh_info field of the output .dynsym section to the
1018
         index of the first global symbol.  */
1019
      elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1020
        maxdindx + 1;
1021
    }
1022
 
1023
  return TRUE;
1024
}
1025
 
1026
/* The RELOCATE_SECTION function is called by the ELF backend linker
1027
   to handle the relocations for a section.
1028
 
1029
   The relocs are always passed as Rela structures; if the section
1030
   actually uses Rel structures, the r_addend field will always be
1031
   zero.
1032
 
1033
   This function is responsible for adjust the section contents as
1034
   necessary, and (if using Rela relocs and generating a
1035
   relocatable output file) adjusting the reloc addend as
1036
   necessary.
1037
 
1038
   This function does not have to worry about setting the reloc
1039
   address or the reloc symbol index.
1040
 
1041
   LOCAL_SYMS is a pointer to the swapped in local symbols.
1042
 
1043
   LOCAL_SECTIONS is an array giving the section in the input file
1044
   corresponding to the st_shndx field of each local symbol.
1045
 
1046
   The global hash table entry for the global symbols can be found
1047
   via elf_sym_hashes (input_bfd).
1048
 
1049
   When generating relocatable output, this function must handle
1050
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1051
   going to be the section symbol corresponding to the output
1052
   section, which means that the addend must be adjusted
1053
   accordingly.  */
1054
 
1055
static bfd_boolean
1056
i370_elf_relocate_section (bfd *output_bfd,
1057
                           struct bfd_link_info *info,
1058
                           bfd *input_bfd,
1059
                           asection *input_section,
1060
                           bfd_byte *contents,
1061
                           Elf_Internal_Rela *relocs,
1062
                           Elf_Internal_Sym *local_syms,
1063
                           asection **local_sections)
1064
{
1065
  Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1066
  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1067
  bfd *dynobj = elf_hash_table (info)->dynobj;
1068
  Elf_Internal_Rela *rel = relocs;
1069
  Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1070
  asection *sreloc = NULL;
1071
  bfd_vma *local_got_offsets;
1072
  bfd_boolean ret = TRUE;
1073
 
1074
#ifdef DEBUG
1075
  _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1076
                      input_bfd, input_section,
1077
                      (long) input_section->reloc_count,
1078
                      (info->relocatable) ? " (relocatable)" : "");
1079
#endif
1080
 
1081
  if (!i370_elf_howto_table[ R_I370_ADDR31 ])
1082
    /* Initialize howto table if needed.  */
1083
    i370_elf_howto_init ();
1084
 
1085
  local_got_offsets = elf_local_got_offsets (input_bfd);
1086
 
1087
  for (; rel < relend; rel++)
1088
    {
1089
      enum i370_reloc_type r_type    = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
1090
      bfd_vma offset                 = rel->r_offset;
1091
      bfd_vma addend                 = rel->r_addend;
1092
      bfd_reloc_status_type r        = bfd_reloc_other;
1093
      Elf_Internal_Sym *sym          = NULL;
1094
      asection *sec                  = NULL;
1095
      struct elf_link_hash_entry * h = NULL;
1096
      const char *sym_name           = NULL;
1097
      reloc_howto_type *howto;
1098
      unsigned long r_symndx;
1099
      bfd_vma relocation;
1100
 
1101
      /* Unknown relocation handling.  */
1102
      if ((unsigned) r_type >= (unsigned) R_I370_max
1103
          || !i370_elf_howto_table[(int)r_type])
1104
        {
1105
          (*_bfd_error_handler) ("%B: unknown relocation type %d",
1106
                                 input_bfd,
1107
                                 (int) r_type);
1108
 
1109
          bfd_set_error (bfd_error_bad_value);
1110
          ret = FALSE;
1111
          continue;
1112
        }
1113
 
1114
      howto = i370_elf_howto_table[(int) r_type];
1115
      r_symndx = ELF32_R_SYM (rel->r_info);
1116
      relocation = 0;
1117
 
1118
      if (r_symndx < symtab_hdr->sh_info)
1119
        {
1120
          sym = local_syms + r_symndx;
1121
          sec = local_sections[r_symndx];
1122
          sym_name = "<local symbol>";
1123
 
1124
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
1125
          addend = rel->r_addend;
1126
        }
1127
      else
1128
        {
1129
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1130
          while (h->root.type == bfd_link_hash_indirect
1131
                 || h->root.type == bfd_link_hash_warning)
1132
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1133
          sym_name = h->root.root.string;
1134
          if (h->root.type == bfd_link_hash_defined
1135
              || h->root.type == bfd_link_hash_defweak)
1136
            {
1137
              sec = h->root.u.def.section;
1138
              if (info->shared
1139
                  && ((! info->symbolic && h->dynindx != -1)
1140
                      || !h->def_regular)
1141
                  && (input_section->flags & SEC_ALLOC) != 0
1142
                  && (r_type == R_I370_ADDR31
1143
                      || r_type == R_I370_COPY
1144
                      || r_type == R_I370_ADDR16
1145
                      || r_type == R_I370_RELATIVE))
1146
                /* In these cases, we don't need the relocation
1147
                   value.  We check specially because in some
1148
                   obscure cases sec->output_section will be NULL.  */
1149
                ;
1150
              else
1151
                relocation = (h->root.u.def.value
1152
                              + sec->output_section->vma
1153
                              + sec->output_offset);
1154
            }
1155
          else if (h->root.type == bfd_link_hash_undefweak)
1156
            ;
1157
          else if (info->unresolved_syms_in_objects == RM_IGNORE
1158
                   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1159
            ;
1160
          else if (!info->relocatable)
1161
            {
1162
              if ((*info->callbacks->undefined_symbol)
1163
                  (info, h->root.root.string, input_bfd,
1164
                   input_section, rel->r_offset,
1165
                   (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1166
                    || ELF_ST_VISIBILITY (h->other))))
1167
                {
1168
                  ret = FALSE;
1169
                  continue;
1170
                }
1171
            }
1172
        }
1173
 
1174
      if (sec != NULL && elf_discarded_section (sec))
1175
        {
1176
          /* For relocs against symbols from removed linkonce sections,
1177
             or sections discarded by a linker script, we just want the
1178
             section contents zeroed.  Avoid any special processing.  */
1179
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1180
          rel->r_info = 0;
1181
          rel->r_addend = 0;
1182
          continue;
1183
        }
1184
 
1185
      if (info->relocatable)
1186
        continue;
1187
 
1188
      switch ((int) r_type)
1189
        {
1190
        default:
1191
          (*_bfd_error_handler)
1192
            ("%B: unknown relocation type %d for symbol %s",
1193
             input_bfd, (int) r_type, sym_name);
1194
 
1195
          bfd_set_error (bfd_error_bad_value);
1196
          ret = FALSE;
1197
          continue;
1198
 
1199
        case (int) R_I370_NONE:
1200
          continue;
1201
 
1202
        /* Relocations that may need to be propagated if this is a shared
1203
           object.  */
1204
        case (int) R_I370_REL31:
1205
          /* If these relocations are not to a named symbol, they can be
1206
             handled right here, no need to bother the dynamic linker.  */
1207
          if (h == NULL
1208
              || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1209
            break;
1210
        /* Fall through.  */
1211
 
1212
        /* Relocations that always need to be propagated if this is a shared
1213
           object.  */
1214
        case (int) R_I370_ADDR31:
1215
        case (int) R_I370_ADDR16:
1216
          if (info->shared
1217
              && r_symndx != 0)
1218
            {
1219
              Elf_Internal_Rela outrel;
1220
              bfd_byte *loc;
1221
              int skip;
1222
 
1223
#ifdef DEBUG
1224
              fprintf (stderr,
1225
                       "i370_elf_relocate_section needs to create relocation for %s\n",
1226
                       (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1227
#endif
1228
 
1229
              /* When generating a shared object, these relocations
1230
                 are copied into the output file to be resolved at run
1231
                 time.  */
1232
 
1233
              if (sreloc == NULL)
1234
                {
1235
                  const char *name;
1236
 
1237
                  name = (bfd_elf_string_from_elf_section
1238
                          (input_bfd,
1239
                           elf_elfheader (input_bfd)->e_shstrndx,
1240
                           elf_section_data (input_section)->rel_hdr.sh_name));
1241
                  if (name == NULL)
1242
                    return FALSE;
1243
 
1244
                  BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1245
                              && strcmp (bfd_get_section_name (input_bfd,
1246
                                                               input_section),
1247
                                         name + 5) == 0);
1248
 
1249
                  sreloc = bfd_get_section_by_name (dynobj, name);
1250
                  BFD_ASSERT (sreloc != NULL);
1251
                }
1252
 
1253
              skip = 0;
1254
 
1255
              outrel.r_offset =
1256
                _bfd_elf_section_offset (output_bfd, info, input_section,
1257
                                         rel->r_offset);
1258
              if (outrel.r_offset == (bfd_vma) -1
1259
                  || outrel.r_offset == (bfd_vma) -2)
1260
                skip = (int) outrel.r_offset;
1261
              outrel.r_offset += (input_section->output_section->vma
1262
                                  + input_section->output_offset);
1263
 
1264
              if (skip)
1265
                memset (&outrel, 0, sizeof outrel);
1266
              /* h->dynindx may be -1 if this symbol was marked to
1267
                 become local.  */
1268
              else if (h != NULL
1269
                       && ((! info->symbolic && h->dynindx != -1)
1270
                           || !h->def_regular))
1271
                {
1272
                  BFD_ASSERT (h->dynindx != -1);
1273
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1274
                  outrel.r_addend = rel->r_addend;
1275
                }
1276
              else
1277
                {
1278
                  if (r_type == R_I370_ADDR31)
1279
                    {
1280
                      outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1281
                      outrel.r_addend = relocation + rel->r_addend;
1282
                    }
1283
                  else
1284
                    {
1285
                      long indx;
1286
 
1287
                      if (bfd_is_abs_section (sec))
1288
                        indx = 0;
1289
                      else if (sec == NULL || sec->owner == NULL)
1290
                        {
1291
                          bfd_set_error (bfd_error_bad_value);
1292
                          return FALSE;
1293
                        }
1294
                      else
1295
                        {
1296
                          asection *osec;
1297
 
1298
                          /* We are turning this relocation into one
1299
                             against a section symbol.  It would be
1300
                             proper to subtract the symbol's value,
1301
                             osec->vma, from the emitted reloc addend,
1302
                             but ld.so expects buggy relocs.  */
1303
                          osec = sec->output_section;
1304
                          indx = elf_section_data (osec)->dynindx;
1305
                          if (indx == 0)
1306
                            {
1307
                              struct elf_link_hash_table *htab;
1308
                              htab = elf_hash_table (info);
1309
                              osec = htab->text_index_section;
1310
                              indx = elf_section_data (osec)->dynindx;
1311
                            }
1312
                          BFD_ASSERT (indx != 0);
1313
#ifdef DEBUG
1314
                          if (indx <= 0)
1315
                            {
1316
                              printf ("indx=%ld section=%s flags=%08x name=%s\n",
1317
                                      indx, osec->name, osec->flags,
1318
                                      h->root.root.string);
1319
                            }
1320
#endif
1321
                        }
1322
 
1323
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
1324
                      outrel.r_addend = relocation + rel->r_addend;
1325
                    }
1326
                }
1327
 
1328
              loc = sreloc->contents;
1329
              loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1330
              bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1331
 
1332
              /* This reloc will be computed at runtime, so there's no
1333
                 need to do anything now, unless this is a RELATIVE
1334
                 reloc in an unallocated section.  */
1335
              if (skip == -1
1336
                  || (input_section->flags & SEC_ALLOC) != 0
1337
                  || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1338
                continue;
1339
            }
1340
          break;
1341
 
1342
        case (int) R_I370_COPY:
1343
        case (int) R_I370_RELATIVE:
1344
          (*_bfd_error_handler)
1345
            ("%B: Relocation %s is not yet supported for symbol %s.",
1346
             input_bfd,
1347
             i370_elf_howto_table[(int) r_type]->name,
1348
             sym_name);
1349
 
1350
          bfd_set_error (bfd_error_invalid_operation);
1351
          ret = FALSE;
1352
          continue;
1353
        }
1354
 
1355
#ifdef DEBUG
1356
      fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1357
               howto->name,
1358
               (int)r_type,
1359
               sym_name,
1360
               r_symndx,
1361
               (long) offset,
1362
               (long) addend);
1363
#endif
1364
 
1365
      r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1366
                                    offset, relocation, addend);
1367
 
1368
      if (r != bfd_reloc_ok)
1369
        {
1370
          ret = FALSE;
1371
          switch (r)
1372
            {
1373
            default:
1374
              break;
1375
 
1376
            case bfd_reloc_overflow:
1377
              {
1378
                const char *name;
1379
 
1380
                if (h != NULL)
1381
                  name = NULL;
1382
                else
1383
                  {
1384
                    name = bfd_elf_string_from_elf_section (input_bfd,
1385
                                                            symtab_hdr->sh_link,
1386
                                                            sym->st_name);
1387
                    if (name == NULL)
1388
                      break;
1389
 
1390
                    if (*name == '\0')
1391
                      name = bfd_section_name (input_bfd, sec);
1392
                  }
1393
 
1394
                (*info->callbacks->reloc_overflow) (info,
1395
                                                    (h ? &h->root : NULL),
1396
                                                    name,
1397
                                                    howto->name,
1398
                                                    (bfd_vma) 0,
1399
                                                    input_bfd,
1400
                                                    input_section,
1401
                                                    offset);
1402
              }
1403
              break;
1404
            }
1405
        }
1406
    }
1407
 
1408
#ifdef DEBUG
1409
  fprintf (stderr, "\n");
1410
#endif
1411
 
1412
  return ret;
1413
}
1414
 
1415
#define TARGET_BIG_SYM          bfd_elf32_i370_vec
1416
#define TARGET_BIG_NAME         "elf32-i370"
1417
#define ELF_ARCH                bfd_arch_i370
1418
#define ELF_MACHINE_CODE        EM_S370
1419
#ifdef EM_I370_OLD
1420
#define ELF_MACHINE_ALT1        EM_I370_OLD
1421
#endif
1422
#define ELF_MAXPAGESIZE         0x1000
1423
#define ELF_OSABI               ELFOSABI_LINUX
1424
 
1425
#define elf_info_to_howto       i370_elf_info_to_howto
1426
 
1427
#define elf_backend_plt_not_loaded 1
1428
#define elf_backend_rela_normal    1
1429
 
1430
#define bfd_elf32_bfd_reloc_type_lookup         i370_elf_reloc_type_lookup
1431
#define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1432
#define bfd_elf32_bfd_set_private_flags         i370_elf_set_private_flags
1433
#define bfd_elf32_bfd_merge_private_bfd_data    i370_elf_merge_private_bfd_data
1434
#define elf_backend_relocate_section            i370_elf_relocate_section
1435
 
1436
/* Dynamic loader support is mostly broken; just enough here to be able to
1437
   link glibc's ld.so without errors.  */
1438
#define elf_backend_create_dynamic_sections     i370_elf_create_dynamic_sections
1439
#define elf_backend_size_dynamic_sections       i370_elf_size_dynamic_sections
1440
#define elf_backend_init_index_section          _bfd_elf_init_1_index_section
1441
#define elf_backend_finish_dynamic_sections     i370_elf_finish_dynamic_sections
1442
#define elf_backend_fake_sections               i370_elf_fake_sections
1443
#define elf_backend_section_from_shdr           i370_elf_section_from_shdr
1444
#define elf_backend_adjust_dynamic_symbol       i370_elf_adjust_dynamic_symbol
1445
#define elf_backend_check_relocs                i370_elf_check_relocs
1446
#define elf_backend_post_process_headers        _bfd_elf_set_osabi
1447
 
1448
static int
1449
i370_noop (void)
1450
{
1451
  return 1;
1452
}
1453
 
1454
#define elf_backend_finish_dynamic_symbol \
1455
  (bfd_boolean (*) \
1456
     (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1457
      Elf_Internal_Sym *)) i370_noop
1458
 
1459
#include "elf32-target.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.