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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* M32R-specific support for 32-bit ELF.
2
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 225 jeremybenn
   2006, 2007, 2008, 2009  Free Software Foundation, Inc.
4 24 jeremybenn
 
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 "sysdep.h"
23
#include "bfd.h"
24
#include "libbfd.h"
25
#include "elf-bfd.h"
26
#include "elf/m32r.h"
27
 
28
#define NOP_INSN                0x7000
29
#define MAKE_PARALLEL(insn)     ((insn) | 0x8000)
30
 
31
/* Use REL instead of RELA to save space.
32
   This only saves space in libraries and object files, but perhaps
33
   relocs will be put in ROM?  All in all though, REL relocs are a pain
34
   to work with.  */
35
/* #define USE_REL      1
36
 
37
#ifndef USE_REL
38
#define USE_REL 0
39
#endif */
40
/* Use RELA. But use REL to link old objects for backwords compatibility.  */
41
 
42
/* Functions for the M32R ELF linker.  */
43
 
44
/* The name of the dynamic interpreter.  This is put in the .interp
45
   section.  */
46
 
47
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
48
 
49
/* The nop opcode we use.  */
50
 
51
#define M32R_NOP 0x7000f000
52
 
53
#define PLT_EMPTY   0x10101010  /* RIE  -> RIE */
54
 
55
/* The size in bytes of an entry in the procedure linkage table.  */
56
 
57
#define PLT_ENTRY_SIZE 20
58
#define PLT_HEADER_SIZE 20
59
 
60
/* The first one entries in a procedure linkage table are reserved,
61
   and the initial contents are unimportant (we zero them out).
62
   Subsequent entries look like this. */
63
 
64
#define PLT0_ENTRY_WORD0  0xd6c00000    /* seth r6, #high(.got+4)          */
65
#define PLT0_ENTRY_WORD1  0x86e60000    /* or3  r6, r6, #low(.got)+4)      */
66
#define PLT0_ENTRY_WORD2  0x24e626c6    /* ld   r4, @r6+    -> ld r6, @r6  */
67
#define PLT0_ENTRY_WORD3  0x1fc6f000    /* jmp  r6          || pnop        */
68
#define PLT0_ENTRY_WORD4  PLT_EMPTY     /* RIE             -> RIE          */
69
 
70
#define PLT0_PIC_ENTRY_WORD0  0xa4cc0004 /* ld   r4, @(4,r12)              */
71
#define PLT0_PIC_ENTRY_WORD1  0xa6cc0008 /* ld   r6, @(8,r12)              */
72
#define PLT0_PIC_ENTRY_WORD2  0x1fc6f000 /* jmp  r6         || nop         */
73
#define PLT0_PIC_ENTRY_WORD3  PLT_EMPTY  /* RIE             -> RIE         */
74
#define PLT0_PIC_ENTRY_WORD4  PLT_EMPTY  /* RIE             -> RIE         */
75
 
76
#define PLT_ENTRY_WORD0  0xe6000000 /* ld24 r6, .name_in_GOT                */
77
#define PLT_ENTRY_WORD1  0x06acf000 /* add  r6, r12          || nop         */
78
#define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT)         */
79
#define PLT_ENTRY_WORD1b 0x86e60000 /* or3  r6, r6, #low(.name_in_GOT)      */
80
#define PLT_ENTRY_WORD2  0x26c61fc6 /* ld  r6, @r6           -> jmp r6      */
81
#define PLT_ENTRY_WORD3  0xe5000000 /* ld24 r5, $offset                     */
82
#define PLT_ENTRY_WORD4  0xff000000 /* bra  .plt0.                          */
83
 
84
 
85
/* Utility to actually perform an R_M32R_10_PCREL reloc.  */
86
 
87
static bfd_reloc_status_type
88
m32r_elf_do_10_pcrel_reloc (bfd *abfd,
89
                            reloc_howto_type *howto,
90
                            asection *input_section,
91
                            bfd_byte *data,
92
                            bfd_vma offset,
93
                            asection *symbol_section ATTRIBUTE_UNUSED,
94
                            bfd_vma symbol_value,
95
                            bfd_vma addend)
96
{
97
  bfd_signed_vma relocation;
98
  unsigned long x;
99
  bfd_reloc_status_type status;
100
 
101
  /* Sanity check the address (offset in section).  */
102
  if (offset > bfd_get_section_limit (abfd, input_section))
103
    return bfd_reloc_outofrange;
104
 
105
  relocation = symbol_value + addend;
106
  /* Make it pc relative.  */
107
  relocation -= (input_section->output_section->vma
108
                 + input_section->output_offset);
109
  /* These jumps mask off the lower two bits of the current address
110
     before doing pcrel calculations.  */
111
  relocation -= (offset & -(bfd_vma) 4);
112
 
113
  if (relocation < -0x200 || relocation > 0x1ff)
114
    status = bfd_reloc_overflow;
115
  else
116
    status = bfd_reloc_ok;
117
 
118
  x = bfd_get_16 (abfd, data + offset);
119
  relocation >>= howto->rightshift;
120
  relocation <<= howto->bitpos;
121
  x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask);
122
  bfd_put_16 (abfd, (bfd_vma) x, data + offset);
123
 
124
  return status;
125
}
126
 
127
/* Handle the R_M32R_10_PCREL reloc.  */
128
 
129
static bfd_reloc_status_type
130
m32r_elf_10_pcrel_reloc (bfd * abfd,
131
                         arelent * reloc_entry,
132
                         asymbol * symbol,
133
                         void * data,
134
                         asection * input_section,
135
                         bfd * output_bfd,
136
                         char ** error_message ATTRIBUTE_UNUSED)
137
{
138
  /* This part is from bfd_elf_generic_reloc.  */
139
  if (output_bfd != NULL
140
      && (symbol->flags & BSF_SECTION_SYM) == 0
141
      && (! reloc_entry->howto->partial_inplace
142
          || reloc_entry->addend == 0))
143
    {
144
      reloc_entry->address += input_section->output_offset;
145
      return bfd_reloc_ok;
146
    }
147
 
148
  if (output_bfd != NULL)
149
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
150
    return bfd_reloc_continue;
151
 
152
  return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto,
153
                                     input_section,
154
                                     data, reloc_entry->address,
155
                                     symbol->section,
156
                                     (symbol->value
157
                                      + symbol->section->output_section->vma
158
                                      + symbol->section->output_offset),
159
                                     reloc_entry->addend);
160
}
161
 
162
/* Do generic partial_inplace relocation.
163
   This is a local replacement for bfd_elf_generic_reloc.  */
164
 
165
static bfd_reloc_status_type
166
m32r_elf_generic_reloc (bfd *input_bfd,
167
                        arelent *reloc_entry,
168
                        asymbol *symbol,
169
                        void * data,
170
                        asection *input_section,
171
                        bfd *output_bfd,
172
                        char **error_message ATTRIBUTE_UNUSED)
173
{
174
  bfd_reloc_status_type ret;
175
  bfd_vma relocation;
176
  bfd_byte *inplace_address;
177
 
178
  /* This part is from bfd_elf_generic_reloc.
179
     If we're relocating, and this an external symbol, we don't want
180
     to change anything.  */
181
  if (output_bfd != NULL
182
      && (symbol->flags & BSF_SECTION_SYM) == 0
183
      && reloc_entry->addend == 0)
184
    {
185
      reloc_entry->address += input_section->output_offset;
186
      return bfd_reloc_ok;
187
    }
188
 
189
  /* Now do the reloc in the usual way.
190
     ??? It would be nice to call bfd_elf_generic_reloc here,
191
     but we have partial_inplace set.  bfd_elf_generic_reloc will
192
     pass the handling back to bfd_install_relocation which will install
193
     a section relative addend which is wrong.  */
194
 
195
  /* Sanity check the address (offset in section).  */
196
  if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
197
    return bfd_reloc_outofrange;
198
 
199
  ret = bfd_reloc_ok;
200
  if (bfd_is_und_section (symbol->section)
201
      && output_bfd == NULL)
202
    ret = bfd_reloc_undefined;
203
 
204
  if (bfd_is_com_section (symbol->section)
205
      || output_bfd != NULL)
206
    relocation = 0;
207
  else
208
    relocation = symbol->value;
209
 
210
  /* Only do this for a final link.  */
211
  if (output_bfd == NULL)
212
    {
213
      relocation += symbol->section->output_section->vma;
214
      relocation += symbol->section->output_offset;
215
    }
216
 
217
  relocation += reloc_entry->addend;
218
  inplace_address = (bfd_byte *) data + reloc_entry->address;
219
 
220
#define DOIT(x)                                         \
221
  x = ( (x & ~reloc_entry->howto->dst_mask) |           \
222
  (((x & reloc_entry->howto->src_mask) +  relocation) & \
223
  reloc_entry->howto->dst_mask))
224
 
225
  switch (reloc_entry->howto->size)
226
    {
227
    case 1:
228
      {
229
        short x = bfd_get_16 (input_bfd, inplace_address);
230
        DOIT (x);
231
        bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address);
232
      }
233
      break;
234
    case 2:
235
      {
236
        unsigned long x = bfd_get_32 (input_bfd, inplace_address);
237
        DOIT (x);
238
        bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address);
239
      }
240
      break;
241
    default:
242
      BFD_ASSERT (0);
243
    }
244
 
245
  if (output_bfd != NULL)
246
    reloc_entry->address += input_section->output_offset;
247
 
248
  return ret;
249
}
250
 
251
/* Handle the R_M32R_SDA16 reloc.
252
   This reloc is used to compute the address of objects in the small data area
253
   and to perform loads and stores from that area.
254
   The lower 16 bits are sign extended and added to the register specified
255
   in the instruction, which is assumed to point to _SDA_BASE_.  */
256
 
257
static bfd_reloc_status_type
258
m32r_elf_sda16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
259
                      arelent *reloc_entry,
260
                      asymbol *symbol,
261
                      void * data ATTRIBUTE_UNUSED,
262
                      asection *input_section,
263
                      bfd *output_bfd,
264
                      char **error_message ATTRIBUTE_UNUSED)
265
{
266
  /* This part is from bfd_elf_generic_reloc.  */
267
  if (output_bfd != NULL
268
      && (symbol->flags & BSF_SECTION_SYM) == 0
269
      && (! reloc_entry->howto->partial_inplace
270
          || reloc_entry->addend == 0))
271
    {
272
      reloc_entry->address += input_section->output_offset;
273
      return bfd_reloc_ok;
274
    }
275
 
276
  if (output_bfd != NULL)
277
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
278
    return bfd_reloc_continue;
279
 
280
  /* FIXME: not sure what to do here yet.  But then again, the linker
281
     may never call us.  */
282
  abort ();
283
}
284
 
285
 
286
/* Handle the R_M32R_HI16_[SU]LO relocs.
287
   HI16_SLO is for the add3 and load/store with displacement instructions.
288
   HI16_ULO is for the or3 instruction.
289
   For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to
290
   the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
291
   we must add one to the high 16 bytes (which will get subtracted off when
292
   the low 16 bits are added).
293
   These relocs have to be done in combination with an R_M32R_LO16 reloc
294
   because there is a carry from the LO16 to the HI16.  Here we just save
295
   the information we need; we do the actual relocation when we see the LO16.
296
   This code is copied from the elf32-mips.c.  We also support an arbitrary
297
   number of HI16 relocs to be associated with a single LO16 reloc.  The
298
   assembler sorts the relocs to ensure each HI16 immediately precedes its
299
   LO16.  However if there are multiple copies, the assembler may not find
300
   the real LO16 so it picks the first one it finds.  */
301
 
302
struct m32r_hi16
303
{
304
  struct m32r_hi16 *next;
305
  bfd_byte *addr;
306
  bfd_vma addend;
307
};
308
 
309
/* FIXME: This should not be a static variable.  */
310
 
311
static struct m32r_hi16 *m32r_hi16_list;
312
 
313
static bfd_reloc_status_type
314
m32r_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
315
                     arelent *reloc_entry,
316
                     asymbol *symbol,
317
                     void * data,
318
                     asection *input_section,
319
                     bfd *output_bfd,
320
                     char **error_message ATTRIBUTE_UNUSED)
321
{
322
  bfd_reloc_status_type ret;
323
  bfd_vma relocation;
324
  struct m32r_hi16 *n;
325
 
326
  /* This part is from bfd_elf_generic_reloc.
327
     If we're relocating, and this an external symbol, we don't want
328
     to change anything.  */
329
  if (output_bfd != NULL
330
      && (symbol->flags & BSF_SECTION_SYM) == 0
331
      && reloc_entry->addend == 0)
332
    {
333
      reloc_entry->address += input_section->output_offset;
334
      return bfd_reloc_ok;
335
    }
336
 
337
  /* Sanity check the address (offset in section).  */
338
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
339
    return bfd_reloc_outofrange;
340
 
341
  ret = bfd_reloc_ok;
342
  if (bfd_is_und_section (symbol->section)
343
      && output_bfd == NULL)
344
    ret = bfd_reloc_undefined;
345
 
346
  if (bfd_is_com_section (symbol->section))
347
    relocation = 0;
348
  else
349
    relocation = symbol->value;
350
 
351
  relocation += symbol->section->output_section->vma;
352
  relocation += symbol->section->output_offset;
353
  relocation += reloc_entry->addend;
354
 
355
  /* Save the information, and let LO16 do the actual relocation.  */
356
  n = bfd_malloc ((bfd_size_type) sizeof *n);
357
  if (n == NULL)
358
    return bfd_reloc_outofrange;
359
  n->addr = (bfd_byte *) data + reloc_entry->address;
360
  n->addend = relocation;
361
  n->next = m32r_hi16_list;
362
  m32r_hi16_list = n;
363
 
364
  if (output_bfd != NULL)
365
    reloc_entry->address += input_section->output_offset;
366
 
367
  return ret;
368
}
369
 
370
/* Handle an M32R ELF HI16 reloc.  */
371
 
372
static void
373
m32r_elf_relocate_hi16 (bfd *input_bfd,
374
                        int type,
375
                        Elf_Internal_Rela *relhi,
376
                        Elf_Internal_Rela *rello,
377
                        bfd_byte *contents,
378
                        bfd_vma addend)
379
{
380
  unsigned long insn;
381
  bfd_vma addlo;
382
 
383
  insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
384
 
385
  addlo = bfd_get_32 (input_bfd, contents + rello->r_offset);
386
  if (type == R_M32R_HI16_SLO)
387
    addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000;
388
  else
389
    addlo &= 0xffff;
390
 
391
  addend += ((insn & 0xffff) << 16) + addlo;
392
 
393
  /* Reaccount for sign extension of low part.  */
394
  if (type == R_M32R_HI16_SLO
395
      && (addend & 0x8000) != 0)
396
    addend += 0x10000;
397
 
398
  bfd_put_32 (input_bfd,
399
              (insn & 0xffff0000) | ((addend >> 16) & 0xffff),
400
              contents + relhi->r_offset);
401
}
402
 
403
/* Do an R_M32R_LO16 relocation.  This is a straightforward 16 bit
404
   inplace relocation; this function exists in order to do the
405
   R_M32R_HI16_[SU]LO relocation described above.  */
406
 
407
static bfd_reloc_status_type
408
m32r_elf_lo16_reloc (bfd *input_bfd,
409
                     arelent *reloc_entry,
410
                     asymbol *symbol,
411
                     void * data,
412
                     asection *input_section,
413
                     bfd *output_bfd,
414
                     char **error_message)
415
{
416
  /* This part is from bfd_elf_generic_reloc.
417
     If we're relocating, and this an external symbol, we don't want
418
     to change anything.  */
419
  if (output_bfd != NULL
420
      && (symbol->flags & BSF_SECTION_SYM) == 0
421
      && reloc_entry->addend == 0)
422
    {
423
      reloc_entry->address += input_section->output_offset;
424
      return bfd_reloc_ok;
425
    }
426
 
427
  if (m32r_hi16_list != NULL)
428
    {
429
      struct m32r_hi16 *l;
430
 
431
      l = m32r_hi16_list;
432
      while (l != NULL)
433
        {
434
          unsigned long insn;
435
          unsigned long val;
436
          unsigned long vallo;
437
          struct m32r_hi16 *next;
438
 
439
          /* Do the HI16 relocation.  Note that we actually don't need
440
             to know anything about the LO16 itself, except where to
441
             find the low 16 bits of the addend needed by the LO16.  */
442
          insn = bfd_get_32 (input_bfd, l->addr);
443
          vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address)
444
                   & 0xffff) ^ 0x8000) - 0x8000;
445
          val = ((insn & 0xffff) << 16) + vallo;
446
          val += l->addend;
447
 
448
          /* Reaccount for sign extension of low part.  */
449
          if ((val & 0x8000) != 0)
450
            val += 0x10000;
451
 
452
          insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff);
453
          bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr);
454
 
455
          next = l->next;
456
          free (l);
457
          l = next;
458
        }
459
 
460
      m32r_hi16_list = NULL;
461
    }
462
 
463
  /* Now do the LO16 reloc in the usual way.
464
     ??? It would be nice to call bfd_elf_generic_reloc here,
465
     but we have partial_inplace set.  bfd_elf_generic_reloc will
466
     pass the handling back to bfd_install_relocation which will install
467
     a section relative addend which is wrong.  */
468
  return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
469
                                input_section, output_bfd, error_message);
470
}
471
 
472
 
