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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [elf32-lm32.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Lattice Mico32-specific support for 32-bit ELF
2
   Copyright 2008, 2009, 2010  Free Software Foundation, Inc.
3
   Contributed by Jon Beniston <jon@beniston.com>
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#include "bfd.h"
23
#include "sysdep.h"
24
#include "libbfd.h"
25
#include "elf-bfd.h"
26
#include "elf/lm32.h"
27
 
28
#define DEFAULT_STACK_SIZE 0x20000
29
 
30
#define PLT_ENTRY_SIZE 20
31
 
32
#define PLT0_ENTRY_WORD0  0
33
#define PLT0_ENTRY_WORD1  0
34
#define PLT0_ENTRY_WORD2  0
35
#define PLT0_ENTRY_WORD3  0
36
#define PLT0_ENTRY_WORD4  0
37
 
38
#define PLT0_PIC_ENTRY_WORD0  0
39
#define PLT0_PIC_ENTRY_WORD1  0
40
#define PLT0_PIC_ENTRY_WORD2  0
41
#define PLT0_PIC_ENTRY_WORD3  0
42
#define PLT0_PIC_ENTRY_WORD4  0
43
 
44
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
45
 
46
extern const bfd_target bfd_elf32_lm32fdpic_vec;
47
 
48
#define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_lm32fdpic_vec)
49
 
50
static bfd_reloc_status_type lm32_elf_gprel_reloc
51
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52
 
53
/* The linker needs to keep track of the number of relocs that it
54
   decides to copy as dynamic relocs in check_relocs for each symbol.
55
   This is so that it can later discard them if they are found to be
56
   unnecessary.  We store the information in a field extending the
57
   regular ELF linker hash table.  */
58
 
59
struct elf_lm32_dyn_relocs
60
{
61
  struct elf_lm32_dyn_relocs *next;
62
 
63
  /* The input section of the reloc.  */
64
  asection *sec;
65
 
66
  /* Total number of relocs copied for the input section.  */
67
  bfd_size_type count;
68
 
69
  /* Number of pc-relative relocs copied for the input section.  */
70
  bfd_size_type pc_count;
71
};
72
 
73
/* lm32 ELF linker hash entry.  */
74
 
75
struct elf_lm32_link_hash_entry
76
{
77
  struct elf_link_hash_entry root;
78
 
79
  /* Track dynamic relocs copied for this symbol.  */
80
  struct elf_lm32_dyn_relocs *dyn_relocs;
81
};
82
 
83
/* lm32 ELF linker hash table.  */
84
 
85
struct elf_lm32_link_hash_table
86
{
87
  struct elf_link_hash_table root;
88
 
89
  /* Short-cuts to get to dynamic linker sections.  */
90
  asection *sgot;
91
  asection *sgotplt;
92
  asection *srelgot;
93
  asection *sfixup32;
94
  asection *splt;
95
  asection *srelplt;
96
  asection *sdynbss;
97
  asection *srelbss;
98
 
99
  int relocs32;
100
};
101
 
102
/* Get the lm32 ELF linker hash table from a link_info structure.  */
103
 
104
#define lm32_elf_hash_table(p) \
105
  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
106
  == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
107
 
108
#define lm32fdpic_got_section(info) \
109
  (lm32_elf_hash_table (info)->sgot)
110
#define lm32fdpic_gotrel_section(info) \
111
  (lm32_elf_hash_table (info)->srelgot)
112
#define lm32fdpic_fixup32_section(info) \
113
  (lm32_elf_hash_table (info)->sfixup32)
114
 
115
struct weak_symbol_list
116
{
117
  const char *name;
118
  struct weak_symbol_list *next;
119
};
120
 
121
/* Create an entry in an lm32 ELF linker hash table.  */
122
 
123
static struct bfd_hash_entry *
124
lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
125
                            struct bfd_hash_table *table,
126
                            const char *string)
127
{
128
  struct elf_lm32_link_hash_entry *ret =
129
    (struct elf_lm32_link_hash_entry *) entry;
130
 
131
  /* Allocate the structure if it has not already been allocated by a
132
     subclass.  */
133
  if (ret == NULL)
134
    ret = bfd_hash_allocate (table,
135
                             sizeof (struct elf_lm32_link_hash_entry));
136
  if (ret == NULL)
137
    return NULL;
138
 
139
  /* Call the allocation method of the superclass.  */
140
  ret = ((struct elf_lm32_link_hash_entry *)
141
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
142
                                     table, string));
143
  if (ret != NULL)
144
    {
145
      struct elf_lm32_link_hash_entry *eh;
146
 
147
      eh = (struct elf_lm32_link_hash_entry *) ret;
148
      eh->dyn_relocs = NULL;
149
    }
150
 
151
  return (struct bfd_hash_entry *) ret;
152
}
153
 
154
/* Create an lm32 ELF linker hash table.  */
155
 
156
static struct bfd_link_hash_table *
157
lm32_elf_link_hash_table_create (bfd *abfd)
158
{
159
  struct elf_lm32_link_hash_table *ret;
160
  bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table);
161
 
162
  ret = bfd_malloc (amt);
163
  if (ret == NULL)
164
    return NULL;
165
 
166
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
167
                                      lm32_elf_link_hash_newfunc,
168
                                      sizeof (struct elf_lm32_link_hash_entry),
169
                                      LM32_ELF_DATA))
170
    {
171
      free (ret);
172
      return NULL;
173
    }
174
 
175
  ret->sgot = NULL;
176
  ret->sgotplt = NULL;
177
  ret->srelgot = NULL;
178
  ret->sfixup32 = NULL;
179
  ret->splt = NULL;
180
  ret->srelplt = NULL;
181
  ret->sdynbss = NULL;
182
  ret->srelbss = NULL;
183
  ret->relocs32 = 0;
184
 
185
  return &ret->root.root;
186
}
187
 
188
/* Add a fixup to the ROFIXUP section.  */
189
 
190
static bfd_vma
191
_lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation)
192
{
193
  bfd_vma fixup_offset;
194
 
195
  if (rofixup->flags & SEC_EXCLUDE)
196
    return -1;
197
 
198
  fixup_offset = rofixup->reloc_count * 4;
199
  if (rofixup->contents)
200
    {
201
      BFD_ASSERT (fixup_offset < rofixup->size);
202
      if (fixup_offset < rofixup->size)
203
      bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset);
204
    }
205
  rofixup->reloc_count++;
206
 
207
  return fixup_offset;
208
}
209
 
210
/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
211
   shortcuts to them in our hash table.  */
212
 
213
static bfd_boolean
214
create_got_section (bfd *dynobj, struct bfd_link_info *info)
215
{
216
  struct elf_lm32_link_hash_table *htab;
217
  asection *s;
218
 
219
  /* This function may be called more than once.  */
220
  s = bfd_get_section_by_name (dynobj, ".got");
221
  if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
222
    return TRUE;
223
 
224
  htab = lm32_elf_hash_table (info);
225
  if (htab == NULL)
226
    return FALSE;
227
 
228
  if (! _bfd_elf_create_got_section (dynobj, info))
229
    return FALSE;
230
 
231
  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
232
  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
233
  htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
234
  if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
235
    abort ();
236
 
237
  return TRUE;
238
}
239
 
240
/* Create .rofixup sections in DYNOBJ, and set up
241
   shortcuts to them in our hash table.  */
242
 
243
static bfd_boolean
244
create_rofixup_section (bfd *dynobj, struct bfd_link_info *info)
245
{
246
  struct elf_lm32_link_hash_table *htab;
247
  htab = lm32_elf_hash_table (info);
248
 
249
  if (htab == NULL)
250
    return FALSE;
251
 
252
  /* Fixup section for R_LM32_32 relocs.  */
253
  lm32fdpic_fixup32_section (info) = bfd_make_section_with_flags (dynobj,
254
                                                                   ".rofixup",
255
                                                                   (SEC_ALLOC
256
                                                                   | SEC_LOAD
257
                                                                   | SEC_HAS_CONTENTS
258
                                                                   | SEC_IN_MEMORY
259
                                                                   | SEC_LINKER_CREATED
260
                                                                   | SEC_READONLY));
261
  if (lm32fdpic_fixup32_section (info) == NULL
262
      || ! bfd_set_section_alignment (dynobj, lm32fdpic_fixup32_section (info), 2))
263
    return FALSE;
264
 
265
  return TRUE;
266
}
267
 
