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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [bfd/] [elf32-lm32.c] - Blame information for rev 205

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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