473
static reloc_howto_type m32r_elf_howto_table[] =
474
{
475
  /* This reloc does nothing.  */
476
  HOWTO (R_M32R_NONE,           /* type */
477
         0,                      /* rightshift */
478
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
479
         32,                    /* bitsize */
480
         FALSE,                 /* pc_relative */
481
         0,                      /* bitpos */
482
         complain_overflow_bitfield, /* complain_on_overflow */
483
         bfd_elf_generic_reloc, /* special_function */
484
         "R_M32R_NONE",         /* name */
485
         FALSE,                 /* partial_inplace */
486
         0,                      /* src_mask */
487
         0,                      /* dst_mask */
488
         FALSE),                /* pcrel_offset */
489
 
490
  /* A 16 bit absolute relocation.  */
491
  HOWTO (R_M32R_16,             /* type */
492
         0,                      /* rightshift */
493
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
494
         16,                    /* bitsize */
495
         FALSE,                 /* pc_relative */
496
         0,                      /* bitpos */
497
         complain_overflow_bitfield, /* complain_on_overflow */
498
         m32r_elf_generic_reloc,/* special_function */
499
         "R_M32R_16",           /* name */
500
         TRUE,                  /* partial_inplace */
501
         0xffff,                /* src_mask */
502
         0xffff,                /* dst_mask */
503
         FALSE),                /* pcrel_offset */
504
 
505
  /* A 32 bit absolute relocation.  */
506
  HOWTO (R_M32R_32,             /* 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
         m32r_elf_generic_reloc,/* special_function */
514
         "R_M32R_32",           /* name */
515
         TRUE,                  /* partial_inplace */
516
         0xffffffff,            /* src_mask */
517
         0xffffffff,            /* dst_mask */
518
         FALSE),                /* pcrel_offset */
519
 
520
  /* A 24 bit address.  */
521
  HOWTO (R_M32R_24,             /* type */
522
         0,                      /* rightshift */
523
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
524
         24,                    /* bitsize */
525
         FALSE,                 /* pc_relative */
526
         0,                      /* bitpos */
527
         complain_overflow_unsigned, /* complain_on_overflow */
528
         m32r_elf_generic_reloc,/* special_function */
529
         "R_M32R_24",           /* name */
530
         TRUE,                  /* partial_inplace */
531
         0xffffff,              /* src_mask */
532
         0xffffff,              /* dst_mask */
533
         FALSE),                /* pcrel_offset */
534
 
535
  /* An PC Relative 10-bit relocation, shifted by 2.
536
     This reloc is complicated because relocations are relative to pc & -4.
537
     i.e. branches in the right insn slot use the address of the left insn
538
     slot for pc.  */
539
  /* ??? It's not clear whether this should have partial_inplace set or not.
540
     Branch relaxing in the assembler can store the addend in the insn,
541
     and if bfd_install_relocation gets called the addend may get added
542
     again.  */
543
  HOWTO (R_M32R_10_PCREL,       /* type */
544
         2,                     /* rightshift */
545
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
546
         10,                    /* bitsize */
547
         TRUE,                  /* pc_relative */
548
         0,                      /* bitpos */
549
         complain_overflow_signed, /* complain_on_overflow */
550
         m32r_elf_10_pcrel_reloc, /* special_function */
551
         "R_M32R_10_PCREL",     /* name */
552
         FALSE,                 /* partial_inplace */
553
         0xff,                  /* src_mask */
554
         0xff,                  /* dst_mask */
555
         TRUE),                 /* pcrel_offset */
556
 
557
  /* A relative 18 bit relocation, right shifted by 2.  */
558
  HOWTO (R_M32R_18_PCREL,       /* type */
559
         2,                     /* rightshift */
560
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
561
         16,                    /* bitsize */
562
         TRUE,                  /* pc_relative */
563
         0,                      /* bitpos */
564
         complain_overflow_signed, /* complain_on_overflow */
565
         bfd_elf_generic_reloc, /* special_function */
566
         "R_M32R_18_PCREL",     /* name */
567
         FALSE,                 /* partial_inplace */
568
         0xffff,                /* src_mask */
569
         0xffff,                /* dst_mask */
570
         TRUE),                 /* pcrel_offset */
571
 
572
  /* A relative 26 bit relocation, right shifted by 2.  */
573
  /* ??? It's not clear whether this should have partial_inplace set or not.
574
     Branch relaxing in the assembler can store the addend in the insn,
575
     and if bfd_install_relocation gets called the addend may get added
576
     again.  */
577
  HOWTO (R_M32R_26_PCREL,       /* type */
578
         2,                     /* rightshift */
579
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
580
         26,                    /* bitsize */
581
         TRUE,                  /* pc_relative */
582
         0,                      /* bitpos */
583
         complain_overflow_signed, /* complain_on_overflow */
584
         bfd_elf_generic_reloc, /* special_function */
585
         "R_M32R_26_PCREL",     /* name */
586
         FALSE,                 /* partial_inplace */
587
         0xffffff,              /* src_mask */
588
         0xffffff,              /* dst_mask */
589
         TRUE),                 /* pcrel_offset */
590
 
591
  /* High 16 bits of address when lower 16 is or'd in.  */
592
  HOWTO (R_M32R_HI16_ULO,       /* type */
593
         16,                    /* rightshift */
594
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
595
         16,                    /* bitsize */
596
         FALSE,                 /* pc_relative */
597
         0,                      /* bitpos */
598
         complain_overflow_dont, /* complain_on_overflow */
599
         m32r_elf_hi16_reloc,   /* special_function */
600
         "R_M32R_HI16_ULO",     /* name */
601
         TRUE,                  /* partial_inplace */
602
         0x0000ffff,            /* src_mask */
603
         0x0000ffff,            /* dst_mask */
604
         FALSE),                /* pcrel_offset */
605
 
606
  /* High 16 bits of address when lower 16 is added in.  */
607
  HOWTO (R_M32R_HI16_SLO,       /* type */
608
         16,                    /* rightshift */
609
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
610
         16,                    /* bitsize */
611
         FALSE,                 /* pc_relative */
612
         0,                      /* bitpos */
613
         complain_overflow_dont, /* complain_on_overflow */
614
         m32r_elf_hi16_reloc,   /* special_function */
615
         "R_M32R_HI16_SLO",     /* name */
616
         TRUE,                  /* partial_inplace */
617
         0x0000ffff,            /* src_mask */
618
         0x0000ffff,            /* dst_mask */
619
         FALSE),                /* pcrel_offset */
620
 
621
  /* Lower 16 bits of address.  */
622
  HOWTO (R_M32R_LO16,           /* type */
623
         0,                      /* rightshift */
624
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
625
         16,                    /* bitsize */
626
         FALSE,                 /* pc_relative */
627
         0,                      /* bitpos */
628
         complain_overflow_dont, /* complain_on_overflow */
629
         m32r_elf_lo16_reloc,   /* special_function */
630
         "R_M32R_LO16",         /* name */
631
         TRUE,                  /* partial_inplace */
632
         0x0000ffff,            /* src_mask */
633
         0x0000ffff,            /* dst_mask */
634
         FALSE),                /* pcrel_offset */
635
 
636
  /* Small data area 16 bits offset.  */
637
  HOWTO (R_M32R_SDA16,          /* type */
638
         0,                      /* rightshift */
639
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
640
         16,                    /* bitsize */
641
         FALSE,                 /* pc_relative */
642
         0,                      /* bitpos */
643
         complain_overflow_signed, /* complain_on_overflow */
644
         m32r_elf_sda16_reloc,  /* special_function */
645
         "R_M32R_SDA16",        /* name */
646
         TRUE,                  /* partial_inplace */  /* FIXME: correct? */
647
         0x0000ffff,            /* src_mask */
648
         0x0000ffff,            /* dst_mask */
649
         FALSE),                /* pcrel_offset */
650
 
651
  /* GNU extension to record C++ vtable hierarchy.  */
652
  HOWTO (R_M32R_GNU_VTINHERIT, /* type */
653
         0,                     /* rightshift */
654
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
655
         0,                     /* bitsize */
656
         FALSE,                 /* pc_relative */
657
         0,                     /* bitpos */
658
         complain_overflow_dont, /* complain_on_overflow */
659
         NULL,                  /* special_function */
660
         "R_M32R_GNU_VTINHERIT", /* name */
661
         FALSE,                 /* partial_inplace */
662
         0,                     /* src_mask */
663
         0,                     /* dst_mask */
664
         FALSE),                /* pcrel_offset */
665
 
666
  /* GNU extension to record C++ vtable member usage.  */
667
  HOWTO (R_M32R_GNU_VTENTRY,     /* type */
668
         0,                     /* rightshift */
669
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
670
         0,                     /* bitsize */
671
         FALSE,                 /* pc_relative */
672
         0,                     /* bitpos */
673
         complain_overflow_dont, /* complain_on_overflow */
674
         _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
675
         "R_M32R_GNU_VTENTRY",   /* name */
676
         FALSE,                 /* partial_inplace */
677
         0,                     /* src_mask */
678
         0,                     /* dst_mask */
679
         FALSE),                /* pcrel_offset */
680
 
681
  EMPTY_HOWTO (13),
682
  EMPTY_HOWTO (14),
683
  EMPTY_HOWTO (15),
684
  EMPTY_HOWTO (16),
685
  EMPTY_HOWTO (17),
686
  EMPTY_HOWTO (18),
687
  EMPTY_HOWTO (19),
688
  EMPTY_HOWTO (20),
689
  EMPTY_HOWTO (21),
690
  EMPTY_HOWTO (22),
691
  EMPTY_HOWTO (23),
692
  EMPTY_HOWTO (24),
693
  EMPTY_HOWTO (25),
694
  EMPTY_HOWTO (26),
695
  EMPTY_HOWTO (27),
696
  EMPTY_HOWTO (28),
697
  EMPTY_HOWTO (29),
698
  EMPTY_HOWTO (30),
699
  EMPTY_HOWTO (31),
700
  EMPTY_HOWTO (32),
701
 
702
  /* A 16 bit absolute relocation.  */
703
  HOWTO (R_M32R_16_RELA,        /* type */
704
         0,                      /* rightshift */
705
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
706
         16,                    /* bitsize */
707
         FALSE,                 /* pc_relative */
708
         0,                      /* bitpos */
709
         complain_overflow_bitfield, /* complain_on_overflow */
710
         bfd_elf_generic_reloc, /* special_function */
711
         "R_M32R_16_RELA",      /* name */
712
         FALSE,                 /* partial_inplace */
713
         0xffff,                /* src_mask */
714
         0xffff,                /* dst_mask */
715
         FALSE),                /* pcrel_offset */
716
 
717
  /* A 32 bit absolute relocation.  */
718
  HOWTO (R_M32R_32_RELA,        /* type */
719
         0,                      /* rightshift */
720
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
721
         32,                    /* bitsize */
722
         FALSE,                 /* pc_relative */
723
         0,                      /* bitpos */
724
         complain_overflow_bitfield, /* complain_on_overflow */
725
         bfd_elf_generic_reloc,/* special_function */
726
         "R_M32R_32_RELA",              /* name */
727
         FALSE,                 /* partial_inplace */
728
         0xffffffff,            /* src_mask */
729
         0xffffffff,            /* dst_mask */
730
         FALSE),                /* pcrel_offset */
731
 
732
  /* A 24 bit address.  */
733
  HOWTO (R_M32R_24_RELA,        /* type */
734
         0,                      /* rightshift */
735
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
736
         24,                    /* bitsize */
737
         FALSE,                 /* pc_relative */
738
         0,                      /* bitpos */
739
         complain_overflow_unsigned, /* complain_on_overflow */
740
         bfd_elf_generic_reloc,/* special_function */
741
         "R_M32R_24_RELA",      /* name */
742
         FALSE,                 /* partial_inplace */
743
         0xffffff,              /* src_mask */
744
         0xffffff,              /* dst_mask */
745
         FALSE),                /* pcrel_offset */
746
 
747
  HOWTO (R_M32R_10_PCREL_RELA,  /* type */
748
         2,                     /* rightshift */
749
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
750
         10,                    /* bitsize */
751
         TRUE,                  /* pc_relative */
752
         0,                      /* bitpos */
753
         complain_overflow_signed, /* complain_on_overflow */
754
         m32r_elf_10_pcrel_reloc, /* special_function */
755
         "R_M32R_10_PCREL_RELA",/* name */
756
         FALSE,                 /* partial_inplace */
757
         0xff,                  /* src_mask */
758
         0xff,                  /* dst_mask */
759
         TRUE),                 /* pcrel_offset */
760
 
761
  /* A relative 18 bit relocation, right shifted by 2.  */
762
  HOWTO (R_M32R_18_PCREL_RELA,  /* type */
763
         2,                     /* rightshift */
764
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
765
         16,                    /* bitsize */
766
         TRUE,                  /* pc_relative */
767
         0,                      /* bitpos */
768
         complain_overflow_signed, /* complain_on_overflow */
769
         bfd_elf_generic_reloc, /* special_function */
770
         "R_M32R_18_PCREL_RELA",/* name */
771
         FALSE,                 /* partial_inplace */
772
         0xffff,                /* src_mask */
773
         0xffff,                /* dst_mask */
774
         TRUE),                 /* pcrel_offset */
775
 
776
  /* A relative 26 bit relocation, right shifted by 2.  */
777
  HOWTO (R_M32R_26_PCREL_RELA,  /* type */
778
         2,                     /* rightshift */
779
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
780
         26,                    /* bitsize */
781
         TRUE,                  /* pc_relative */
782
         0,                      /* bitpos */
783
         complain_overflow_signed, /* complain_on_overflow */
784
         bfd_elf_generic_reloc, /* special_function */
785
         "R_M32R_26_PCREL_RELA",/* name */
786
         FALSE,                 /* partial_inplace */
787
         0xffffff,              /* src_mask */
788
         0xffffff,              /* dst_mask */
789
         TRUE),                 /* pcrel_offset */
790
 
791
  /* High 16 bits of address when lower 16 is or'd in.  */
792
  HOWTO (R_M32R_HI16_ULO_RELA,  /* type */
793
         16,                    /* rightshift */
794
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
795
         16,                    /* bitsize */
796
         FALSE,                 /* pc_relative */
797
         0,                      /* bitpos */
798
         complain_overflow_dont, /* complain_on_overflow */
799
         bfd_elf_generic_reloc, /* special_function */
800
         "R_M32R_HI16_ULO_RELA",/* name */
801
         FALSE,                 /* partial_inplace */
802
         0x0000ffff,            /* src_mask */
803
         0x0000ffff,            /* dst_mask */
804
         FALSE),                /* pcrel_offset */
805
 
806
  /* High 16 bits of address when lower 16 is added in.  */
807
  HOWTO (R_M32R_HI16_SLO_RELA,  /* type */
808
         16,                    /* rightshift */
809
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
810
         16,                    /* bitsize */
811
         FALSE,                 /* pc_relative */
812
         0,                      /* bitpos */
813
         complain_overflow_dont, /* complain_on_overflow */
814
         bfd_elf_generic_reloc, /* special_function */
815
         "R_M32R_HI16_SLO_RELA",/* name */
816
         FALSE,                 /* partial_inplace */
817
         0x0000ffff,            /* src_mask */
818
         0x0000ffff,            /* dst_mask */
819
         FALSE),                /* pcrel_offset */
820
 
821
  /* Lower 16 bits of address.  */
822
  HOWTO (R_M32R_LO16_RELA,      /* type */
823
         0,                      /* rightshift */
824
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
825
         16,                    /* bitsize */
826
         FALSE,                 /* pc_relative */
827
         0,                      /* bitpos */
828
         complain_overflow_dont, /* complain_on_overflow */
829
         bfd_elf_generic_reloc, /* special_function */
830
         "R_M32R_LO16_RELA",    /* name */
831
         FALSE,                 /* partial_inplace */
832
         0x0000ffff,            /* src_mask */
833
         0x0000ffff,            /* dst_mask */
834
         FALSE),                /* pcrel_offset */
835
 
836
  /* Small data area 16 bits offset.  */
837
  HOWTO (R_M32R_SDA16_RELA,     /* type */
838
         0,                      /* rightshift */
839
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
840
         16,                    /* bitsize */
841
         FALSE,                 /* pc_relative */
842
         0,                      /* bitpos */
843
         complain_overflow_signed, /* complain_on_overflow */
844
         bfd_elf_generic_reloc, /* special_function */
845
         "R_M32R_SDA16_RELA",   /* name */
846
         TRUE,                  /* partial_inplace */  /* FIXME: correct? */
847
         0x0000ffff,            /* src_mask */
848
         0x0000ffff,            /* dst_mask */
849
         FALSE),                /* pcrel_offset */
850
 
851
  /* GNU extension to record C++ vtable hierarchy.  */
852
  HOWTO (R_M32R_RELA_GNU_VTINHERIT, /* type */
853
         0,                     /* rightshift */
854
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
855
         0,                     /* bitsize */
856
         FALSE,                 /* pc_relative */
857
         0,                     /* bitpos */
858
         complain_overflow_dont, /* complain_on_overflow */
859
         NULL,                  /* special_function */
860
         "R_M32R_RELA_GNU_VTINHERIT", /* name */
861
         FALSE,                 /* partial_inplace */
862
         0,                     /* src_mask */
863
         0,                     /* dst_mask */
864
         FALSE),                /* pcrel_offset */
865
 
866
  /* GNU extension to record C++ vtable member usage.  */
867
  HOWTO (R_M32R_RELA_GNU_VTENTRY,     /* type */
868
         0,                     /* rightshift */
869
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
870
         0,                     /* bitsize */
871
         FALSE,                 /* pc_relative */
872
         0,                     /* bitpos */
873
         complain_overflow_dont, /* complain_on_overflow */
874
         _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
875
         "R_M32R_RELA_GNU_VTENTRY",   /* name */
876
         FALSE,                 /* partial_inplace */
877
         0,                     /* src_mask */
878
         0,                     /* dst_mask */
879
         FALSE),                /* pcrel_offset */
880
 
881
  /* A 32 bit PC relative relocation.  */
882
  HOWTO (R_M32R_REL32,          /* type */
883
         0,                      /* rightshift */
884
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
885
         32,                    /* bitsize */
886
         TRUE,                  /* pc_relative */
887
         0,                      /* bitpos */
888
         complain_overflow_bitfield, /* complain_on_overflow */
889
         bfd_elf_generic_reloc,/* special_function */
890
         "R_M32R_REL32",                /* name */
891
         FALSE,                 /* partial_inplace */
892
         0xffffffff,            /* src_mask */
893
         0xffffffff,            /* dst_mask */
894
         TRUE),                 /* pcrel_offset */
895
 
896
  EMPTY_HOWTO (46),
897
  EMPTY_HOWTO (47),
898
 
899
  /* Like R_M32R_24, but referring to the GOT table entry for
900
     the symbol.  */
901
  HOWTO (R_M32R_GOT24,          /* type */
902
         0,                      /* rightshift */
903
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
904
         24,                    /* bitsize */
905
         FALSE,                 /* pc_relative */
906
         0,                      /* bitpos */
907
         complain_overflow_unsigned, /* complain_on_overflow */
908
         bfd_elf_generic_reloc, /* special_function */
909
         "R_M32R_GOT24",        /* name */
910
         FALSE,                 /* partial_inplace */
911
         0xffffff,              /* src_mask */
912
         0xffffff,              /* dst_mask */
913
         FALSE),                /* pcrel_offset */
914
 
915
  /* Like R_M32R_PCREL, but referring to the procedure linkage table
916
     entry for the symbol.  */
917
  HOWTO (R_M32R_26_PLTREL,      /* type */
918
         2,                     /* rightshift */
919
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
920
         24,                    /* bitsize */
921
         TRUE,                  /* pc_relative */
922
         0,                      /* bitpos */
923
         complain_overflow_signed, /* complain_on_overflow */
924
         bfd_elf_generic_reloc, /* special_function */
925
         "R_M32R_26_PLTREL",    /* name */
926
         FALSE,                 /* partial_inplace */
927
         0xffffff,              /* src_mask */
928
         0xffffff,              /* dst_mask */
929
         TRUE),                 /* pcrel_offset */
930
 
931
  /* This is used only by the dynamic linker.  The symbol should exist
932
     both in the object being run and in some shared library.  The
933
     dynamic linker copies the data addressed by the symbol from the
934
     shared library into the object, because the object being
935
     run has to have the data at some particular address.  */
936
  HOWTO (R_M32R_COPY,           /* type */
937
         0,                      /* rightshift */
938
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
939
         32,                    /* bitsize */
940
         FALSE,                 /* pc_relative */
941
         0,                      /* bitpos */
942
         complain_overflow_bitfield, /* complain_on_overflow */
943
         bfd_elf_generic_reloc, /* special_function */
944
         "R_M32R_COPY",         /* name */
945
         FALSE,                 /* partial_inplace */
946
         0xffffffff,            /* src_mask */
947
         0xffffffff,            /* dst_mask */
948
         FALSE),                /* pcrel_offset */
949
 
950
  /* Like R_M32R_24, but used when setting global offset table
951
     entries.  */
952
  HOWTO (R_M32R_GLOB_DAT,       /* type */
953
         0,                      /* rightshift */
954
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
955
         32,                    /* bitsize */
956
         FALSE,                 /* pc_relative */
957
         0,                      /* bitpos */
958
         complain_overflow_bitfield, /* complain_on_overflow */
959
         bfd_elf_generic_reloc, /* special_function */
960
         "R_M32R_GLOB_DAT",     /* name */
961
         FALSE,                 /* partial_inplace */
962
         0xffffffff,            /* src_mask */
963
         0xffffffff,            /* dst_mask */
964
         FALSE),                /* pcrel_offset */
965
 
966
  /* Marks a procedure linkage table entry for a symbol.  */
967
  HOWTO (R_M32R_JMP_SLOT,       /* type */
968
         0,                      /* rightshift */
969
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
970
         32,                    /* bitsize */
971
         FALSE,                 /* pc_relative */
972
         0,                      /* bitpos */
973
         complain_overflow_bitfield, /* complain_on_overflow */
974
         bfd_elf_generic_reloc, /* special_function */
975
         "R_M32R_JMP_SLOT",     /* name */
976
         FALSE,                 /* partial_inplace */
977
         0xffffffff,            /* src_mask */
978
         0xffffffff,            /* dst_mask */
979
         FALSE),                /* pcrel_offset */
980
 
981
  /* Used only by the dynamic linker.  When the object is run, this
982
     longword is set to the load address of the object, plus the
983
     addend.  */
984
  HOWTO (R_M32R_RELATIVE,       /* type */
985
         0,                      /* rightshift */
986
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
987
         32,                    /* bitsize */
988
         FALSE,                 /* pc_relative */
989
         0,                      /* bitpos */
990
         complain_overflow_bitfield, /* complain_on_overflow */
991
         bfd_elf_generic_reloc, /* special_function */
992
         "R_M32R_RELATIVE",     /* name */
993
         FALSE,                 /* partial_inplace */
994
         0xffffffff,            /* src_mask */
995
         0xffffffff,            /* dst_mask */
996
         FALSE),                /* pcrel_offset */
997
 
998
  HOWTO (R_M32R_GOTOFF,         /* type */
999
         0,                      /* rightshift */
1000
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1001
         24,                    /* bitsize */
1002
         FALSE,                 /* pc_relative */
1003
         0,                      /* bitpos */
1004
         complain_overflow_bitfield, /* complain_on_overflow */
1005
         bfd_elf_generic_reloc, /* special_function */
1006
         "R_M32R_GOTOFF",       /* name */
1007
         FALSE,                 /* partial_inplace */
1008
         0xffffff,              /* src_mask */
1009
         0xffffff,              /* dst_mask */
1010
         FALSE),                /* pcrel_offset */
1011
 
1012
  /* An PC Relative 24-bit relocation used when setting PIC offset
1013
     table register. */
1014
  HOWTO (R_M32R_GOTPC24,        /* type */
1015
         0,                      /* rightshift */
1016
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1017
         24,                    /* bitsize */
1018
         TRUE,                  /* pc_relative */
1019
         0,                      /* bitpos */
1020
         complain_overflow_unsigned, /* complain_on_overflow */
1021
         bfd_elf_generic_reloc, /* special_function */
1022
         "R_M32R_GOTPC24",      /* name */
1023
         FALSE,                 /* partial_inplace */
1024
         0xffffff,              /* src_mask */
1025
         0xffffff,              /* dst_mask */
1026
         TRUE),                 /* pcrel_offset */
1027
 
1028
  /* Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1029
     the symbol.  */
1030
  HOWTO (R_M32R_GOT16_HI_ULO,   /* type */
1031
         16,                    /* rightshift */
1032
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1033
         16,                    /* bitsize */
1034
         FALSE,                 /* pc_relative */
1035
         0,                      /* bitpos */
1036
         complain_overflow_dont, /* complain_on_overflow */
1037
         bfd_elf_generic_reloc, /* special_function */
1038
         "R_M32R_GOT16_HI_ULO", /* name */
1039
         FALSE,                 /* partial_inplace */
1040
         0x0000ffff,            /* src_mask */
1041
         0x0000ffff,            /* dst_mask */
1042
         FALSE),                /* pcrel_offset */
1043
 
1044
  /* Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1045
     the symbol.  */
1046
  HOWTO (R_M32R_GOT16_HI_SLO,   /* type */
1047
         16,                    /* rightshift */
1048
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1049
         16,                    /* bitsize */
1050
         FALSE,                 /* pc_relative */
1051
         0,                      /* bitpos */
1052
         complain_overflow_dont, /* complain_on_overflow */
1053
         bfd_elf_generic_reloc, /* special_function */
1054
         "R_M32R_GOT16_HI_SLO", /* name */
1055
         FALSE,                 /* partial_inplace */
1056
         0x0000ffff,            /* src_mask */
1057
         0x0000ffff,            /* dst_mask */
1058
         FALSE),                /* pcrel_offset */
1059
 
1060
  /* Like R_M32R_LO16, but referring to the GOT table entry for
1061
     the symbol.  */
1062
  HOWTO (R_M32R_GOT16_LO,       /* type */
1063
         0,                      /* rightshift */
1064
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1065
         16,                    /* bitsize */
1066
         FALSE,                 /* pc_relative */
1067
         0,                      /* bitpos */
1068
         complain_overflow_dont, /* complain_on_overflow */
1069
         bfd_elf_generic_reloc, /* special_function */
1070
         "R_M32R_GOT16_LO",     /* name */
1071
         FALSE,                 /* partial_inplace */
1072
         0x0000ffff,            /* src_mask */
1073
         0x0000ffff,            /* dst_mask */
1074
         FALSE),                /* pcrel_offset */
1075
 
1076
  /* An PC Relative relocation used when setting PIC offset table register.
1077
     Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1078
     the symbol.  */
1079
  HOWTO (R_M32R_GOTPC_HI_ULO,   /* type */
1080
         16,                    /* rightshift */
1081
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1082
         16,                    /* bitsize */
1083
         FALSE,                 /* pc_relative */
1084
         0,                      /* bitpos */
1085
         complain_overflow_dont, /* complain_on_overflow */
1086
         bfd_elf_generic_reloc, /* special_function */
1087
         "R_M32R_GOTPC_HI_ULO", /* name */
1088
         FALSE,                 /* partial_inplace */
1089
         0x0000ffff,            /* src_mask */
1090
         0x0000ffff,            /* dst_mask */
1091
         TRUE),                 /* pcrel_offset */
1092
 
1093
  /* An PC Relative relocation used when setting PIC offset table register.
1094
     Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1095
     the symbol.  */
1096
  HOWTO (R_M32R_GOTPC_HI_SLO,   /* type */
1097
         16,                    /* rightshift */
1098
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1099
         16,                    /* bitsize */
1100
         FALSE,                 /* pc_relative */
1101
         0,                      /* bitpos */
1102
         complain_overflow_dont, /* complain_on_overflow */
1103
         bfd_elf_generic_reloc, /* special_function */
1104
         "R_M32R_GOTPC_HI_SLO", /* name */
1105
         FALSE,                 /* partial_inplace */
1106
         0x0000ffff,            /* src_mask */
1107
         0x0000ffff,            /* dst_mask */
1108
         TRUE),                 /* pcrel_offset */
1109
 
1110
  /* An PC Relative relocation used when setting PIC offset table register.
1111
     Like R_M32R_LO16, but referring to the GOT table entry for
1112
     the symbol.  */
1113
  HOWTO (R_M32R_GOTPC_LO,       /* type */
1114
         0,                      /* rightshift */
1115
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1116
         16,                    /* bitsize */
1117
         FALSE,                 /* pc_relative */
1118
         0,                      /* bitpos */
1119
         complain_overflow_dont, /* complain_on_overflow */
1120
         bfd_elf_generic_reloc, /* special_function */
1121
         "R_M32R_GOTPC_LO",     /* name */
1122
         FALSE,                 /* partial_inplace */
1123
         0x0000ffff,            /* src_mask */
1124
         0x0000ffff,            /* dst_mask */
1125
         TRUE),                 /* pcrel_offset */
1126
 
1127
  HOWTO (R_M32R_GOTOFF_HI_ULO,  /* type */
1128
         16,                    /* rightshift */
1129
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1130
         16,                    /* bitsize */
1131
         FALSE,                 /* pc_relative */
1132
         0,                      /* bitpos */
1133
         complain_overflow_dont, /* complain_on_overflow */
1134
         bfd_elf_generic_reloc, /* special_function */
1135
         "R_M32R_GOTOFF_HI_ULO",/* name */
1136
         FALSE,                 /* partial_inplace */
1137
         0x0000ffff,            /* src_mask */
1138
         0x0000ffff,            /* dst_mask */
1139
         FALSE),                /* pcrel_offset */
1140
 
1141
  HOWTO (R_M32R_GOTOFF_HI_SLO,  /* type */
1142
         16,                    /* rightshift */
1143
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1144
         16,                    /* bitsize */
1145
         FALSE,                 /* pc_relative */
1146
         0,                      /* bitpos */
1147
         complain_overflow_dont, /* complain_on_overflow */
1148
         bfd_elf_generic_reloc, /* special_function */
1149
         "R_M32R_GOTOFF_HI_SLO",/* name */
1150
         FALSE,                 /* partial_inplace */
1151
         0x0000ffff,            /* src_mask */
1152
         0x0000ffff,            /* dst_mask */
1153
         FALSE),                /* pcrel_offset */
1154
 
1155
  HOWTO (R_M32R_GOTOFF_LO,      /* type */
1156
         0,                      /* rightshift */
1157
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1158
         16,                    /* bitsize */
1159
         FALSE,                 /* pc_relative */
1160
         0,                      /* bitpos */
1161
         complain_overflow_dont, /* complain_on_overflow */
1162
         bfd_elf_generic_reloc, /* special_function */
1163
         "R_M32R_GOTOFF_LO",    /* name */
1164
         FALSE,                 /* partial_inplace */
1165
         0x0000ffff,            /* src_mask */
1166
         0x0000ffff,            /* dst_mask */
1167
         FALSE),                /* pcrel_offset */
1168
};
1169
 