268
static reloc_howto_type lm32_elf_howto_table [] =
269
{
270
  /* This reloc does nothing.  */
271
  HOWTO (R_LM32_NONE,               /* type */
272
         0,                         /* rightshift */
273
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
274
         32,                        /* bitsize */
275
         FALSE,                     /* pc_relative */
276
         0,                         /* bitpos */
277
         complain_overflow_bitfield,/* complain_on_overflow */
278
         bfd_elf_generic_reloc,     /* special_function */
279
         "R_LM32_NONE",             /* name */
280
         FALSE,                     /* partial_inplace */
281
         0,                         /* src_mask */
282
         0,                         /* dst_mask */
283
         FALSE),                    /* pcrel_offset */
284
 
285
  /* An 8 bit absolute relocation.  */
286
  HOWTO (R_LM32_8,                  /* type */
287
         0,                         /* rightshift */
288
         0,                         /* size (0 = byte, 1 = short, 2 = long) */
289
         8,                         /* bitsize */
290
         FALSE,                     /* pc_relative */
291
         0,                         /* bitpos */
292
         complain_overflow_bitfield,/* complain_on_overflow */
293
         bfd_elf_generic_reloc,     /* special_function */
294
         "R_LM32_8",                /* name */
295
         FALSE,                     /* partial_inplace */
296
         0,                         /* src_mask */
297
         0xff,                      /* dst_mask */
298
         FALSE),                    /* pcrel_offset */
299
 
300
  /* A 16 bit absolute relocation.  */
301
  HOWTO (R_LM32_16,                 /* type */
302
         0,                         /* rightshift */
303
         1,                         /* size (0 = byte, 1 = short, 2 = long) */
304
         16,                        /* bitsize */
305
         FALSE,                     /* pc_relative */
306
         0,                         /* bitpos */
307
         complain_overflow_bitfield,/* complain_on_overflow */
308
         bfd_elf_generic_reloc,     /* special_function */
309
         "R_LM32_16",               /* name */
310
         FALSE,                     /* partial_inplace */
311
         0,                         /* src_mask */
312
         0xffff,                    /* dst_mask */
313
         FALSE),                    /* pcrel_offset */
314
 
315
  /* A 32 bit absolute relocation.  */
316
  HOWTO (R_LM32_32,                 /* type */
317
         0,                         /* rightshift */
318
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
319
         32,                        /* bitsize */
320
         FALSE,                     /* pc_relative */
321
         0,                         /* bitpos */
322
         complain_overflow_bitfield,/* complain_on_overflow */
323
         bfd_elf_generic_reloc,     /* special_function */
324
         "R_LM32_32",               /* name */
325
         FALSE,                     /* partial_inplace */
326
         0,                         /* src_mask */
327
         0xffffffff,                /* dst_mask */
328
         FALSE),                    /* pcrel_offset */
329
 
330
  HOWTO (R_LM32_HI16,               /* type */
331
         16,                        /* rightshift */
332
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
333
         16,                        /* bitsize */
334
         FALSE,                     /* pc_relative */
335
         0,                         /* bitpos */
336
         complain_overflow_bitfield,/* complain_on_overflow */
337
         bfd_elf_generic_reloc,     /* special_function */
338
         "R_LM32_HI16",             /* name */
339
         FALSE,                     /* partial_inplace */
340
         0,                         /* src_mask */
341
         0xffff,                    /* dst_mask */
342
         FALSE),                    /* pcrel_offset */
343
 
344
  HOWTO (R_LM32_LO16,               /* type */
345
         0,                         /* rightshift */
346
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
347
         16,                        /* bitsize */
348
         FALSE,                     /* pc_relative */
349
         0,                         /* bitpos */
350
         complain_overflow_dont,    /* complain_on_overflow */
351
         bfd_elf_generic_reloc,     /* special_function */
352
         "R_LM32_LO16",             /* name */
353
         FALSE,                     /* partial_inplace */
354
         0,                         /* src_mask */
355
         0xffff,                    /* dst_mask */
356
         FALSE),                    /* pcrel_offset */
357
 
358
  HOWTO (R_LM32_GPREL16,            /* type */
359
         0,                         /* rightshift */
360
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
361
         16,                        /* bitsize */
362
         FALSE,                     /* pc_relative */
363
         0,                         /* bitpos */
364
         complain_overflow_dont,    /* complain_on_overflow */
365
         lm32_elf_gprel_reloc,      /* special_function */
366
         "R_LM32_GPREL16",          /* name */
367
         FALSE,                     /* partial_inplace */
368
         0,                         /* src_mask */
369
         0xffff,                    /* dst_mask */
370
         FALSE),                    /* pcrel_offset */
371
 
372
  HOWTO (R_LM32_CALL,               /* type */
373
         2,                         /* rightshift */
374
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
375
         26,                        /* bitsize */
376
         TRUE,                      /* pc_relative */
377
         0,                         /* bitpos */
378
         complain_overflow_signed,  /* complain_on_overflow */
379
         bfd_elf_generic_reloc,     /* special_function */
380
         "R_LM32_CALL",             /* name */
381
         FALSE,                     /* partial_inplace */
382
         0,                         /* src_mask */
383
         0x3ffffff,                 /* dst_mask */
384
         TRUE),                     /* pcrel_offset */
385
 
386
  HOWTO (R_LM32_BRANCH,             /* type */
387
         2,                         /* rightshift */
388
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
389
         16,                        /* bitsize */
390
         TRUE,                      /* pc_relative */
391
         0,                         /* bitpos */
392
         complain_overflow_signed,  /* complain_on_overflow */
393
         bfd_elf_generic_reloc,     /* special_function */
394
         "R_LM32_BRANCH",           /* name */
395
         FALSE,                     /* partial_inplace */
396
         0,                         /* src_mask */
397
         0xffff,                    /* dst_mask */
398
         TRUE),                     /* pcrel_offset */
399
 
400
  /* GNU extension to record C++ vtable hierarchy.  */
401
  HOWTO (R_LM32_GNU_VTINHERIT,      /* type */
402
         0,                         /* rightshift */
403
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
404
         0,                         /* bitsize */
405
         FALSE,                     /* pc_relative */
406
         0,                         /* bitpos */
407
         complain_overflow_dont,    /* complain_on_overflow */
408
         NULL,                      /* special_function */
409
         "R_LM32_GNU_VTINHERIT",    /* name */
410
         FALSE,                     /* partial_inplace */
411
         0,                         /* src_mask */
412
         0,                         /* dst_mask */
413
         FALSE),                    /* pcrel_offset */
414
 
415
  /* GNU extension to record C++ vtable member usage.  */
416
  HOWTO (R_LM32_GNU_VTENTRY,        /* type */
417
         0,                         /* rightshift */
418
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
419
         0,                         /* bitsize */
420
         FALSE,                     /* pc_relative */
421
         0,                         /* bitpos */
422
         complain_overflow_dont,    /* complain_on_overflow */
423
         _bfd_elf_rel_vtable_reloc_fn,/* special_function */
424
         "R_LM32_GNU_VTENTRY",      /* name */
425
         FALSE,                     /* partial_inplace */
426
         0,                         /* src_mask */
427
         0,                         /* dst_mask */
428
         FALSE),                    /* pcrel_offset */
429
 
430
  HOWTO (R_LM32_16_GOT,             /* type */
431
         0,                         /* rightshift */
432
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
433
         16,                        /* bitsize */
434
         FALSE,                     /* pc_relative */
435
         0,                         /* bitpos */
436
         complain_overflow_signed,  /* complain_on_overflow */
437
         bfd_elf_generic_reloc,     /* special_function */
438
         "R_LM32_16_GOT",           /* name */
439
         FALSE,                     /* partial_inplace */
440
         0,                         /* src_mask */
441
         0xffff,                    /* dst_mask */
442
         FALSE),                    /* pcrel_offset */
443
 
444
  HOWTO (R_LM32_GOTOFF_HI16,        /* type */
445
         16,                        /* rightshift */
446
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
447
         16,                        /* bitsize */
448
         FALSE,                     /* pc_relative */
449
         0,                         /* bitpos */
450
         complain_overflow_dont,    /* complain_on_overflow */
451
         bfd_elf_generic_reloc,     /* special_function */
452
         "R_LM32_GOTOFF_HI16",      /* name */
453
         FALSE,                     /* partial_inplace */
454
         0xffff,                    /* src_mask */
455
         0xffff,                    /* dst_mask */
456
         FALSE),                    /* pcrel_offset */
457
 
458
  HOWTO (R_LM32_GOTOFF_LO16,        /* type */
459
         0,                         /* rightshift */
460
         2,                         /* size (0 = byte, 1 = short, 2 = long) */
461
         16,                        /* bitsize */
462
         FALSE,                     /* pc_relative */
463
         0,                         /* bitpos */
464
         complain_overflow_dont,    /* complain_on_overflow */
465
         bfd_elf_generic_reloc,     /* special_function */
466
         "R_LM32_GOTOFF_LO16",      /* name */
467
         FALSE,                     /* partial_inplace */
468
         0xffff,                    /* src_mask */
469
         0xffff,                    /* dst_mask */
470
         FALSE),                    /* pcrel_offset */
471
 
472
  HOWTO (R_LM32_COPY,           /* type */
473
         0,                      /* rightshift */
474
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
475
         32,                    /* bitsize */
476
         FALSE,                 /* pc_relative */
477
         0,                      /* bitpos */
478
         complain_overflow_bitfield, /* complain_on_overflow */
479
         bfd_elf_generic_reloc, /* special_function */
480
         "R_LM32_COPY",         /* name */
481
         FALSE,                 /* partial_inplace */
482
         0xffffffff,            /* src_mask */
483
         0xffffffff,            /* dst_mask */
484
         FALSE),                /* pcrel_offset */
485
 
486
  HOWTO (R_LM32_GLOB_DAT,       /* type */
487
         0,                      /* rightshift */
488
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
489
         32,                    /* bitsize */
490
         FALSE,                 /* pc_relative */
491
         0,                      /* bitpos */
492
         complain_overflow_bitfield, /* complain_on_overflow */
493
         bfd_elf_generic_reloc, /* special_function */
494
         "R_LM32_GLOB_DAT",     /* name */
495
         FALSE,                 /* partial_inplace */
496
         0xffffffff,            /* src_mask */
497
         0xffffffff,            /* dst_mask */
498
         FALSE),                /* pcrel_offset */
499
 
500
  HOWTO (R_LM32_JMP_SLOT,       /* type */
501
         0,                      /* rightshift */
502
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
503
         32,                    /* bitsize */
504
         FALSE,                 /* pc_relative */
505
         0,                      /* bitpos */
506
         complain_overflow_bitfield, /* complain_on_overflow */
507
         bfd_elf_generic_reloc, /* special_function */
508
         "R_LM32_JMP_SLOT",     /* name */
509
         FALSE,                 /* partial_inplace */
510
         0xffffffff,            /* src_mask */
511
         0xffffffff,            /* dst_mask */
512
         FALSE),                /* pcrel_offset */
513
 
514
  HOWTO (R_LM32_RELATIVE,       /* type */
515
         0,                      /* rightshift */
516
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
517
         32,                    /* bitsize */
518
         FALSE,                 /* pc_relative */
519
         0,                      /* bitpos */
520
         complain_overflow_bitfield, /* complain_on_overflow */
521
         bfd_elf_generic_reloc, /* special_function */
522
         "R_LM32_RELATIVE",     /* name */
523
         FALSE,                 /* partial_inplace */
524
         0xffffffff,            /* src_mask */
525
         0xffffffff,            /* dst_mask */
526
         FALSE),                /* pcrel_offset */
527
 
528
};
529
 
530
/* Map BFD reloc types to lm32 ELF reloc types. */
531
 
532
struct lm32_reloc_map
533
{
534
    bfd_reloc_code_real_type bfd_reloc_val;
535
    unsigned char elf_reloc_val;
536
};
537
 
538
static const struct lm32_reloc_map lm32_reloc_map[] =
539
{
540
  { BFD_RELOC_NONE,             R_LM32_NONE },
541
  { BFD_RELOC_8,                R_LM32_8 },
542
  { BFD_RELOC_16,               R_LM32_16 },
543
  { BFD_RELOC_32,               R_LM32_32 },
544
  { BFD_RELOC_HI16,             R_LM32_HI16 },
545
  { BFD_RELOC_LO16,             R_LM32_LO16 },
546
  { BFD_RELOC_GPREL16,          R_LM32_GPREL16 },
547
  { BFD_RELOC_LM32_CALL,        R_LM32_CALL },
548
  { BFD_RELOC_LM32_BRANCH,      R_LM32_BRANCH },
549
  { BFD_RELOC_VTABLE_INHERIT,   R_LM32_GNU_VTINHERIT },
550
  { BFD_RELOC_VTABLE_ENTRY,     R_LM32_GNU_VTENTRY },
551
  { BFD_RELOC_LM32_16_GOT,      R_LM32_16_GOT },
552
  { BFD_RELOC_LM32_GOTOFF_HI16, R_LM32_GOTOFF_HI16 },
553
  { BFD_RELOC_LM32_GOTOFF_LO16, R_LM32_GOTOFF_LO16 },
554
  { BFD_RELOC_LM32_COPY,        R_LM32_COPY },
555
  { BFD_RELOC_LM32_GLOB_DAT,    R_LM32_GLOB_DAT },
556
  { BFD_RELOC_LM32_JMP_SLOT,    R_LM32_JMP_SLOT },
557
  { BFD_RELOC_LM32_RELATIVE,    R_LM32_RELATIVE },
558
};
559
 
560
static reloc_howto_type *
561
lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
562
                        bfd_reloc_code_real_type code)
563
{
564
  unsigned int i;
565
 
566
  for (i = 0; i < sizeof (lm32_reloc_map) / sizeof (lm32_reloc_map[0]); i++)
567
    if (lm32_reloc_map[i].bfd_reloc_val == code)
568
      return &lm32_elf_howto_table[lm32_reloc_map[i].elf_reloc_val];
569
  return NULL;
570
}
571
 
572
static reloc_howto_type *
573
lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
574
                        const char *r_name)
575
{
576
  unsigned int i;
577
 
578
  for (i = 0;
579
       i < sizeof (lm32_elf_howto_table) / sizeof (lm32_elf_howto_table[0]);
580
       i++)
581
    if (lm32_elf_howto_table[i].name != NULL
582
        && strcasecmp (lm32_elf_howto_table[i].name, r_name) == 0)
583
      return &lm32_elf_howto_table[i];
584
 
585
  return NULL;
586
}
587
 
588
 
589
/* Set the howto pointer for an Lattice Mico32 ELF reloc.  */
590
 
591
static void
592
lm32_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
593
                         arelent *cache_ptr,
594
                         Elf_Internal_Rela *dst)
595
{
596
  unsigned int r_type;
597
 
598
  r_type = ELF32_R_TYPE (dst->r_info);
599
  BFD_ASSERT (r_type < (unsigned int) R_LM32_max);
600
  cache_ptr->howto = &lm32_elf_howto_table[r_type];
601
}
602
 
603
/* Set the right machine number for an Lattice Mico32 ELF file. */
604
 
605
static bfd_boolean
606
lm32_elf_object_p (bfd *abfd)
607
{
608
  return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32);
609
}
610
 
611
/* Set machine type flags just before file is written out. */
612
 
613
static void
614
lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
615
{
616
  elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32;
617
  elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH;
618
  switch (bfd_get_mach (abfd))
619
    {
620
      case bfd_mach_lm32:
621
        elf_elfheader (abfd)->e_flags |= E_LM32_MACH;
622
        break;
623
      default:
624
        abort ();
625
    }
626
}
627
 
628
/* Set the GP value for OUTPUT_BFD.  Returns FALSE if this is a
629
   dangerous relocation.  */
630
 
631
static bfd_boolean
632
lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
633
{
634
  unsigned int count;
635
  asymbol **sym;
636
  unsigned int i;
637
 
638
  /* If we've already figured out what GP will be, just return it. */
639
  *pgp = _bfd_get_gp_value (output_bfd);
640
  if (*pgp)
641
    return TRUE;
642
 
643
  count = bfd_get_symcount (output_bfd);
644
  sym = bfd_get_outsymbols (output_bfd);
645
 
646
  /* The linker script will have created a symbol named `_gp' with the
647
     appropriate value.  */
648
  if (sym == NULL)
649
    i = count;
650
  else
651
    {
652
      for (i = 0; i < count; i++, sym++)
653
        {
654
          const char *name;
655
 
656
          name = bfd_asymbol_name (*sym);
657
          if (*name == '_' && strcmp (name, "_gp") == 0)
658
            {
659
              *pgp = bfd_asymbol_value (*sym);
660
              _bfd_set_gp_value (output_bfd, *pgp);
661
              break;
662
            }
663
        }
664
    }
665
 
666
  if (i >= count)
667
    {
668
      /* Only get the error once.  */
669
      *pgp = 4;
670
      _bfd_set_gp_value (output_bfd, *pgp);
671
      return FALSE;
672
    }
673
 
674
  return TRUE;
675
}
676
 
677
/* We have to figure out the gp value, so that we can adjust the
678
   symbol value correctly.  We look up the symbol _gp in the output
679
   BFD.  If we can't find it, we're stuck.  We cache it in the ELF
680
   target data.  We don't need to adjust the symbol value for an
681
   external symbol if we are producing relocatable output.  */