1170
/* Map BFD reloc types to M32R ELF reloc types.  */
1171
 
1172
struct m32r_reloc_map
1173
{
1174
  bfd_reloc_code_real_type bfd_reloc_val;
1175
  unsigned char elf_reloc_val;
1176
};
1177
 
1178
#ifdef USE_M32R_OLD_RELOC
1179
static const struct m32r_reloc_map m32r_reloc_map_old[] =
1180
{
1181
  { BFD_RELOC_NONE, R_M32R_NONE },
1182
  { BFD_RELOC_16, R_M32R_16 },
1183
  { BFD_RELOC_32, R_M32R_32 },
1184
  { BFD_RELOC_M32R_24, R_M32R_24 },
1185
  { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL },
1186
  { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL },
1187
  { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL },
1188
  { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO },
1189
  { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO },
1190
  { BFD_RELOC_M32R_LO16, R_M32R_LO16 },
1191
  { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 },
1192
  { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT },
1193
  { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY },
1194
};
1195
#else
1196
static const struct m32r_reloc_map m32r_reloc_map[] =
1197
{
1198
  { BFD_RELOC_NONE, R_M32R_NONE },
1199
  { BFD_RELOC_16, R_M32R_16_RELA },
1200
  { BFD_RELOC_32, R_M32R_32_RELA },
1201
  { BFD_RELOC_M32R_24, R_M32R_24_RELA },
1202
  { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL_RELA },
1203
  { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL_RELA },
1204
  { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL_RELA },
1205
  { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO_RELA },
1206
  { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO_RELA },
1207
  { BFD_RELOC_M32R_LO16, R_M32R_LO16_RELA },
1208
  { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
1209
  { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
1210
  { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
1211
  { BFD_RELOC_32_PCREL, R_M32R_REL32 },
1212
 
1213
  { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
1214
  { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
1215
  { BFD_RELOC_M32R_COPY, R_M32R_COPY },
1216
  { BFD_RELOC_M32R_GLOB_DAT, R_M32R_GLOB_DAT },
1217
  { BFD_RELOC_M32R_JMP_SLOT, R_M32R_JMP_SLOT },
1218
  { BFD_RELOC_M32R_RELATIVE, R_M32R_RELATIVE },
1219
  { BFD_RELOC_M32R_GOTOFF, R_M32R_GOTOFF },
1220
  { BFD_RELOC_M32R_GOTPC24, R_M32R_GOTPC24 },
1221
  { BFD_RELOC_M32R_GOT16_HI_ULO, R_M32R_GOT16_HI_ULO },
1222
  { BFD_RELOC_M32R_GOT16_HI_SLO, R_M32R_GOT16_HI_SLO },
1223
  { BFD_RELOC_M32R_GOT16_LO, R_M32R_GOT16_LO },
1224
  { BFD_RELOC_M32R_GOTPC_HI_ULO, R_M32R_GOTPC_HI_ULO },
1225
  { BFD_RELOC_M32R_GOTPC_HI_SLO, R_M32R_GOTPC_HI_SLO },
1226
  { BFD_RELOC_M32R_GOTPC_LO, R_M32R_GOTPC_LO },
1227
  { BFD_RELOC_M32R_GOTOFF_HI_ULO, R_M32R_GOTOFF_HI_ULO },
1228
  { BFD_RELOC_M32R_GOTOFF_HI_SLO, R_M32R_GOTOFF_HI_SLO },
1229
  { BFD_RELOC_M32R_GOTOFF_LO, R_M32R_GOTOFF_LO },
1230
};
1231
#endif
1232
 
1233
static reloc_howto_type *
1234
bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1235
                                 bfd_reloc_code_real_type code)
1236
{
1237
  unsigned int i;
1238
 
1239
#ifdef USE_M32R_OLD_RELOC
1240
  for (i = 0;
1241
       i < sizeof (m32r_reloc_map_old) / sizeof (struct m32r_reloc_map);
1242
       i++)
1243
    if (m32r_reloc_map_old[i].bfd_reloc_val == code)
1244
      return &m32r_elf_howto_table[m32r_reloc_map_old[i].elf_reloc_val];
1245
 
1246
#else /* ! USE_M32R_OLD_RELOC */
1247
 
1248
  for (i = 0;
1249
       i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map);
1250
       i++)
1251
    if (m32r_reloc_map[i].bfd_reloc_val == code)
1252
      return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val];
1253
#endif
1254
 
1255
  return NULL;
1256
}
1257
 
1258
static reloc_howto_type *
1259
bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1260
                                 const char *r_name)
1261
{
1262
  unsigned int i;
1263
 
1264
  for (i = 0;
1265
       i < sizeof (m32r_elf_howto_table) / sizeof (m32r_elf_howto_table[0]);
1266
       i++)
1267
    if (m32r_elf_howto_table[i].name != NULL
1268
        && strcasecmp (m32r_elf_howto_table[i].name, r_name) == 0)
1269
      return &m32r_elf_howto_table[i];
1270
 
1271
  return NULL;
1272
}
1273
 
1274
/* Set the howto pointer for an M32R ELF reloc.  */
1275
 
1276
static void
1277
m32r_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1278
                        arelent *cache_ptr,
1279
                        Elf_Internal_Rela *dst)
1280
{
1281
  unsigned int r_type;
1282
 
1283
  r_type = ELF32_R_TYPE (dst->r_info);
1284
  BFD_ASSERT (ELF32_R_TYPE(dst->r_info) <= (unsigned int) R_M32R_GNU_VTENTRY);
1285
  cache_ptr->howto = &m32r_elf_howto_table[r_type];
1286
}
1287
 
1288
static void
1289
m32r_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1290
                    arelent *cache_ptr,
1291
                    Elf_Internal_Rela *dst)
1292
{
1293
  BFD_ASSERT ((ELF32_R_TYPE(dst->r_info) == (unsigned int) R_M32R_NONE)
1294
              || ((ELF32_R_TYPE(dst->r_info) > (unsigned int) R_M32R_GNU_VTENTRY)
1295
                  && (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_M32R_max)));
1296
  cache_ptr->howto = &m32r_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
1297
}
1298
 
1299
 
1300
/* Given a BFD section, try to locate the corresponding ELF section
1301
   index.  */
1302
 
1303
static bfd_boolean
1304
_bfd_m32r_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
1305
                                        asection *sec,
1306
                                        int *retval)
1307
{
1308
  if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1309
    {
1310
      *retval = SHN_M32R_SCOMMON;
1311
      return TRUE;
1312
    }
1313
  return FALSE;
1314
}
1315
 
1316
/* M32R ELF uses two common sections.  One is the usual one, and the other
1317
   is for small objects.  All the small objects are kept together, and then
1318
   referenced via one register, which yields faster assembler code.  It is
1319
   up to the compiler to emit an instruction to load the register with
1320
   _SDA_BASE.  This is what we use for the small common section.  This
1321
   approach is copied from elf32-mips.c.  */
1322
static asection m32r_elf_scom_section;
1323
static asymbol m32r_elf_scom_symbol;
1324
static asymbol *m32r_elf_scom_symbol_ptr;
1325
 
1326
/* Handle the special M32R section numbers that a symbol may use.  */
1327
 
1328
static void
1329
_bfd_m32r_elf_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
1330
{
1331
  elf_symbol_type *elfsym = (elf_symbol_type *) asym;
1332
 
1333
  switch (elfsym->internal_elf_sym.st_shndx)
1334
    {
1335
    case SHN_M32R_SCOMMON:
1336
      if (m32r_elf_scom_section.name == NULL)
1337
        {
1338
          /* Initialize the small common section.  */
1339
          m32r_elf_scom_section.name = ".scommon";
1340
          m32r_elf_scom_section.flags = SEC_IS_COMMON;
1341
          m32r_elf_scom_section.output_section = &m32r_elf_scom_section;
1342
          m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol;
1343
          m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr;
1344
          m32r_elf_scom_symbol.name = ".scommon";
1345
          m32r_elf_scom_symbol.flags = BSF_SECTION_SYM;
1346
          m32r_elf_scom_symbol.section = &m32r_elf_scom_section;
1347
          m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol;
1348
        }
1349
      asym->section = &m32r_elf_scom_section;
1350
      asym->value = elfsym->internal_elf_sym.st_size;
1351
      break;
1352
    }
1353
}
1354
 
1355
/* Hook called by the linker routine which adds symbols from an object
1356
   file.  We must handle the special M32R section numbers here.
1357
   We also keep watching for whether we need to create the sdata special
1358
   linker sections.  */
1359
 
1360
static bfd_boolean
1361
m32r_elf_add_symbol_hook (bfd *abfd,
1362
                          struct bfd_link_info *info,
1363
                          Elf_Internal_Sym *sym,
1364
                          const char **namep,
1365
                          flagword *flagsp ATTRIBUTE_UNUSED,
1366
                          asection **secp,
1367
                          bfd_vma *valp)
1368
{
1369
  if (! info->relocatable
1370
      && (*namep)[0] == '_' && (*namep)[1] == 'S'
1371
      && strcmp (*namep, "_SDA_BASE_") == 0
1372
      && is_elf_hash_table (info->hash))
1373
    {
1374
      /* This is simpler than using _bfd_elf_create_linker_section
1375
         (our needs are simpler than ppc's needs).  Also
1376
         _bfd_elf_create_linker_section currently has a bug where if a .sdata
1377
         section already exists a new one is created that follows it which
1378
         screws of _SDA_BASE_ address calcs because output_offset != 0.  */
1379
      struct elf_link_hash_entry *h;
1380
      struct bfd_link_hash_entry *bh;
1381
      asection *s = bfd_get_section_by_name (abfd, ".sdata");
1382
 
1383
      /* The following code was cobbled from elf32-ppc.c and elflink.c.  */
1384
      if (s == NULL)
1385
        {
1386
          flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1387
                            | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1388
 
1389
          s = bfd_make_section_anyway_with_flags (abfd, ".sdata",
1390
                                                  flags);
1391
          if (s == NULL)
1392
            return FALSE;
1393
          bfd_set_section_alignment (abfd, s, 2);
1394
        }
1395
 
1396
      bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_",
1397
                                 FALSE, FALSE, FALSE);
1398
 
1399
      if ((bh == NULL || bh->type == bfd_link_hash_undefined)
1400
          && !(_bfd_generic_link_add_one_symbol (info,
1401
                                                 abfd,
1402
                                                 "_SDA_BASE_",
1403
                                                 BSF_GLOBAL,
1404
                                                 s,
1405
                                                 (bfd_vma) 32768,
1406
                                                 NULL,
1407
                                                 FALSE,
1408
                                                 get_elf_backend_data (abfd)->collect,
1409
                                                 &bh)))
1410
        return FALSE;
1411
      h = (struct elf_link_hash_entry *) bh;
1412
      h->type = STT_OBJECT;
1413
    }
1414
 
1415
  switch (sym->st_shndx)
1416
    {
1417
    case SHN_M32R_SCOMMON:
1418
      *secp = bfd_make_section_old_way (abfd, ".scommon");
1419
      (*secp)->flags |= SEC_IS_COMMON;
1420
      *valp = sym->st_size;
1421
      break;
1422
    }
1423
 
1424
  return TRUE;
1425
}
1426
 
1427
/* We have to figure out the SDA_BASE value, so that we can adjust the
1428
   symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
1429
   BFD.  If we can't find it, we're stuck.  We cache it in the ELF
1430
   target data.  We don't need to adjust the symbol value for an
1431
   external symbol if we are producing relocatable output.  */
1432
 
1433
static bfd_reloc_status_type
1434
m32r_elf_final_sda_base (bfd *output_bfd,
1435
                         struct bfd_link_info *info,
1436
                         const char **error_message,
1437
                         bfd_vma *psb)
1438
{
1439
  if (elf_gp (output_bfd) == 0)
1440
    {
1441
      struct bfd_link_hash_entry *h;
1442
 
1443
      h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
1444
      if (h != NULL && h->type == bfd_link_hash_defined)
1445
        elf_gp (output_bfd) = (h->u.def.value
1446
                               + h->u.def.section->output_section->vma
1447
                               + h->u.def.section->output_offset);
1448
      else
1449
        {
1450
          /* Only get the error once.  */
1451
          *psb = elf_gp (output_bfd) = 4;
1452
          *error_message =
1453
            (const char *) _("SDA relocation when _SDA_BASE_ not defined");
1454
          return bfd_reloc_dangerous;
1455
        }
1456
    }
1457
  *psb = elf_gp (output_bfd);
1458
  return bfd_reloc_ok;
1459
}
1460
 
1461
/* Return size of a PLT entry.  */
1462
#define elf_m32r_sizeof_plt(info) PLT_ENTRY_SIZE
1463
 
1464
/* The m32r linker needs to keep track of the number of relocs that it
1465
   decides to copy in check_relocs for each symbol.  This is so that
1466
   it can discard PC relative relocs if it doesn't need them when
1467
   linking with -Bsymbolic.  We store the information in a field
1468
   extending the regular ELF linker hash table.  */
1469
 
1470
/* This structure keeps track of the number of PC relative relocs we
1471
   have copied for a given symbol.  */
1472
 
1473
struct elf_m32r_pcrel_relocs_copied
1474
{
1475
  /* Next section.  */
1476
  struct elf_m32r_pcrel_relocs_copied *next;
1477
  /* A section in dynobj.  */
1478
  asection *section;
1479
  /* Number of relocs copied in this section.  */
1480
  bfd_size_type count;
1481
};
1482
 
1483
/* The sh linker needs to keep track of the number of relocs that it
1484
   decides to copy as dynamic relocs in check_relocs for each symbol.
1485
   This is so that it can later discard them if they are found to be
1486
   unnecessary.  We store the information in a field extending the
1487
   regular ELF linker hash table.  */
1488
 
1489
struct elf_m32r_dyn_relocs
1490
{
1491
  struct elf_m32r_dyn_relocs *next;
1492
 
1493
  /* The input section of the reloc.  */
1494
  asection *sec;
1495
 
1496
  /* Total number of relocs copied for the input section.  */
1497
  bfd_size_type count;
1498
 
1499
  /* Number of pc-relative relocs copied for the input section.  */
1500
  bfd_size_type pc_count;
1501
};
1502
 
1503
 
1504
/* m32r ELF linker hash entry.  */
1505
 
1506
struct elf_m32r_link_hash_entry
1507
{
1508
  struct elf_link_hash_entry root;
1509
 
1510
  /* Track dynamic relocs copied for this symbol.  */
1511
  struct elf_m32r_dyn_relocs *dyn_relocs;
1512
};
1513
 
1514
/* m32r ELF linker hash table.  */
1515
 
1516
struct elf_m32r_link_hash_table
1517
{
1518
  struct elf_link_hash_table root;
1519
 
1520
  /* Short-cuts to get to dynamic linker sections.  */
1521
  asection *sgot;
1522
  asection *sgotplt;
1523
  asection *srelgot;
1524
  asection *splt;
1525
  asection *srelplt;
1526
  asection *sdynbss;
1527
  asection *srelbss;
1528
 
1529 225 jeremybenn
  /* Small local sym cache.  */
1530
  struct sym_cache sym_cache;
1531 24 jeremybenn
};
1532
 
1533
/* Traverse an m32r ELF linker hash table.  */
1534
 
1535
#define m32r_elf_link_hash_traverse(table, func, info)                  \
1536
  (elf_link_hash_traverse                                               \
1537
   (&(table)->root,                                                     \
1538
    (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1539
    (info)))
1540
 
1541
/* Get the m32r ELF linker hash table from a link_info structure.  */
1542
 
1543
 
1544
#define m32r_elf_hash_table(p) \
1545
  ((struct elf_m32r_link_hash_table *) ((p)->hash))
1546
 
1547
/* Create an entry in an m32r ELF linker hash table.  */
1548
 
1549
static struct bfd_hash_entry *
1550
m32r_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1551
                            struct bfd_hash_table *table,
1552
                            const char *string)
1553
{
1554
  struct elf_m32r_link_hash_entry *ret =
1555
    (struct elf_m32r_link_hash_entry *) entry;
1556
 
1557
  /* Allocate the structure if it has not already been allocated by a
1558
     subclass.  */
1559
  if (ret == NULL)
1560
    ret = bfd_hash_allocate (table,
1561
                             sizeof (struct elf_m32r_link_hash_entry));
1562
  if (ret == NULL)
1563
    return NULL;
1564
 
1565
  /* Call the allocation method of the superclass.  */
1566
  ret = ((struct elf_m32r_link_hash_entry *)
1567
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1568
                                     table, string));
1569
  if (ret != NULL)
1570
    {
1571
      struct elf_m32r_link_hash_entry *eh;
1572
 
1573
      eh = (struct elf_m32r_link_hash_entry *) ret;
1574
      eh->dyn_relocs = NULL;
1575
    }
1576
 
1577
  return (struct bfd_hash_entry *) ret;
1578
}
1579
 
1580
/* Create an m32r ELF linker hash table.  */
1581
 
1582
static struct bfd_link_hash_table *
1583
m32r_elf_link_hash_table_create (bfd *abfd)
1584
{
1585
  struct elf_m32r_link_hash_table *ret;
1586
  bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
1587
 
1588
  ret = bfd_malloc (amt);
1589
  if (ret == NULL)
1590
    return NULL;
1591
 
1592
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1593
                                      m32r_elf_link_hash_newfunc,
1594
                                      sizeof (struct elf_m32r_link_hash_entry)))
1595
    {
1596
      free (ret);
1597
      return NULL;
1598
    }
1599
 
1600
  ret->sgot = NULL;
1601
  ret->sgotplt = NULL;
1602
  ret->srelgot = NULL;
1603
  ret->splt = NULL;
1604
  ret->srelplt = NULL;
1605
  ret->sdynbss = NULL;
1606
  ret->srelbss = NULL;
1607 225 jeremybenn
  ret->sym_cache.abfd = NULL;
1608 24 jeremybenn
 
1609
  return &ret->root.root;
1610
}
1611
 
1612
/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1613
   shortcuts to them in our hash table.  */
1614
 
1615
static bfd_boolean
1616
create_got_section (bfd *dynobj, struct bfd_link_info *info)
1617
{
1618
  struct elf_m32r_link_hash_table *htab;
1619
 
1620
  if (! _bfd_elf_create_got_section (dynobj, info))
1621
    return FALSE;
1622
 
1623
  htab = m32r_elf_hash_table (info);
1624
  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1625
  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1626 225 jeremybenn
  htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1627
  if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
1628 24 jeremybenn
    abort ();
1629
 
1630
  return TRUE;
1631
}
1632
 
1633
/* Create dynamic sections when linking against a dynamic object.  */
1634
 
1635
static bfd_boolean
1636
m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1637
{
1638
  struct elf_m32r_link_hash_table *htab;
1639
  flagword flags, pltflags;
1640
  asection *s;
1641
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1642
  int ptralign = 2; /* 32bit */
1643
 
1644
  htab = m32r_elf_hash_table (info);
1645
 
1646
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1647
     .rel[a].bss sections.  */
1648
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1649
           | SEC_LINKER_CREATED);
1650
 
1651
  pltflags = flags;
1652
  pltflags |= SEC_CODE;
1653
  if (bed->plt_not_loaded)
1654
    pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1655
  if (bed->plt_readonly)
1656
    pltflags |= SEC_READONLY;
1657
 
1658
  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
1659
  htab->splt = s;
1660
  if (s == NULL
1661
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1662
    return FALSE;
1663
 
1664
  if (bed->want_plt_sym)
1665
    {
1666
      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1667
         .plt section.  */
1668
      struct bfd_link_hash_entry *bh = NULL;
1669
      struct elf_link_hash_entry *h;
1670
 
1671
      if (! (_bfd_generic_link_add_one_symbol
1672
             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1673
              (bfd_vma) 0, NULL, FALSE,
1674
              get_elf_backend_data (abfd)->collect, &bh)))
1675
        return FALSE;
1676
      h = (struct elf_link_hash_entry *) bh;
1677
      h->def_regular = 1;
1678
      h->type = STT_OBJECT;
1679
      htab->root.hplt = h;
1680
 
1681
      if (info->shared
1682
          && ! bfd_elf_link_record_dynamic_symbol (info, h))
1683
        return FALSE;
1684
    }
1685
 
1686
  s = bfd_make_section_with_flags (abfd,
1687
                                   bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
1688
                                   flags | SEC_READONLY);
1689
  htab->srelplt = s;
1690
  if (s == NULL
1691
      || ! bfd_set_section_alignment (abfd, s, ptralign))
1692
    return FALSE;
1693
 
1694
  if (htab->sgot == NULL
1695
      && ! create_got_section (abfd, info))
1696
    return FALSE;
1697
 
1698
  {
1699
    const char *secname;
1700
    char *relname;
1701
    flagword secflags;
1702
    asection *sec;
1703
 
1704
    for (sec = abfd->sections; sec; sec = sec->next)
1705
      {
1706
        secflags = bfd_get_section_flags (abfd, sec);
1707
        if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
1708
            || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
1709
          continue;
1710
        secname = bfd_get_section_name (abfd, sec);
1711
        relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
1712
        strcpy (relname, ".rela");
1713
        strcat (relname, secname);
1714
        if (bfd_get_section_by_name (abfd, secname))
1715
          continue;
1716
        s = bfd_make_section_with_flags (abfd, relname,
1717
                                         flags | SEC_READONLY);
1718
        if (s == NULL
1719
            || ! bfd_set_section_alignment (abfd, s, ptralign))
1720
          return FALSE;
1721
      }
1722
  }
1723
 
1724
  if (bed->want_dynbss)
1725
    {
1726
      /* The .dynbss section is a place to put symbols which are defined
1727
         by dynamic objects, are referenced by regular objects, and are
1728
         not functions.  We must allocate space for them in the process
1729
         image and use a R_*_COPY reloc to tell the dynamic linker to
1730
         initialize them at run time.  The linker script puts the .dynbss
1731
         section into the .bss section of the final image.  */
1732
      s = bfd_make_section_with_flags (abfd, ".dynbss",
1733
                                       SEC_ALLOC | SEC_LINKER_CREATED);
1734
      htab->sdynbss = s;
1735
      if (s == NULL)
1736
        return FALSE;
1737
      /* The .rel[a].bss section holds copy relocs.  This section is not
1738
         normally needed.  We need to create it here, though, so that the
1739
         linker will map it to an output section.  We can't just create it
1740
         only if we need it, because we will not know whether we need it
1741
         until we have seen all the input files, and the first time the
1742
         main linker code calls BFD after examining all the input files
1743
         (size_dynamic_sections) the input sections have already been
1744
         mapped to the output sections.  If the section turns out not to
1745
         be needed, we can discard it later.  We will never need this
1746
         section when generating a shared object, since they do not use
1747
         copy relocs.  */
1748
      if (! info->shared)
1749
        {
1750
          s = bfd_make_section_with_flags (abfd,
1751
                                           (bed->default_use_rela_p
1752
                                            ? ".rela.bss" : ".rel.bss"),
1753
                                           flags | SEC_READONLY);
1754
          htab->srelbss = s;
1755
          if (s == NULL
1756
              || ! bfd_set_section_alignment (abfd, s, ptralign))
1757
            return FALSE;
1758
        }
1759
    }
1760
 
1761
  return TRUE;
1762
}
1763
 
1764
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
1765
 
1766
static void
1767
m32r_elf_copy_indirect_symbol (struct bfd_link_info *info,
1768
                               struct elf_link_hash_entry *dir,
1769
                               struct elf_link_hash_entry *ind)
1770
{
1771
  struct elf_m32r_link_hash_entry * edir;
1772
  struct elf_m32r_link_hash_entry * eind;
1773
 
1774
  edir = (struct elf_m32r_link_hash_entry *) dir;
1775
  eind = (struct elf_m32r_link_hash_entry *) ind;
1776
 
1777
  if (eind->dyn_relocs != NULL)
1778
    {
1779
      if (edir->dyn_relocs != NULL)
1780
        {
1781
          struct elf_m32r_dyn_relocs **pp;
1782
          struct elf_m32r_dyn_relocs *p;
1783
 
1784
          /* Add reloc counts against the indirect sym to the direct sym
1785
             list.  Merge any entries against the same section.  */
1786
          for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
1787
            {
1788
              struct elf_m32r_dyn_relocs *q;
1789
 
1790
              for (q = edir->dyn_relocs; q != NULL; q = q->next)
1791
                if (q->sec == p->sec)
1792
                  {
1793
                    q->pc_count += p->pc_count;
1794
                    q->count += p->count;
1795
                    *pp = p->next;
1796
                    break;
1797
                  }
1798
              if (q == NULL)
1799
                pp = &p->next;
1800
            }
1801
          *pp = edir->dyn_relocs;
1802
        }
1803
 
1804
      edir->dyn_relocs = eind->dyn_relocs;
1805
      eind->dyn_relocs = NULL;
1806
    }
1807
 
1808
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1809
}
1810
 
1811
 
1812
/* Adjust a symbol defined by a dynamic object and referenced by a
1813
   regular object.  The current definition is in some section of the
1814
   dynamic object, but we're not including those sections.  We have to
1815
   change the definition to something the rest of the link can
1816
   understand.  */
1817
 
1818
static bfd_boolean
1819
m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1820
                                struct elf_link_hash_entry *h)
1821
{
1822
  struct elf_m32r_link_hash_table *htab;
1823
  struct elf_m32r_link_hash_entry *eh;
1824
  struct elf_m32r_dyn_relocs *p;
1825
  bfd *dynobj;
1826
  asection *s;
1827
 
1828
#ifdef DEBUG_PIC
1829
  printf ("m32r_elf_adjust_dynamic_symbol()\n");
1830
#endif
1831
 
1832
  dynobj = elf_hash_table (info)->dynobj;
1833
 
1834
  /* Make sure we know what is going on here.  */
1835
  BFD_ASSERT (dynobj != NULL
1836
              && (h->needs_plt
1837
                  || h->u.weakdef != NULL
1838
                  || (h->def_dynamic
1839
                      && h->ref_regular
1840
                      && !h->def_regular)));
1841
 
1842
  /* If this is a function, put it in the procedure linkage table.  We
1843
     will fill in the contents of the procedure linkage table later,
1844
     when we know the address of the .got section.  */
1845
  if (h->type == STT_FUNC
1846
      || h->needs_plt)
1847
    {
1848
      if (! info->shared
1849
          && !h->def_dynamic
1850
          && !h->ref_dynamic
1851
          && h->root.type != bfd_link_hash_undefweak
1852
          && h->root.type != bfd_link_hash_undefined)
1853
        {
1854
          /* This case can occur if we saw a PLT reloc in an input
1855
             file, but the symbol was never referred to by a dynamic
1856
             object.  In such a case, we don't actually need to build
1857
             a procedure linkage table, and we can just do a PCREL
1858
             reloc instead.  */
1859
          h->plt.offset = (bfd_vma) -1;
1860
          h->needs_plt = 0;
1861
        }
1862
 
1863
      return TRUE;
1864
    }
1865
  else
1866
    h->plt.offset = (bfd_vma) -1;
1867
 
1868
  /* If this is a weak symbol, and there is a real definition, the
1869
     processor independent code will have arranged for us to see the
1870
     real definition first, and we can just use the same value.  */
1871
  if (h->u.weakdef != NULL)
1872
    {
1873
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1874
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
1875
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
1876
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
1877
      return TRUE;
1878
    }
1879
 
1880
  /* This is a reference to a symbol defined by a dynamic object which
1881
     is not a function.  */
1882
 
1883
  /* If we are creating a shared library, we must presume that the
1884
     only references to the symbol are via the global offset table.
1885
     For such cases we need not do anything here; the relocations will
1886
     be handled correctly by relocate_section.  */
1887
  if (info->shared)
1888
    return TRUE;
1889
 
1890
  /* If there are no references to this symbol that do not use the
1891
     GOT, we don't need to generate a copy reloc.  */
1892
  if (!h->non_got_ref)
1893
    return TRUE;
1894
 
1895
  /* If -z nocopyreloc was given, we won't generate them either.  */
1896
  if (info->nocopyreloc)
1897
    {
1898
      h->non_got_ref = 0;
1899
      return TRUE;
1900
    }
1901
 
1902
  eh = (struct elf_m32r_link_hash_entry *) h;
1903
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
1904
    {
1905
      s = p->sec->output_section;
1906
      if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1907
        break;
1908
    }
1909
 
1910
  /* If we didn't find any dynamic relocs in sections which needs the
1911
     copy reloc, then we'll be keeping the dynamic relocs and avoiding
1912
     the copy reloc.  */
1913
  if (p == NULL)
1914
    {
1915
      h->non_got_ref = 0;
1916
      return TRUE;
1917
    }
1918
 
1919
  if (h->size == 0)
1920
    {
1921
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1922
                             h->root.root.string);
1923
      return TRUE;
1924
    }
1925
 
1926
  /* We must allocate the symbol in our .dynbss section, which will
1927
     become part of the .bss section of the executable.  There will be
1928
     an entry for this symbol in the .dynsym section.  The dynamic
1929
     object will contain position independent code, so all references
1930
     from the dynamic object to this symbol will go through the global
1931
     offset table.  The dynamic linker will use the .dynsym entry to
1932
     determine the address it must put in the global offset table, so
1933
     both the dynamic object and the regular object will refer to the
1934
     same memory location for the variable.  */
1935
 
1936
  htab = m32r_elf_hash_table (info);
1937
  s = htab->sdynbss;
1938
  BFD_ASSERT (s != NULL);
1939
 
1940
  /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
1941
     to copy the initial value out of the dynamic object and into the
1942
     runtime process image.  We need to remember the offset into the
1943
     .rela.bss section we are going to use.  */
1944
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1945
    {
1946
      asection *srel;
1947
 
1948
      srel = htab->srelbss;
1949
      BFD_ASSERT (srel != NULL);
1950
      srel->size += sizeof (Elf32_External_Rela);
1951
      h->needs_copy = 1;
1952
    }
1953
 
1954
  return _bfd_elf_adjust_dynamic_copy (h, s);
1955
}
1956
 
1957
/* Allocate space in .plt, .got and associated reloc sections for
1958
   dynamic relocs.  */
1959
 