682
 
683
static bfd_reloc_status_type
684
lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
685
                    char **error_message, bfd_vma *pgp)
686
{
687
  if (bfd_is_und_section (symbol->section) && !relocatable)
688
    {
689
      *pgp = 0;
690
      return bfd_reloc_undefined;
691
    }
692
 
693
  *pgp = _bfd_get_gp_value (output_bfd);
694
  if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
695
    {
696
      if (relocatable)
697
        {
698
          /* Make up a value.  */
699
          *pgp = symbol->section->output_section->vma + 0x4000;
700
          _bfd_set_gp_value (output_bfd, *pgp);
701
        }
702
      else if (!lm32_elf_assign_gp (output_bfd, pgp))
703
        {
704
          *error_message =
705
            (char *)
706
            _("global pointer relative relocation when _gp not defined");
707
          return bfd_reloc_dangerous;
708
        }
709
    }
710
 
711
  return bfd_reloc_ok;
712
}
713
 
714
static bfd_reloc_status_type
715
lm32_elf_do_gprel_relocate (bfd *abfd,
716
                            reloc_howto_type *howto,
717
                            asection *input_section ATTRIBUTE_UNUSED,
718
                            bfd_byte *data,
719
                            bfd_vma offset,
720
                            bfd_vma symbol_value,
721
                            bfd_vma addend)
722
{
723
  return _bfd_final_link_relocate (howto, abfd, input_section,
724
                                   data, offset, symbol_value, addend);
725
}
726
 
727
static bfd_reloc_status_type
728
lm32_elf_gprel_reloc (bfd *abfd,
729
                      arelent *reloc_entry,
730
                      asymbol *symbol,
731
                      void *data,
732
                      asection *input_section,
733
                      bfd *output_bfd,
734
                      char **msg)
735
{
736
  bfd_vma relocation;
737
  bfd_vma gp;
738
  bfd_reloc_status_type r;
739
 
740
  if (output_bfd != (bfd *) NULL
741
      && (symbol->flags & BSF_SECTION_SYM) == 0
742
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
743
    {
744
      reloc_entry->address += input_section->output_offset;
745
      return bfd_reloc_ok;
746
    }
747
 
748
  if (output_bfd != NULL)
749
    return bfd_reloc_ok;
750
 
751
  relocation = symbol->value
752
    + symbol->section->output_section->vma + symbol->section->output_offset;
753
 
754
  if ((r =
755
       lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok)
756
    {
757
      relocation = relocation + reloc_entry->addend - gp;
758
      reloc_entry->addend = 0;
759
      if ((signed) relocation < -32768 || (signed) relocation > 32767)
760
        {
761
          *msg = _("global pointer relative address out of range");
762
          r = bfd_reloc_outofrange;
763
        }
764
      else
765
        {
766
          r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto,
767
                                             input_section,
768
                                             data, reloc_entry->address,
769
                                             relocation, reloc_entry->addend);
770
        }
771
    }
772
 
773
  return r;
774
}
775
 
776
/* Find the segment number in which OSEC, and output section, is
777
   located.  */
778
 
779
static unsigned
780
_lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec)
781
{
782
  struct elf_segment_map *m;
783
  Elf_Internal_Phdr *p;
784
 
785
  /* Find the segment that contains the output_section.  */
786
  for (m = elf_tdata (output_bfd)->segment_map,
787
         p = elf_tdata (output_bfd)->phdr;
788
       m != NULL;
789
       m = m->next, p++)
790
    {
791
      int i;
792
 
793
      for (i = m->count - 1; i >= 0; i--)
794
        if (m->sections[i] == osec)
795
          break;
796
 
797
      if (i >= 0)
798
        break;
799
    }
800
 
801
  return p - elf_tdata (output_bfd)->phdr;
802
}
803
 
804
/* Determine if an output section is read-only.  */
805
 
806
inline static bfd_boolean
807
_lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
808
{
809
  unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec);
810
 
811
  return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
812
}
813
 
814
/* Relocate a section */
815
 
816
static bfd_boolean
817
lm32_elf_relocate_section (bfd *output_bfd,
818
                           struct bfd_link_info *info,
819
                           bfd *input_bfd,
820
                           asection *input_section,
821
                           bfd_byte *contents,
822
                           Elf_Internal_Rela *relocs,
823
                           Elf_Internal_Sym *local_syms,
824
                           asection **local_sections)
825
{
826
  Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
827
  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
828
  Elf_Internal_Rela *rel, *relend;
829
  struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
830
  bfd *dynobj;
831
  bfd_vma *local_got_offsets;
832
  asection *sgot, *splt, *sreloc;
833
 
834
  if (htab == NULL)
835
    return FALSE;
836
 
837
  dynobj = htab->root.dynobj;
838
  local_got_offsets = elf_local_got_offsets (input_bfd);
839
 
840
  sgot = htab->sgot;
841
  splt = htab->splt;
842
  sreloc = NULL;
843
 
844
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
845
  sym_hashes = elf_sym_hashes (input_bfd);
846
 
847
  rel = relocs;
848
  relend = relocs + input_section->reloc_count;
849
  for (; rel < relend; rel++)
850
    {
851
      reloc_howto_type *howto;
852
      unsigned int r_type;
853
      unsigned long r_symndx;
854
      Elf_Internal_Sym *sym;
855
      asection *sec;
856
      struct elf_link_hash_entry *h;
857
      bfd_vma relocation;
858
      bfd_vma gp;
859
      bfd_reloc_status_type r;
860
      const char *name = NULL;
861
      asection *osec;
862
 
863
      r_symndx = ELF32_R_SYM (rel->r_info);
864
      r_type = ELF32_R_TYPE (rel->r_info);
865
 
866
      if (r_type == R_LM32_GNU_VTENTRY
867
          || r_type == R_LM32_GNU_VTINHERIT )
868
        continue;
869
 
870
      h = NULL;
871
      sym = NULL;
872
      sec = NULL;
873
 
874
      howto = lm32_elf_howto_table + r_type;
875
 
876
      if (r_symndx < symtab_hdr->sh_info)
877
        {
878
          /* It's a local symbol.  */
879
          sym = local_syms + r_symndx;
880
          osec = sec = local_sections[r_symndx];
881
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
882
          name = bfd_elf_string_from_elf_section
883
            (input_bfd, symtab_hdr->sh_link, sym->st_name);
884
          name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
885
        }
886
      else
887
        {
888
          /* It's a global symbol.  */
889
          bfd_boolean unresolved_reloc;
890
          bfd_boolean warned;
891
 
892
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
893
                                   r_symndx, symtab_hdr, sym_hashes,
894
                                   h, sec, relocation,
895
                                   unresolved_reloc, warned);
896
          osec = sec;
897
          name = h->root.root.string;
898
        }
899
 
900
      if (sec != NULL && elf_discarded_section (sec))
901
        {
902
          /* For relocs against symbols from removed linkonce sections,
903
             or sections discarded by a linker script, we just want the
904
             section contents zeroed.  Avoid any special processing.  */
905
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
906
          rel->r_info = 0;
907
          rel->r_addend = 0;
908
          continue;
909
        }
910
 
911
      if (info->relocatable)
912
        {
913
          /* This is a relocatable link.  We don't have to change
914
             anything, unless the reloc is against a section symbol,
915
             in which case we have to adjust according to where the
916
             section symbol winds up in the output section.  */
917
          if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
918
            continue;
919
 
920
          /* If partial_inplace, we need to store any additional addend
921
             back in the section.  */
922
          if (! howto->partial_inplace)
923
            continue;
924
 
925
          /* Shouldn't reach here.  */
926
          abort ();
927
          r = bfd_reloc_ok;
928
        }
929
      else
930
        {
931
          switch (howto->type)
932
            {
933
            case R_LM32_GPREL16:
934
              if (!lm32_elf_assign_gp (output_bfd, &gp))
935
                r = bfd_reloc_dangerous;
936
              else
937
                {
938
                  relocation = relocation + rel->r_addend - gp;
939
                  rel->r_addend = 0;
940
                  if ((signed)relocation < -32768 || (signed)relocation > 32767)
941
                    r = bfd_reloc_outofrange;
942
                  else
943
                    {
944
                      r = _bfd_final_link_relocate (howto, input_bfd,
945
                                                  input_section, contents,
946
                                          rel->r_offset, relocation,
947
                                          rel->r_addend);
948
                   }
949
                }
950
              break;
951
            case R_LM32_16_GOT:
952
              /* Relocation is to the entry for this symbol in the global
953
                 offset table.  */
954
              BFD_ASSERT (sgot != NULL);
955
              if (h != NULL)
956
                {
957
                  bfd_boolean dyn;
958
                  bfd_vma off;
959
 
960
                  off = h->got.offset;
961
                  BFD_ASSERT (off != (bfd_vma) -1);
962
 
963
                  dyn = htab->root.dynamic_sections_created;
964
                  if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
965
                      || (info->shared
966
                          && (info->symbolic
967
                              || h->dynindx == -1
968
                              || h->forced_local)
969
                          && h->def_regular))
970
                    {
971
                      /* This is actually a static link, or it is a
972
                         -Bsymbolic link and the symbol is defined
973
                         locally, or the symbol was forced to be local
974
                         because of a version file.  We must initialize
975
                         this entry in the global offset table.  Since the
976
                         offset must always be a multiple of 4, we use the
977
                         least significant bit to record whether we have
978
                         initialized it already.
979
 
980
                         When doing a dynamic link, we create a .rela.got
981
                         relocation entry to initialize the value.  This
982
                         is done in the finish_dynamic_symbol routine.  */
983
                      if ((off & 1) != 0)
984
                        off &= ~1;
985
                      else
986
                        {
987
                          /* Write entry in GOT */
988
                          bfd_put_32 (output_bfd, relocation,
989
                                      sgot->contents + off);
990
                          /* Create entry in .rofixup pointing to GOT entry.  */
991
                           if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
992
                             {
993
                               _lm32fdpic_add_rofixup (output_bfd,
994
                                                       lm32fdpic_fixup32_section
995
                                                        (info),
996
                                                       sgot->output_section->vma
997
                                                        + sgot->output_offset
998
                                                        + off);
999
                             }
1000
                          /* Mark GOT entry as having been written.  */
1001
                          h->got.offset |= 1;
1002
                        }
1003
                    }
1004
 
1005
                  relocation = sgot->output_offset + off;
1006
                }
1007
              else
1008
                {
1009
                  bfd_vma off;
1010
                  bfd_byte *loc;
1011
 
1012
                  BFD_ASSERT (local_got_offsets != NULL
1013
                              && local_got_offsets[r_symndx] != (bfd_vma) -1);
1014
 
1015
                  /* Get offset into GOT table.  */
1016
                  off = local_got_offsets[r_symndx];
1017
 
1018
                  /* The offset must always be a multiple of 4.  We use
1019
                     the least significant bit to record whether we have
1020
                     already processed this entry.  */
1021
                  if ((off & 1) != 0)
1022
                    off &= ~1;
1023
                  else
1024
                    {
1025
                      /* Write entry in GOT.  */
1026
                      bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1027
                      /* Create entry in .rofixup pointing to GOT entry.  */
1028
                      if (IS_FDPIC (output_bfd))
1029
                        {
1030
                          _lm32fdpic_add_rofixup (output_bfd,
1031
                                                  lm32fdpic_fixup32_section
1032
                                                   (info),
1033
                                                  sgot->output_section->vma
1034
                                                   + sgot->output_offset
1035
                                                   + off);
1036
                        }
1037
 
1038
                      if (info->shared)
1039
                        {
1040
                          asection *srelgot;
1041
                          Elf_Internal_Rela outrel;
1042
 
1043
                          /* We need to generate a R_LM32_RELATIVE reloc
1044
                             for the dynamic linker.  */
1045
                          srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1046
                          BFD_ASSERT (srelgot != NULL);
1047
 
1048
                          outrel.r_offset = (sgot->output_section->vma
1049
                                             + sgot->output_offset
1050
                                             + off);
1051
                          outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1052
                          outrel.r_addend = relocation;
1053
                          loc = srelgot->contents;
1054
                          loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1055
                          bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1056
                          ++srelgot->reloc_count;
1057
                        }
1058
 
1059
                      local_got_offsets[r_symndx] |= 1;
1060
                    }
1061
 
1062
 
1063
                  relocation = sgot->output_offset + off;
1064
                }
1065
 
1066
              /* Addend should be zero.  */
1067
              if (rel->r_addend != 0)
1068
                (*_bfd_error_handler) (_("internal error: addend should be zero for R_LM32_16_GOT"));
1069
 
1070
              r = _bfd_final_link_relocate (howto,
1071
                                            input_bfd,
1072
                                            input_section,
1073
                                            contents,
1074
                                            rel->r_offset,
1075
                                            relocation,
1076
                                            rel->r_addend);
1077
              break;
1078
 
1079
            case R_LM32_GOTOFF_LO16:
1080
            case R_LM32_GOTOFF_HI16:
1081
              /* Relocation is offset from GOT.  */
1082
              BFD_ASSERT (sgot != NULL);
1083
              relocation -= sgot->output_section->vma;
1084
              /* Account for sign-extension.  */
1085
              if ((r_type == R_LM32_GOTOFF_HI16)
1086
                  && ((relocation + rel->r_addend) & 0x8000))
1087
                rel->r_addend += 0x10000;
1088
              r = _bfd_final_link_relocate (howto,
1089
                                            input_bfd,
1090
                                            input_section,
1091
                                            contents,
1092
                                            rel->r_offset,
1093
                                            relocation,
1094
                                            rel->r_addend);
1095
              break;
1096
 
1097
            case R_LM32_32:
1098
              if (IS_FDPIC (output_bfd))
1099
                {
1100
                  if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1101
                    {
1102
                      /* Only create .rofixup entries for relocs in loadable sections.  */
1103
                      if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1104
                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1105
 
1106
                        {
1107
                          /* Check address to be modified is writable.  */
1108
                          if (_lm32fdpic_osec_readonly_p (output_bfd,
1109
                                                          input_section
1110
                                                           ->output_section))
1111
                            {
1112
                              info->callbacks->warning
1113
                                (info,
1114
                                 _("cannot emit dynamic relocations in read-only section"),
1115
                                 name, input_bfd, input_section, rel->r_offset);
1116
                               return FALSE;
1117
                            }
1118
                          /* Create entry in .rofixup section.  */
1119
                          _lm32fdpic_add_rofixup (output_bfd,
1120
                                                  lm32fdpic_fixup32_section (info),
1121
                                                  input_section->output_section->vma
1122
                                                   + input_section->output_offset
1123
                                                   + rel->r_offset);
1124
                        }
1125
                    }
1126
                }
1127
              /* Fall through.  */
1128
 
1129
            default:
1130
              r = _bfd_final_link_relocate (howto,
1131
                                            input_bfd,
1132
                                            input_section,
1133
                                            contents,
1134
                                            rel->r_offset,
1135
                                            relocation,
1136
                                            rel->r_addend);
1137
              break;
1138
            }
1139
        }