1960
static bfd_boolean
1961
allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1962
{
1963
  struct bfd_link_info *info;
1964
  struct elf_m32r_link_hash_table *htab;
1965
  struct elf_m32r_link_hash_entry *eh;
1966
  struct elf_m32r_dyn_relocs *p;
1967
 
1968
  if (h->root.type == bfd_link_hash_indirect)
1969
    return TRUE;
1970
 
1971
  if (h->root.type == bfd_link_hash_warning)
1972
    /* When warning symbols are created, they **replace** the "real"
1973
       entry in the hash table, thus we never get to see the real
1974
       symbol in a hash traversal.  So look at it now.  */
1975
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1976
 
1977
  info = (struct bfd_link_info *) inf;
1978
  htab = m32r_elf_hash_table (info);
1979
 
1980
  eh = (struct elf_m32r_link_hash_entry *) h;
1981
 
1982
  if (htab->root.dynamic_sections_created
1983
      && h->plt.refcount > 0)
1984
    {
1985
      /* Make sure this symbol is output as a dynamic symbol.
1986
         Undefined weak syms won't yet be marked as dynamic.  */
1987
      if (h->dynindx == -1
1988
          && !h->forced_local)
1989
        {
1990
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
1991
            return FALSE;
1992
        }
1993
 
1994
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1995
        {
1996
          asection *s = htab->splt;
1997
 
1998
          /* If this is the first .plt entry, make room for the special
1999
             first entry.  */
2000
          if (s->size == 0)
2001
            s->size += PLT_ENTRY_SIZE;
2002
 
2003
          h->plt.offset = s->size;
2004
 
2005
          /* If this symbol is not defined in a regular file, and we are
2006
             not generating a shared library, then set the symbol to this
2007
             location in the .plt.  This is required to make function
2008
             pointers compare as equal between the normal executable and
2009
             the shared library.  */
2010
          if (! info->shared
2011
              && !h->def_regular)
2012
            {
2013
              h->root.u.def.section = s;
2014
              h->root.u.def.value = h->plt.offset;
2015
            }
2016
 
2017
          /* Make room for this entry.  */
2018
          s->size += PLT_ENTRY_SIZE;
2019
 
2020
          /* We also need to make an entry in the .got.plt section, which
2021
             will be placed in the .got section by the linker script.  */
2022
          htab->sgotplt->size += 4;
2023
 
2024
          /* We also need to make an entry in the .rel.plt section.  */
2025
          htab->srelplt->size += sizeof (Elf32_External_Rela);
2026
        }
2027
      else
2028
        {
2029
          h->plt.offset = (bfd_vma) -1;
2030
          h->needs_plt = 0;
2031
        }
2032
    }
2033
  else
2034
    {
2035
      h->plt.offset = (bfd_vma) -1;
2036
      h->needs_plt = 0;
2037
    }
2038
 
2039
  if (h->got.refcount > 0)
2040
    {
2041
      asection *s;
2042
      bfd_boolean dyn;
2043
 
2044
      /* Make sure this symbol is output as a dynamic symbol.
2045
         Undefined weak syms won't yet be marked as dynamic.  */
2046
      if (h->dynindx == -1
2047
          && !h->forced_local)
2048
        {
2049
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
2050
            return FALSE;
2051
        }
2052
 
2053
      s = htab->sgot;
2054
 
2055
      h->got.offset = s->size;
2056
      s->size += 4;
2057
      dyn = htab->root.dynamic_sections_created;
2058
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2059
        htab->srelgot->size += sizeof (Elf32_External_Rela);
2060
    }
2061
  else
2062
    h->got.offset = (bfd_vma) -1;
2063
 
2064
  if (eh->dyn_relocs == NULL)
2065
    return TRUE;
2066
 
2067
  /* In the shared -Bsymbolic case, discard space allocated for
2068
     dynamic pc-relative relocs against symbols which turn out to be
2069
     defined in regular objects.  For the normal shared case, discard
2070
     space for pc-relative relocs that have become local due to symbol
2071
     visibility changes.  */
2072
 
2073
  if (info->shared)
2074
    {
2075
      if (h->def_regular
2076
          && (h->forced_local
2077
              || info->symbolic))
2078
        {
2079
          struct elf_m32r_dyn_relocs **pp;
2080
 
2081
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2082
            {
2083
              p->count -= p->pc_count;
2084
              p->pc_count = 0;
2085
              if (p->count == 0)
2086
                *pp = p->next;
2087
              else
2088
                pp = &p->next;
2089
            }
2090
        }
2091
 
2092
      /* Also discard relocs on undefined weak syms with non-default
2093
         visibility.  */
2094
      if (eh->dyn_relocs != NULL
2095
          && h->root.type == bfd_link_hash_undefweak)
2096
        {
2097
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2098
            eh->dyn_relocs = NULL;
2099
 
2100
          /* Make sure undefined weak symbols are output as a dynamic
2101
             symbol in PIEs.  */
2102
          else if (h->dynindx == -1
2103
                   && !h->forced_local)
2104
            {
2105
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2106
                return FALSE;
2107
            }
2108
        }
2109
    }
2110
  else
2111
    {
2112
      /* For the non-shared case, discard space for relocs against
2113
         symbols which turn out to need copy relocs or are not
2114
         dynamic.  */
2115
 
2116
      if (!h->non_got_ref
2117
          && ((h->def_dynamic
2118
               && !h->def_regular)
2119
              || (htab->root.dynamic_sections_created
2120
                  && (h->root.type == bfd_link_hash_undefweak
2121
                      || h->root.type == bfd_link_hash_undefined))))
2122
        {
2123
          /* Make sure this symbol is output as a dynamic symbol.
2124
             Undefined weak syms won't yet be marked as dynamic.  */
2125
          if (h->dynindx == -1
2126
              && !h->forced_local)
2127
            {
2128
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2129
                return FALSE;
2130
            }
2131
 
2132
          /* If that succeeded, we know we'll be keeping all the
2133
             relocs.  */
2134
          if (h->dynindx != -1)
2135
            goto keep;
2136
        }
2137
 
2138
      eh->dyn_relocs = NULL;
2139
 
2140
    keep: ;
2141
    }
2142
 
2143
  /* Finally, allocate space.  */
2144
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2145
    {
2146
      asection *sreloc = elf_section_data (p->sec)->sreloc;
2147
      sreloc->size += p->count * sizeof (Elf32_External_Rela);
2148
    }
2149
 
2150
  return TRUE;
2151
}
2152
 
2153
/* Find any dynamic relocs that apply to read-only sections.  */
2154
 
2155
static bfd_boolean
2156
readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2157
{
2158
  struct elf_m32r_link_hash_entry *eh;
2159
  struct elf_m32r_dyn_relocs *p;
2160
 
2161
  if (h->root.type == bfd_link_hash_warning)
2162
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2163
 
2164
  eh = (struct elf_m32r_link_hash_entry *) h;
2165
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2166
    {
2167
      asection *s = p->sec->output_section;
2168
 
2169
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
2170
        {
2171
          struct bfd_link_info *info = (struct bfd_link_info *) inf;
2172
 
2173
          info->flags |= DF_TEXTREL;
2174
 
2175
          /* Not an error, just cut short the traversal.  */
2176
          return FALSE;
2177
        }
2178
    }
2179
  return TRUE;
2180
}
2181
 
2182
/* Set the sizes of the dynamic sections.  */
2183
 
2184
static bfd_boolean
2185
m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2186
                                struct bfd_link_info *info)
2187
{
2188
  struct elf_m32r_link_hash_table *htab;
2189
  bfd *dynobj;
2190
  asection *s;
2191
  bfd_boolean relocs;
2192
  bfd *ibfd;
2193
 
2194
#ifdef DEBUG_PIC
2195
  printf ("m32r_elf_size_dynamic_sections()\n");
2196
#endif
2197
 
2198
  htab = m32r_elf_hash_table (info);
2199
  dynobj = htab->root.dynobj;
2200
  BFD_ASSERT (dynobj != NULL);
2201
 
2202
  if (htab->root.dynamic_sections_created)
2203
    {
2204
      /* Set the contents of the .interp section to the interpreter.  */
2205
      if (info->executable)
2206
        {
2207
          s = bfd_get_section_by_name (dynobj, ".interp");
2208
          BFD_ASSERT (s != NULL);
2209
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2210
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2211
        }
2212
    }
2213
 
2214
  /* Set up .got offsets for local syms, and space for local dynamic
2215
     relocs.  */
2216
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2217
    {
2218
      bfd_signed_vma *local_got;
2219
      bfd_signed_vma *end_local_got;
2220
      bfd_size_type locsymcount;
2221
      Elf_Internal_Shdr *symtab_hdr;
2222
      asection *srel;
2223
 
2224
      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2225
        continue;
2226
 
2227
      for (s = ibfd->sections; s != NULL; s = s->next)
2228
        {
2229
          struct elf_m32r_dyn_relocs *p;
2230
 
2231
          for (p = ((struct elf_m32r_dyn_relocs *)
2232
                    elf_section_data (s)->local_dynrel);
2233
               p != NULL;
2234
               p = p->next)
2235
            {
2236
              if (! bfd_is_abs_section (p->sec)
2237
                  && bfd_is_abs_section (p->sec->output_section))
2238
                {
2239
                  /* Input section has been discarded, either because
2240
                     it is a copy of a linkonce section or due to
2241
                     linker script /DISCARD/, so we'll be discarding
2242
                     the relocs too.  */
2243
                }
2244
              else if (p->count != 0)
2245
                {
2246
                  srel = elf_section_data (p->sec)->sreloc;
2247
                  srel->size += p->count * sizeof (Elf32_External_Rela);
2248
                  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2249
                    info->flags |= DF_TEXTREL;
2250
                }
2251
            }
2252
        }
2253
 
2254
      local_got = elf_local_got_refcounts (ibfd);
2255
      if (!local_got)
2256
        continue;
2257
 
2258
      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2259
      locsymcount = symtab_hdr->sh_info;
2260
      end_local_got = local_got + locsymcount;
2261
      s = htab->sgot;
2262
      srel = htab->srelgot;
2263
      for (; local_got < end_local_got; ++local_got)
2264
        {
2265
          if (*local_got > 0)
2266
            {
2267
              *local_got = s->size;
2268
              s->size += 4;
2269
              if (info->shared)
2270
                srel->size += sizeof (Elf32_External_Rela);
2271
            }
2272
          else
2273
            *local_got = (bfd_vma) -1;
2274
        }
2275
    }
2276
 
2277
  /* Allocate global sym .plt and .got entries, and space for global
2278
     sym dynamic relocs.  */
2279
  elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2280
 
2281
  /* We now have determined the sizes of the various dynamic sections.
2282
     Allocate memory for them.  */
2283
  relocs = FALSE;
2284
  for (s = dynobj->sections; s != NULL; s = s->next)
2285
    {
2286
      if ((s->flags & SEC_LINKER_CREATED) == 0)
2287
        continue;
2288
 
2289
      if (s == htab->splt
2290
          || s == htab->sgot
2291
          || s == htab->sgotplt
2292
          || s == htab->sdynbss)
2293
        {
2294
          /* Strip this section if we don't need it; see the
2295
             comment below.  */
2296
        }
2297
      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2298
        {
2299
          if (s->size != 0 && s != htab->srelplt)
2300
            relocs = TRUE;
2301
 
2302
          /* We use the reloc_count field as a counter if we need
2303
             to copy relocs into the output file.  */
2304
          s->reloc_count = 0;
2305
        }
2306
      else
2307
        /* It's not one of our sections, so don't allocate space.  */
2308
        continue;
2309
 
2310
      if (s->size == 0)
2311
        {
2312
          /* If we don't need this section, strip it from the
2313
             output file.  This is mostly to handle .rela.bss and
2314
             .rela.plt.  We must create both sections in
2315
             create_dynamic_sections, because they must be created
2316
             before the linker maps input sections to output
2317
             sections.  The linker does that before
2318
             adjust_dynamic_symbol is called, and it is that
2319
             function which decides whether anything needs to go
2320
             into these sections.  */
2321
          s->flags |= SEC_EXCLUDE;
2322
          continue;
2323
        }
2324
 
2325
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
2326
        continue;
2327
 
2328
      /* Allocate memory for the section contents.  We use bfd_zalloc
2329
         here in case unused entries are not reclaimed before the
2330
         section's contents are written out.  This should not happen,
2331
         but this way if it does, we get a R_M32R_NONE reloc instead
2332
         of garbage.  */
2333
      s->contents = bfd_zalloc (dynobj, s->size);
2334
      if (s->contents == NULL)
2335
        return FALSE;
2336
    }
2337
 
2338
  if (htab->root.dynamic_sections_created)
2339
    {
2340
      /* Add some entries to the .dynamic section.  We fill in the
2341
         values later, in m32r_elf_finish_dynamic_sections, but we
2342
         must add the entries now so that we get the correct size for
2343
         the .dynamic section.  The DT_DEBUG entry is filled in by the
2344
         dynamic linker and used by the debugger.  */
2345
#define add_dynamic_entry(TAG, VAL) \
2346
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2347
 
2348
     if (info->executable)
2349
        {
2350
          if (! add_dynamic_entry (DT_DEBUG, 0))
2351
            return FALSE;
2352
        }
2353
 
2354
      if (htab->splt->size != 0)
2355
        {
2356
          if (! add_dynamic_entry (DT_PLTGOT, 0)
2357
              || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2358
              || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2359
              || ! add_dynamic_entry (DT_JMPREL, 0))
2360
            return FALSE;
2361
        }
2362
 
2363
      if (relocs)
2364
        {
2365
          if (! add_dynamic_entry (DT_RELA, 0)
2366
              || ! add_dynamic_entry (DT_RELASZ, 0)
2367
              || ! add_dynamic_entry (DT_RELAENT,
2368
                                      sizeof (Elf32_External_Rela)))
2369
            return FALSE;
2370
 
2371
          /* If any dynamic relocs apply to a read-only section,
2372
             then we need a DT_TEXTREL entry.  */
2373
          if ((info->flags & DF_TEXTREL) == 0)
2374
            elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2375
                                    info);
2376
 
2377
          if ((info->flags & DF_TEXTREL) != 0)
2378
            {
2379
              if (! add_dynamic_entry (DT_TEXTREL, 0))
2380
                return FALSE;
2381
            }
2382
        }
2383
    }
2384
#undef add_dynamic_entry
2385
 
2386
  return TRUE;
2387
}
2388
 
2389
/* Relocate an M32R/D ELF section.
2390
   There is some attempt to make this function usable for many architectures,
2391
   both for RELA and REL type relocs, if only to serve as a learning tool.
2392
 
2393
   The RELOCATE_SECTION function is called by the new ELF backend linker
2394
   to handle the relocations for a section.
2395
 
2396
   The relocs are always passed as Rela structures; if the section
2397
   actually uses Rel structures, the r_addend field will always be
2398
   zero.
2399
 
2400
   This function is responsible for adjust the section contents as
2401
   necessary, and (if using Rela relocs and generating a
2402
   relocatable output file) adjusting the reloc addend as
2403
   necessary.
2404
 
2405
   This function does not have to worry about setting the reloc
2406
   address or the reloc symbol index.
2407
 
2408
   LOCAL_SYMS is a pointer to the swapped in local symbols.
2409
 
2410
   LOCAL_SECTIONS is an array giving the section in the input file
2411
   corresponding to the st_shndx field of each local symbol.
2412
 
2413
   The global hash table entry for the global symbols can be found
2414
   via elf_sym_hashes (input_bfd).
2415
 
2416
   When generating relocatable output, this function must handle
2417
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2418
   going to be the section symbol corresponding to the output
2419
   section, which means that the addend must be adjusted
2420
   accordingly.  */
2421
 
2422
static bfd_boolean
2423
m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
2424
                           struct bfd_link_info *info,
2425
                           bfd *input_bfd,
2426
                           asection *input_section,
2427
                           bfd_byte *contents,
2428
                           Elf_Internal_Rela *relocs,
2429
                           Elf_Internal_Sym *local_syms,
2430
                           asection **local_sections)