1140
 
1141
      if (r != bfd_reloc_ok)
1142
        {
1143
          const char *msg = NULL;
1144
          arelent bfd_reloc;
1145
 
1146
          lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1147
          howto = bfd_reloc.howto;
1148
 
1149
          if (h != NULL)
1150
            name = h->root.root.string;
1151
          else
1152
            {
1153
              name = (bfd_elf_string_from_elf_section
1154
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
1155
              if (name == NULL || *name == '\0')
1156
                name = bfd_section_name (input_bfd, sec);
1157
            }
1158
 
1159
          switch (r)
1160
            {
1161
            case bfd_reloc_overflow:
1162
              if ((h != NULL)
1163
                 && (h->root.type == bfd_link_hash_undefweak))
1164
                break;
1165
              if (! ((*info->callbacks->reloc_overflow)
1166
                     (info, (h ? &h->root : NULL), name, howto->name,
1167
                      (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
1168
                return FALSE;
1169
              break;
1170
 
1171
            case bfd_reloc_undefined:
1172
              if (! ((*info->callbacks->undefined_symbol)
1173
                     (info, name, input_bfd, input_section,
1174
                      rel->r_offset, TRUE)))
1175
                return FALSE;
1176
              break;
1177
 
1178
            case bfd_reloc_outofrange:
1179
              msg = _("internal error: out of range error");
1180
              goto common_error;
1181
 
1182
            case bfd_reloc_notsupported:
1183
              msg = _("internal error: unsupported relocation error");
1184
              goto common_error;
1185
 
1186
            case bfd_reloc_dangerous:
1187
              msg = _("internal error: dangerous error");
1188
              goto common_error;
1189
 
1190
            default:
1191
              msg = _("internal error: unknown error");
1192
              /* fall through */
1193
 
1194
            common_error:
1195
              if (!((*info->callbacks->warning)
1196
                    (info, msg, name, input_bfd, input_section,
1197
                     rel->r_offset)))
1198
                return FALSE;
1199
              break;
1200
            }
1201
        }
1202
    }
1203
 
1204
  return TRUE;
1205
}
1206
 
1207
static asection *
1208
lm32_elf_gc_mark_hook (asection *sec,
1209
                       struct bfd_link_info *info,
1210
                       Elf_Internal_Rela *rel,
1211
                       struct elf_link_hash_entry *h,
1212
                       Elf_Internal_Sym *sym)
1213
{
1214
  if (h != NULL)
1215
    switch (ELF32_R_TYPE (rel->r_info))
1216
      {
1217
      case R_LM32_GNU_VTINHERIT:
1218
      case R_LM32_GNU_VTENTRY:
1219
        return NULL;
1220
      }
1221
 
1222
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1223
}
1224
 
1225
static bfd_boolean
1226
lm32_elf_gc_sweep_hook (bfd *abfd,
1227
                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
1228
                        asection *sec,
1229
                        const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1230
{
1231
  /* Update the got entry reference counts for the section being removed.  */
1232
  Elf_Internal_Shdr *symtab_hdr;
1233
  struct elf_link_hash_entry **sym_hashes;
1234
  bfd_signed_vma *local_got_refcounts;
1235
  const Elf_Internal_Rela *rel, *relend;
1236
 
1237
  elf_section_data (sec)->local_dynrel = NULL;
1238
 
1239
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1240
  sym_hashes = elf_sym_hashes (abfd);
1241
  local_got_refcounts = elf_local_got_refcounts (abfd);
1242
 
1243
  relend = relocs + sec->reloc_count;
1244
  for (rel = relocs; rel < relend; rel++)
1245
    {
1246
      unsigned long r_symndx;
1247
      struct elf_link_hash_entry *h = NULL;
1248
 
1249
      r_symndx = ELF32_R_SYM (rel->r_info);
1250
      if (r_symndx >= symtab_hdr->sh_info)
1251
        {
1252
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1253
          while (h->root.type == bfd_link_hash_indirect
1254
                 || h->root.type == bfd_link_hash_warning)
1255
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1256
        }
1257
 
1258
      switch (ELF32_R_TYPE (rel->r_info))
1259
        {
1260
        case R_LM32_16_GOT:
1261
          if (h != NULL)
1262
            {
1263
              if (h->got.refcount > 0)
1264
                h->got.refcount--;
1265
            }
1266
          else
1267
            {
1268
              if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1269
                local_got_refcounts[r_symndx]--;
1270
            }
1271
          break;
1272
 
1273
        default:
1274
          break;
1275
        }
1276
    }
1277
  return TRUE;
1278
}
1279
 
1280
/* Look through the relocs for a section during the first phase.  */
1281
 
1282
static bfd_boolean
1283
lm32_elf_check_relocs (bfd *abfd,
1284
                       struct bfd_link_info *info,
1285
                       asection *sec,
1286
                       const Elf_Internal_Rela *relocs)
1287
{
1288
  Elf_Internal_Shdr *symtab_hdr;
1289
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1290
  const Elf_Internal_Rela *rel;
1291
  const Elf_Internal_Rela *rel_end;
1292
  struct elf_lm32_link_hash_table *htab;
1293
  bfd *dynobj;
1294
  bfd_vma *local_got_offsets;
1295
  asection *sgot, *srelgot, *sreloc;
1296
 
1297
  if (info->relocatable)
1298
    return TRUE;
1299
 
1300
  sgot = srelgot = sreloc = NULL;
1301
 
1302
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1303
  sym_hashes = elf_sym_hashes (abfd);
1304
  sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1305
  if (!elf_bad_symtab (abfd))
1306
    sym_hashes_end -= symtab_hdr->sh_info;
1307
 
1308
  htab = lm32_elf_hash_table (info);
1309
  if (htab == NULL)
1310
    return FALSE;
1311
 
1312
  dynobj = htab->root.dynobj;
1313
  local_got_offsets = elf_local_got_offsets (abfd);
1314
 
1315
  rel_end = relocs + sec->reloc_count;
1316
  for (rel = relocs; rel < rel_end; rel++)
1317
    {
1318
      int r_type;
1319
      struct elf_link_hash_entry *h;
1320
      unsigned long r_symndx;
1321
 
1322
      r_symndx = ELF32_R_SYM (rel->r_info);
1323
      r_type = ELF32_R_TYPE (rel->r_info);
1324
      if (r_symndx < symtab_hdr->sh_info)
1325
        h = NULL;
1326
      else
1327
        {
1328
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1329
          while (h->root.type == bfd_link_hash_indirect
1330
                 || h->root.type == bfd_link_hash_warning)
1331
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1332
        }
1333
 
1334
      /* Some relocs require a global offset table.  */
1335
      if (htab->sgot == NULL)
1336
        {
1337
          switch (r_type)
1338
            {
1339
            case R_LM32_16_GOT:
1340
            case R_LM32_GOTOFF_HI16:
1341
            case R_LM32_GOTOFF_LO16:
1342
              if (dynobj == NULL)
1343
                htab->root.dynobj = dynobj = abfd;
1344
              if (! create_got_section (dynobj, info))
1345
                return FALSE;
1346
              break;
1347
            }
1348
        }
1349
 
1350
      /* Some relocs require a rofixup table. */
1351
      if (IS_FDPIC (abfd))
1352
        {
1353
          switch (r_type)
1354
            {
1355
            case R_LM32_32:
1356
              /* FDPIC requires a GOT if there is a .rofixup section
1357
                 (Normal ELF doesn't). */
1358
              if (dynobj == NULL)
1359
                htab->root.dynobj = dynobj = abfd;
1360
              if (! create_got_section (dynobj, info))
1361
                return FALSE;
1362
              /* Create .rofixup section */
1363
              if (htab->sfixup32 == NULL)
1364
                {
1365
                  if (! create_rofixup_section (abfd, info))
1366
                    return FALSE;
1367
                }
1368
              break;
1369
            case R_LM32_16_GOT:
1370
            case R_LM32_GOTOFF_HI16:
1371
            case R_LM32_GOTOFF_LO16:
1372
              /* Create .rofixup section.  */
1373
              if (htab->sfixup32 == NULL)
1374
                {
1375
                  if (! create_rofixup_section (abfd, info))
1376
                    return FALSE;
1377
                }
1378
              break;
1379
            }
1380
        }
1381
 
1382
      switch (r_type)
1383
        {
1384
        case R_LM32_16_GOT:
1385
          if (h != NULL)
1386
            h->got.refcount += 1;
1387
          else
1388
            {
1389
              bfd_signed_vma *local_got_refcounts;
1390
 
1391
              /* This is a global offset table entry for a local symbol.  */
1392
              local_got_refcounts = elf_local_got_refcounts (abfd);
1393
              if (local_got_refcounts == NULL)
1394
                {
1395
                  bfd_size_type size;
1396
 
1397
                  size = symtab_hdr->sh_info;
1398
                  size *= sizeof (bfd_signed_vma);
1399
                  local_got_refcounts = bfd_zalloc (abfd, size);
1400
                  if (local_got_refcounts == NULL)
1401
                    return FALSE;
1402
                  elf_local_got_refcounts (abfd) = local_got_refcounts;
1403
                }
1404
              local_got_refcounts[r_symndx] += 1;
1405
            }
1406
          break;
1407
 
1408
        /* This relocation describes the C++ object vtable hierarchy.
1409
           Reconstruct it for later use during GC.  */
1410
        case R_LM32_GNU_VTINHERIT:
1411
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1412
            return FALSE;
1413
          break;
1414
 
1415
        /* This relocation describes which C++ vtable entries are actually
1416
           used.  Record for later use during GC.  */
1417
        case R_LM32_GNU_VTENTRY:
1418
          if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1419
            return FALSE;
1420
          break;
1421
 
1422
        }
1423
    }
1424
 
1425
  return TRUE;
1426
}
1427
 
1428
/* Finish up the dynamic sections.  */
1429
 
1430
static bfd_boolean
1431
lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1432
                                  struct bfd_link_info *info)
1433
{
1434
  struct elf_lm32_link_hash_table *htab;
1435
  bfd *dynobj;
1436
  asection *sdyn;
1437
  asection *sgot;
1438
 
1439
  htab = lm32_elf_hash_table (info);
1440
  if (htab == NULL)
1441
    return FALSE;
1442
 
1443
  dynobj = htab->root.dynobj;
1444
 
1445
  sgot = htab->sgotplt;
1446
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1447
 
1448
  if (htab->root.dynamic_sections_created)
1449
    {
1450
      asection *splt;
1451
      Elf32_External_Dyn *dyncon, *dynconend;
1452
 
1453
      BFD_ASSERT (sgot != NULL && sdyn != NULL);
1454
 
1455
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
1456
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1457
 
1458
      for (; dyncon < dynconend; dyncon++)
1459
        {
1460
          Elf_Internal_Dyn dyn;
1461
          const char *name;
1462
          asection *s;
1463
 
1464
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1465
 
1466
          switch (dyn.d_tag)
1467
            {
1468
            default:
1469
              break;
1470
 
1471
            case DT_PLTGOT:
1472
              name = ".got";
1473
              s = htab->sgot->output_section;
1474
              goto get_vma;
1475
            case DT_JMPREL:
1476
              name = ".rela.plt";
1477
              s = htab->srelplt->output_section;
1478
            get_vma:
1479
              BFD_ASSERT (s != NULL);
1480
              dyn.d_un.d_ptr = s->vma;
1481
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1482
              break;
1483
 
1484
            case DT_PLTRELSZ:
1485
              s = htab->srelplt->output_section;
1486
              BFD_ASSERT (s != NULL);
1487
              dyn.d_un.d_val = s->size;
1488
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1489
              break;
1490
 
1491
            case DT_RELASZ:
1492
              /* My reading of the SVR4 ABI indicates that the
1493
                 procedure linkage table relocs (DT_JMPREL) should be
1494
                 included in the overall relocs (DT_RELA).  This is
1495
                 what Solaris does.  However, UnixWare can not handle
1496
                 that case.  Therefore, we override the DT_RELASZ entry
1497
                 here to make it not include the JMPREL relocs.  Since
1498
                 the linker script arranges for .rela.plt to follow all
1499
                 other relocation sections, we don't have to worry
1500
                 about changing the DT_RELA entry.  */
1501
              if (htab->srelplt != NULL)
1502
                {
1503
                  s = htab->srelplt->output_section;
1504
                  dyn.d_un.d_val -= s->size;
1505
                }
1506
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1507
              break;
1508
            }
1509
        }
1510
 
1511
      /* Fill in the first entry in the procedure linkage table.  */
1512
      splt = htab->splt;
1513
      if (splt && splt->size > 0)
1514
        {
1515
          if (info->shared)
1516
            {
1517
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1518
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1519
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1520
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1521
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1522
            }
1523
          else
1524
            {
1525
              unsigned long addr;
1526
              /* addr = .got + 4 */
1527
              addr = sgot->output_section->vma + sgot->output_offset + 4;
1528
              bfd_put_32 (output_bfd,
1529
                          PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1530
                          splt->contents);
1531
              bfd_put_32 (output_bfd,
1532
                          PLT0_ENTRY_WORD1 | (addr & 0xffff),
1533
                          splt->contents + 4);
1534
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1535
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1536
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1537
            }
1538
 
1539
          elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1540
            PLT_ENTRY_SIZE;
1541
        }
1542
    }
1543
 
1544
  /* Fill in the first three entries in the global offset table.  */
1545
  if (sgot && sgot->size > 0)
1546
    {
1547
      if (sdyn == NULL)
1548
        bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1549
      else
1550
        bfd_put_32 (output_bfd,
1551
                    sdyn->output_section->vma + sdyn->output_offset,
1552
                    sgot->contents);
1553
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1554
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1555
 
1556
      /* FIXME:  This can be null if create_dynamic_sections wasn't called. */
1557
      if (elf_section_data (sgot->output_section) != NULL)
1558
        elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1559
    }
1560
 
1561
  if (lm32fdpic_fixup32_section (info))
1562
    {
1563
      struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1564
      bfd_vma got_value = hgot->root.u.def.value
1565
            + hgot->root.u.def.section->output_section->vma
1566
            + hgot->root.u.def.section->output_offset;
1567
      struct bfd_link_hash_entry *hend;
1568
 
1569
      /* Last entry is pointer to GOT.  */
1570
      _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1571
 
1572
      /* Check we wrote enough entries.  */
1573
      if (lm32fdpic_fixup32_section (info)->size
1574
              != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1575
        {
1576
          (*_bfd_error_handler)
1577
            ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
1578
            lm32fdpic_fixup32_section (info)->size/4,
1579
            lm32fdpic_fixup32_section (info)->reloc_count);
1580
          return FALSE;
1581
        }
1582
 
1583
      hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1584
              FALSE, FALSE, TRUE);
1585
      if (hend
1586
          && (hend->type == bfd_link_hash_defined
1587
              || hend->type == bfd_link_hash_defweak))
1588
        {
1589
          bfd_vma value =
1590
            lm32fdpic_fixup32_section (info)->output_section->vma
1591
            + lm32fdpic_fixup32_section (info)->output_offset
1592
            + lm32fdpic_fixup32_section (info)->size
1593
            - hend->u.def.section->output_section->vma
1594
            - hend->u.def.section->output_offset;
1595
          BFD_ASSERT (hend->u.def.value == value);
1596
          if (hend->u.def.value != value)
1597
            {
1598
              (*_bfd_error_handler)
1599
                ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
1600
              return FALSE;
1601
            }
1602
        }
1603
    }
1604
 
1605
  return TRUE;
1606
}
1607
 
1608
/* Finish up dynamic symbol handling.  We set the contents of various
1609
   dynamic sections here.  */
1610
 
1611
static bfd_boolean
1612
lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1613
                                struct bfd_link_info *info,
1614
                                struct elf_link_hash_entry *h,
1615
                                Elf_Internal_Sym *sym)
1616
{
1617
  struct elf_lm32_link_hash_table *htab;
1618
  bfd *dynobj;
1619
  bfd_byte *loc;
1620
 
1621
  htab = lm32_elf_hash_table (info);
1622
  if (htab == NULL)
1623
    return FALSE;
1624
 
1625
  dynobj = htab->root.dynobj;
1626
 
1627
  if (h->plt.offset != (bfd_vma) -1)
1628
    {
1629
      asection *splt;
1630
      asection *sgot;
1631
      asection *srela;
1632
 
1633
      bfd_vma plt_index;
1634
      bfd_vma got_offset;
1635
      Elf_Internal_Rela rela;
1636
 
1637
      /* This symbol has an entry in the procedure linkage table.  Set
1638
         it up.  */
1639
      BFD_ASSERT (h->dynindx != -1);
1640
 
1641
      splt = htab->splt;
1642
      sgot = htab->sgotplt;
1643
      srela = htab->srelplt;
1644
      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1645
 
1646
      /* Get the index in the procedure linkage table which
1647
         corresponds to this symbol.  This is the index of this symbol
1648
         in all the symbols for which we are making plt entries.  The
1649
         first entry in the procedure linkage table is reserved.  */
1650
      plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1651
 
1652
      /* Get the offset into the .got table of the entry that
1653
        corresponds to this function.  Each .got entry is 4 bytes.
1654
        The first three are reserved.  */
1655
      got_offset = (plt_index + 3) * 4;
1656
 
1657
      /* Fill in the entry in the procedure linkage table.  */
1658
      if (! info->shared)
1659
        {
1660
          /* TODO */
1661
        }
1662
      else
1663
        {
1664
          /* TODO */
1665
        }
1666
 
1667
      /* Fill in the entry in the global offset table.  */
1668
      bfd_put_32 (output_bfd,
1669
                  (splt->output_section->vma
1670
                   + splt->output_offset
1671
                   + h->plt.offset
1672
                   + 12), /* same offset */
1673
                  sgot->contents + got_offset);
1674
 
1675
      /* Fill in the entry in the .rela.plt section.  */
1676
      rela.r_offset = (sgot->output_section->vma
1677
                       + sgot->output_offset
1678
                       + got_offset);
1679
      rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1680
      rela.r_addend = 0;
1681
      loc = srela->contents;
1682
      loc += plt_index * sizeof (Elf32_External_Rela);
1683
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1684
 
1685
      if (!h->def_regular)
1686
        {
1687
          /* Mark the symbol as undefined, rather than as defined in
1688
             the .plt section.  Leave the value alone.  */
1689
          sym->st_shndx = SHN_UNDEF;
1690
        }
1691
 
1692
    }
1693
 
1694
  if (h->got.offset != (bfd_vma) -1)
1695
    {
1696
      asection *sgot;
1697
      asection *srela;
1698
      Elf_Internal_Rela rela;
1699
 
1700
      /* This symbol has an entry in the global offset table.  Set it
1701
         up.  */
1702
      sgot = htab->sgot;
1703
      srela = htab->srelgot;
1704
      BFD_ASSERT (sgot != NULL && srela != NULL);
1705
 
1706
      rela.r_offset = (sgot->output_section->vma
1707
                       + sgot->output_offset
1708
                       + (h->got.offset &~ 1));
1709
 
1710
      /* If this is a -Bsymbolic link, and the symbol is defined
1711
         locally, we just want to emit a RELATIVE reloc.  Likewise if
1712
         the symbol was forced to be local because of a version file.
1713
         The entry in the global offset table will already have been
1714
         initialized in the relocate_section function.  */
1715
      if (info->shared
1716
          && (info->symbolic
1717
              || h->dynindx == -1
1718
              || h->forced_local)
1719
          && h->def_regular)
1720
        {
1721
          rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1722
          rela.r_addend = (h->root.u.def.value
1723
                           + h->root.u.def.section->output_section->vma
1724
                           + h->root.u.def.section->output_offset);
1725
        }
1726
      else
1727
        {
1728
          BFD_ASSERT ((h->got.offset & 1) == 0);
1729
          bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1730
          rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1731
          rela.r_addend = 0;
1732
        }
1733
 
1734
      loc = srela->contents;
1735
      loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1736
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1737
      ++srela->reloc_count;
1738
    }
1739
 
1740
  if (h->needs_copy)
1741
    {
1742
      asection *s;
1743
      Elf_Internal_Rela rela;
1744
 
1745
      /* This symbols needs a copy reloc.  Set it up.  */
1746
      BFD_ASSERT (h->dynindx != -1
1747
                  && (h->root.type == bfd_link_hash_defined
1748
                      || h->root.type == bfd_link_hash_defweak));
1749
 
1750
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
1751
                                   ".rela.bss");
1752
      BFD_ASSERT (s != NULL);
1753
 
1754
      rela.r_offset = (h->root.u.def.value
1755
                       + h->root.u.def.section->output_section->vma
1756
                       + h->root.u.def.section->output_offset);
1757
      rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1758
      rela.r_addend = 0;
1759
      loc = s->contents;
1760
      loc += s->reloc_count * sizeof (Elf32_External_Rela);
1761
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1762
      ++s->reloc_count;
1763
    }
1764
 
1765
  /* Mark some specially defined symbols as absolute.  */
1766
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1767
      || h == htab->root.hgot)
1768
    sym->st_shndx = SHN_ABS;
1769
 
1770
  return TRUE;
1771
}
1772
 
1773
static enum elf_reloc_type_class
1774
lm32_elf_reloc_type_class (const Elf_Internal_Rela *rela)
1775
{
1776
  switch ((int) ELF32_R_TYPE (rela->r_info))
1777
    {
1778
    case R_LM32_RELATIVE:  return reloc_class_relative;
1779
    case R_LM32_JMP_SLOT:  return reloc_class_plt;
1780
    case R_LM32_COPY:      return reloc_class_copy;
1781
    default:               return reloc_class_normal;
1782
    }
1783
}
1784
 
1785
/* Adjust a symbol defined by a dynamic object and referenced by a
1786
   regular object.  The current definition is in some section of the
1787
   dynamic object, but we're not including those sections.  We have to
1788
   change the definition to something the rest of the link can
1789
   understand.  */
1790
 
1791
static bfd_boolean
1792
lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1793
                                struct elf_link_hash_entry *h)
1794
{
1795
  struct elf_lm32_link_hash_table *htab;
1796
  struct elf_lm32_link_hash_entry *eh;
1797
  struct elf_lm32_dyn_relocs *p;
1798
  bfd *dynobj;
1799
  asection *s;
1800
 
1801
  dynobj = elf_hash_table (info)->dynobj;
1802
 
1803
  /* Make sure we know what is going on here.  */
1804
  BFD_ASSERT (dynobj != NULL
1805
              && (h->needs_plt
1806
                  || h->u.weakdef != NULL
1807
                  || (h->def_dynamic
1808
                      && h->ref_regular
1809
                      && !h->def_regular)));
1810
 
1811
  /* If this is a function, put it in the procedure linkage table.  We
1812
     will fill in the contents of the procedure linkage table later,
1813
     when we know the address of the .got section.  */
1814
  if (h->type == STT_FUNC
1815
      || h->needs_plt)
1816
    {
1817
      if (! info->shared
1818
          && !h->def_dynamic
1819
          && !h->ref_dynamic
1820
          && h->root.type != bfd_link_hash_undefweak
1821
          && h->root.type != bfd_link_hash_undefined)
1822
        {
1823
          /* This case can occur if we saw a PLT reloc in an input
1824
             file, but the symbol was never referred to by a dynamic
1825
             object.  In such a case, we don't actually need to build
1826
             a procedure linkage table, and we can just do a PCREL
1827
             reloc instead.  */
1828
          h->plt.offset = (bfd_vma) -1;
1829
          h->needs_plt = 0;
1830
        }
1831
 
1832
      return TRUE;
1833
    }
1834
  else
1835
    h->plt.offset = (bfd_vma) -1;
1836
 
1837
  /* If this is a weak symbol, and there is a real definition, the
1838
     processor independent code will have arranged for us to see the
1839
     real definition first, and we can just use the same value.  */
1840
  if (h->u.weakdef != NULL)
1841
    {
1842
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1843
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
1844
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
1845
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
1846
      return TRUE;
1847
    }
1848
 
1849
  /* This is a reference to a symbol defined by a dynamic object which
1850
     is not a function.  */
1851
 
1852
  /* If we are creating a shared library, we must presume that the
1853
     only references to the symbol are via the global offset table.
1854
     For such cases we need not do anything here; the relocations will
1855
     be handled correctly by relocate_section.  */
1856
  if (info->shared)
1857
    return TRUE;
1858
 
1859
  /* If there are no references to this symbol that do not use the
1860
     GOT, we don't need to generate a copy reloc.  */
1861
  if (!h->non_got_ref)
1862
    return TRUE;
1863
 
1864
  /* If -z nocopyreloc was given, we won't generate them either.  */
1865
  if (info->nocopyreloc)
1866
    {
1867
      h->non_got_ref = 0;
1868
      return TRUE;
1869
    }
1870
 
1871
  eh = (struct elf_lm32_link_hash_entry *) h;
1872
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
1873
    {
1874
      s = p->sec->output_section;
1875
      if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1876
        break;
1877
    }
1878
 
1879
  /* If we didn't find any dynamic relocs in sections which needs the
1880
     copy reloc, then we'll be keeping the dynamic relocs and avoiding
1881
     the copy reloc.  */
1882
  if (p == NULL)
1883
    {
1884
      h->non_got_ref = 0;
1885
      return TRUE;
1886
    }
1887
 
1888
  if (h->size == 0)
1889
    {
1890
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1891
                             h->root.root.string);
1892
      return TRUE;
1893
    }