2431
{
2432
  Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2433
  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2434
  Elf_Internal_Rela *rel, *relend;
2435
  /* Assume success.  */
2436
  bfd_boolean ret = TRUE;
2437
 
2438
  struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2439
  bfd *dynobj;
2440
  bfd_vma *local_got_offsets;
2441
  asection *sgot, *splt, *sreloc;
2442
  bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2443
 
2444
  dynobj = htab->root.dynobj;
2445
  local_got_offsets = elf_local_got_offsets (input_bfd);
2446
 
2447
  sgot = htab->sgot;
2448
  splt = htab->splt;
2449
  sreloc = NULL;
2450
 
2451
  rel = relocs;
2452
  relend = relocs + input_section->reloc_count;
2453
  for (; rel < relend; rel++)
2454
    {
2455
      int r_type;
2456
      reloc_howto_type *howto;
2457
      unsigned long r_symndx;
2458
      struct elf_link_hash_entry *h;
2459
      /* We can't modify r_addend here as elf_link_input_bfd has an assert to
2460
         ensure it's zero (we use REL relocs, not RELA).  Therefore this
2461
         should be assigning zero to `addend', but for clarity we use
2462
         `r_addend'.  */
2463
      bfd_vma addend = rel->r_addend;
2464
      bfd_vma offset = rel->r_offset;
2465
      bfd_vma relocation;
2466
      Elf_Internal_Sym *sym;
2467
      asection *sec;
2468
      const char *sym_name;
2469
      bfd_reloc_status_type r;
2470
      const char *errmsg = NULL;
2471
      bfd_boolean use_rel = FALSE;
2472
 
2473
      h = NULL;
2474
      r_type = ELF32_R_TYPE (rel->r_info);
2475
      if (r_type < 0 || r_type >= (int) R_M32R_max)
2476
        {
2477
          (*_bfd_error_handler) (_("%B: unknown relocation type %d"),
2478
                                 input_bfd,
2479
                                 (int) r_type);
2480
          bfd_set_error (bfd_error_bad_value);
2481
          ret = FALSE;
2482
          continue;
2483
        }
2484
 
2485
      if (   r_type == R_M32R_GNU_VTENTRY
2486
          || r_type == R_M32R_GNU_VTINHERIT
2487
          || r_type == R_M32R_NONE
2488
          || r_type == R_M32R_RELA_GNU_VTENTRY
2489
          || r_type == R_M32R_RELA_GNU_VTINHERIT)
2490
        continue;
2491
 
2492
      if (r_type <= R_M32R_GNU_VTENTRY)
2493
        use_rel = TRUE;
2494
 
2495
      howto = m32r_elf_howto_table + r_type;
2496
      r_symndx = ELF32_R_SYM (rel->r_info);
2497
 
2498
      sym = NULL;
2499
      sec = NULL;
2500
      h = NULL;
2501
 
2502
      if (r_symndx < symtab_hdr->sh_info)
2503
        {
2504
          /* Local symbol.  */
2505
          sym = local_syms + r_symndx;
2506
          sec = local_sections[r_symndx];
2507
          sym_name = "<local symbol>";
2508
 
2509
          if (!use_rel)
2510
            {
2511
              relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2512
              addend = rel->r_addend;
2513
            }
2514
          else
2515
            {
2516
              relocation = (sec->output_section->vma
2517
                            + sec->output_offset
2518
                            + sym->st_value);
2519
            }
2520
        }
2521
      else
2522
        {
2523
          /* External symbol.  */
2524
          relocation = 0;
2525
 
2526
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2527
          while (h->root.type == bfd_link_hash_indirect
2528
                 || h->root.type == bfd_link_hash_warning)
2529
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2530
          sym_name = h->root.root.string;
2531
 
2532
          if (h->root.type == bfd_link_hash_defined
2533
              || h->root.type == bfd_link_hash_defweak)
2534
            {
2535
              bfd_boolean dyn;
2536
              sec = h->root.u.def.section;
2537
 
2538
              dyn = htab->root.dynamic_sections_created;
2539
              sec = h->root.u.def.section;
2540
              if (r_type == R_M32R_GOTPC24
2541
                  || (r_type == R_M32R_GOTPC_HI_ULO
2542
                      || r_type == R_M32R_GOTPC_HI_SLO
2543
                      || r_type == R_M32R_GOTPC_LO)
2544
                  || (r_type == R_M32R_26_PLTREL
2545
                      && h->plt.offset != (bfd_vma) -1)
2546
                  || ((r_type == R_M32R_GOT24
2547
                       || r_type == R_M32R_GOT16_HI_ULO
2548
                       || r_type == R_M32R_GOT16_HI_SLO
2549
                       || r_type == R_M32R_GOT16_LO)
2550
                      && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2551
                                                          info->shared, h)
2552
                      && (! info->shared
2553
                          || (! info->symbolic && h->dynindx != -1)
2554
                          || !h->def_regular))
2555
                  || (info->shared
2556
                      && ((! info->symbolic && h->dynindx != -1)
2557
                          || !h->def_regular)
2558
                      && (((r_type == R_M32R_16_RELA
2559
                            || r_type == R_M32R_32_RELA
2560
                            || r_type == R_M32R_24_RELA
2561
                            || r_type == R_M32R_HI16_ULO_RELA
2562
                            || r_type == R_M32R_HI16_SLO_RELA
2563
                            || r_type == R_M32R_LO16_RELA)
2564
                           && !h->forced_local)
2565
                          || r_type == R_M32R_REL32
2566
                          || r_type == R_M32R_10_PCREL_RELA
2567
                          || r_type == R_M32R_18_PCREL_RELA
2568
                          || r_type == R_M32R_26_PCREL_RELA)
2569
                      && ((input_section->flags & SEC_ALLOC) != 0
2570
                          /* DWARF will emit R_M32R_16(24,32) relocations
2571
                             in its sections against symbols defined
2572
                             externally in shared libraries.  We can't do
2573
                             anything with them here.  */
2574
                          || ((input_section->flags & SEC_DEBUGGING) != 0
2575
                              && h->def_dynamic))))
2576
                {
2577
                  /* In these cases, we don't need the relocation
2578
                     value.  We check specially because in some
2579
                     obscure cases sec->output_section will be NULL.  */
2580
                }
2581
              else if (sec->output_section != NULL)
2582
                relocation = (h->root.u.def.value
2583
                              + sec->output_section->vma
2584
                              + sec->output_offset);
2585
              else if (!info->relocatable)
2586
                {
2587
                  (*_bfd_error_handler)
2588
                    (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2589
                     input_bfd,
2590
                     input_section,
2591
                     (long) rel->r_offset,
2592
                     howto->name,
2593
                     h->root.root.string);
2594
                }
2595
            }
2596
          else if (h->root.type == bfd_link_hash_undefweak)
2597
            ;
2598
          else if (info->unresolved_syms_in_objects == RM_IGNORE
2599
                   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2600
            ;
2601
          else if (!info->relocatable)
2602
            {
2603
              if (! ((*info->callbacks->undefined_symbol)
2604
                     (info, h->root.root.string, input_bfd,
2605
                      input_section, offset,
2606
                      (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2607
                       || ELF_ST_VISIBILITY (h->other)))))
2608
                return FALSE;
2609
            }
2610
        }
2611
 
2612
      if (sec != NULL && elf_discarded_section (sec))
2613
        {
2614
          /* For relocs against symbols from removed linkonce sections,
2615
             or sections discarded by a linker script, we just want the
2616
             section contents zeroed.  Avoid any special processing.  */
2617
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2618
          rel->r_info = 0;
2619
          rel->r_addend = 0;
2620
          continue;
2621
        }
2622
 
2623
      if (info->relocatable && !use_rel)
2624
        {
2625
          /* This is a relocatable link.  We don't have to change
2626
             anything, unless the reloc is against a section symbol,
2627
             in which case we have to adjust according to where the
2628
             section symbol winds up in the output section.  */
2629
          if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2630
            rel->r_addend += sec->output_offset;
2631
          continue;
2632
        }
2633
 
2634
      if (info->relocatable && use_rel)
2635
        {
2636
          /* This is a relocatable link.  We don't have to change
2637
             anything, unless the reloc is against a section symbol,
2638
             in which case we have to adjust according to where the
2639
             section symbol winds up in the output section.  */
2640
          if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2641
            continue;
2642
 
2643
          addend += sec->output_offset;
2644
 
2645
          /* If partial_inplace, we need to store any additional addend
2646
             back in the section.  */
2647
          if (! howto->partial_inplace)
2648
            continue;
2649
          /* ??? Here is a nice place to call a special_function
2650
             like handler.  */
2651
          if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2652
            r = _bfd_relocate_contents (howto, input_bfd,
2653
                                        addend, contents + offset);
2654
          else
2655
            {
2656
              Elf_Internal_Rela *lorel;
2657
 
2658
              /* We allow an arbitrary number of HI16 relocs before the
2659
                 LO16 reloc.  This permits gcc to emit the HI and LO relocs
2660
                 itself.  */
2661
              for (lorel = rel + 1;
2662
                   (lorel < relend
2663
                    && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2664
                        || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2665
                   lorel++)
2666
                continue;
2667
              if (lorel < relend
2668
                  && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2669
                {
2670
                  m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2671
                                          contents, addend);
2672
                  r = bfd_reloc_ok;
2673
                }
2674
              else
2675
                r = _bfd_relocate_contents (howto, input_bfd,
2676
                                            addend, contents + offset);
2677
            }
2678
        }
2679
      else
2680
        {
2681
          /* Sanity check the address.  */
2682
          if (offset > high_address)
2683
            {
2684
              r = bfd_reloc_outofrange;
2685
              goto check_reloc;
2686
            }
2687
 
2688
          switch ((int) r_type)
2689
            {
2690
            case R_M32R_GOTOFF:
2691
              /* Relocation is relative to the start of the global offset
2692
                 table (for ld24 rx, #uimm24). eg access at label+addend
2693
 
2694
                 ld24 rx. #label@GOTOFF + addend
2695
                 sub  rx, r12.  */
2696
 
2697
              BFD_ASSERT (sgot != NULL);
2698
 
2699
              relocation = -(relocation - sgot->output_section->vma);
2700
              rel->r_addend = -rel->r_addend;
2701
              break;
2702
 
2703
            case R_M32R_GOTOFF_HI_ULO:
2704
            case R_M32R_GOTOFF_HI_SLO:
2705
            case R_M32R_GOTOFF_LO:
2706
              BFD_ASSERT (sgot != NULL);
2707
 
2708
              relocation -= sgot->output_section->vma;
2709
 
2710
              if ((r_type == R_M32R_GOTOFF_HI_SLO)
2711
                  && ((relocation + rel->r_addend) & 0x8000))
2712
                rel->r_addend += 0x10000;
2713
              break;
2714
 
2715
            case R_M32R_GOTPC24:
2716
              /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2717
                 ld24 rx,#_GLOBAL_OFFSET_TABLE_
2718
               */
2719
             relocation = sgot->output_section->vma;
2720
             break;
2721
 
2722
            case R_M32R_GOTPC_HI_ULO:
2723
            case R_M32R_GOTPC_HI_SLO:
2724
            case R_M32R_GOTPC_LO:
2725
              {
2726
                /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2727
                   bl .+4
2728
                   seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2729
                   or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2730
                   or
2731
                   bl .+4
2732
                   seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2733
                   add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2734
                 */
2735
                relocation = sgot->output_section->vma;
2736
                relocation -= (input_section->output_section->vma
2737
                               + input_section->output_offset
2738
                               + rel->r_offset);
2739
                if ((r_type == R_M32R_GOTPC_HI_SLO)
2740
                     && ((relocation + rel->r_addend) & 0x8000))
2741
                  rel->r_addend += 0x10000;
2742
 
2743
                break;
2744
              }
2745
            case R_M32R_GOT16_HI_ULO:
2746
            case R_M32R_GOT16_HI_SLO:
2747
            case R_M32R_GOT16_LO:
2748
              /* Fall through.  */
2749
            case R_M32R_GOT24:
2750
              /* Relocation is to the entry for this symbol in the global
2751
                 offset table.  */
2752
              BFD_ASSERT (sgot != NULL);
2753
 
2754
              if (h != NULL)
2755
                {
2756
                  bfd_boolean dyn;
2757
                  bfd_vma off;
2758
 
2759
                  off = h->got.offset;
2760
                  BFD_ASSERT (off != (bfd_vma) -1);
2761
 
2762
                  dyn = htab->root.dynamic_sections_created;
2763
                  if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2764
                      || (info->shared
2765
                          && (info->symbolic
2766
                              || h->dynindx == -1
2767
                              || h->forced_local)
2768
                          && h->def_regular))
2769
                    {
2770
                      /* This is actually a static link, or it is a
2771
                         -Bsymbolic link and the symbol is defined
2772
                         locally, or the symbol was forced to be local
2773
                         because of a version file.  We must initialize
2774
                         this entry in the global offset table.  Since the
2775
                         offset must always be a multiple of 4, we use the
2776
                         least significant bit to record whether we have
2777
                         initialized it already.
2778
 
2779
                         When doing a dynamic link, we create a .rela.got
2780
                         relocation entry to initialize the value.  This
2781
                         is done in the finish_dynamic_symbol routine.  */
2782
                      if ((off & 1) != 0)
2783
                        off &= ~1;
2784
                      else
2785
                        {
2786
                          bfd_put_32 (output_bfd, relocation,
2787
                                      sgot->contents + off);
2788
                          h->got.offset |= 1;
2789
                        }
2790
                    }
2791
 
2792
                  relocation = sgot->output_offset + off;
2793
                }
2794
              else
2795
                {
2796
                  bfd_vma off;
2797
                  bfd_byte *loc;
2798
 
2799
                  BFD_ASSERT (local_got_offsets != NULL
2800
                              && local_got_offsets[r_symndx] != (bfd_vma) -1);
2801
 
2802
                  off = local_got_offsets[r_symndx];
2803
 
2804
                  /* The offset must always be a multiple of 4.  We use
2805
                     the least significant bit to record whether we have
2806
                     already processed this entry.  */
2807
                  if ((off & 1) != 0)
2808
                    off &= ~1;
2809
                  else
2810
                    {
2811
                      bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2812
 
2813
                      if (info->shared)
2814
                        {
2815
                          asection *srelgot;
2816
                          Elf_Internal_Rela outrel;
2817
 
2818
                          /* We need to generate a R_M32R_RELATIVE reloc
2819
                             for the dynamic linker.  */
2820
                          srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2821
                          BFD_ASSERT (srelgot != NULL);
2822
 
2823
                          outrel.r_offset = (sgot->output_section->vma
2824
                                             + sgot->output_offset
2825
                                             + off);
2826
                          outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2827
                          outrel.r_addend = relocation;
2828
                          loc = srelgot->contents;
2829
                          loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
2830
                          bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2831
                          ++srelgot->reloc_count;
2832
                        }
2833
 
2834
                      local_got_offsets[r_symndx] |= 1;
2835
                    }
2836
 
2837
                  relocation = sgot->output_offset + off;
2838
                }
2839
              if ((r_type == R_M32R_GOT16_HI_SLO)
2840
                  && ((relocation + rel->r_addend) & 0x8000))
2841
                rel->r_addend += 0x10000;
2842
 
2843
              break;
2844
 
2845
            case R_M32R_26_PLTREL:
2846
              /* Relocation is to the entry for this symbol in the
2847
                 procedure linkage table.  */
2848
 
2849
              /* The native assembler will generate a 26_PLTREL reloc
2850
                 for a local symbol if you assemble a call from one
2851
                 section to another when using -K pic. */
2852
              if (h == NULL)
2853
                break;
2854
 
2855
              if (h->forced_local)
2856
                break;
2857
 
2858
              if (h->plt.offset == (bfd_vma) -1)
2859
                /* We didn't make a PLT entry for this symbol.  This
2860
                   happens when statically linking PIC code, or when
2861
                   using -Bsymbolic.  */
2862
                break;
2863
 
2864
              relocation = (splt->output_section->vma
2865
                            + splt->output_offset
2866
                            + h->plt.offset);
2867
              break;
2868
 
2869
            case R_M32R_HI16_SLO_RELA:
2870
              if ((relocation + rel->r_addend) & 0x8000)
2871
                rel->r_addend += 0x10000;
2872
              /* Fall through.  */
2873
 
2874
            case R_M32R_16_RELA:
2875
            case R_M32R_24_RELA:
2876
            case R_M32R_32_RELA:
2877
            case R_M32R_REL32:
2878
            case R_M32R_10_PCREL_RELA:
2879
            case R_M32R_18_PCREL_RELA:
2880
            case R_M32R_26_PCREL_RELA:
2881
            case R_M32R_HI16_ULO_RELA:
2882
            case R_M32R_LO16_RELA:
2883
              if (info->shared
2884
                  && r_symndx != 0
2885
                  && (input_section->flags & SEC_ALLOC) != 0
2886
                  && ((   r_type != R_M32R_10_PCREL_RELA
2887
                       && r_type != R_M32R_18_PCREL_RELA
2888
                       && r_type != R_M32R_26_PCREL_RELA
2889
                       && r_type != R_M32R_REL32)
2890
                      || (h != NULL
2891
                          && h->dynindx != -1
2892
                          && (! info->symbolic
2893
                              || !h->def_regular))))
2894
                {
2895
                  Elf_Internal_Rela outrel;
2896
                  bfd_boolean skip, relocate;
2897
                  bfd_byte *loc;
2898
 
2899
                  /* When generating a shared object, these relocations
2900
                     are copied into the output file to be resolved at run
2901
                     time.  */
2902
                  if (sreloc == NULL)
2903
                    {
2904 225 jeremybenn
                      sreloc = _bfd_elf_get_dynamic_reloc_section
2905
                        (input_bfd, input_section, /*rela?*/ TRUE);
2906
                      if (sreloc == NULL)
2907
                        return FALSE;
2908 24 jeremybenn
                    }
2909
 
2910
                  skip = FALSE;
2911
                  relocate = FALSE;
2912
 
2913
                  outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2914
                                                             info,
2915
                                                             input_section,
2916
                                                             rel->r_offset);
2917
                  if (outrel.r_offset == (bfd_vma) -1)
2918
                    skip = TRUE;
2919
                  else if (outrel.r_offset == (bfd_vma) -2)
2920
                    skip = relocate = TRUE;
2921
                  outrel.r_offset += (input_section->output_section->vma
2922
                                      + input_section->output_offset);
2923
 
2924
                  if (skip)
2925
                    memset (&outrel, 0, sizeof outrel);
2926
                  else if (   r_type == R_M32R_10_PCREL_RELA
2927
                           || r_type == R_M32R_18_PCREL_RELA
2928
                           || r_type == R_M32R_26_PCREL_RELA
2929
                           || r_type == R_M32R_REL32)
2930
                    {
2931
                      BFD_ASSERT (h != NULL && h->dynindx != -1);
2932
                      outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2933
                      outrel.r_addend = rel->r_addend;
2934
                    }
2935
                  else
2936
                    {
2937
                    /* h->dynindx may be -1 if this symbol was marked to
2938
                       become local.  */
2939
                    if (h == NULL
2940
                        || ((info->symbolic || h->dynindx == -1)
2941
                             && h->def_regular))
2942
                      {
2943
                        relocate = TRUE;
2944
                        outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2945
                        outrel.r_addend = relocation + rel->r_addend;
2946
                      }
2947
                    else
2948
                      {
2949
                        BFD_ASSERT (h->dynindx != -1);
2950
                        outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2951
                        outrel.r_addend = relocation + rel->r_addend;
2952
                      }
2953
                    }
2954
 
2955
                  loc = sreloc->contents;
2956
                  loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
2957
                  bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2958
                  ++sreloc->reloc_count;
2959
 
2960
                  /* If this reloc is against an external symbol, we do
2961
                     not want to fiddle with the addend.  Otherwise, we
2962
                     need to include the symbol value so that it becomes
2963
                     an addend for the dynamic reloc.  */
2964
                  if (! relocate)
2965
                    continue;
2966
                  break;
2967
                }
2968
              else if (r_type != R_M32R_10_PCREL_RELA)
2969
                break;
2970
              /* Fall through.  */
2971
 
2972
            case (int) R_M32R_10_PCREL :
2973
              r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
2974
                                              contents, offset,
2975
                                              sec, relocation, addend);
2976
              goto check_reloc;
2977
 
2978
            case (int) R_M32R_HI16_SLO :
2979
            case (int) R_M32R_HI16_ULO :
2980
              {
2981
                Elf_Internal_Rela *lorel;
2982
 
2983
                /* We allow an arbitrary number of HI16 relocs before the
2984
                   LO16 reloc.  This permits gcc to emit the HI and LO relocs
2985
                   itself.  */
2986
                for (lorel = rel + 1;
2987
                     (lorel < relend
2988
                      && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2989
                          || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2990
                     lorel++)
2991
                  continue;
2992
                if (lorel < relend
2993
                    && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2994
                  {
2995
                    m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2996
                                            contents, relocation + addend);
2997
                    r = bfd_reloc_ok;
2998
                  }
2999
                else
3000
                  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3001
                                                contents, offset,
3002
                                                relocation, addend);
3003
              }
3004
 
3005
              goto check_reloc;
3006
 
3007
            case (int) R_M32R_SDA16_RELA:
3008
            case (int) R_M32R_SDA16 :
3009
              {
3010
                const char *name;
3011
 
3012
                BFD_ASSERT (sec != NULL);
3013
                name = bfd_get_section_name (abfd, sec);
3014
 
3015
                if (   strcmp (name, ".sdata") == 0
3016
                    || strcmp (name, ".sbss") == 0
3017
                    || strcmp (name, ".scommon") == 0)
3018
                  {
3019
                    bfd_vma sda_base;
3020
                    bfd *out_bfd = sec->output_section->owner;
3021
 
3022
                    r = m32r_elf_final_sda_base (out_bfd, info,
3023
                                                 &errmsg,
3024
                                                 &sda_base);
3025
                    if (r != bfd_reloc_ok)
3026
                      {
3027
                        ret = FALSE;
3028
                        goto check_reloc;
3029
                      }
3030
 
3031
                    /* At this point `relocation' contains the object's
3032
                       address.  */
3033
                    relocation -= sda_base;
3034
                    /* Now it contains the offset from _SDA_BASE_.  */
3035
                  }
3036
                else
3037
                  {
3038
                    (*_bfd_error_handler)
3039
                      (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3040
                       input_bfd,
3041
                       sec,
3042
                       sym_name,
3043
                       m32r_elf_howto_table[(int) r_type].name);
3044
                    /*bfd_set_error (bfd_error_bad_value); ??? why? */
3045
                    ret = FALSE;
3046
                    continue;
3047
                  }
3048
              }
3049
              /* Fall through.  */
3050
 
3051
            default : /* OLD_M32R_RELOC */
3052
 
3053
              r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3054
                                            contents, offset,
3055
                                            relocation, addend);
3056
              goto check_reloc;
3057
            }
3058
 
3059
          r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3060
                                        contents, rel->r_offset,
3061
                                        relocation, rel->r_addend);
3062
 
3063
        }
3064
 
3065
    check_reloc:
3066
 
3067
      if (r != bfd_reloc_ok)