1894
 
1895
  /* We must allocate the symbol in our .dynbss section, which will
1896
     become part of the .bss section of the executable.  There will be
1897
     an entry for this symbol in the .dynsym section.  The dynamic
1898
     object will contain position independent code, so all references
1899
     from the dynamic object to this symbol will go through the global
1900
     offset table.  The dynamic linker will use the .dynsym entry to
1901
     determine the address it must put in the global offset table, so
1902
     both the dynamic object and the regular object will refer to the
1903
     same memory location for the variable.  */
1904
 
1905
  htab = lm32_elf_hash_table (info);
1906
  if (htab == NULL)
1907
    return FALSE;
1908
 
1909
  s = htab->sdynbss;
1910
  BFD_ASSERT (s != NULL);
1911
 
1912
  /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1913
     to copy the initial value out of the dynamic object and into the
1914
     runtime process image.  We need to remember the offset into the
1915
     .rela.bss section we are going to use.  */
1916
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1917
    {
1918
      asection *srel;
1919
 
1920
      srel = htab->srelbss;
1921
      BFD_ASSERT (srel != NULL);
1922
      srel->size += sizeof (Elf32_External_Rela);
1923
      h->needs_copy = 1;
1924
    }
1925
 
1926
  return _bfd_elf_adjust_dynamic_copy (h, s);
1927
}
1928
 
1929
/* Allocate space in .plt, .got and associated reloc sections for
1930
   dynamic relocs.  */
1931
 
1932
static bfd_boolean
1933
allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1934
{
1935
  struct bfd_link_info *info;
1936
  struct elf_lm32_link_hash_table *htab;
1937
  struct elf_lm32_link_hash_entry *eh;
1938
  struct elf_lm32_dyn_relocs *p;
1939
 
1940
  if (h->root.type == bfd_link_hash_indirect)
1941
    return TRUE;
1942
 
1943
  if (h->root.type == bfd_link_hash_warning)
1944
    /* When warning symbols are created, they **replace** the "real"
1945
       entry in the hash table, thus we never get to see the real
1946
       symbol in a hash traversal.  So look at it now.  */
1947
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1948
 
1949
  info = (struct bfd_link_info *) inf;
1950
  htab = lm32_elf_hash_table (info);
1951
  if (htab == NULL)
1952
    return FALSE;
1953
 
1954
  eh = (struct elf_lm32_link_hash_entry *) h;
1955
 
1956
  if (htab->root.dynamic_sections_created
1957
      && h->plt.refcount > 0)
1958
    {
1959
      /* Make sure this symbol is output as a dynamic symbol.
1960
         Undefined weak syms won't yet be marked as dynamic.  */
1961
      if (h->dynindx == -1
1962
          && !h->forced_local)
1963
        {
1964
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
1965
            return FALSE;
1966
        }
1967
 
1968
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1969
        {
1970
          asection *s = htab->splt;
1971
 
1972
          /* If this is the first .plt entry, make room for the special
1973
             first entry.  */
1974
          if (s->size == 0)
1975
            s->size += PLT_ENTRY_SIZE;
1976
 
1977
          h->plt.offset = s->size;
1978
 
1979
          /* If this symbol is not defined in a regular file, and we are
1980
             not generating a shared library, then set the symbol to this
1981
             location in the .plt.  This is required to make function
1982
             pointers compare as equal between the normal executable and
1983
             the shared library.  */
1984
          if (! info->shared
1985
              && !h->def_regular)
1986
            {
1987
              h->root.u.def.section = s;
1988
              h->root.u.def.value = h->plt.offset;
1989
            }
1990
 
1991
          /* Make room for this entry.  */
1992
          s->size += PLT_ENTRY_SIZE;
1993
 
1994
          /* We also need to make an entry in the .got.plt section, which
1995
             will be placed in the .got section by the linker script.  */
1996
          htab->sgotplt->size += 4;
1997
 
1998
          /* We also need to make an entry in the .rel.plt section.  */
1999
          htab->srelplt->size += sizeof (Elf32_External_Rela);
2000
        }
2001
      else
2002
        {
2003
          h->plt.offset = (bfd_vma) -1;
2004
          h->needs_plt = 0;
2005
        }
2006
    }
2007
  else
2008
    {
2009
      h->plt.offset = (bfd_vma) -1;
2010
      h->needs_plt = 0;
2011
    }
2012
 
2013
  if (h->got.refcount > 0)
2014
    {
2015
      asection *s;
2016
      bfd_boolean dyn;
2017
 
2018
      /* Make sure this symbol is output as a dynamic symbol.
2019
         Undefined weak syms won't yet be marked as dynamic.  */
2020
      if (h->dynindx == -1
2021
          && !h->forced_local)
2022
        {
2023
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
2024
            return FALSE;
2025
        }
2026
 
2027
      s = htab->sgot;
2028
 
2029
      h->got.offset = s->size;
2030
      s->size += 4;
2031
      dyn = htab->root.dynamic_sections_created;
2032
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2033
        htab->srelgot->size += sizeof (Elf32_External_Rela);
2034
    }
2035
  else
2036
    h->got.offset = (bfd_vma) -1;
2037
 
2038
  if (eh->dyn_relocs == NULL)
2039
    return TRUE;
2040
 
2041
  /* In the shared -Bsymbolic case, discard space allocated for
2042
     dynamic pc-relative relocs against symbols which turn out to be
2043
     defined in regular objects.  For the normal shared case, discard
2044
     space for pc-relative relocs that have become local due to symbol
2045
     visibility changes.  */
2046
 
2047
  if (info->shared)
2048
    {
2049
      if (h->def_regular
2050
          && (h->forced_local
2051
              || info->symbolic))
2052
        {
2053
          struct elf_lm32_dyn_relocs **pp;
2054
 
2055
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2056
            {
2057
              p->count -= p->pc_count;
2058
              p->pc_count = 0;
2059
              if (p->count == 0)
2060
                *pp = p->next;
2061
              else
2062
                pp = &p->next;
2063
            }
2064
        }
2065
 
2066
      /* Also discard relocs on undefined weak syms with non-default
2067
         visibility.  */
2068
      if (eh->dyn_relocs != NULL
2069
          && h->root.type == bfd_link_hash_undefweak)
2070
        {
2071
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2072
            eh->dyn_relocs = NULL;
2073
 
2074
          /* Make sure undefined weak symbols are output as a dynamic
2075
             symbol in PIEs.  */
2076
          else if (h->dynindx == -1
2077
                   && !h->forced_local)
2078
            {
2079
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2080
                return FALSE;
2081
            }
2082
        }
2083
    }
2084
  else
2085
    {
2086
      /* For the non-shared case, discard space for relocs against
2087
         symbols which turn out to need copy relocs or are not
2088
         dynamic.  */
2089
 
2090
      if (!h->non_got_ref
2091
          && ((h->def_dynamic
2092
               && !h->def_regular)
2093
              || (htab->root.dynamic_sections_created
2094
                  && (h->root.type == bfd_link_hash_undefweak
2095
                      || h->root.type == bfd_link_hash_undefined))))
2096
        {
2097
          /* Make sure this symbol is output as a dynamic symbol.
2098
             Undefined weak syms won't yet be marked as dynamic.  */
2099
          if (h->dynindx == -1
2100
              && !h->forced_local)
2101
            {
2102
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2103
                return FALSE;
2104
            }
2105
 
2106
          /* If that succeeded, we know we'll be keeping all the
2107
             relocs.  */
2108
          if (h->dynindx != -1)
2109
            goto keep;
2110
        }
2111
 
2112
      eh->dyn_relocs = NULL;
2113
 
2114
    keep: ;
2115
    }
2116
 
2117
  /* Finally, allocate space.  */
2118
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2119
    {
2120
      asection *sreloc = elf_section_data (p->sec)->sreloc;
2121
      sreloc->size += p->count * sizeof (Elf32_External_Rela);
2122
    }
2123
 
2124
  return TRUE;
2125
}
2126
 
2127
/* Find any dynamic relocs that apply to read-only sections.  */
2128
 
2129
static bfd_boolean
2130
readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2131
{
2132
  struct elf_lm32_link_hash_entry *eh;
2133
  struct elf_lm32_dyn_relocs *p;
2134
 
2135
  if (h->root.type == bfd_link_hash_warning)
2136
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2137
 
2138
  eh = (struct elf_lm32_link_hash_entry *) h;
2139
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2140
    {
2141
      asection *s = p->sec->output_section;
2142
 
2143
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
2144
        {
2145
          struct bfd_link_info *info = (struct bfd_link_info *) inf;
2146
 
2147
          info->flags |= DF_TEXTREL;
2148
 
2149
          /* Not an error, just cut short the traversal.  */
2150
          return FALSE;
2151
        }
2152
    }
2153
  return TRUE;
2154
}
2155
 
2156
/* Set the sizes of the dynamic sections.  */
2157
 
2158
static bfd_boolean
2159
lm32_elf_size_dynamic_sections (bfd *output_bfd,
2160
                                struct bfd_link_info *info)
2161
{
2162
  struct elf_lm32_link_hash_table *htab;
2163
  bfd *dynobj;
2164
  asection *s;
2165
  bfd_boolean relocs;
2166
  bfd *ibfd;
2167
 
2168
  htab = lm32_elf_hash_table (info);
2169
  if (htab == NULL)
2170
    return FALSE;
2171
 
2172
  dynobj = htab->root.dynobj;
2173
  BFD_ASSERT (dynobj != NULL);
2174
 
2175
  if (htab->root.dynamic_sections_created)
2176
    {
2177
      /* Set the contents of the .interp section to the interpreter.  */
2178
      if (info->executable)
2179
        {
2180
          s = bfd_get_section_by_name (dynobj, ".interp");
2181
          BFD_ASSERT (s != NULL);
2182
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2183
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2184
        }
2185
    }
2186
 
2187
  /* Set up .got offsets for local syms, and space for local dynamic
2188
     relocs.  */
2189
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2190
    {
2191
      bfd_signed_vma *local_got;
2192
      bfd_signed_vma *end_local_got;
2193
      bfd_size_type locsymcount;
2194
      Elf_Internal_Shdr *symtab_hdr;
2195
      asection *srel;
2196
 
2197
      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2198
        continue;
2199
 
2200
      for (s = ibfd->sections; s != NULL; s = s->next)
2201
        {
2202
          struct elf_lm32_dyn_relocs *p;
2203
 
2204
          for (p = ((struct elf_lm32_dyn_relocs *)
2205
                    elf_section_data (s)->local_dynrel);
2206
               p != NULL;
2207
               p = p->next)
2208
            {
2209
              if (! bfd_is_abs_section (p->sec)
2210
                  && bfd_is_abs_section (p->sec->output_section))
2211
                {
2212
                  /* Input section has been discarded, either because
2213
                     it is a copy of a linkonce section or due to
2214
                     linker script /DISCARD/, so we'll be discarding
2215
                     the relocs too.  */
2216
                }
2217
              else if (p->count != 0)
2218
                {
2219
                  srel = elf_section_data (p->sec)->sreloc;
2220
                  srel->size += p->count * sizeof (Elf32_External_Rela);
2221
                  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2222
                    info->flags |= DF_TEXTREL;
2223
                }
2224
            }
2225
        }
2226
 
2227
      local_got = elf_local_got_refcounts (ibfd);
2228
      if (!local_got)
2229
        continue;
2230
 
2231
      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2232
      locsymcount = symtab_hdr->sh_info;
2233
      end_local_got = local_got + locsymcount;
2234
      s = htab->sgot;
2235
      srel = htab->srelgot;
2236
      for (; local_got < end_local_got; ++local_got)
2237
        {
2238
          if (*local_got > 0)
2239
            {
2240
              *local_got = s->size;
2241
              s->size += 4;
2242
              if (info->shared)
2243
                srel->size += sizeof (Elf32_External_Rela);
2244
            }
2245
          else
2246
            *local_got = (bfd_vma) -1;
2247
        }
2248
    }
2249
 
2250
  /* Allocate global sym .plt and .got entries, and space for global
2251
     sym dynamic relocs.  */
2252
  elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2253
 
2254
  /* We now have determined the sizes of the various dynamic sections.
2255
     Allocate memory for them.  */
2256
  relocs = FALSE;
2257
  for (s = dynobj->sections; s != NULL; s = s->next)
2258
    {
2259
      if ((s->flags & SEC_LINKER_CREATED) == 0)
2260
        continue;
2261
 
2262
      if (s == htab->splt
2263
          || s == htab->sgot
2264
          || s == htab->sgotplt
2265
          || s == htab->sdynbss)
2266
        {
2267
          /* Strip this section if we don't need it; see the
2268
             comment below.  */
2269
        }
2270
      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2271
        {
2272
          if (s->size != 0 && s != htab->srelplt)
2273
            relocs = TRUE;
2274
 
2275
          /* We use the reloc_count field as a counter if we need
2276
             to copy relocs into the output file.  */
2277
          s->reloc_count = 0;
2278
        }
2279
      else
2280
        /* It's not one of our sections, so don't allocate space.  */
2281
        continue;
2282
 
2283
      if (s->size == 0)
2284
        {
2285
          /* If we don't need this section, strip it from the
2286
             output file.  This is mostly to handle .rela.bss and
2287
             .rela.plt.  We must create both sections in
2288
             create_dynamic_sections, because they must be created
2289
             before the linker maps input sections to output
2290
             sections.  The linker does that before
2291
             adjust_dynamic_symbol is called, and it is that
2292
             function which decides whether anything needs to go
2293
             into these sections.  */
2294
          s->flags |= SEC_EXCLUDE;
2295
          continue;
2296
        }
2297
 
2298
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
2299
        continue;
2300
 
2301
      /* Allocate memory for the section contents.  We use bfd_zalloc
2302
         here in case unused entries are not reclaimed before the
2303
         section's contents are written out.  This should not happen,
2304
         but this way if it does, we get a R_LM32_NONE reloc instead
2305
         of garbage.  */
2306
      s->contents = bfd_zalloc (dynobj, s->size);
2307
      if (s->contents == NULL)
2308
        return FALSE;
2309
    }
2310
 
2311
  if (htab->root.dynamic_sections_created)
2312
    {
2313
      /* Add some entries to the .dynamic section.  We fill in the
2314
         values later, in lm32_elf_finish_dynamic_sections, but we
2315
         must add the entries now so that we get the correct size for
2316
         the .dynamic section.  The DT_DEBUG entry is filled in by the
2317
         dynamic linker and used by the debugger.  */
2318
#define add_dynamic_entry(TAG, VAL) \
2319
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2320
 
2321
     if (info->executable)
2322
        {
2323
          if (! add_dynamic_entry (DT_DEBUG, 0))
2324
            return FALSE;
2325
        }
2326
 
2327
      if (htab->splt->size != 0)
2328
        {
2329
          if (! add_dynamic_entry (DT_PLTGOT, 0)
2330
              || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2331
              || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2332
              || ! add_dynamic_entry (DT_JMPREL, 0))
2333
            return FALSE;
2334
        }
2335
 
2336
      if (relocs)
2337
        {
2338
          if (! add_dynamic_entry (DT_RELA, 0)
2339
              || ! add_dynamic_entry (DT_RELASZ, 0)
2340
              || ! add_dynamic_entry (DT_RELAENT,
2341
                                      sizeof (Elf32_External_Rela)))
2342
            return FALSE;
2343
 
2344
          /* If any dynamic relocs apply to a read-only section,
2345
             then we need a DT_TEXTREL entry.  */
2346
          if ((info->flags & DF_TEXTREL) == 0)
2347
            elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2348
                                    info);
2349
 
2350
          if ((info->flags & DF_TEXTREL) != 0)
2351
            {
2352
              if (! add_dynamic_entry (DT_TEXTREL, 0))
2353
                return FALSE;
2354
            }
2355
        }
2356
    }
2357
#undef add_dynamic_entry
2358
 
2359
  /* Allocate .rofixup section.  */
2360
  if (IS_FDPIC (output_bfd))
2361
    {
2362
      struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2363
      int rgot_weak_count = 0;
2364
      int r32_count = 0;
2365
      int rgot_count = 0;
2366
      /* Look for deleted sections.  */
2367
      for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2368
        {
2369
          for (s = ibfd->sections; s != NULL; s = s->next)
2370
            {
2371
              if (s->reloc_count)
2372
                {
2373
                  /* Count relocs that need .rofixup entires.  */
2374
                  Elf_Internal_Rela *internal_relocs, *end;
2375
                  internal_relocs = elf_section_data (s)->relocs;
2376
                  if (internal_relocs == NULL)
2377
                    internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2378
                  if (internal_relocs != NULL)
2379
                    {
2380
                      end = internal_relocs + s->reloc_count;
2381
                      while (internal_relocs < end)
2382
                        {
2383
                          Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2384
                          struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2385
                          unsigned long r_symndx;
2386
                          struct elf_link_hash_entry *h;
2387
 
2388
                          symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2389
                          sym_hashes = elf_sym_hashes (ibfd);
2390
                          r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2391
                          h = NULL;
2392
                          if (r_symndx < symtab_hdr->sh_info)
2393
                            {
2394
                            }
2395
                          else
2396
                            {
2397
                              h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2398
                              while (h->root.type == bfd_link_hash_indirect
2399
                                     || h->root.type == bfd_link_hash_warning)
2400
                                h = (struct elf_link_hash_entry *) h->root.u.i.link;
2401
                              }
2402
 
2403
                          /* Don't generate entries for weak symbols.  */
2404
                          if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2405
                            {
2406
                              if (!elf_discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2407
                                {
2408
                                  switch (ELF32_R_TYPE (internal_relocs->r_info))
2409
                                    {
2410
                                    case R_LM32_32:
2411
                                      r32_count++;
2412
                                      break;
2413
                                    case R_LM32_16_GOT:
2414
                                      rgot_count++;
2415
                                      break;
2416
                                    }
2417
                                }
2418
                            }
2419
                          else
2420
                            {
2421
                              struct weak_symbol_list *current, *new_entry;
2422
                              /* Is this symbol already in the list?  */
2423
                              for (current = list_start; current; current = current->next)
2424
                                {
2425
                                  if (!strcmp (current->name, h->root.root.string))
2426
                                    break;
2427
                                }
2428
                              if (!current && !elf_discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2429
                                {
2430
                                  /* Will this have an entry in the GOT.  */
2431
                                  if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2432
                                    {
2433
                                      /* Create a new entry.  */
2434
                                      new_entry = malloc (sizeof (struct weak_symbol_list));
2435
                                      if (!new_entry)
2436
                                        return FALSE;
2437
                                      new_entry->name = h->root.root.string;
2438
                                      new_entry->next = NULL;
2439
                                      /* Add to list */
2440
                                      if (list_start == NULL)
2441
                                        {
2442
                                          list_start = new_entry;
2443
                                          list_end = new_entry;
2444
                                        }
2445
                                      else
2446
                                        {
2447
                                          list_end->next = new_entry;
2448
                                          list_end = new_entry;
2449
                                        }
2450
                                      /* Increase count of undefined weak symbols in the got.  */
2451
                                      rgot_weak_count++;
2452
                                    }
2453
                                }
2454
                            }
2455
                          internal_relocs++;
2456
                        }
2457
                    }
2458
                  else
2459
                    return FALSE;
2460
                }
2461
            }
2462
        }
2463
      /* Free list.  */
2464
      while (list_start)
2465
        {
2466
          list_end = list_start->next;
2467
          free (list_start);
2468
          list_start = list_end;
2469
        }
2470
 
2471
      /* Size sections.  */
2472
      lm32fdpic_fixup32_section (info)->size = (r32_count + (htab->sgot->size / 4) - rgot_weak_count + 1) * 4;
2473
      if (lm32fdpic_fixup32_section (info)->size == 0)
2474
        lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2475
      else
2476
        {
2477
          lm32fdpic_fixup32_section (info)->contents =
2478
             bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2479
          if (lm32fdpic_fixup32_section (info)->contents == NULL)
2480
            return FALSE;
2481
        }
2482
    }
2483
 
2484
  return TRUE;
2485
}
2486
 
2487
/* Create dynamic sections when linking against a dynamic object.  */
2488
 
2489
static bfd_boolean
2490
lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2491
{
2492
  struct elf_lm32_link_hash_table *htab;
2493
  flagword flags, pltflags;
2494
  asection *s;
2495
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2496
  int ptralign = 2; /* 32bit */
2497
 
2498
  htab = lm32_elf_hash_table (info);
2499
  if (htab == NULL)
2500
    return FALSE;
2501
 
2502
  /* Make sure we have a GOT - For the case where we have a dynamic object
2503
     but none of the relocs in check_relocs */
2504
  if (! create_got_section (abfd, info))
2505
    return FALSE;
2506
  if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2507
    {
2508
      if (! create_rofixup_section (abfd, info))
2509
        return FALSE;
2510
    }
2511
 
2512
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2513
     .rel[a].bss sections.  */
2514
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2515
           | SEC_LINKER_CREATED);
2516
 
2517
  pltflags = flags;
2518
  pltflags |= SEC_CODE;
2519
  if (bed->plt_not_loaded)
2520
    pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2521
  if (bed->plt_readonly)
2522
    pltflags |= SEC_READONLY;
2523
 
2524
  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
2525
  htab->splt = s;
2526
  if (s == NULL
2527
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2528
    return FALSE;
2529
 
2530
  if (bed->want_plt_sym)
2531
    {
2532
      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2533
         .plt section.  */
2534
      struct bfd_link_hash_entry *bh = NULL;
2535
      struct elf_link_hash_entry *h;
2536
 
2537
      if (! (_bfd_generic_link_add_one_symbol
2538
             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2539
              (bfd_vma) 0, NULL, FALSE,
2540
              get_elf_backend_data (abfd)->collect, &bh)))
2541
        return FALSE;
2542
      h = (struct elf_link_hash_entry *) bh;
2543
      h->def_regular = 1;
2544
      h->type = STT_OBJECT;
2545
      htab->root.hplt = h;
2546
 
2547
      if (info->shared
2548
          && ! bfd_elf_link_record_dynamic_symbol (info, h))
2549
        return FALSE;
2550
    }
2551
 
2552
  s = bfd_make_section_with_flags (abfd,
2553
                                   bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
2554
                                   flags | SEC_READONLY);
2555
  htab->srelplt = s;
2556
  if (s == NULL
2557
      || ! bfd_set_section_alignment (abfd, s, ptralign))
2558
    return FALSE;
2559
 
2560
  if (htab->sgot == NULL
2561
      && ! create_got_section (abfd, info))
2562
    return FALSE;
2563
 
2564
  {
2565
    const char *secname;
2566
    char *relname;
2567
    flagword secflags;
2568
    asection *sec;
2569
 
2570
    for (sec = abfd->sections; sec; sec = sec->next)
2571
      {
2572
        secflags = bfd_get_section_flags (abfd, sec);
2573
        if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
2574
            || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
2575
          continue;
2576
        secname = bfd_get_section_name (abfd, sec);
2577
        relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
2578
        strcpy (relname, ".rela");
2579
        strcat (relname, secname);
2580
        if (bfd_get_section_by_name (abfd, secname))
2581
          continue;
2582
        s = bfd_make_section_with_flags (abfd, relname,
2583
                                         flags | SEC_READONLY);
2584
        if (s == NULL
2585
            || ! bfd_set_section_alignment (abfd, s, ptralign))
2586
          return FALSE;
2587
      }
2588
  }
2589
 
2590
  if (bed->want_dynbss)
2591
    {
2592
      /* The .dynbss section is a place to put symbols which are defined
2593
         by dynamic objects, are referenced by regular objects, and are
2594
         not functions.  We must allocate space for them in the process
2595
         image and use a R_*_COPY reloc to tell the dynamic linker to
2596
         initialize them at run time.  The linker script puts the .dynbss
2597
         section into the .bss section of the final image.  */
2598
      s = bfd_make_section_with_flags (abfd, ".dynbss",
2599
                                       SEC_ALLOC | SEC_LINKER_CREATED);
2600
      htab->sdynbss = s;
2601
      if (s == NULL)
2602
        return FALSE;
2603
      /* The .rel[a].bss section holds copy relocs.  This section is not
2604
         normally needed.  We need to create it here, though, so that the
2605
         linker will map it to an output section.  We can't just create it
2606
         only if we need it, because we will not know whether we need it
2607
         until we have seen all the input files, and the first time the
2608
         main linker code calls BFD after examining all the input files
2609
         (size_dynamic_sections) the input sections have already been
2610
         mapped to the output sections.  If the section turns out not to
2611
         be needed, we can discard it later.  We will never need this
2612
         section when generating a shared object, since they do not use
2613
         copy relocs.  */
2614
      if (! info->shared)
2615
        {
2616
          s = bfd_make_section_with_flags (abfd,
2617
                                           (bed->default_use_rela_p
2618
                                            ? ".rela.bss" : ".rel.bss"),
2619
                                           flags | SEC_READONLY);
2620
          htab->srelbss = s;
2621
          if (s == NULL
2622
              || ! bfd_set_section_alignment (abfd, s, ptralign))
2623
            return FALSE;
2624
        }
2625
    }
2626
 
2627
  return TRUE;
2628
}
2629
 