3068
        {
3069
          /* FIXME: This should be generic enough to go in a utility.  */
3070
          const char *name;
3071
 
3072
          if (h != NULL)
3073
            name = h->root.root.string;
3074
          else
3075
            {
3076
              name = (bfd_elf_string_from_elf_section
3077
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
3078
              if (name == NULL || *name == '\0')
3079
                name = bfd_section_name (input_bfd, sec);
3080
            }
3081
 
3082
          if (errmsg != NULL)
3083
            goto common_error;
3084
 
3085
          switch (r)
3086
            {
3087
            case bfd_reloc_overflow:
3088
              if (! ((*info->callbacks->reloc_overflow)
3089
                     (info, (h ? &h->root : NULL), name, howto->name,
3090
                      (bfd_vma) 0, input_bfd, input_section, offset)))
3091
                return FALSE;
3092
              break;
3093
 
3094
            case bfd_reloc_undefined:
3095
              if (! ((*info->callbacks->undefined_symbol)
3096
                     (info, name, input_bfd, input_section,
3097
                      offset, TRUE)))
3098
                return FALSE;
3099
              break;
3100
 
3101
            case bfd_reloc_outofrange:
3102
              errmsg = _("internal error: out of range error");
3103
              goto common_error;
3104
 
3105
            case bfd_reloc_notsupported:
3106
              errmsg = _("internal error: unsupported relocation error");
3107
              goto common_error;
3108
 
3109
            case bfd_reloc_dangerous:
3110
              errmsg = _("internal error: dangerous error");
3111
              goto common_error;
3112
 
3113
            default:
3114
              errmsg = _("internal error: unknown error");
3115
              /* fall through */
3116
 
3117
            common_error:
3118
              if (!((*info->callbacks->warning)
3119
                    (info, errmsg, name, input_bfd, input_section,
3120
                     offset)))
3121
                return FALSE;
3122
              break;
3123
            }
3124
        }
3125
    }
3126
 
3127
  return ret;
3128
}
3129
 
3130
/* Finish up dynamic symbol handling.  We set the contents of various
3131
   dynamic sections here.  */
3132
 
3133
static bfd_boolean
3134
m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3135
                                struct bfd_link_info *info,
3136
                                struct elf_link_hash_entry *h,
3137
                                Elf_Internal_Sym *sym)
3138
{
3139
  struct elf_m32r_link_hash_table *htab;
3140
  bfd *dynobj;
3141
  bfd_byte *loc;
3142
 
3143
#ifdef DEBUG_PIC
3144
  printf ("m32r_elf_finish_dynamic_symbol()\n");
3145
#endif
3146
 
3147
  htab = m32r_elf_hash_table (info);
3148
  dynobj = htab->root.dynobj;
3149
 
3150
  if (h->plt.offset != (bfd_vma) -1)
3151
    {
3152
      asection *splt;
3153
      asection *sgot;
3154
      asection *srela;
3155
 
3156
      bfd_vma plt_index;
3157
      bfd_vma got_offset;
3158
      Elf_Internal_Rela rela;
3159
 
3160
      /* This symbol has an entry in the procedure linkage table.  Set
3161
         it up.  */
3162
 
3163
      BFD_ASSERT (h->dynindx != -1);
3164
 
3165
      splt = htab->splt;
3166
      sgot = htab->sgotplt;
3167
      srela = htab->srelplt;
3168
      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3169
 
3170
      /* Get the index in the procedure linkage table which
3171
         corresponds to this symbol.  This is the index of this symbol
3172
         in all the symbols for which we are making plt entries.  The
3173
         first entry in the procedure linkage table is reserved.  */
3174
      plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3175
 
3176
      /* Get the offset into the .got table of the entry that
3177
        corresponds to this function.  Each .got entry is 4 bytes.
3178
        The first three are reserved.  */
3179
      got_offset = (plt_index + 3) * 4;
3180
 
3181
      /* Fill in the entry in the procedure linkage table.  */
3182
      if (! info->shared)
3183
        {
3184
          bfd_put_32 (output_bfd,
3185
              (PLT_ENTRY_WORD0b
3186
               + (((sgot->output_section->vma
3187
                    + sgot->output_offset
3188
                    + got_offset) >> 16) & 0xffff)),
3189
              splt->contents + h->plt.offset);
3190
          bfd_put_32 (output_bfd,
3191
              (PLT_ENTRY_WORD1b
3192
               + ((sgot->output_section->vma
3193
                   + sgot->output_offset
3194
                   + got_offset) & 0xffff)),
3195
              splt->contents + h->plt.offset + 4);
3196
          bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3197
              splt->contents + h->plt.offset + 8);
3198
          bfd_put_32 (output_bfd,
3199
              (PLT_ENTRY_WORD3
3200
               + plt_index * sizeof (Elf32_External_Rela)),
3201
              splt->contents + h->plt.offset + 12);
3202
          bfd_put_32 (output_bfd,
3203
              (PLT_ENTRY_WORD4
3204
               + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3205
              splt->contents + h->plt.offset + 16);
3206
        }
3207
      else
3208
        {
3209
          bfd_put_32 (output_bfd,
3210
              PLT_ENTRY_WORD0 + got_offset,
3211
              splt->contents + h->plt.offset);
3212
          bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3213
              splt->contents + h->plt.offset + 4);
3214
          bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3215
              splt->contents + h->plt.offset + 8);
3216
          bfd_put_32 (output_bfd,
3217
              (PLT_ENTRY_WORD3
3218
               + plt_index * sizeof (Elf32_External_Rela)),
3219
              splt->contents + h->plt.offset + 12);
3220
          bfd_put_32 (output_bfd,
3221
              (PLT_ENTRY_WORD4
3222
               + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3223
              splt->contents + h->plt.offset + 16);
3224
        }
3225
 
3226
      /* Fill in the entry in the global offset table.  */
3227
      bfd_put_32 (output_bfd,
3228
                  (splt->output_section->vma
3229
                   + splt->output_offset
3230
                   + h->plt.offset
3231
                   + 12), /* same offset */
3232
                  sgot->contents + got_offset);
3233
 
3234
      /* Fill in the entry in the .rela.plt section.  */
3235
      rela.r_offset = (sgot->output_section->vma
3236
                       + sgot->output_offset
3237
                       + got_offset);
3238
      rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3239
      rela.r_addend = 0;
3240
      loc = srela->contents;
3241
      loc += plt_index * sizeof (Elf32_External_Rela);
3242
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3243
 
3244
      if (!h->def_regular)
3245
        {
3246
          /* Mark the symbol as undefined, rather than as defined in
3247
             the .plt section.  Leave the value alone.  */
3248
          sym->st_shndx = SHN_UNDEF;
3249
        }
3250
    }
3251
 
3252
  if (h->got.offset != (bfd_vma) -1)
3253
    {
3254
      asection *sgot;
3255
      asection *srela;
3256
      Elf_Internal_Rela rela;
3257
 
3258
      /* This symbol has an entry in the global offset table.  Set it
3259
         up.  */
3260
 
3261
      sgot = htab->sgot;
3262
      srela = htab->srelgot;
3263
      BFD_ASSERT (sgot != NULL && srela != NULL);
3264
 
3265
      rela.r_offset = (sgot->output_section->vma
3266
                       + sgot->output_offset
3267
                       + (h->got.offset &~ 1));
3268
 
3269
      /* If this is a -Bsymbolic link, and the symbol is defined
3270
         locally, we just want to emit a RELATIVE reloc.  Likewise if
3271
         the symbol was forced to be local because of a version file.
3272
         The entry in the global offset table will already have been
3273
         initialized in the relocate_section function.  */
3274
      if (info->shared
3275
          && (info->symbolic
3276
              || h->dynindx == -1
3277
              || h->forced_local)
3278
          && h->def_regular)
3279
        {
3280
          rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3281
          rela.r_addend = (h->root.u.def.value
3282
                           + h->root.u.def.section->output_section->vma
3283
                           + h->root.u.def.section->output_offset);
3284
        }
3285
      else
3286
        {
3287
          BFD_ASSERT ((h->got.offset & 1) == 0);
3288
          bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3289
          rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3290
          rela.r_addend = 0;
3291
        }
3292
 
3293
      loc = srela->contents;
3294
      loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3295
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3296
      ++srela->reloc_count;
3297
    }
3298
 
3299
  if (h->needs_copy)
3300
    {
3301
      asection *s;
3302
      Elf_Internal_Rela rela;
3303
 
3304
      /* This symbols needs a copy reloc.  Set it up.  */
3305
 
3306
      BFD_ASSERT (h->dynindx != -1
3307
                  && (h->root.type == bfd_link_hash_defined
3308
                      || h->root.type == bfd_link_hash_defweak));
3309
 
3310
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
3311
                                   ".rela.bss");
3312
      BFD_ASSERT (s != NULL);
3313
 
3314
      rela.r_offset = (h->root.u.def.value
3315
                       + h->root.u.def.section->output_section->vma
3316
                       + h->root.u.def.section->output_offset);
3317
      rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3318
      rela.r_addend = 0;
3319
      loc = s->contents;
3320
      loc += s->reloc_count * sizeof (Elf32_External_Rela);
3321
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3322
      ++s->reloc_count;
3323
    }
3324
 
3325
  /* Mark some specially defined symbols as absolute.  */
3326
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3327
      || h == htab->root.hgot)
3328
    sym->st_shndx = SHN_ABS;
3329
 
3330
  return TRUE;
3331
}
3332
 
3333
 
3334
/* Finish up the dynamic sections.  */
3335
 
3336
static bfd_boolean
3337
m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3338
                                  struct bfd_link_info *info)
3339
{
3340
  struct elf_m32r_link_hash_table *htab;
3341
  bfd *dynobj;
3342
  asection *sdyn;
3343
  asection *sgot;
3344
 
3345
#ifdef DEBUG_PIC
3346
  printf ("m32r_elf_finish_dynamic_sections()\n");
3347
#endif
3348
 
3349
  htab = m32r_elf_hash_table (info);
3350
  dynobj = htab->root.dynobj;
3351
 
3352
  sgot = htab->sgotplt;
3353
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3354
 
3355
  if (htab->root.dynamic_sections_created)
3356
    {
3357
      asection *splt;
3358
      Elf32_External_Dyn *dyncon, *dynconend;
3359
 
3360
      BFD_ASSERT (sgot != NULL && sdyn != NULL);
3361
 
3362
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
3363
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3364
 
3365
      for (; dyncon < dynconend; dyncon++)
3366
        {
3367
          Elf_Internal_Dyn dyn;
3368
          const char *name;
3369
          asection *s;
3370
 
3371
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3372
 
3373
          switch (dyn.d_tag)
3374
            {
3375
            default:
3376
              break;
3377
 
3378
            case DT_PLTGOT:
3379
              name = ".got";
3380
              s = htab->sgot->output_section;
3381
              goto get_vma;
3382
            case DT_JMPREL:
3383
              name = ".rela.plt";
3384
              s = htab->srelplt->output_section;
3385
            get_vma:
3386
              BFD_ASSERT (s != NULL);
3387
              dyn.d_un.d_ptr = s->vma;
3388
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3389
              break;
3390
 
3391
            case DT_PLTRELSZ:
3392
              s = htab->srelplt->output_section;
3393
              BFD_ASSERT (s != NULL);
3394
              dyn.d_un.d_val = s->size;
3395
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3396
              break;
3397
 
3398
            case DT_RELASZ:
3399
              /* My reading of the SVR4 ABI indicates that the
3400
                 procedure linkage table relocs (DT_JMPREL) should be
3401
                 included in the overall relocs (DT_RELA).  This is
3402
                 what Solaris does.  However, UnixWare can not handle
3403
                 that case.  Therefore, we override the DT_RELASZ entry
3404
                 here to make it not include the JMPREL relocs.  Since
3405
                 the linker script arranges for .rela.plt to follow all
3406
                 other relocation sections, we don't have to worry
3407
                 about changing the DT_RELA entry.  */
3408
              if (htab->srelplt != NULL)
3409
                {
3410
                  s = htab->srelplt->output_section;
3411
                  dyn.d_un.d_val -= s->size;
3412
                }
3413
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3414
              break;
3415
            }
3416
        }
3417
 
3418
      /* Fill in the first entry in the procedure linkage table.  */
3419
      splt = htab->splt;
3420
      if (splt && splt->size > 0)
3421
        {
3422
          if (info->shared)
3423
            {
3424
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3425
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3426
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3427
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3428
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3429
            }
3430
          else
3431
            {
3432
              unsigned long addr;
3433
              /* addr = .got + 4 */
3434
              addr = sgot->output_section->vma + sgot->output_offset + 4;
3435
              bfd_put_32 (output_bfd,
3436
                          PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3437
                          splt->contents);
3438
              bfd_put_32 (output_bfd,
3439
                          PLT0_ENTRY_WORD1 | (addr & 0xffff),
3440
                          splt->contents + 4);
3441
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3442
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3443
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3444
            }
3445
 
3446
          elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3447
            PLT_ENTRY_SIZE;
3448
        }
3449
    }
3450
 
3451
  /* Fill in the first three entries in the global offset table.  */
3452
  if (sgot && sgot->size > 0)
3453
    {
3454
      if (sdyn == NULL)
3455
        bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3456
      else
3457
        bfd_put_32 (output_bfd,
3458
                    sdyn->output_section->vma + sdyn->output_offset,
3459
                    sgot->contents);
3460
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3461
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3462
 
3463
      elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3464
    }
3465
 
3466
  return TRUE;
3467
}
3468
 
3469
 
3470
/* Set the right machine number.  */
3471
 
3472
static bfd_boolean
3473
m32r_elf_object_p (bfd *abfd)
3474
{
3475
  switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3476
    {
3477
    default:
3478
    case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
3479
    case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3480
    case E_M32R2_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3481
    }
3482
  return TRUE;
3483
}
3484
 
3485
/* Store the machine number in the flags field.  */
3486
 
3487
static void
3488
m32r_elf_final_write_processing (bfd *abfd,
3489
                                 bfd_boolean linker ATTRIBUTE_UNUSED)
3490
{
3491
  unsigned long val;
3492
 
3493
  switch (bfd_get_mach (abfd))
3494
    {
3495
    default:
3496
    case bfd_mach_m32r:  val = E_M32R_ARCH; break;
3497
    case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3498
    case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3499
    }
3500
 
3501
  elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3502
  elf_elfheader (abfd)->e_flags |= val;
3503
}
3504
 
3505
/* Function to keep M32R specific file flags.  */
3506
 
3507
static bfd_boolean
3508
m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3509
{
3510
  BFD_ASSERT (!elf_flags_init (abfd)
3511
              || elf_elfheader (abfd)->e_flags == flags);
3512
 
3513
  elf_elfheader (abfd)->e_flags = flags;
3514
  elf_flags_init (abfd) = TRUE;
3515
  return TRUE;
3516
}
3517
 
3518
/* Merge backend specific data from an object file to the output
3519
   object file when linking.  */
3520
 
3521
static bfd_boolean
3522
m32r_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3523
{
3524
  flagword out_flags;
3525
  flagword in_flags;
3526
 
3527
  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3528
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3529
    return TRUE;
3530
 
3531
  in_flags  = elf_elfheader (ibfd)->e_flags;
3532
  out_flags = elf_elfheader (obfd)->e_flags;
3533
 
3534
  if (! elf_flags_init (obfd))
3535
    {
3536
      /* If the input is the default architecture then do not
3537
         bother setting the flags for the output architecture,
3538
         instead allow future merges to do this.  If no future
3539
         merges ever set these flags then they will retain their
3540
         unitialised values, which surprise surprise, correspond
3541
         to the default values.  */
3542
      if (bfd_get_arch_info (ibfd)->the_default)
3543
        return TRUE;
3544
 
3545
      elf_flags_init (obfd) = TRUE;
3546
      elf_elfheader (obfd)->e_flags = in_flags;
3547
 
3548
      if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3549
          && bfd_get_arch_info (obfd)->the_default)
3550
        return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3551
                                  bfd_get_mach (ibfd));
3552
 
3553
      return TRUE;
3554
    }
3555
 
3556
  /* Check flag compatibility.  */
3557
  if (in_flags == out_flags)
3558
    return TRUE;
3559
 
3560
  if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3561
    {
3562
      if (   ((in_flags  & EF_M32R_ARCH) != E_M32R_ARCH)
3563
          || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3564
          || ((in_flags  & EF_M32R_ARCH) == E_M32R2_ARCH))
3565
        {
3566
          (*_bfd_error_handler)
3567
            (_("%B: Instruction set mismatch with previous modules"), ibfd);
3568
 
3569
          bfd_set_error (bfd_error_bad_value);
3570
          return FALSE;
3571
        }
3572
    }
3573
 
3574
  return TRUE;
3575
}
3576
 
3577
/* Display the flags field.  */
3578
 
3579
static bfd_boolean
3580
m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3581
{
3582
  FILE * file = (FILE *) ptr;
3583
 
3584
  BFD_ASSERT (abfd != NULL && ptr != NULL);
3585
 
3586
  _bfd_elf_print_private_bfd_data (abfd, ptr);
3587
 
3588
  fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3589
 
3590
  switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3591
    {
3592
    default:
3593
    case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
3594
    case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3595
    case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3596
    }
3597
 
3598
  fputc ('\n', file);
3599
 
3600
  return TRUE;
3601
}
3602
 
3603
static asection *
3604
m32r_elf_gc_mark_hook (asection *sec,
3605
                       struct bfd_link_info *info,
3606
                       Elf_Internal_Rela *rel,
3607
                       struct elf_link_hash_entry *h,
3608
                       Elf_Internal_Sym *sym)
3609
{
3610
  if (h != NULL)
3611
    switch (ELF32_R_TYPE (rel->r_info))
3612
      {
3613
      case R_M32R_GNU_VTINHERIT:
3614
      case R_M32R_GNU_VTENTRY:
3615
      case R_M32R_RELA_GNU_VTINHERIT:
3616
      case R_M32R_RELA_GNU_VTENTRY:
3617
        return NULL;
3618
      }
3619
 
3620
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3621
}
3622
 
3623
static bfd_boolean
3624
m32r_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
3625
                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
3626
                        asection *sec ATTRIBUTE_UNUSED,