2630
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
2631
 
2632
static void
2633
lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2634
                               struct elf_link_hash_entry *dir,
2635
                               struct elf_link_hash_entry *ind)
2636
{
2637
  struct elf_lm32_link_hash_entry * edir;
2638
  struct elf_lm32_link_hash_entry * eind;
2639
 
2640
  edir = (struct elf_lm32_link_hash_entry *) dir;
2641
  eind = (struct elf_lm32_link_hash_entry *) ind;
2642
 
2643
  if (eind->dyn_relocs != NULL)
2644
    {
2645
      if (edir->dyn_relocs != NULL)
2646
        {
2647
          struct elf_lm32_dyn_relocs **pp;
2648
          struct elf_lm32_dyn_relocs *p;
2649
 
2650
          /* Add reloc counts against the indirect sym to the direct sym
2651
             list.  Merge any entries against the same section.  */
2652
          for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2653
            {
2654
              struct elf_lm32_dyn_relocs *q;
2655
 
2656
              for (q = edir->dyn_relocs; q != NULL; q = q->next)
2657
                if (q->sec == p->sec)
2658
                  {
2659
                    q->pc_count += p->pc_count;
2660
                    q->count += p->count;
2661
                    *pp = p->next;
2662
                    break;
2663
                  }
2664
              if (q == NULL)
2665
                pp = &p->next;
2666
            }
2667
          *pp = edir->dyn_relocs;
2668
        }
2669
 
2670
      edir->dyn_relocs = eind->dyn_relocs;
2671
      eind->dyn_relocs = NULL;
2672
    }
2673
 
2674
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2675
}
2676
 
2677
static bfd_boolean
2678
lm32_elf_always_size_sections (bfd *output_bfd,
2679
                                 struct bfd_link_info *info)
2680
{
2681
  if (!info->relocatable)
2682
    {
2683
      struct elf_link_hash_entry *h;
2684
 
2685
      /* Force a PT_GNU_STACK segment to be created.  */
2686
      if (! elf_tdata (output_bfd)->stack_flags)
2687
        elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
2688
 
2689
      /* Define __stacksize if it's not defined yet.  */
2690
      h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2691
                                FALSE, FALSE, FALSE);
2692
      if (! h || h->root.type != bfd_link_hash_defined
2693
          || h->type != STT_OBJECT
2694
          || !h->def_regular)
2695
        {
2696
          struct bfd_link_hash_entry *bh = NULL;
2697
 
2698
          if (!(_bfd_generic_link_add_one_symbol
2699
                (info, output_bfd, "__stacksize",
2700
                 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
2701
                 (const char *) NULL, FALSE,
2702
                 get_elf_backend_data (output_bfd)->collect, &bh)))
2703
            return FALSE;
2704
 
2705
          h = (struct elf_link_hash_entry *) bh;
2706
          h->def_regular = 1;
2707
          h->type = STT_OBJECT;
2708
          /* This one must NOT be hidden.  */
2709
        }
2710
    }
2711
 
2712
  return TRUE;
2713
}
2714
 
2715
static bfd_boolean
2716
lm32_elf_modify_segment_map (bfd *output_bfd,
2717
                             struct bfd_link_info *info)
2718
{
2719
  struct elf_segment_map *m;
2720
 
2721
  /* objcopy and strip preserve what's already there using elf32_lm32fdpic_copy_
2722
     private_bfd_data ().  */
2723
  if (! info)
2724
    return TRUE;
2725
 
2726
  for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
2727
    if (m->p_type == PT_GNU_STACK)
2728
      break;
2729
 
2730
  if (m)
2731
    {
2732
      asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2733
      struct elf_link_hash_entry *h;
2734
 
2735
      if (sec)
2736
        {
2737
          /* Obtain the pointer to the __stacksize symbol.  */
2738
          h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2739
                                    FALSE, FALSE, FALSE);
2740
          while (h->root.type == bfd_link_hash_indirect
2741
                 || h->root.type == bfd_link_hash_warning)
2742
            h = (struct elf_link_hash_entry *)h->root.u.i.link;
2743
          BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2744
 
2745
          /* Set the section size from the symbol value.  We
2746
             intentionally ignore the symbol section.  */
2747
          if (h->root.type == bfd_link_hash_defined)
2748
            sec->size = h->root.u.def.value;
2749
          else
2750
            sec->size = DEFAULT_STACK_SIZE;
2751
 
2752
          /* Add the stack section to the PT_GNU_STACK segment,
2753
             such that its size and alignment requirements make it
2754
             to the segment.  */
2755
          m->sections[m->count] = sec;
2756
          m->count++;
2757
        }
2758
    }
2759
 
2760
  return TRUE;
2761
}
2762
 
2763
static bfd_boolean
2764
lm32_elf_modify_program_headers (bfd *output_bfd,
2765
                                       struct bfd_link_info *info)
2766
{
2767
  struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
2768
  struct elf_segment_map *m;
2769
  Elf_Internal_Phdr *p;
2770
 
2771
  if (! info)
2772
    return TRUE;
2773
 
2774
  for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
2775
    if (m->p_type == PT_GNU_STACK)
2776
      break;
2777
 
2778
  if (m)
2779
    {
2780
      struct elf_link_hash_entry *h;
2781
 
2782
      /* Obtain the pointer to the __stacksize symbol.  */
2783
      h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2784
                                FALSE, FALSE, FALSE);
2785
      if (h)
2786
        {
2787
          while (h->root.type == bfd_link_hash_indirect
2788
                 || h->root.type == bfd_link_hash_warning)
2789
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2790
          BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2791
        }
2792
 
2793
      /* Set the header p_memsz from the symbol value.  We
2794
         intentionally ignore the symbol section.  */
2795
      if (h && h->root.type == bfd_link_hash_defined)
2796
        p->p_memsz = h->root.u.def.value;
2797
      else
2798
        p->p_memsz = DEFAULT_STACK_SIZE;
2799
 
2800
      p->p_align = 8;
2801
    }
2802
 
2803
  return TRUE;
2804
}
2805
 
2806
 
2807
static bfd_boolean
2808
lm32_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2809
{
2810
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2811
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2812
    return TRUE;
2813
 
2814
  BFD_ASSERT (!elf_flags_init (obfd)
2815
              || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
2816
 
2817
  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2818
  elf_flags_init (obfd) = TRUE;
2819
 
2820
  /* Copy object attributes.  */
2821
  _bfd_elf_copy_obj_attributes (ibfd, obfd);
2822
 
2823
  return TRUE;
2824
}
2825
 
2826
 
2827
static bfd_boolean
2828
lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2829
{
2830
  unsigned i;
2831
 
2832
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2833
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2834
    return TRUE;
2835
 
2836
  if (! lm32_elf_copy_private_bfd_data (ibfd, obfd))
2837
    return FALSE;
2838
 
2839
  if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2840
      || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2841
    return TRUE;
2842
 
2843
  /* Copy the stack size.  */
2844
  for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2845
    if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2846
      {
2847
        Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2848
 
2849
        for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2850
          if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2851
            {
2852
              memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2853
 
2854
              /* Rewrite the phdrs, since we're only called after they were first written.  */
2855
              if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2856
                            ->s->sizeof_ehdr, SEEK_SET) != 0
2857
                  || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2858
                                     elf_elfheader (obfd)->e_phnum) != 0)
2859
                return FALSE;
2860
              break;
2861
            }
2862
 
2863
        break;
2864
      }
2865
 
2866
  return TRUE;
2867
}
2868
 
2869
 
2870
#define ELF_ARCH                bfd_arch_lm32
2871
#define ELF_MACHINE_CODE        EM_LATTICEMICO32
2872
#define ELF_MAXPAGESIZE         0x1000
2873
 
2874
#define TARGET_BIG_SYM          bfd_elf32_lm32_vec
2875
#define TARGET_BIG_NAME         "elf32-lm32"
2876
 
2877
#define bfd_elf32_bfd_reloc_type_lookup         lm32_reloc_type_lookup
2878
#define bfd_elf32_bfd_reloc_name_lookup         lm32_reloc_name_lookup
2879
#define elf_info_to_howto                       lm32_info_to_howto_rela
2880
#define elf_info_to_howto_rel                   0
2881
#define elf_backend_rela_normal                 1
2882
#define elf_backend_object_p                    lm32_elf_object_p
2883
#define elf_backend_final_write_processing      lm32_elf_final_write_processing
2884
#define elf_backend_can_gc_sections             1
2885
#define elf_backend_can_refcount                1
2886
#define elf_backend_gc_mark_hook                lm32_elf_gc_mark_hook
2887
#define elf_backend_gc_sweep_hook               lm32_elf_gc_sweep_hook
2888
#define elf_backend_plt_readonly                1
2889
#define elf_backend_want_got_plt                1
2890
#define elf_backend_want_plt_sym                0
2891
#define elf_backend_got_header_size             12
2892
#define bfd_elf32_bfd_link_hash_table_create    lm32_elf_link_hash_table_create
2893
#define elf_backend_check_relocs                lm32_elf_check_relocs
2894
#define elf_backend_reloc_type_class            lm32_elf_reloc_type_class
2895
#define elf_backend_copy_indirect_symbol        lm32_elf_copy_indirect_symbol
2896
#define elf_backend_size_dynamic_sections       lm32_elf_size_dynamic_sections
2897
#define elf_backend_omit_section_dynsym         ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2898
#define elf_backend_create_dynamic_sections     lm32_elf_create_dynamic_sections
2899
#define elf_backend_finish_dynamic_sections     lm32_elf_finish_dynamic_sections
2900
#define elf_backend_adjust_dynamic_symbol       lm32_elf_adjust_dynamic_symbol
2901
#define elf_backend_finish_dynamic_symbol       lm32_elf_finish_dynamic_symbol
2902
#define elf_backend_relocate_section            lm32_elf_relocate_section
2903
 
2904
#include "elf32-target.h"
2905
 
2906
#undef  ELF_MAXPAGESIZE
2907
#define ELF_MAXPAGESIZE         0x4000
2908
 
2909
 
2910
#undef  TARGET_BIG_SYM
2911
#define TARGET_BIG_SYM          bfd_elf32_lm32fdpic_vec
2912
#undef  TARGET_BIG_NAME
2913
#define TARGET_BIG_NAME         "elf32-lm32fdpic"
2914
#undef  elf32_bed
2915
#define elf32_bed               elf32_lm32fdpic_bed
2916
 
2917
#undef  elf_backend_always_size_sections
2918
#define elf_backend_always_size_sections        lm32_elf_always_size_sections
2919
#undef  elf_backend_modify_segment_map
2920
#define elf_backend_modify_segment_map          lm32_elf_modify_segment_map
2921
#undef  elf_backend_modify_program_headers
2922
#define elf_backend_modify_program_headers      lm32_elf_modify_program_headers
2923
#undef  bfd_elf32_bfd_copy_private_bfd_data
2924
#define bfd_elf32_bfd_copy_private_bfd_data     lm32_elf_fdpic_copy_private_bfd_data
2925
 
2926
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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