3627
                        const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3628
{
3629
  /* Update the got entry reference counts for the section being removed.  */
3630
  Elf_Internal_Shdr *symtab_hdr;
3631
  struct elf_link_hash_entry **sym_hashes;
3632
  bfd_signed_vma *local_got_refcounts;
3633
  const Elf_Internal_Rela *rel, *relend;
3634
 
3635
  if (info->relocatable)
3636
    return TRUE;
3637
 
3638
  elf_section_data (sec)->local_dynrel = NULL;
3639
 
3640
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3641
  sym_hashes = elf_sym_hashes (abfd);
3642
  local_got_refcounts = elf_local_got_refcounts (abfd);
3643
 
3644
  relend = relocs + sec->reloc_count;
3645
  for (rel = relocs; rel < relend; rel++)
3646
    {
3647
      unsigned long r_symndx;
3648
      struct elf_link_hash_entry *h = NULL;
3649
 
3650
      r_symndx = ELF32_R_SYM (rel->r_info);
3651
      if (r_symndx >= symtab_hdr->sh_info)
3652
        {
3653
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3654
          while (h->root.type == bfd_link_hash_indirect
3655
                 || h->root.type == bfd_link_hash_warning)
3656
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
3657
        }
3658
 
3659
      switch (ELF32_R_TYPE (rel->r_info))
3660
        {
3661
        case R_M32R_GOT16_HI_ULO:
3662
        case R_M32R_GOT16_HI_SLO:
3663
        case R_M32R_GOT16_LO:
3664
        case R_M32R_GOTOFF:
3665
        case R_M32R_GOTOFF_HI_ULO:
3666
        case R_M32R_GOTOFF_HI_SLO:
3667
        case R_M32R_GOTOFF_LO:
3668
        case R_M32R_GOT24:
3669
        case R_M32R_GOTPC_HI_ULO:
3670
        case R_M32R_GOTPC_HI_SLO:
3671
        case R_M32R_GOTPC_LO:
3672
        case R_M32R_GOTPC24:
3673
          if (h != NULL)
3674
            {
3675
              if (h->got.refcount > 0)
3676
                h->got.refcount--;
3677
            }
3678
          else
3679
            {
3680
              if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
3681
                local_got_refcounts[r_symndx]--;
3682
            }
3683
          break;
3684
 
3685
        case R_M32R_16_RELA:
3686
        case R_M32R_24_RELA:
3687
        case R_M32R_32_RELA:
3688
        case R_M32R_REL32:
3689
        case R_M32R_HI16_ULO_RELA:
3690
        case R_M32R_HI16_SLO_RELA:
3691
        case R_M32R_LO16_RELA:
3692
        case R_M32R_SDA16_RELA:
3693
        case R_M32R_10_PCREL_RELA:
3694
        case R_M32R_18_PCREL_RELA:
3695
        case R_M32R_26_PCREL_RELA:
3696
          if (h != NULL)
3697
            {
3698
              struct elf_m32r_link_hash_entry *eh;
3699
              struct elf_m32r_dyn_relocs **pp;
3700
              struct elf_m32r_dyn_relocs *p;
3701
 
3702
              if (!info->shared && h->plt.refcount > 0)
3703
                h->plt.refcount -= 1;
3704
 
3705
              eh = (struct elf_m32r_link_hash_entry *) h;
3706
 
3707
              for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3708
                if (p->sec == sec)
3709
                  {
3710
                    if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3711
                        || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3712
                        || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3713
                        || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3714
                      p->pc_count -= 1;
3715
                    p->count -= 1;
3716
                    if (p->count == 0)
3717
                      *pp = p->next;
3718
                    break;
3719
                  }
3720
            }
3721
          break;
3722
 
3723
        case R_M32R_26_PLTREL:
3724
          if (h != NULL)
3725
            {
3726
              if (h->plt.refcount > 0)
3727
                h->plt.refcount--;
3728
            }
3729
          break;
3730
 
3731
        default:
3732
          break;
3733
        }
3734
    }
3735
 
3736
  return TRUE;
3737
}
3738
 
3739
/* Look through the relocs for a section during the first phase.
3740
   Since we don't do .gots or .plts, we just need to consider the
3741
   virtual table relocs for gc.  */
3742
 
3743
static bfd_boolean
3744
m32r_elf_check_relocs (bfd *abfd,
3745
                       struct bfd_link_info *info,
3746
                       asection *sec,
3747
                       const Elf_Internal_Rela *relocs)
3748
{
3749
  Elf_Internal_Shdr *symtab_hdr;
3750
  struct elf_link_hash_entry **sym_hashes;
3751
  const Elf_Internal_Rela *rel;
3752
  const Elf_Internal_Rela *rel_end;
3753
  struct elf_m32r_link_hash_table *htab;
3754
  bfd *dynobj;
3755
  bfd_vma *local_got_offsets;
3756
  asection *sgot, *srelgot, *sreloc;
3757
 
3758
  if (info->relocatable)
3759
    return TRUE;
3760
 
3761
  sgot = srelgot = sreloc = NULL;
3762
 
3763
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3764
  sym_hashes = elf_sym_hashes (abfd);
3765
 
3766
  htab = m32r_elf_hash_table (info);
3767
  dynobj = htab->root.dynobj;
3768
  local_got_offsets = elf_local_got_offsets (abfd);
3769
 
3770
  rel_end = relocs + sec->reloc_count;
3771
  for (rel = relocs; rel < rel_end; rel++)
3772
    {
3773
      int r_type;
3774
      struct elf_link_hash_entry *h;
3775
      unsigned long r_symndx;
3776
 
3777
      r_symndx = ELF32_R_SYM (rel->r_info);
3778
      r_type = ELF32_R_TYPE (rel->r_info);
3779
      if (r_symndx < symtab_hdr->sh_info)
3780
        h = NULL;
3781
      else
3782
        {
3783
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3784
          while (h->root.type == bfd_link_hash_indirect
3785
                 || h->root.type == bfd_link_hash_warning)
3786
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
3787
        }
3788
 
3789
      /* Some relocs require a global offset table.  */
3790
      if (htab->sgot == NULL)
3791
        {
3792
          switch (r_type)
3793
            {
3794
            case R_M32R_GOT16_HI_ULO:
3795
            case R_M32R_GOT16_HI_SLO:
3796
            case R_M32R_GOTOFF:
3797
            case R_M32R_GOTOFF_HI_ULO:
3798
            case R_M32R_GOTOFF_HI_SLO:
3799
            case R_M32R_GOTOFF_LO:
3800
            case R_M32R_GOT16_LO:
3801
            case R_M32R_GOTPC24:
3802
            case R_M32R_GOTPC_HI_ULO:
3803
            case R_M32R_GOTPC_HI_SLO:
3804
            case R_M32R_GOTPC_LO:
3805
            case R_M32R_GOT24:
3806
              if (dynobj == NULL)
3807
                htab->root.dynobj = dynobj = abfd;
3808
              if (! create_got_section (dynobj, info))
3809
                return FALSE;
3810
              break;
3811
 
3812
            default:
3813
              break;
3814
          }
3815
        }
3816
 
3817
      switch (r_type)
3818
        {
3819
        case R_M32R_GOT16_HI_ULO:
3820
        case R_M32R_GOT16_HI_SLO:
3821
        case R_M32R_GOT16_LO:
3822
        case R_M32R_GOT24:
3823
 
3824
          if (h != NULL)
3825
            h->got.refcount += 1;
3826
          else
3827
            {
3828
              bfd_signed_vma *local_got_refcounts;
3829
 
3830
              /* This is a global offset table entry for a local
3831
                 symbol.  */
3832
              local_got_refcounts = elf_local_got_refcounts (abfd);
3833
              if (local_got_refcounts == NULL)
3834
                {
3835
                  bfd_size_type size;
3836
 
3837
                  size = symtab_hdr->sh_info;
3838
                  size *= sizeof (bfd_signed_vma);
3839
                  local_got_refcounts = bfd_zalloc (abfd, size);
3840
                  if (local_got_refcounts == NULL)
3841
                    return FALSE;
3842
                  elf_local_got_refcounts (abfd) = local_got_refcounts;
3843
                }
3844
              local_got_refcounts[r_symndx] += 1;
3845
            }
3846
          break;
3847
 
3848
        case R_M32R_26_PLTREL:
3849
          /* This symbol requires a procedure linkage table entry.  We
3850
             actually build the entry in adjust_dynamic_symbol,
3851
             because this might be a case of linking PIC code without
3852
             linking in any dynamic objects, in which case we don't
3853
             need to generate a procedure linkage table after all.  */
3854
 
3855
          /* If this is a local symbol, we resolve it directly without
3856
             creating a procedure linkage table entry.  */
3857
          if (h == NULL)
3858
            continue;
3859
 
3860
          if (h->forced_local)
3861
            break;
3862
 
3863
          h->needs_plt = 1;
3864
          h->plt.refcount += 1;
3865
          break;
3866
 
3867
        case R_M32R_16_RELA:
3868
        case R_M32R_24_RELA:
3869
        case R_M32R_32_RELA:
3870
        case R_M32R_REL32:
3871
        case R_M32R_HI16_ULO_RELA:
3872
        case R_M32R_HI16_SLO_RELA:
3873
        case R_M32R_LO16_RELA:
3874
        case R_M32R_SDA16_RELA:
3875
        case R_M32R_10_PCREL_RELA:
3876
        case R_M32R_18_PCREL_RELA:
3877
        case R_M32R_26_PCREL_RELA:
3878
 
3879
          if (h != NULL && !info->shared)
3880
            {
3881
              h->non_got_ref = 1;
3882
              h->plt.refcount += 1;
3883
            }
3884
 
3885
          /* If we are creating a shared library, and this is a reloc
3886
             against a global symbol, or a non PC relative reloc
3887
             against a local symbol, then we need to copy the reloc
3888
             into the shared library.  However, if we are linking with
3889
             -Bsymbolic, we do not need to copy a reloc against a
3890
             global symbol which is defined in an object we are
3891
             including in the link (i.e., DEF_REGULAR is set).  At
3892
             this point we have not seen all the input files, so it is
3893
             possible that DEF_REGULAR is not set now but will be set
3894
             later (it is never cleared).  We account for that
3895
             possibility below by storing information in the
3896
             dyn_relocs field of the hash table entry. A similar
3897
             situation occurs when creating shared libraries and symbol
3898
             visibility changes render the symbol local.
3899
 
3900
             If on the other hand, we are creating an executable, we
3901
             may need to keep relocations for symbols satisfied by a
3902
             dynamic library if we manage to avoid copy relocs for the
3903
             symbol.  */
3904
          if ((info->shared
3905
               && (sec->flags & SEC_ALLOC) != 0
3906
               && ((   r_type != R_M32R_26_PCREL_RELA
3907
                    && r_type != R_M32R_18_PCREL_RELA
3908
                    && r_type != R_M32R_10_PCREL_RELA
3909
                    && r_type != R_M32R_REL32)
3910
                   || (h != NULL
3911
                       && (! info->symbolic
3912
                           || h->root.type == bfd_link_hash_defweak
3913
                           || !h->def_regular))))
3914
              || (!info->shared
3915
                  && (sec->flags & SEC_ALLOC) != 0
3916
                  && h != NULL
3917
                  && (h->root.type == bfd_link_hash_defweak
3918
                      || !h->def_regular)))
3919
            {
3920
              struct elf_m32r_dyn_relocs *p;
3921
              struct elf_m32r_dyn_relocs **head;
3922
 
3923
              if (dynobj == NULL)
3924
                htab->root.dynobj = dynobj = abfd;
3925
 
3926
              /* When creating a shared object, we must copy these
3927
                 relocs into the output file.  We create a reloc
3928
                 section in dynobj and make room for the reloc.  */
3929
              if (sreloc == NULL)
3930
                {
3931 225 jeremybenn
                  sreloc = _bfd_elf_make_dynamic_reloc_section
3932
                    (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3933 24 jeremybenn
 
3934 225 jeremybenn
                  if (sreloc == NULL)
3935
                    return FALSE;
3936 24 jeremybenn
                }
3937
 
3938
              /* If this is a global symbol, we count the number of
3939
                 relocations we need for this symbol.  */
3940
              if (h != NULL)
3941
                head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3942
              else
3943
                {
3944 225 jeremybenn
                  /* Track dynamic relocs needed for local syms too.  */
3945 24 jeremybenn
                  asection *s;
3946
                  void *vpp;
3947 225 jeremybenn
                  Elf_Internal_Sym *isym;
3948 24 jeremybenn
 
3949 225 jeremybenn
                  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3950
                                                abfd, r_symndx);
3951
                  if (isym == NULL)
3952
                    return FALSE;
3953 24 jeremybenn
 
3954 225 jeremybenn
                  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3955
                  if (s == NULL)
3956
                    s = sec;
3957
 
3958 24 jeremybenn
                  vpp = &elf_section_data (s)->local_dynrel;
3959
                  head = (struct elf_m32r_dyn_relocs **) vpp;
3960
                }
3961
 
3962
              p = *head;
3963
              if (p == NULL || p->sec != sec)
3964
                {
3965
                  bfd_size_type amt = sizeof (*p);
3966
 
3967
                  p = bfd_alloc (dynobj, amt);
3968
                  if (p == NULL)
3969
                    return FALSE;
3970
                  p->next = *head;
3971
                  *head = p;
3972
                  p->sec = sec;
3973
                  p->count = 0;
3974
                  p->pc_count = 0;
3975
                }
3976
 
3977
              p->count += 1;
3978
              if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3979
                  || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3980
                  || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3981
                  || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3982
                p->pc_count += 1;
3983
            }
3984
          break;
3985
 
3986
        /* This relocation describes the C++ object vtable hierarchy.
3987
           Reconstruct it for later use during GC.  */
3988
        case R_M32R_RELA_GNU_VTINHERIT:
3989
        case R_M32R_GNU_VTINHERIT:
3990
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3991
            return FALSE;
3992
          break;
3993
 
3994
        /* This relocation describes which C++ vtable entries are actually
3995
           used.  Record for later use during GC.  */
3996
        case R_M32R_GNU_VTENTRY:
3997
          BFD_ASSERT (h != NULL);
3998
          if (h != NULL
3999
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4000
            return FALSE;
4001
          break;
4002
        case R_M32R_RELA_GNU_VTENTRY:
4003
          BFD_ASSERT (h != NULL);
4004
          if (h != NULL
4005
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4006
            return FALSE;
4007
          break;
4008
        }
4009
    }
4010
 
4011
  return TRUE;
4012
}
4013
 
4014
static const struct bfd_elf_special_section m32r_elf_special_sections[] =
4015
{
4016
  { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
4017
  { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
4018
  { NULL,                     0,  0, 0,            0 }
4019
};
4020
 
4021
static bfd_boolean
4022
m32r_elf_fake_sections (bfd *abfd,
4023
                        Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
4024
                        asection *sec)
4025
{
4026
  const char *name;
4027
 
4028
  name = bfd_get_section_name (abfd, sec);
4029
 
4030
  /* The generic elf_fake_sections will set up REL_HDR using the
4031
     default kind of relocations.  But, we may actually need both
4032
     kinds of relocations, so we set up the second header here.
4033
 
4034
     This is not necessary for the O32 ABI since that only uses Elf32_Rel
4035
     relocations (cf. System V ABI, MIPS RISC Processor Supplement,
4036
     3rd Edition, p. 4-17).  It breaks the IRIX 5/6 32-bit ld, since one
4037
     of the resulting empty .rela.<section> sections starts with
4038
     sh_offset == object size, and ld doesn't allow that.  While the check
4039
     is arguably bogus for empty or SHT_NOBITS sections, it can easily be
4040
     avoided by not emitting those useless sections in the first place.  */
4041
  if ((sec->flags & SEC_RELOC) != 0)
4042
    {
4043
      struct bfd_elf_section_data *esd;
4044
      bfd_size_type amt = sizeof (Elf_Internal_Shdr);
4045
 
4046
      esd = elf_section_data (sec);
4047
      BFD_ASSERT (esd->rel_hdr2 == NULL);
4048
      esd->rel_hdr2 = bfd_zalloc (abfd, amt);
4049
      if (!esd->rel_hdr2)
4050
        return FALSE;
4051
      _bfd_elf_init_reloc_shdr (abfd, esd->rel_hdr2, sec,
4052
                                !sec->use_rela_p);
4053
    }
4054
 
4055
  return TRUE;
4056
}
4057
 
4058
static enum elf_reloc_type_class
4059
m32r_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4060
{
4061
  switch ((int) ELF32_R_TYPE (rela->r_info))
4062
    {
4063
    case R_M32R_RELATIVE:  return reloc_class_relative;
4064
    case R_M32R_JMP_SLOT:  return reloc_class_plt;
4065
    case R_M32R_COPY:      return reloc_class_copy;
4066
    default:               return reloc_class_normal;
4067
    }
4068
}
4069
 
4070
#define ELF_ARCH                bfd_arch_m32r
4071
#define ELF_MACHINE_CODE        EM_M32R
4072
#define ELF_MACHINE_ALT1        EM_CYGNUS_M32R
4073
#define ELF_MAXPAGESIZE         0x1 /* Explicitly requested by Mitsubishi.  */
4074
 
4075
#define TARGET_BIG_SYM          bfd_elf32_m32r_vec
4076
#define TARGET_BIG_NAME         "elf32-m32r"
4077
#define TARGET_LITTLE_SYM       bfd_elf32_m32rle_vec
4078
#define TARGET_LITTLE_NAME      "elf32-m32rle"
4079
 
4080
#define elf_info_to_howto                       m32r_info_to_howto
4081
#define elf_info_to_howto_rel                   m32r_info_to_howto_rel
4082
#define elf_backend_section_from_bfd_section    _bfd_m32r_elf_section_from_bfd_section
4083
#define elf_backend_symbol_processing           _bfd_m32r_elf_symbol_processing
4084
#define elf_backend_add_symbol_hook             m32r_elf_add_symbol_hook
4085
#define elf_backend_relocate_section            m32r_elf_relocate_section
4086
#define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
4087
#define elf_backend_gc_sweep_hook               m32r_elf_gc_sweep_hook
4088
#define elf_backend_check_relocs                m32r_elf_check_relocs
4089
 
4090
#define elf_backend_create_dynamic_sections     m32r_elf_create_dynamic_sections
4091
#define bfd_elf32_bfd_link_hash_table_create    m32r_elf_link_hash_table_create
4092
#define elf_backend_size_dynamic_sections       m32r_elf_size_dynamic_sections
4093
#define elf_backend_omit_section_dynsym \
4094
  ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4095
#define elf_backend_finish_dynamic_sections     m32r_elf_finish_dynamic_sections
4096
#define elf_backend_adjust_dynamic_symbol       m32r_elf_adjust_dynamic_symbol
4097
#define elf_backend_finish_dynamic_symbol       m32r_elf_finish_dynamic_symbol
4098
#define elf_backend_reloc_type_class            m32r_elf_reloc_type_class
4099
#define elf_backend_copy_indirect_symbol        m32r_elf_copy_indirect_symbol
4100
 
4101
#define elf_backend_can_gc_sections             1
4102
/*#if !USE_REL
4103
#define elf_backend_rela_normal                 1
4104
#endif*/
4105
#define elf_backend_can_refcount 1
4106
#define elf_backend_want_got_plt 1
4107
#define elf_backend_plt_readonly 1
4108
#define elf_backend_want_plt_sym 0
4109
#define elf_backend_got_header_size 12
4110
 
4111
#define elf_backend_may_use_rel_p       1
4112
#ifdef USE_M32R_OLD_RELOC
4113
#define elf_backend_default_use_rela_p  0
4114
#define elf_backend_may_use_rela_p      0
4115
#else
4116
#define elf_backend_default_use_rela_p  1
4117
#define elf_backend_may_use_rela_p      1
4118
#define elf_backend_fake_sections       m32r_elf_fake_sections
4119
#endif
4120
 
4121
#define elf_backend_object_p                    m32r_elf_object_p
4122
#define elf_backend_final_write_processing      m32r_elf_final_write_processing
4123
#define bfd_elf32_bfd_merge_private_bfd_data    m32r_elf_merge_private_bfd_data
4124
#define bfd_elf32_bfd_set_private_flags         m32r_elf_set_private_flags
4125
#define bfd_elf32_bfd_print_private_bfd_data    m32r_elf_print_private_bfd_data
4126
#define elf_backend_special_sections            m32r_elf_special_sections
4127
 
4128
#include "elf32-target.h"
4129
 
4130
#undef  ELF_MAXPAGESIZE
4131
#define ELF_MAXPAGESIZE         0x1000
4132
 
4133
#undef  TARGET_BIG_SYM
4134
#define TARGET_BIG_SYM          bfd_elf32_m32rlin_vec
4135
#undef  TARGET_BIG_NAME
4136
#define TARGET_BIG_NAME         "elf32-m32r-linux"
4137
#undef  TARGET_LITTLE_SYM
4138
#define TARGET_LITTLE_SYM       bfd_elf32_m32rlelin_vec
4139
#undef  TARGET_LITTLE_NAME
4140
#define TARGET_LITTLE_NAME      "elf32-m32rle-linux"
4141
#undef  elf32_bed
4142
#define elf32_bed               elf32_m32r_lin_bed
4143
 
4144
#include "elf32-target.h"
4145
 

powered by: WebSVN 2.1.0

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