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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elf32-m32r.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* M32R-specific support for 32-bit ELF.
2
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3
   2006, 2007 Free Software Foundation, Inc.
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#include "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
  /* Small local sym to section mapping cache.  */
1530
  struct sym_sec_cache sym_sec;
1531
};
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
  ret->sym_sec.abfd = NULL;
1608
 
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
  if (! htab->sgot || ! htab->sgotplt)
1627
    abort ();
1628
 
1629
  htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
1630
                                               (SEC_ALLOC
1631
                                                | SEC_LOAD
1632
                                                | SEC_HAS_CONTENTS
1633
                                                | SEC_IN_MEMORY
1634
                                                | SEC_LINKER_CREATED
1635
                                                | SEC_READONLY));
1636
  if (htab->srelgot == NULL
1637
      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1638
    return FALSE;
1639
 
1640
  return TRUE;
1641
}
1642
 
1643
/* Create dynamic sections when linking against a dynamic object.  */
1644
 
1645
static bfd_boolean
1646
m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1647
{
1648
  struct elf_m32r_link_hash_table *htab;
1649
  flagword flags, pltflags;
1650
  asection *s;
1651
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1652
  int ptralign = 2; /* 32bit */
1653
 
1654
  htab = m32r_elf_hash_table (info);
1655
 
1656
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1657
     .rel[a].bss sections.  */
1658
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1659
           | SEC_LINKER_CREATED);
1660
 
1661
  pltflags = flags;
1662
  pltflags |= SEC_CODE;
1663
  if (bed->plt_not_loaded)
1664
    pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1665
  if (bed->plt_readonly)
1666
    pltflags |= SEC_READONLY;
1667
 
1668
  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
1669
  htab->splt = s;
1670
  if (s == NULL
1671
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1672
    return FALSE;
1673
 
1674
  if (bed->want_plt_sym)
1675
    {
1676
      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1677
         .plt section.  */
1678
      struct bfd_link_hash_entry *bh = NULL;
1679
      struct elf_link_hash_entry *h;
1680
 
1681
      if (! (_bfd_generic_link_add_one_symbol
1682
             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1683
              (bfd_vma) 0, NULL, FALSE,
1684
              get_elf_backend_data (abfd)->collect, &bh)))
1685
        return FALSE;
1686
      h = (struct elf_link_hash_entry *) bh;
1687
      h->def_regular = 1;
1688
      h->type = STT_OBJECT;
1689
      htab->root.hplt = h;
1690
 
1691
      if (info->shared
1692
          && ! bfd_elf_link_record_dynamic_symbol (info, h))
1693
        return FALSE;
1694
    }
1695
 
1696
  s = bfd_make_section_with_flags (abfd,
1697
                                   bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
1698
                                   flags | SEC_READONLY);
1699
  htab->srelplt = s;
1700
  if (s == NULL
1701
      || ! bfd_set_section_alignment (abfd, s, ptralign))
1702
    return FALSE;
1703
 
1704
  if (htab->sgot == NULL
1705
      && ! create_got_section (abfd, info))
1706
    return FALSE;
1707
 
1708
  {
1709
    const char *secname;
1710
    char *relname;
1711
    flagword secflags;
1712
    asection *sec;
1713
 
1714
    for (sec = abfd->sections; sec; sec = sec->next)
1715
      {
1716
        secflags = bfd_get_section_flags (abfd, sec);
1717
        if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
1718
            || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
1719
          continue;
1720
        secname = bfd_get_section_name (abfd, sec);
1721
        relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
1722
        strcpy (relname, ".rela");
1723
        strcat (relname, secname);
1724
        if (bfd_get_section_by_name (abfd, secname))
1725
          continue;
1726
        s = bfd_make_section_with_flags (abfd, relname,
1727
                                         flags | SEC_READONLY);
1728
        if (s == NULL
1729
            || ! bfd_set_section_alignment (abfd, s, ptralign))
1730
          return FALSE;
1731
      }
1732
  }
1733
 
1734
  if (bed->want_dynbss)
1735
    {
1736
      /* The .dynbss section is a place to put symbols which are defined
1737
         by dynamic objects, are referenced by regular objects, and are
1738
         not functions.  We must allocate space for them in the process
1739
         image and use a R_*_COPY reloc to tell the dynamic linker to
1740
         initialize them at run time.  The linker script puts the .dynbss
1741
         section into the .bss section of the final image.  */
1742
      s = bfd_make_section_with_flags (abfd, ".dynbss",
1743
                                       SEC_ALLOC | SEC_LINKER_CREATED);
1744
      htab->sdynbss = s;
1745
      if (s == NULL)
1746
        return FALSE;
1747
      /* The .rel[a].bss section holds copy relocs.  This section is not
1748
         normally needed.  We need to create it here, though, so that the
1749
         linker will map it to an output section.  We can't just create it
1750
         only if we need it, because we will not know whether we need it
1751
         until we have seen all the input files, and the first time the
1752
         main linker code calls BFD after examining all the input files
1753
         (size_dynamic_sections) the input sections have already been
1754
         mapped to the output sections.  If the section turns out not to
1755
         be needed, we can discard it later.  We will never need this
1756
         section when generating a shared object, since they do not use
1757
         copy relocs.  */
1758
      if (! info->shared)
1759
        {
1760
          s = bfd_make_section_with_flags (abfd,
1761
                                           (bed->default_use_rela_p
1762
                                            ? ".rela.bss" : ".rel.bss"),
1763
                                           flags | SEC_READONLY);
1764
          htab->srelbss = s;
1765
          if (s == NULL
1766
              || ! bfd_set_section_alignment (abfd, s, ptralign))
1767
            return FALSE;
1768
        }
1769
    }
1770
 
1771
  return TRUE;
1772
}
1773
 
1774
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
1775
 
1776
static void
1777
m32r_elf_copy_indirect_symbol (struct bfd_link_info *info,
1778
                               struct elf_link_hash_entry *dir,
1779
                               struct elf_link_hash_entry *ind)
1780
{
1781
  struct elf_m32r_link_hash_entry * edir;
1782
  struct elf_m32r_link_hash_entry * eind;
1783
 
1784
  edir = (struct elf_m32r_link_hash_entry *) dir;
1785
  eind = (struct elf_m32r_link_hash_entry *) ind;
1786
 
1787
  if (eind->dyn_relocs != NULL)
1788
    {
1789
      if (edir->dyn_relocs != NULL)
1790
        {
1791
          struct elf_m32r_dyn_relocs **pp;
1792
          struct elf_m32r_dyn_relocs *p;
1793
 
1794
          /* Add reloc counts against the indirect sym to the direct sym
1795
             list.  Merge any entries against the same section.  */
1796
          for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
1797
            {
1798
              struct elf_m32r_dyn_relocs *q;
1799
 
1800
              for (q = edir->dyn_relocs; q != NULL; q = q->next)
1801
                if (q->sec == p->sec)
1802
                  {
1803
                    q->pc_count += p->pc_count;
1804
                    q->count += p->count;
1805
                    *pp = p->next;
1806
                    break;
1807
                  }
1808
              if (q == NULL)
1809
                pp = &p->next;
1810
            }
1811
          *pp = edir->dyn_relocs;
1812
        }
1813
 
1814
      edir->dyn_relocs = eind->dyn_relocs;
1815
      eind->dyn_relocs = NULL;
1816
    }
1817
 
1818
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1819
}
1820
 
1821
 
1822
/* Adjust a symbol defined by a dynamic object and referenced by a
1823
   regular object.  The current definition is in some section of the
1824
   dynamic object, but we're not including those sections.  We have to
1825
   change the definition to something the rest of the link can
1826
   understand.  */
1827
 
1828
static bfd_boolean
1829
m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1830
                                struct elf_link_hash_entry *h)
1831
{
1832
  struct elf_m32r_link_hash_table *htab;
1833
  struct elf_m32r_link_hash_entry *eh;
1834
  struct elf_m32r_dyn_relocs *p;
1835
  bfd *dynobj;
1836
  asection *s;
1837
 
1838
#ifdef DEBUG_PIC
1839
  printf ("m32r_elf_adjust_dynamic_symbol()\n");
1840
#endif
1841
 
1842
  dynobj = elf_hash_table (info)->dynobj;
1843
 
1844
  /* Make sure we know what is going on here.  */
1845
  BFD_ASSERT (dynobj != NULL
1846
              && (h->needs_plt
1847
                  || h->u.weakdef != NULL
1848
                  || (h->def_dynamic
1849
                      && h->ref_regular
1850
                      && !h->def_regular)));
1851
 
1852
  /* If this is a function, put it in the procedure linkage table.  We
1853
     will fill in the contents of the procedure linkage table later,
1854
     when we know the address of the .got section.  */
1855
  if (h->type == STT_FUNC
1856
      || h->needs_plt)
1857
    {
1858
      if (! info->shared
1859
          && !h->def_dynamic
1860
          && !h->ref_dynamic
1861
          && h->root.type != bfd_link_hash_undefweak
1862
          && h->root.type != bfd_link_hash_undefined)
1863
        {
1864
          /* This case can occur if we saw a PLT reloc in an input
1865
             file, but the symbol was never referred to by a dynamic
1866
             object.  In such a case, we don't actually need to build
1867
             a procedure linkage table, and we can just do a PCREL
1868
             reloc instead.  */
1869
          h->plt.offset = (bfd_vma) -1;
1870
          h->needs_plt = 0;
1871
        }
1872
 
1873
      return TRUE;
1874
    }
1875
  else
1876
    h->plt.offset = (bfd_vma) -1;
1877
 
1878
  /* If this is a weak symbol, and there is a real definition, the
1879
     processor independent code will have arranged for us to see the
1880
     real definition first, and we can just use the same value.  */
1881
  if (h->u.weakdef != NULL)
1882
    {
1883
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1884
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
1885
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
1886
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
1887
      return TRUE;
1888
    }
1889
 
1890
  /* This is a reference to a symbol defined by a dynamic object which
1891
     is not a function.  */
1892
 
1893
  /* If we are creating a shared library, we must presume that the
1894
     only references to the symbol are via the global offset table.
1895
     For such cases we need not do anything here; the relocations will
1896
     be handled correctly by relocate_section.  */
1897
  if (info->shared)
1898
    return TRUE;
1899
 
1900
  /* If there are no references to this symbol that do not use the
1901
     GOT, we don't need to generate a copy reloc.  */
1902
  if (!h->non_got_ref)
1903
    return TRUE;
1904
 
1905
  /* If -z nocopyreloc was given, we won't generate them either.  */
1906
  if (info->nocopyreloc)
1907
    {
1908
      h->non_got_ref = 0;
1909
      return TRUE;
1910
    }
1911
 
1912
  eh = (struct elf_m32r_link_hash_entry *) h;
1913
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
1914
    {
1915
      s = p->sec->output_section;
1916
      if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1917
        break;
1918
    }
1919
 
1920
  /* If we didn't find any dynamic relocs in sections which needs the
1921
     copy reloc, then we'll be keeping the dynamic relocs and avoiding
1922
     the copy reloc.  */
1923
  if (p == NULL)
1924
    {
1925
      h->non_got_ref = 0;
1926
      return TRUE;
1927
    }
1928
 
1929
  if (h->size == 0)
1930
    {
1931
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1932
                             h->root.root.string);
1933
      return TRUE;
1934
    }
1935
 
1936
  /* We must allocate the symbol in our .dynbss section, which will
1937
     become part of the .bss section of the executable.  There will be
1938
     an entry for this symbol in the .dynsym section.  The dynamic
1939
     object will contain position independent code, so all references
1940
     from the dynamic object to this symbol will go through the global
1941
     offset table.  The dynamic linker will use the .dynsym entry to
1942
     determine the address it must put in the global offset table, so
1943
     both the dynamic object and the regular object will refer to the
1944
     same memory location for the variable.  */
1945
 
1946
  htab = m32r_elf_hash_table (info);
1947
  s = htab->sdynbss;
1948
  BFD_ASSERT (s != NULL);
1949
 
1950
  /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
1951
     to copy the initial value out of the dynamic object and into the
1952
     runtime process image.  We need to remember the offset into the
1953
     .rela.bss section we are going to use.  */
1954
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1955
    {
1956
      asection *srel;
1957
 
1958
      srel = htab->srelbss;
1959
      BFD_ASSERT (srel != NULL);
1960
      srel->size += sizeof (Elf32_External_Rela);
1961
      h->needs_copy = 1;
1962
    }
1963
 
1964
  return _bfd_elf_adjust_dynamic_copy (h, s);
1965
}
1966
 
1967
/* Allocate space in .plt, .got and associated reloc sections for
1968
   dynamic relocs.  */
1969
 
1970
static bfd_boolean
1971
allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1972
{
1973
  struct bfd_link_info *info;
1974
  struct elf_m32r_link_hash_table *htab;
1975
  struct elf_m32r_link_hash_entry *eh;
1976
  struct elf_m32r_dyn_relocs *p;
1977
 
1978
  if (h->root.type == bfd_link_hash_indirect)
1979
    return TRUE;
1980
 
1981
  if (h->root.type == bfd_link_hash_warning)
1982
    /* When warning symbols are created, they **replace** the "real"
1983
       entry in the hash table, thus we never get to see the real
1984
       symbol in a hash traversal.  So look at it now.  */
1985
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1986
 
1987
  info = (struct bfd_link_info *) inf;
1988
  htab = m32r_elf_hash_table (info);
1989
 
1990
  eh = (struct elf_m32r_link_hash_entry *) h;
1991
 
1992
  if (htab->root.dynamic_sections_created
1993
      && h->plt.refcount > 0)
1994
    {
1995
      /* Make sure this symbol is output as a dynamic symbol.
1996
         Undefined weak syms won't yet be marked as dynamic.  */
1997
      if (h->dynindx == -1
1998
          && !h->forced_local)
1999
        {
2000
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
2001
            return FALSE;
2002
        }
2003
 
2004
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2005
        {
2006
          asection *s = htab->splt;
2007
 
2008
          /* If this is the first .plt entry, make room for the special
2009
             first entry.  */
2010
          if (s->size == 0)
2011
            s->size += PLT_ENTRY_SIZE;
2012
 
2013
          h->plt.offset = s->size;
2014
 
2015
          /* If this symbol is not defined in a regular file, and we are
2016
             not generating a shared library, then set the symbol to this
2017
             location in the .plt.  This is required to make function
2018
             pointers compare as equal between the normal executable and
2019
             the shared library.  */
2020
          if (! info->shared
2021
              && !h->def_regular)
2022
            {
2023
              h->root.u.def.section = s;
2024
              h->root.u.def.value = h->plt.offset;
2025
            }
2026
 
2027
          /* Make room for this entry.  */
2028
          s->size += PLT_ENTRY_SIZE;
2029
 
2030
          /* We also need to make an entry in the .got.plt section, which
2031
             will be placed in the .got section by the linker script.  */
2032
          htab->sgotplt->size += 4;
2033
 
2034
          /* We also need to make an entry in the .rel.plt section.  */
2035
          htab->srelplt->size += sizeof (Elf32_External_Rela);
2036
        }
2037
      else
2038
        {
2039
          h->plt.offset = (bfd_vma) -1;
2040
          h->needs_plt = 0;
2041
        }
2042
    }
2043
  else
2044
    {
2045
      h->plt.offset = (bfd_vma) -1;
2046
      h->needs_plt = 0;
2047
    }
2048
 
2049
  if (h->got.refcount > 0)
2050
    {
2051
      asection *s;
2052
      bfd_boolean dyn;
2053
 
2054
      /* Make sure this symbol is output as a dynamic symbol.
2055
         Undefined weak syms won't yet be marked as dynamic.  */
2056
      if (h->dynindx == -1
2057
          && !h->forced_local)
2058
        {
2059
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
2060
            return FALSE;
2061
        }
2062
 
2063
      s = htab->sgot;
2064
 
2065
      h->got.offset = s->size;
2066
      s->size += 4;
2067
      dyn = htab->root.dynamic_sections_created;
2068
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2069
        htab->srelgot->size += sizeof (Elf32_External_Rela);
2070
    }
2071
  else
2072
    h->got.offset = (bfd_vma) -1;
2073
 
2074
  if (eh->dyn_relocs == NULL)
2075
    return TRUE;
2076
 
2077
  /* In the shared -Bsymbolic case, discard space allocated for
2078
     dynamic pc-relative relocs against symbols which turn out to be
2079
     defined in regular objects.  For the normal shared case, discard
2080
     space for pc-relative relocs that have become local due to symbol
2081
     visibility changes.  */
2082
 
2083
  if (info->shared)
2084
    {
2085
      if (h->def_regular
2086
          && (h->forced_local
2087
              || info->symbolic))
2088
        {
2089
          struct elf_m32r_dyn_relocs **pp;
2090
 
2091
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2092
            {
2093
              p->count -= p->pc_count;
2094
              p->pc_count = 0;
2095
              if (p->count == 0)
2096
                *pp = p->next;
2097
              else
2098
                pp = &p->next;
2099
            }
2100
        }
2101
 
2102
      /* Also discard relocs on undefined weak syms with non-default
2103
         visibility.  */
2104
      if (eh->dyn_relocs != NULL
2105
          && h->root.type == bfd_link_hash_undefweak)
2106
        {
2107
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2108
            eh->dyn_relocs = NULL;
2109
 
2110
          /* Make sure undefined weak symbols are output as a dynamic
2111
             symbol in PIEs.  */
2112
          else if (h->dynindx == -1
2113
                   && !h->forced_local)
2114
            {
2115
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2116
                return FALSE;
2117
            }
2118
        }
2119
    }
2120
  else
2121
    {
2122
      /* For the non-shared case, discard space for relocs against
2123
         symbols which turn out to need copy relocs or are not
2124
         dynamic.  */
2125
 
2126
      if (!h->non_got_ref
2127
          && ((h->def_dynamic
2128
               && !h->def_regular)
2129
              || (htab->root.dynamic_sections_created
2130
                  && (h->root.type == bfd_link_hash_undefweak
2131
                      || h->root.type == bfd_link_hash_undefined))))
2132
        {
2133
          /* Make sure this symbol is output as a dynamic symbol.
2134
             Undefined weak syms won't yet be marked as dynamic.  */
2135
          if (h->dynindx == -1
2136
              && !h->forced_local)
2137
            {
2138
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2139
                return FALSE;
2140
            }
2141
 
2142
          /* If that succeeded, we know we'll be keeping all the
2143
             relocs.  */
2144
          if (h->dynindx != -1)
2145
            goto keep;
2146
        }
2147
 
2148
      eh->dyn_relocs = NULL;
2149
 
2150
    keep: ;
2151
    }
2152
 
2153
  /* Finally, allocate space.  */
2154
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2155
    {
2156
      asection *sreloc = elf_section_data (p->sec)->sreloc;
2157
      sreloc->size += p->count * sizeof (Elf32_External_Rela);
2158
    }
2159
 
2160
  return TRUE;
2161
}
2162
 
2163
/* Find any dynamic relocs that apply to read-only sections.  */
2164
 
2165
static bfd_boolean
2166
readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2167
{
2168
  struct elf_m32r_link_hash_entry *eh;
2169
  struct elf_m32r_dyn_relocs *p;
2170
 
2171
  if (h->root.type == bfd_link_hash_warning)
2172
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2173
 
2174
  eh = (struct elf_m32r_link_hash_entry *) h;
2175
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2176
    {
2177
      asection *s = p->sec->output_section;
2178
 
2179
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
2180
        {
2181
          struct bfd_link_info *info = (struct bfd_link_info *) inf;
2182
 
2183
          info->flags |= DF_TEXTREL;
2184
 
2185
          /* Not an error, just cut short the traversal.  */
2186
          return FALSE;
2187
        }
2188
    }
2189
  return TRUE;
2190
}
2191
 
2192
/* Set the sizes of the dynamic sections.  */
2193
 
2194
static bfd_boolean
2195
m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2196
                                struct bfd_link_info *info)
2197
{
2198
  struct elf_m32r_link_hash_table *htab;
2199
  bfd *dynobj;
2200
  asection *s;
2201
  bfd_boolean relocs;
2202
  bfd *ibfd;
2203
 
2204
#ifdef DEBUG_PIC
2205
  printf ("m32r_elf_size_dynamic_sections()\n");
2206
#endif
2207
 
2208
  htab = m32r_elf_hash_table (info);
2209
  dynobj = htab->root.dynobj;
2210
  BFD_ASSERT (dynobj != NULL);
2211
 
2212
  if (htab->root.dynamic_sections_created)
2213
    {
2214
      /* Set the contents of the .interp section to the interpreter.  */
2215
      if (info->executable)
2216
        {
2217
          s = bfd_get_section_by_name (dynobj, ".interp");
2218
          BFD_ASSERT (s != NULL);
2219
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2220
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2221
        }
2222
    }
2223
 
2224
  /* Set up .got offsets for local syms, and space for local dynamic
2225
     relocs.  */
2226
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2227
    {
2228
      bfd_signed_vma *local_got;
2229
      bfd_signed_vma *end_local_got;
2230
      bfd_size_type locsymcount;
2231
      Elf_Internal_Shdr *symtab_hdr;
2232
      asection *srel;
2233
 
2234
      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2235
        continue;
2236
 
2237
      for (s = ibfd->sections; s != NULL; s = s->next)
2238
        {
2239
          struct elf_m32r_dyn_relocs *p;
2240
 
2241
          for (p = ((struct elf_m32r_dyn_relocs *)
2242
                    elf_section_data (s)->local_dynrel);
2243
               p != NULL;
2244
               p = p->next)
2245
            {
2246
              if (! bfd_is_abs_section (p->sec)
2247
                  && bfd_is_abs_section (p->sec->output_section))
2248
                {
2249
                  /* Input section has been discarded, either because
2250
                     it is a copy of a linkonce section or due to
2251
                     linker script /DISCARD/, so we'll be discarding
2252
                     the relocs too.  */
2253
                }
2254
              else if (p->count != 0)
2255
                {
2256
                  srel = elf_section_data (p->sec)->sreloc;
2257
                  srel->size += p->count * sizeof (Elf32_External_Rela);
2258
                  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2259
                    info->flags |= DF_TEXTREL;
2260
                }
2261
            }
2262
        }
2263
 
2264
      local_got = elf_local_got_refcounts (ibfd);
2265
      if (!local_got)
2266
        continue;
2267
 
2268
      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2269
      locsymcount = symtab_hdr->sh_info;
2270
      end_local_got = local_got + locsymcount;
2271
      s = htab->sgot;
2272
      srel = htab->srelgot;
2273
      for (; local_got < end_local_got; ++local_got)
2274
        {
2275
          if (*local_got > 0)
2276
            {
2277
              *local_got = s->size;
2278
              s->size += 4;
2279
              if (info->shared)
2280
                srel->size += sizeof (Elf32_External_Rela);
2281
            }
2282
          else
2283
            *local_got = (bfd_vma) -1;
2284
        }
2285
    }
2286
 
2287
  /* Allocate global sym .plt and .got entries, and space for global
2288
     sym dynamic relocs.  */
2289
  elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2290
 
2291
  /* We now have determined the sizes of the various dynamic sections.
2292
     Allocate memory for them.  */
2293
  relocs = FALSE;
2294
  for (s = dynobj->sections; s != NULL; s = s->next)
2295
    {
2296
      if ((s->flags & SEC_LINKER_CREATED) == 0)
2297
        continue;
2298
 
2299
      if (s == htab->splt
2300
          || s == htab->sgot
2301
          || s == htab->sgotplt
2302
          || s == htab->sdynbss)
2303
        {
2304
          /* Strip this section if we don't need it; see the
2305
             comment below.  */
2306
        }
2307
      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2308
        {
2309
          if (s->size != 0 && s != htab->srelplt)
2310
            relocs = TRUE;
2311
 
2312
          /* We use the reloc_count field as a counter if we need
2313
             to copy relocs into the output file.  */
2314
          s->reloc_count = 0;
2315
        }
2316
      else
2317
        /* It's not one of our sections, so don't allocate space.  */
2318
        continue;
2319
 
2320
      if (s->size == 0)
2321
        {
2322
          /* If we don't need this section, strip it from the
2323
             output file.  This is mostly to handle .rela.bss and
2324
             .rela.plt.  We must create both sections in
2325
             create_dynamic_sections, because they must be created
2326
             before the linker maps input sections to output
2327
             sections.  The linker does that before
2328
             adjust_dynamic_symbol is called, and it is that
2329
             function which decides whether anything needs to go
2330
             into these sections.  */
2331
          s->flags |= SEC_EXCLUDE;
2332
          continue;
2333
        }
2334
 
2335
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
2336
        continue;
2337
 
2338
      /* Allocate memory for the section contents.  We use bfd_zalloc
2339
         here in case unused entries are not reclaimed before the
2340
         section's contents are written out.  This should not happen,
2341
         but this way if it does, we get a R_M32R_NONE reloc instead
2342
         of garbage.  */
2343
      s->contents = bfd_zalloc (dynobj, s->size);
2344
      if (s->contents == NULL)
2345
        return FALSE;
2346
    }
2347
 
2348
  if (htab->root.dynamic_sections_created)
2349
    {
2350
      /* Add some entries to the .dynamic section.  We fill in the
2351
         values later, in m32r_elf_finish_dynamic_sections, but we
2352
         must add the entries now so that we get the correct size for
2353
         the .dynamic section.  The DT_DEBUG entry is filled in by the
2354
         dynamic linker and used by the debugger.  */
2355
#define add_dynamic_entry(TAG, VAL) \
2356
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2357
 
2358
     if (info->executable)
2359
        {
2360
          if (! add_dynamic_entry (DT_DEBUG, 0))
2361
            return FALSE;
2362
        }
2363
 
2364
      if (htab->splt->size != 0)
2365
        {
2366
          if (! add_dynamic_entry (DT_PLTGOT, 0)
2367
              || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2368
              || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2369
              || ! add_dynamic_entry (DT_JMPREL, 0))
2370
            return FALSE;
2371
        }
2372
 
2373
      if (relocs)
2374
        {
2375
          if (! add_dynamic_entry (DT_RELA, 0)
2376
              || ! add_dynamic_entry (DT_RELASZ, 0)
2377
              || ! add_dynamic_entry (DT_RELAENT,
2378
                                      sizeof (Elf32_External_Rela)))
2379
            return FALSE;
2380
 
2381
          /* If any dynamic relocs apply to a read-only section,
2382
             then we need a DT_TEXTREL entry.  */
2383
          if ((info->flags & DF_TEXTREL) == 0)
2384
            elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2385
                                    info);
2386
 
2387
          if ((info->flags & DF_TEXTREL) != 0)
2388
            {
2389
              if (! add_dynamic_entry (DT_TEXTREL, 0))
2390
                return FALSE;
2391
            }
2392
        }
2393
    }
2394
#undef add_dynamic_entry
2395
 
2396
  return TRUE;
2397
}
2398
 
2399
/* Relocate an M32R/D ELF section.
2400
   There is some attempt to make this function usable for many architectures,
2401
   both for RELA and REL type relocs, if only to serve as a learning tool.
2402
 
2403
   The RELOCATE_SECTION function is called by the new ELF backend linker
2404
   to handle the relocations for a section.
2405
 
2406
   The relocs are always passed as Rela structures; if the section
2407
   actually uses Rel structures, the r_addend field will always be
2408
   zero.
2409
 
2410
   This function is responsible for adjust the section contents as
2411
   necessary, and (if using Rela relocs and generating a
2412
   relocatable output file) adjusting the reloc addend as
2413
   necessary.
2414
 
2415
   This function does not have to worry about setting the reloc
2416
   address or the reloc symbol index.
2417
 
2418
   LOCAL_SYMS is a pointer to the swapped in local symbols.
2419
 
2420
   LOCAL_SECTIONS is an array giving the section in the input file
2421
   corresponding to the st_shndx field of each local symbol.
2422
 
2423
   The global hash table entry for the global symbols can be found
2424
   via elf_sym_hashes (input_bfd).
2425
 
2426
   When generating relocatable output, this function must handle
2427
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2428
   going to be the section symbol corresponding to the output
2429
   section, which means that the addend must be adjusted
2430
   accordingly.  */
2431
 
2432
static bfd_boolean
2433
m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
2434
                           struct bfd_link_info *info,
2435
                           bfd *input_bfd,
2436
                           asection *input_section,
2437
                           bfd_byte *contents,
2438
                           Elf_Internal_Rela *relocs,
2439
                           Elf_Internal_Sym *local_syms,
2440
                           asection **local_sections)
2441
{
2442
  Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2443
  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2444
  Elf_Internal_Rela *rel, *relend;
2445
  /* Assume success.  */
2446
  bfd_boolean ret = TRUE;
2447
 
2448
  struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2449
  bfd *dynobj;
2450
  bfd_vma *local_got_offsets;
2451
  asection *sgot, *splt, *sreloc;
2452
  bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2453
 
2454
  dynobj = htab->root.dynobj;
2455
  local_got_offsets = elf_local_got_offsets (input_bfd);
2456
 
2457
  sgot = htab->sgot;
2458
  splt = htab->splt;
2459
  sreloc = NULL;
2460
 
2461
  rel = relocs;
2462
  relend = relocs + input_section->reloc_count;
2463
  for (; rel < relend; rel++)
2464
    {
2465
      int r_type;
2466
      reloc_howto_type *howto;
2467
      unsigned long r_symndx;
2468
      struct elf_link_hash_entry *h;
2469
      /* We can't modify r_addend here as elf_link_input_bfd has an assert to
2470
         ensure it's zero (we use REL relocs, not RELA).  Therefore this
2471
         should be assigning zero to `addend', but for clarity we use
2472
         `r_addend'.  */
2473
      bfd_vma addend = rel->r_addend;
2474
      bfd_vma offset = rel->r_offset;
2475
      bfd_vma relocation;
2476
      Elf_Internal_Sym *sym;
2477
      asection *sec;
2478
      const char *sym_name;
2479
      bfd_reloc_status_type r;
2480
      const char *errmsg = NULL;
2481
      bfd_boolean use_rel = FALSE;
2482
 
2483
      h = NULL;
2484
      r_type = ELF32_R_TYPE (rel->r_info);
2485
      if (r_type < 0 || r_type >= (int) R_M32R_max)
2486
        {
2487
          (*_bfd_error_handler) (_("%B: unknown relocation type %d"),
2488
                                 input_bfd,
2489
                                 (int) r_type);
2490
          bfd_set_error (bfd_error_bad_value);
2491
          ret = FALSE;
2492
          continue;
2493
        }
2494
 
2495
      if (   r_type == R_M32R_GNU_VTENTRY
2496
          || r_type == R_M32R_GNU_VTINHERIT
2497
          || r_type == R_M32R_NONE
2498
          || r_type == R_M32R_RELA_GNU_VTENTRY
2499
          || r_type == R_M32R_RELA_GNU_VTINHERIT)
2500
        continue;
2501
 
2502
      if (r_type <= R_M32R_GNU_VTENTRY)
2503
        use_rel = TRUE;
2504
 
2505
      howto = m32r_elf_howto_table + r_type;
2506
      r_symndx = ELF32_R_SYM (rel->r_info);
2507
 
2508
      sym = NULL;
2509
      sec = NULL;
2510
      h = NULL;
2511
 
2512
      if (r_symndx < symtab_hdr->sh_info)
2513
        {
2514
          /* Local symbol.  */
2515
          sym = local_syms + r_symndx;
2516
          sec = local_sections[r_symndx];
2517
          sym_name = "<local symbol>";
2518
 
2519
          if (!use_rel)
2520
            {
2521
              relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2522
              addend = rel->r_addend;
2523
            }
2524
          else
2525
            {
2526
              relocation = (sec->output_section->vma
2527
                            + sec->output_offset
2528
                            + sym->st_value);
2529
            }
2530
        }
2531
      else
2532
        {
2533
          /* External symbol.  */
2534
          relocation = 0;
2535
 
2536
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2537
          while (h->root.type == bfd_link_hash_indirect
2538
                 || h->root.type == bfd_link_hash_warning)
2539
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2540
          sym_name = h->root.root.string;
2541
 
2542
          if (h->root.type == bfd_link_hash_defined
2543
              || h->root.type == bfd_link_hash_defweak)
2544
            {
2545
              bfd_boolean dyn;
2546
              sec = h->root.u.def.section;
2547
 
2548
              dyn = htab->root.dynamic_sections_created;
2549
              sec = h->root.u.def.section;
2550
              if (r_type == R_M32R_GOTPC24
2551
                  || (r_type == R_M32R_GOTPC_HI_ULO
2552
                      || r_type == R_M32R_GOTPC_HI_SLO
2553
                      || r_type == R_M32R_GOTPC_LO)
2554
                  || (r_type == R_M32R_26_PLTREL
2555
                      && h->plt.offset != (bfd_vma) -1)
2556
                  || ((r_type == R_M32R_GOT24
2557
                       || r_type == R_M32R_GOT16_HI_ULO
2558
                       || r_type == R_M32R_GOT16_HI_SLO
2559
                       || r_type == R_M32R_GOT16_LO)
2560
                      && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2561
                                                          info->shared, h)
2562
                      && (! info->shared
2563
                          || (! info->symbolic && h->dynindx != -1)
2564
                          || !h->def_regular))
2565
                  || (info->shared
2566
                      && ((! info->symbolic && h->dynindx != -1)
2567
                          || !h->def_regular)
2568
                      && (((r_type == R_M32R_16_RELA
2569
                            || r_type == R_M32R_32_RELA
2570
                            || r_type == R_M32R_24_RELA
2571
                            || r_type == R_M32R_HI16_ULO_RELA
2572
                            || r_type == R_M32R_HI16_SLO_RELA
2573
                            || r_type == R_M32R_LO16_RELA)
2574
                           && !h->forced_local)
2575
                          || r_type == R_M32R_REL32
2576
                          || r_type == R_M32R_10_PCREL_RELA
2577
                          || r_type == R_M32R_18_PCREL_RELA
2578
                          || r_type == R_M32R_26_PCREL_RELA)
2579
                      && ((input_section->flags & SEC_ALLOC) != 0
2580
                          /* DWARF will emit R_M32R_16(24,32) relocations
2581
                             in its sections against symbols defined
2582
                             externally in shared libraries.  We can't do
2583
                             anything with them here.  */
2584
                          || ((input_section->flags & SEC_DEBUGGING) != 0
2585
                              && h->def_dynamic))))
2586
                {
2587
                  /* In these cases, we don't need the relocation
2588
                     value.  We check specially because in some
2589
                     obscure cases sec->output_section will be NULL.  */
2590
                }
2591
              else if (sec->output_section != NULL)
2592
                relocation = (h->root.u.def.value
2593
                              + sec->output_section->vma
2594
                              + sec->output_offset);
2595
              else if (!info->relocatable)
2596
                {
2597
                  (*_bfd_error_handler)
2598
                    (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2599
                     input_bfd,
2600
                     input_section,
2601
                     (long) rel->r_offset,
2602
                     howto->name,
2603
                     h->root.root.string);
2604
                }
2605
            }
2606
          else if (h->root.type == bfd_link_hash_undefweak)
2607
            ;
2608
          else if (info->unresolved_syms_in_objects == RM_IGNORE
2609
                   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2610
            ;
2611
          else if (!info->relocatable)
2612
            {
2613
              if (! ((*info->callbacks->undefined_symbol)
2614
                     (info, h->root.root.string, input_bfd,
2615
                      input_section, offset,
2616
                      (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2617
                       || ELF_ST_VISIBILITY (h->other)))))
2618
                return FALSE;
2619
            }
2620
        }
2621
 
2622
      if (sec != NULL && elf_discarded_section (sec))
2623
        {
2624
          /* For relocs against symbols from removed linkonce sections,
2625
             or sections discarded by a linker script, we just want the
2626
             section contents zeroed.  Avoid any special processing.  */
2627
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2628
          rel->r_info = 0;
2629
          rel->r_addend = 0;
2630
          continue;
2631
        }
2632
 
2633
      if (info->relocatable && !use_rel)
2634
        {
2635
          /* This is a relocatable link.  We don't have to change
2636
             anything, unless the reloc is against a section symbol,
2637
             in which case we have to adjust according to where the
2638
             section symbol winds up in the output section.  */
2639
          if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2640
            rel->r_addend += sec->output_offset;
2641
          continue;
2642
        }
2643
 
2644
      if (info->relocatable && use_rel)
2645
        {
2646
          /* This is a relocatable link.  We don't have to change
2647
             anything, unless the reloc is against a section symbol,
2648
             in which case we have to adjust according to where the
2649
             section symbol winds up in the output section.  */
2650
          if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2651
            continue;
2652
 
2653
          addend += sec->output_offset;
2654
 
2655
          /* If partial_inplace, we need to store any additional addend
2656
             back in the section.  */
2657
          if (! howto->partial_inplace)
2658
            continue;
2659
          /* ??? Here is a nice place to call a special_function
2660
             like handler.  */
2661
          if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2662
            r = _bfd_relocate_contents (howto, input_bfd,
2663
                                        addend, contents + offset);
2664
          else
2665
            {
2666
              Elf_Internal_Rela *lorel;
2667
 
2668
              /* We allow an arbitrary number of HI16 relocs before the
2669
                 LO16 reloc.  This permits gcc to emit the HI and LO relocs
2670
                 itself.  */
2671
              for (lorel = rel + 1;
2672
                   (lorel < relend
2673
                    && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2674
                        || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2675
                   lorel++)
2676
                continue;
2677
              if (lorel < relend
2678
                  && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2679
                {
2680
                  m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2681
                                          contents, addend);
2682
                  r = bfd_reloc_ok;
2683
                }
2684
              else
2685
                r = _bfd_relocate_contents (howto, input_bfd,
2686
                                            addend, contents + offset);
2687
            }
2688
        }
2689
      else
2690
        {
2691
          /* Sanity check the address.  */
2692
          if (offset > high_address)
2693
            {
2694
              r = bfd_reloc_outofrange;
2695
              goto check_reloc;
2696
            }
2697
 
2698
          switch ((int) r_type)
2699
            {
2700
            case R_M32R_GOTOFF:
2701
              /* Relocation is relative to the start of the global offset
2702
                 table (for ld24 rx, #uimm24). eg access at label+addend
2703
 
2704
                 ld24 rx. #label@GOTOFF + addend
2705
                 sub  rx, r12.  */
2706
 
2707
              BFD_ASSERT (sgot != NULL);
2708
 
2709
              relocation = -(relocation - sgot->output_section->vma);
2710
              rel->r_addend = -rel->r_addend;
2711
              break;
2712
 
2713
            case R_M32R_GOTOFF_HI_ULO:
2714
            case R_M32R_GOTOFF_HI_SLO:
2715
            case R_M32R_GOTOFF_LO:
2716
              BFD_ASSERT (sgot != NULL);
2717
 
2718
              relocation -= sgot->output_section->vma;
2719
 
2720
              if ((r_type == R_M32R_GOTOFF_HI_SLO)
2721
                  && ((relocation + rel->r_addend) & 0x8000))
2722
                rel->r_addend += 0x10000;
2723
              break;
2724
 
2725
            case R_M32R_GOTPC24:
2726
              /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2727
                 ld24 rx,#_GLOBAL_OFFSET_TABLE_
2728
               */
2729
             relocation = sgot->output_section->vma;
2730
             break;
2731
 
2732
            case R_M32R_GOTPC_HI_ULO:
2733
            case R_M32R_GOTPC_HI_SLO:
2734
            case R_M32R_GOTPC_LO:
2735
              {
2736
                /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2737
                   bl .+4
2738
                   seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2739
                   or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2740
                   or
2741
                   bl .+4
2742
                   seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2743
                   add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2744
                 */
2745
                relocation = sgot->output_section->vma;
2746
                relocation -= (input_section->output_section->vma
2747
                               + input_section->output_offset
2748
                               + rel->r_offset);
2749
                if ((r_type == R_M32R_GOTPC_HI_SLO)
2750
                     && ((relocation + rel->r_addend) & 0x8000))
2751
                  rel->r_addend += 0x10000;
2752
 
2753
                break;
2754
              }
2755
            case R_M32R_GOT16_HI_ULO:
2756
            case R_M32R_GOT16_HI_SLO:
2757
            case R_M32R_GOT16_LO:
2758
              /* Fall through.  */
2759
            case R_M32R_GOT24:
2760
              /* Relocation is to the entry for this symbol in the global
2761
                 offset table.  */
2762
              BFD_ASSERT (sgot != NULL);
2763
 
2764
              if (h != NULL)
2765
                {
2766
                  bfd_boolean dyn;
2767
                  bfd_vma off;
2768
 
2769
                  off = h->got.offset;
2770
                  BFD_ASSERT (off != (bfd_vma) -1);
2771
 
2772
                  dyn = htab->root.dynamic_sections_created;
2773
                  if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2774
                      || (info->shared
2775
                          && (info->symbolic
2776
                              || h->dynindx == -1
2777
                              || h->forced_local)
2778
                          && h->def_regular))
2779
                    {
2780
                      /* This is actually a static link, or it is a
2781
                         -Bsymbolic link and the symbol is defined
2782
                         locally, or the symbol was forced to be local
2783
                         because of a version file.  We must initialize
2784
                         this entry in the global offset table.  Since the
2785
                         offset must always be a multiple of 4, we use the
2786
                         least significant bit to record whether we have
2787
                         initialized it already.
2788
 
2789
                         When doing a dynamic link, we create a .rela.got
2790
                         relocation entry to initialize the value.  This
2791
                         is done in the finish_dynamic_symbol routine.  */
2792
                      if ((off & 1) != 0)
2793
                        off &= ~1;
2794
                      else
2795
                        {
2796
                          bfd_put_32 (output_bfd, relocation,
2797
                                      sgot->contents + off);
2798
                          h->got.offset |= 1;
2799
                        }
2800
                    }
2801
 
2802
                  relocation = sgot->output_offset + off;
2803
                }
2804
              else
2805
                {
2806
                  bfd_vma off;
2807
                  bfd_byte *loc;
2808
 
2809
                  BFD_ASSERT (local_got_offsets != NULL
2810
                              && local_got_offsets[r_symndx] != (bfd_vma) -1);
2811
 
2812
                  off = local_got_offsets[r_symndx];
2813
 
2814
                  /* The offset must always be a multiple of 4.  We use
2815
                     the least significant bit to record whether we have
2816
                     already processed this entry.  */
2817
                  if ((off & 1) != 0)
2818
                    off &= ~1;
2819
                  else
2820
                    {
2821
                      bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2822
 
2823
                      if (info->shared)
2824
                        {
2825
                          asection *srelgot;
2826
                          Elf_Internal_Rela outrel;
2827
 
2828
                          /* We need to generate a R_M32R_RELATIVE reloc
2829
                             for the dynamic linker.  */
2830
                          srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2831
                          BFD_ASSERT (srelgot != NULL);
2832
 
2833
                          outrel.r_offset = (sgot->output_section->vma
2834
                                             + sgot->output_offset
2835
                                             + off);
2836
                          outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2837
                          outrel.r_addend = relocation;
2838
                          loc = srelgot->contents;
2839
                          loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
2840
                          bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2841
                          ++srelgot->reloc_count;
2842
                        }
2843
 
2844
                      local_got_offsets[r_symndx] |= 1;
2845
                    }
2846
 
2847
                  relocation = sgot->output_offset + off;
2848
                }
2849
              if ((r_type == R_M32R_GOT16_HI_SLO)
2850
                  && ((relocation + rel->r_addend) & 0x8000))
2851
                rel->r_addend += 0x10000;
2852
 
2853
              break;
2854
 
2855
            case R_M32R_26_PLTREL:
2856
              /* Relocation is to the entry for this symbol in the
2857
                 procedure linkage table.  */
2858
 
2859
              /* The native assembler will generate a 26_PLTREL reloc
2860
                 for a local symbol if you assemble a call from one
2861
                 section to another when using -K pic. */
2862
              if (h == NULL)
2863
                break;
2864
 
2865
              if (h->forced_local)
2866
                break;
2867
 
2868
              if (h->plt.offset == (bfd_vma) -1)
2869
                /* We didn't make a PLT entry for this symbol.  This
2870
                   happens when statically linking PIC code, or when
2871
                   using -Bsymbolic.  */
2872
                break;
2873
 
2874
              relocation = (splt->output_section->vma
2875
                            + splt->output_offset
2876
                            + h->plt.offset);
2877
              break;
2878
 
2879
            case R_M32R_HI16_SLO_RELA:
2880
              if ((relocation + rel->r_addend) & 0x8000)
2881
                rel->r_addend += 0x10000;
2882
              /* Fall through.  */
2883
 
2884
            case R_M32R_16_RELA:
2885
            case R_M32R_24_RELA:
2886
            case R_M32R_32_RELA:
2887
            case R_M32R_REL32:
2888
            case R_M32R_10_PCREL_RELA:
2889
            case R_M32R_18_PCREL_RELA:
2890
            case R_M32R_26_PCREL_RELA:
2891
            case R_M32R_HI16_ULO_RELA:
2892
            case R_M32R_LO16_RELA:
2893
              if (info->shared
2894
                  && r_symndx != 0
2895
                  && (input_section->flags & SEC_ALLOC) != 0
2896
                  && ((   r_type != R_M32R_10_PCREL_RELA
2897
                       && r_type != R_M32R_18_PCREL_RELA
2898
                       && r_type != R_M32R_26_PCREL_RELA
2899
                       && r_type != R_M32R_REL32)
2900
                      || (h != NULL
2901
                          && h->dynindx != -1
2902
                          && (! info->symbolic
2903
                              || !h->def_regular))))
2904
                {
2905
                  Elf_Internal_Rela outrel;
2906
                  bfd_boolean skip, relocate;
2907
                  bfd_byte *loc;
2908
 
2909
                  /* When generating a shared object, these relocations
2910
                     are copied into the output file to be resolved at run
2911
                     time.  */
2912
                  if (sreloc == NULL)
2913
                    {
2914
                      const char *name;
2915
 
2916
                      name = (bfd_elf_string_from_elf_section
2917
                              (input_bfd,
2918
                               elf_elfheader (input_bfd)->e_shstrndx,
2919
                               elf_section_data (input_section)->rel_hdr.sh_name));
2920
                      if (name == NULL)
2921
                        return FALSE;
2922
 
2923
                      BFD_ASSERT (CONST_STRNEQ (name, ".rela")
2924
                                  && strcmp (bfd_get_section_name (input_bfd,
2925
                                                                   input_section),
2926
                                             name + 5) == 0);
2927
 
2928
                      sreloc = bfd_get_section_by_name (dynobj, name);
2929
                      BFD_ASSERT (sreloc != NULL);
2930
                    }
2931
 
2932
                  skip = FALSE;
2933
                  relocate = FALSE;
2934
 
2935
                  outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2936
                                                             info,
2937
                                                             input_section,
2938
                                                             rel->r_offset);
2939
                  if (outrel.r_offset == (bfd_vma) -1)
2940
                    skip = TRUE;
2941
                  else if (outrel.r_offset == (bfd_vma) -2)
2942
                    skip = relocate = TRUE;
2943
                  outrel.r_offset += (input_section->output_section->vma
2944
                                      + input_section->output_offset);
2945
 
2946
                  if (skip)
2947
                    memset (&outrel, 0, sizeof outrel);
2948
                  else if (   r_type == R_M32R_10_PCREL_RELA
2949
                           || r_type == R_M32R_18_PCREL_RELA
2950
                           || r_type == R_M32R_26_PCREL_RELA
2951
                           || r_type == R_M32R_REL32)
2952
                    {
2953
                      BFD_ASSERT (h != NULL && h->dynindx != -1);
2954
                      outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2955
                      outrel.r_addend = rel->r_addend;
2956
                    }
2957
                  else
2958
                    {
2959
                    /* h->dynindx may be -1 if this symbol was marked to
2960
                       become local.  */
2961
                    if (h == NULL
2962
                        || ((info->symbolic || h->dynindx == -1)
2963
                             && h->def_regular))
2964
                      {
2965
                        relocate = TRUE;
2966
                        outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2967
                        outrel.r_addend = relocation + rel->r_addend;
2968
                      }
2969
                    else
2970
                      {
2971
                        BFD_ASSERT (h->dynindx != -1);
2972
                        outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2973
                        outrel.r_addend = relocation + rel->r_addend;
2974
                      }
2975
                    }
2976
 
2977
                  loc = sreloc->contents;
2978
                  loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
2979
                  bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2980
                  ++sreloc->reloc_count;
2981
 
2982
                  /* If this reloc is against an external symbol, we do
2983
                     not want to fiddle with the addend.  Otherwise, we
2984
                     need to include the symbol value so that it becomes
2985
                     an addend for the dynamic reloc.  */
2986
                  if (! relocate)
2987
                    continue;
2988
                  break;
2989
                }
2990
              else if (r_type != R_M32R_10_PCREL_RELA)
2991
                break;
2992
              /* Fall through.  */
2993
 
2994
            case (int) R_M32R_10_PCREL :
2995
              r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
2996
                                              contents, offset,
2997
                                              sec, relocation, addend);
2998
              goto check_reloc;
2999
 
3000
            case (int) R_M32R_HI16_SLO :
3001
            case (int) R_M32R_HI16_ULO :
3002
              {
3003
                Elf_Internal_Rela *lorel;
3004
 
3005
                /* We allow an arbitrary number of HI16 relocs before the
3006
                   LO16 reloc.  This permits gcc to emit the HI and LO relocs
3007
                   itself.  */
3008
                for (lorel = rel + 1;
3009
                     (lorel < relend
3010
                      && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
3011
                          || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
3012
                     lorel++)
3013
                  continue;
3014
                if (lorel < relend
3015
                    && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
3016
                  {
3017
                    m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
3018
                                            contents, relocation + addend);
3019
                    r = bfd_reloc_ok;
3020
                  }
3021
                else
3022
                  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3023
                                                contents, offset,
3024
                                                relocation, addend);
3025
              }
3026
 
3027
              goto check_reloc;
3028
 
3029
            case (int) R_M32R_SDA16_RELA:
3030
            case (int) R_M32R_SDA16 :
3031
              {
3032
                const char *name;
3033
 
3034
                BFD_ASSERT (sec != NULL);
3035
                name = bfd_get_section_name (abfd, sec);
3036
 
3037
                if (   strcmp (name, ".sdata") == 0
3038
                    || strcmp (name, ".sbss") == 0
3039
                    || strcmp (name, ".scommon") == 0)
3040
                  {
3041
                    bfd_vma sda_base;
3042
                    bfd *out_bfd = sec->output_section->owner;
3043
 
3044
                    r = m32r_elf_final_sda_base (out_bfd, info,
3045
                                                 &errmsg,
3046
                                                 &sda_base);
3047
                    if (r != bfd_reloc_ok)
3048
                      {
3049
                        ret = FALSE;
3050
                        goto check_reloc;
3051
                      }
3052
 
3053
                    /* At this point `relocation' contains the object's
3054
                       address.  */
3055
                    relocation -= sda_base;
3056
                    /* Now it contains the offset from _SDA_BASE_.  */
3057
                  }
3058
                else
3059
                  {
3060
                    (*_bfd_error_handler)
3061
                      (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3062
                       input_bfd,
3063
                       sec,
3064
                       sym_name,
3065
                       m32r_elf_howto_table[(int) r_type].name);
3066
                    /*bfd_set_error (bfd_error_bad_value); ??? why? */
3067
                    ret = FALSE;
3068
                    continue;
3069
                  }
3070
              }
3071
              /* Fall through.  */
3072
 
3073
            default : /* OLD_M32R_RELOC */
3074
 
3075
              r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3076
                                            contents, offset,
3077
                                            relocation, addend);
3078
              goto check_reloc;
3079
            }
3080
 
3081
          r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3082
                                        contents, rel->r_offset,
3083
                                        relocation, rel->r_addend);
3084
 
3085
        }
3086
 
3087
    check_reloc:
3088
 
3089
      if (r != bfd_reloc_ok)
3090
        {
3091
          /* FIXME: This should be generic enough to go in a utility.  */
3092
          const char *name;
3093
 
3094
          if (h != NULL)
3095
            name = h->root.root.string;
3096
          else
3097
            {
3098
              name = (bfd_elf_string_from_elf_section
3099
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
3100
              if (name == NULL || *name == '\0')
3101
                name = bfd_section_name (input_bfd, sec);
3102
            }
3103
 
3104
          if (errmsg != NULL)
3105
            goto common_error;
3106
 
3107
          switch (r)
3108
            {
3109
            case bfd_reloc_overflow:
3110
              if (! ((*info->callbacks->reloc_overflow)
3111
                     (info, (h ? &h->root : NULL), name, howto->name,
3112
                      (bfd_vma) 0, input_bfd, input_section, offset)))
3113
                return FALSE;
3114
              break;
3115
 
3116
            case bfd_reloc_undefined:
3117
              if (! ((*info->callbacks->undefined_symbol)
3118
                     (info, name, input_bfd, input_section,
3119
                      offset, TRUE)))
3120
                return FALSE;
3121
              break;
3122
 
3123
            case bfd_reloc_outofrange:
3124
              errmsg = _("internal error: out of range error");
3125
              goto common_error;
3126
 
3127
            case bfd_reloc_notsupported:
3128
              errmsg = _("internal error: unsupported relocation error");
3129
              goto common_error;
3130
 
3131
            case bfd_reloc_dangerous:
3132
              errmsg = _("internal error: dangerous error");
3133
              goto common_error;
3134
 
3135
            default:
3136
              errmsg = _("internal error: unknown error");
3137
              /* fall through */
3138
 
3139
            common_error:
3140
              if (!((*info->callbacks->warning)
3141
                    (info, errmsg, name, input_bfd, input_section,
3142
                     offset)))
3143
                return FALSE;
3144
              break;
3145
            }
3146
        }
3147
    }
3148
 
3149
  return ret;
3150
}
3151
 
3152
/* Finish up dynamic symbol handling.  We set the contents of various
3153
   dynamic sections here.  */
3154
 
3155
static bfd_boolean
3156
m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3157
                                struct bfd_link_info *info,
3158
                                struct elf_link_hash_entry *h,
3159
                                Elf_Internal_Sym *sym)
3160
{
3161
  struct elf_m32r_link_hash_table *htab;
3162
  bfd *dynobj;
3163
  bfd_byte *loc;
3164
 
3165
#ifdef DEBUG_PIC
3166
  printf ("m32r_elf_finish_dynamic_symbol()\n");
3167
#endif
3168
 
3169
  htab = m32r_elf_hash_table (info);
3170
  dynobj = htab->root.dynobj;
3171
 
3172
  if (h->plt.offset != (bfd_vma) -1)
3173
    {
3174
      asection *splt;
3175
      asection *sgot;
3176
      asection *srela;
3177
 
3178
      bfd_vma plt_index;
3179
      bfd_vma got_offset;
3180
      Elf_Internal_Rela rela;
3181
 
3182
      /* This symbol has an entry in the procedure linkage table.  Set
3183
         it up.  */
3184
 
3185
      BFD_ASSERT (h->dynindx != -1);
3186
 
3187
      splt = htab->splt;
3188
      sgot = htab->sgotplt;
3189
      srela = htab->srelplt;
3190
      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3191
 
3192
      /* Get the index in the procedure linkage table which
3193
         corresponds to this symbol.  This is the index of this symbol
3194
         in all the symbols for which we are making plt entries.  The
3195
         first entry in the procedure linkage table is reserved.  */
3196
      plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3197
 
3198
      /* Get the offset into the .got table of the entry that
3199
        corresponds to this function.  Each .got entry is 4 bytes.
3200
        The first three are reserved.  */
3201
      got_offset = (plt_index + 3) * 4;
3202
 
3203
      /* Fill in the entry in the procedure linkage table.  */
3204
      if (! info->shared)
3205
        {
3206
          bfd_put_32 (output_bfd,
3207
              (PLT_ENTRY_WORD0b
3208
               + (((sgot->output_section->vma
3209
                    + sgot->output_offset
3210
                    + got_offset) >> 16) & 0xffff)),
3211
              splt->contents + h->plt.offset);
3212
          bfd_put_32 (output_bfd,
3213
              (PLT_ENTRY_WORD1b
3214
               + ((sgot->output_section->vma
3215
                   + sgot->output_offset
3216
                   + got_offset) & 0xffff)),
3217
              splt->contents + h->plt.offset + 4);
3218
          bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3219
              splt->contents + h->plt.offset + 8);
3220
          bfd_put_32 (output_bfd,
3221
              (PLT_ENTRY_WORD3
3222
               + plt_index * sizeof (Elf32_External_Rela)),
3223
              splt->contents + h->plt.offset + 12);
3224
          bfd_put_32 (output_bfd,
3225
              (PLT_ENTRY_WORD4
3226
               + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3227
              splt->contents + h->plt.offset + 16);
3228
        }
3229
      else
3230
        {
3231
          bfd_put_32 (output_bfd,
3232
              PLT_ENTRY_WORD0 + got_offset,
3233
              splt->contents + h->plt.offset);
3234
          bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3235
              splt->contents + h->plt.offset + 4);
3236
          bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3237
              splt->contents + h->plt.offset + 8);
3238
          bfd_put_32 (output_bfd,
3239
              (PLT_ENTRY_WORD3
3240
               + plt_index * sizeof (Elf32_External_Rela)),
3241
              splt->contents + h->plt.offset + 12);
3242
          bfd_put_32 (output_bfd,
3243
              (PLT_ENTRY_WORD4
3244
               + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3245
              splt->contents + h->plt.offset + 16);
3246
        }
3247
 
3248
      /* Fill in the entry in the global offset table.  */
3249
      bfd_put_32 (output_bfd,
3250
                  (splt->output_section->vma
3251
                   + splt->output_offset
3252
                   + h->plt.offset
3253
                   + 12), /* same offset */
3254
                  sgot->contents + got_offset);
3255
 
3256
      /* Fill in the entry in the .rela.plt section.  */
3257
      rela.r_offset = (sgot->output_section->vma
3258
                       + sgot->output_offset
3259
                       + got_offset);
3260
      rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3261
      rela.r_addend = 0;
3262
      loc = srela->contents;
3263
      loc += plt_index * sizeof (Elf32_External_Rela);
3264
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3265
 
3266
      if (!h->def_regular)
3267
        {
3268
          /* Mark the symbol as undefined, rather than as defined in
3269
             the .plt section.  Leave the value alone.  */
3270
          sym->st_shndx = SHN_UNDEF;
3271
        }
3272
    }
3273
 
3274
  if (h->got.offset != (bfd_vma) -1)
3275
    {
3276
      asection *sgot;
3277
      asection *srela;
3278
      Elf_Internal_Rela rela;
3279
 
3280
      /* This symbol has an entry in the global offset table.  Set it
3281
         up.  */
3282
 
3283
      sgot = htab->sgot;
3284
      srela = htab->srelgot;
3285
      BFD_ASSERT (sgot != NULL && srela != NULL);
3286
 
3287
      rela.r_offset = (sgot->output_section->vma
3288
                       + sgot->output_offset
3289
                       + (h->got.offset &~ 1));
3290
 
3291
      /* If this is a -Bsymbolic link, and the symbol is defined
3292
         locally, we just want to emit a RELATIVE reloc.  Likewise if
3293
         the symbol was forced to be local because of a version file.
3294
         The entry in the global offset table will already have been
3295
         initialized in the relocate_section function.  */
3296
      if (info->shared
3297
          && (info->symbolic
3298
              || h->dynindx == -1
3299
              || h->forced_local)
3300
          && h->def_regular)
3301
        {
3302
          rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3303
          rela.r_addend = (h->root.u.def.value
3304
                           + h->root.u.def.section->output_section->vma
3305
                           + h->root.u.def.section->output_offset);
3306
        }
3307
      else
3308
        {
3309
          BFD_ASSERT ((h->got.offset & 1) == 0);
3310
          bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3311
          rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3312
          rela.r_addend = 0;
3313
        }
3314
 
3315
      loc = srela->contents;
3316
      loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3317
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3318
      ++srela->reloc_count;
3319
    }
3320
 
3321
  if (h->needs_copy)
3322
    {
3323
      asection *s;
3324
      Elf_Internal_Rela rela;
3325
 
3326
      /* This symbols needs a copy reloc.  Set it up.  */
3327
 
3328
      BFD_ASSERT (h->dynindx != -1
3329
                  && (h->root.type == bfd_link_hash_defined
3330
                      || h->root.type == bfd_link_hash_defweak));
3331
 
3332
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
3333
                                   ".rela.bss");
3334
      BFD_ASSERT (s != NULL);
3335
 
3336
      rela.r_offset = (h->root.u.def.value
3337
                       + h->root.u.def.section->output_section->vma
3338
                       + h->root.u.def.section->output_offset);
3339
      rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3340
      rela.r_addend = 0;
3341
      loc = s->contents;
3342
      loc += s->reloc_count * sizeof (Elf32_External_Rela);
3343
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3344
      ++s->reloc_count;
3345
    }
3346
 
3347
  /* Mark some specially defined symbols as absolute.  */
3348
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3349
      || h == htab->root.hgot)
3350
    sym->st_shndx = SHN_ABS;
3351
 
3352
  return TRUE;
3353
}
3354
 
3355
 
3356
/* Finish up the dynamic sections.  */
3357
 
3358
static bfd_boolean
3359
m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3360
                                  struct bfd_link_info *info)
3361
{
3362
  struct elf_m32r_link_hash_table *htab;
3363
  bfd *dynobj;
3364
  asection *sdyn;
3365
  asection *sgot;
3366
 
3367
#ifdef DEBUG_PIC
3368
  printf ("m32r_elf_finish_dynamic_sections()\n");
3369
#endif
3370
 
3371
  htab = m32r_elf_hash_table (info);
3372
  dynobj = htab->root.dynobj;
3373
 
3374
  sgot = htab->sgotplt;
3375
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3376
 
3377
  if (htab->root.dynamic_sections_created)
3378
    {
3379
      asection *splt;
3380
      Elf32_External_Dyn *dyncon, *dynconend;
3381
 
3382
      BFD_ASSERT (sgot != NULL && sdyn != NULL);
3383
 
3384
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
3385
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3386
 
3387
      for (; dyncon < dynconend; dyncon++)
3388
        {
3389
          Elf_Internal_Dyn dyn;
3390
          const char *name;
3391
          asection *s;
3392
 
3393
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3394
 
3395
          switch (dyn.d_tag)
3396
            {
3397
            default:
3398
              break;
3399
 
3400
            case DT_PLTGOT:
3401
              name = ".got";
3402
              s = htab->sgot->output_section;
3403
              goto get_vma;
3404
            case DT_JMPREL:
3405
              name = ".rela.plt";
3406
              s = htab->srelplt->output_section;
3407
            get_vma:
3408
              BFD_ASSERT (s != NULL);
3409
              dyn.d_un.d_ptr = s->vma;
3410
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3411
              break;
3412
 
3413
            case DT_PLTRELSZ:
3414
              s = htab->srelplt->output_section;
3415
              BFD_ASSERT (s != NULL);
3416
              dyn.d_un.d_val = s->size;
3417
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3418
              break;
3419
 
3420
            case DT_RELASZ:
3421
              /* My reading of the SVR4 ABI indicates that the
3422
                 procedure linkage table relocs (DT_JMPREL) should be
3423
                 included in the overall relocs (DT_RELA).  This is
3424
                 what Solaris does.  However, UnixWare can not handle
3425
                 that case.  Therefore, we override the DT_RELASZ entry
3426
                 here to make it not include the JMPREL relocs.  Since
3427
                 the linker script arranges for .rela.plt to follow all
3428
                 other relocation sections, we don't have to worry
3429
                 about changing the DT_RELA entry.  */
3430
              if (htab->srelplt != NULL)
3431
                {
3432
                  s = htab->srelplt->output_section;
3433
                  dyn.d_un.d_val -= s->size;
3434
                }
3435
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3436
              break;
3437
            }
3438
        }
3439
 
3440
      /* Fill in the first entry in the procedure linkage table.  */
3441
      splt = htab->splt;
3442
      if (splt && splt->size > 0)
3443
        {
3444
          if (info->shared)
3445
            {
3446
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3447
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3448
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3449
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3450
              bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3451
            }
3452
          else
3453
            {
3454
              unsigned long addr;
3455
              /* addr = .got + 4 */
3456
              addr = sgot->output_section->vma + sgot->output_offset + 4;
3457
              bfd_put_32 (output_bfd,
3458
                          PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3459
                          splt->contents);
3460
              bfd_put_32 (output_bfd,
3461
                          PLT0_ENTRY_WORD1 | (addr & 0xffff),
3462
                          splt->contents + 4);
3463
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3464
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3465
              bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3466
            }
3467
 
3468
          elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3469
            PLT_ENTRY_SIZE;
3470
        }
3471
    }
3472
 
3473
  /* Fill in the first three entries in the global offset table.  */
3474
  if (sgot && sgot->size > 0)
3475
    {
3476
      if (sdyn == NULL)
3477
        bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3478
      else
3479
        bfd_put_32 (output_bfd,
3480
                    sdyn->output_section->vma + sdyn->output_offset,
3481
                    sgot->contents);
3482
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3483
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3484
 
3485
      elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3486
    }
3487
 
3488
  return TRUE;
3489
}
3490
 
3491
 
3492
/* Set the right machine number.  */
3493
 
3494
static bfd_boolean
3495
m32r_elf_object_p (bfd *abfd)
3496
{
3497
  switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3498
    {
3499
    default:
3500
    case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
3501
    case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3502
    case E_M32R2_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3503
    }
3504
  return TRUE;
3505
}
3506
 
3507
/* Store the machine number in the flags field.  */
3508
 
3509
static void
3510
m32r_elf_final_write_processing (bfd *abfd,
3511
                                 bfd_boolean linker ATTRIBUTE_UNUSED)
3512
{
3513
  unsigned long val;
3514
 
3515
  switch (bfd_get_mach (abfd))
3516
    {
3517
    default:
3518
    case bfd_mach_m32r:  val = E_M32R_ARCH; break;
3519
    case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3520
    case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3521
    }
3522
 
3523
  elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3524
  elf_elfheader (abfd)->e_flags |= val;
3525
}
3526
 
3527
/* Function to keep M32R specific file flags.  */
3528
 
3529
static bfd_boolean
3530
m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3531
{
3532
  BFD_ASSERT (!elf_flags_init (abfd)
3533
              || elf_elfheader (abfd)->e_flags == flags);
3534
 
3535
  elf_elfheader (abfd)->e_flags = flags;
3536
  elf_flags_init (abfd) = TRUE;
3537
  return TRUE;
3538
}
3539
 
3540
/* Merge backend specific data from an object file to the output
3541
   object file when linking.  */
3542
 
3543
static bfd_boolean
3544
m32r_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3545
{
3546
  flagword out_flags;
3547
  flagword in_flags;
3548
 
3549
  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3550
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3551
    return TRUE;
3552
 
3553
  in_flags  = elf_elfheader (ibfd)->e_flags;
3554
  out_flags = elf_elfheader (obfd)->e_flags;
3555
 
3556
  if (! elf_flags_init (obfd))
3557
    {
3558
      /* If the input is the default architecture then do not
3559
         bother setting the flags for the output architecture,
3560
         instead allow future merges to do this.  If no future
3561
         merges ever set these flags then they will retain their
3562
         unitialised values, which surprise surprise, correspond
3563
         to the default values.  */
3564
      if (bfd_get_arch_info (ibfd)->the_default)
3565
        return TRUE;
3566
 
3567
      elf_flags_init (obfd) = TRUE;
3568
      elf_elfheader (obfd)->e_flags = in_flags;
3569
 
3570
      if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3571
          && bfd_get_arch_info (obfd)->the_default)
3572
        return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3573
                                  bfd_get_mach (ibfd));
3574
 
3575
      return TRUE;
3576
    }
3577
 
3578
  /* Check flag compatibility.  */
3579
  if (in_flags == out_flags)
3580
    return TRUE;
3581
 
3582
  if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3583
    {
3584
      if (   ((in_flags  & EF_M32R_ARCH) != E_M32R_ARCH)
3585
          || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3586
          || ((in_flags  & EF_M32R_ARCH) == E_M32R2_ARCH))
3587
        {
3588
          (*_bfd_error_handler)
3589
            (_("%B: Instruction set mismatch with previous modules"), ibfd);
3590
 
3591
          bfd_set_error (bfd_error_bad_value);
3592
          return FALSE;
3593
        }
3594
    }
3595
 
3596
  return TRUE;
3597
}
3598
 
3599
/* Display the flags field.  */
3600
 
3601
static bfd_boolean
3602
m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3603
{
3604
  FILE * file = (FILE *) ptr;
3605
 
3606
  BFD_ASSERT (abfd != NULL && ptr != NULL);
3607
 
3608
  _bfd_elf_print_private_bfd_data (abfd, ptr);
3609
 
3610
  fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3611
 
3612
  switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3613
    {
3614
    default:
3615
    case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
3616
    case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3617
    case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3618
    }
3619
 
3620
  fputc ('\n', file);
3621
 
3622
  return TRUE;
3623
}
3624
 
3625
static asection *
3626
m32r_elf_gc_mark_hook (asection *sec,
3627
                       struct bfd_link_info *info,
3628
                       Elf_Internal_Rela *rel,
3629
                       struct elf_link_hash_entry *h,
3630
                       Elf_Internal_Sym *sym)
3631
{
3632
  if (h != NULL)
3633
    switch (ELF32_R_TYPE (rel->r_info))
3634
      {
3635
      case R_M32R_GNU_VTINHERIT:
3636
      case R_M32R_GNU_VTENTRY:
3637
      case R_M32R_RELA_GNU_VTINHERIT:
3638
      case R_M32R_RELA_GNU_VTENTRY:
3639
        return NULL;
3640
      }
3641
 
3642
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3643
}
3644
 
3645
static bfd_boolean
3646
m32r_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
3647
                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
3648
                        asection *sec ATTRIBUTE_UNUSED,
3649
                        const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3650
{
3651
  /* Update the got entry reference counts for the section being removed.  */
3652
  Elf_Internal_Shdr *symtab_hdr;
3653
  struct elf_link_hash_entry **sym_hashes;
3654
  bfd_signed_vma *local_got_refcounts;
3655
  const Elf_Internal_Rela *rel, *relend;
3656
 
3657
  if (info->relocatable)
3658
    return TRUE;
3659
 
3660
  elf_section_data (sec)->local_dynrel = NULL;
3661
 
3662
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3663
  sym_hashes = elf_sym_hashes (abfd);
3664
  local_got_refcounts = elf_local_got_refcounts (abfd);
3665
 
3666
  relend = relocs + sec->reloc_count;
3667
  for (rel = relocs; rel < relend; rel++)
3668
    {
3669
      unsigned long r_symndx;
3670
      struct elf_link_hash_entry *h = NULL;
3671
 
3672
      r_symndx = ELF32_R_SYM (rel->r_info);
3673
      if (r_symndx >= symtab_hdr->sh_info)
3674
        {
3675
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3676
          while (h->root.type == bfd_link_hash_indirect
3677
                 || h->root.type == bfd_link_hash_warning)
3678
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
3679
        }
3680
 
3681
      switch (ELF32_R_TYPE (rel->r_info))
3682
        {
3683
        case R_M32R_GOT16_HI_ULO:
3684
        case R_M32R_GOT16_HI_SLO:
3685
        case R_M32R_GOT16_LO:
3686
        case R_M32R_GOTOFF:
3687
        case R_M32R_GOTOFF_HI_ULO:
3688
        case R_M32R_GOTOFF_HI_SLO:
3689
        case R_M32R_GOTOFF_LO:
3690
        case R_M32R_GOT24:
3691
        case R_M32R_GOTPC_HI_ULO:
3692
        case R_M32R_GOTPC_HI_SLO:
3693
        case R_M32R_GOTPC_LO:
3694
        case R_M32R_GOTPC24:
3695
          if (h != NULL)
3696
            {
3697
              if (h->got.refcount > 0)
3698
                h->got.refcount--;
3699
            }
3700
          else
3701
            {
3702
              if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
3703
                local_got_refcounts[r_symndx]--;
3704
            }
3705
          break;
3706
 
3707
        case R_M32R_16_RELA:
3708
        case R_M32R_24_RELA:
3709
        case R_M32R_32_RELA:
3710
        case R_M32R_REL32:
3711
        case R_M32R_HI16_ULO_RELA:
3712
        case R_M32R_HI16_SLO_RELA:
3713
        case R_M32R_LO16_RELA:
3714
        case R_M32R_SDA16_RELA:
3715
        case R_M32R_10_PCREL_RELA:
3716
        case R_M32R_18_PCREL_RELA:
3717
        case R_M32R_26_PCREL_RELA:
3718
          if (h != NULL)
3719
            {
3720
              struct elf_m32r_link_hash_entry *eh;
3721
              struct elf_m32r_dyn_relocs **pp;
3722
              struct elf_m32r_dyn_relocs *p;
3723
 
3724
              if (!info->shared && h->plt.refcount > 0)
3725
                h->plt.refcount -= 1;
3726
 
3727
              eh = (struct elf_m32r_link_hash_entry *) h;
3728
 
3729
              for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3730
                if (p->sec == sec)
3731
                  {
3732
                    if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3733
                        || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3734
                        || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3735
                        || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3736
                      p->pc_count -= 1;
3737
                    p->count -= 1;
3738
                    if (p->count == 0)
3739
                      *pp = p->next;
3740
                    break;
3741
                  }
3742
            }
3743
          break;
3744
 
3745
        case R_M32R_26_PLTREL:
3746
          if (h != NULL)
3747
            {
3748
              if (h->plt.refcount > 0)
3749
                h->plt.refcount--;
3750
            }
3751
          break;
3752
 
3753
        default:
3754
          break;
3755
        }
3756
    }
3757
 
3758
  return TRUE;
3759
}
3760
 
3761
/* Look through the relocs for a section during the first phase.
3762
   Since we don't do .gots or .plts, we just need to consider the
3763
   virtual table relocs for gc.  */
3764
 
3765
static bfd_boolean
3766
m32r_elf_check_relocs (bfd *abfd,
3767
                       struct bfd_link_info *info,
3768
                       asection *sec,
3769
                       const Elf_Internal_Rela *relocs)
3770
{
3771
  Elf_Internal_Shdr *symtab_hdr;
3772
  struct elf_link_hash_entry **sym_hashes;
3773
  const Elf_Internal_Rela *rel;
3774
  const Elf_Internal_Rela *rel_end;
3775
  struct elf_m32r_link_hash_table *htab;
3776
  bfd *dynobj;
3777
  bfd_vma *local_got_offsets;
3778
  asection *sgot, *srelgot, *sreloc;
3779
 
3780
  if (info->relocatable)
3781
    return TRUE;
3782
 
3783
  sgot = srelgot = sreloc = NULL;
3784
 
3785
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3786
  sym_hashes = elf_sym_hashes (abfd);
3787
 
3788
  htab = m32r_elf_hash_table (info);
3789
  dynobj = htab->root.dynobj;
3790
  local_got_offsets = elf_local_got_offsets (abfd);
3791
 
3792
  rel_end = relocs + sec->reloc_count;
3793
  for (rel = relocs; rel < rel_end; rel++)
3794
    {
3795
      int r_type;
3796
      struct elf_link_hash_entry *h;
3797
      unsigned long r_symndx;
3798
 
3799
      r_symndx = ELF32_R_SYM (rel->r_info);
3800
      r_type = ELF32_R_TYPE (rel->r_info);
3801
      if (r_symndx < symtab_hdr->sh_info)
3802
        h = NULL;
3803
      else
3804
        {
3805
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3806
          while (h->root.type == bfd_link_hash_indirect
3807
                 || h->root.type == bfd_link_hash_warning)
3808
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
3809
        }
3810
 
3811
      /* Some relocs require a global offset table.  */
3812
      if (htab->sgot == NULL)
3813
        {
3814
          switch (r_type)
3815
            {
3816
            case R_M32R_GOT16_HI_ULO:
3817
            case R_M32R_GOT16_HI_SLO:
3818
            case R_M32R_GOTOFF:
3819
            case R_M32R_GOTOFF_HI_ULO:
3820
            case R_M32R_GOTOFF_HI_SLO:
3821
            case R_M32R_GOTOFF_LO:
3822
            case R_M32R_GOT16_LO:
3823
            case R_M32R_GOTPC24:
3824
            case R_M32R_GOTPC_HI_ULO:
3825
            case R_M32R_GOTPC_HI_SLO:
3826
            case R_M32R_GOTPC_LO:
3827
            case R_M32R_GOT24:
3828
              if (dynobj == NULL)
3829
                htab->root.dynobj = dynobj = abfd;
3830
              if (! create_got_section (dynobj, info))
3831
                return FALSE;
3832
              break;
3833
 
3834
            default:
3835
              break;
3836
          }
3837
        }
3838
 
3839
      switch (r_type)
3840
        {
3841
        case R_M32R_GOT16_HI_ULO:
3842
        case R_M32R_GOT16_HI_SLO:
3843
        case R_M32R_GOT16_LO:
3844
        case R_M32R_GOT24:
3845
 
3846
          if (h != NULL)
3847
            h->got.refcount += 1;
3848
          else
3849
            {
3850
              bfd_signed_vma *local_got_refcounts;
3851
 
3852
              /* This is a global offset table entry for a local
3853
                 symbol.  */
3854
              local_got_refcounts = elf_local_got_refcounts (abfd);
3855
              if (local_got_refcounts == NULL)
3856
                {
3857
                  bfd_size_type size;
3858
 
3859
                  size = symtab_hdr->sh_info;
3860
                  size *= sizeof (bfd_signed_vma);
3861
                  local_got_refcounts = bfd_zalloc (abfd, size);
3862
                  if (local_got_refcounts == NULL)
3863
                    return FALSE;
3864
                  elf_local_got_refcounts (abfd) = local_got_refcounts;
3865
                }
3866
              local_got_refcounts[r_symndx] += 1;
3867
            }
3868
          break;
3869
 
3870
        case R_M32R_26_PLTREL:
3871
          /* This symbol requires a procedure linkage table entry.  We
3872
             actually build the entry in adjust_dynamic_symbol,
3873
             because this might be a case of linking PIC code without
3874
             linking in any dynamic objects, in which case we don't
3875
             need to generate a procedure linkage table after all.  */
3876
 
3877
          /* If this is a local symbol, we resolve it directly without
3878
             creating a procedure linkage table entry.  */
3879
          if (h == NULL)
3880
            continue;
3881
 
3882
          if (h->forced_local)
3883
            break;
3884
 
3885
          h->needs_plt = 1;
3886
          h->plt.refcount += 1;
3887
          break;
3888
 
3889
        case R_M32R_16_RELA:
3890
        case R_M32R_24_RELA:
3891
        case R_M32R_32_RELA:
3892
        case R_M32R_REL32:
3893
        case R_M32R_HI16_ULO_RELA:
3894
        case R_M32R_HI16_SLO_RELA:
3895
        case R_M32R_LO16_RELA:
3896
        case R_M32R_SDA16_RELA:
3897
        case R_M32R_10_PCREL_RELA:
3898
        case R_M32R_18_PCREL_RELA:
3899
        case R_M32R_26_PCREL_RELA:
3900
 
3901
          if (h != NULL && !info->shared)
3902
            {
3903
              h->non_got_ref = 1;
3904
              h->plt.refcount += 1;
3905
            }
3906
 
3907
          /* If we are creating a shared library, and this is a reloc
3908
             against a global symbol, or a non PC relative reloc
3909
             against a local symbol, then we need to copy the reloc
3910
             into the shared library.  However, if we are linking with
3911
             -Bsymbolic, we do not need to copy a reloc against a
3912
             global symbol which is defined in an object we are
3913
             including in the link (i.e., DEF_REGULAR is set).  At
3914
             this point we have not seen all the input files, so it is
3915
             possible that DEF_REGULAR is not set now but will be set
3916
             later (it is never cleared).  We account for that
3917
             possibility below by storing information in the
3918
             dyn_relocs field of the hash table entry. A similar
3919
             situation occurs when creating shared libraries and symbol
3920
             visibility changes render the symbol local.
3921
 
3922
             If on the other hand, we are creating an executable, we
3923
             may need to keep relocations for symbols satisfied by a
3924
             dynamic library if we manage to avoid copy relocs for the
3925
             symbol.  */
3926
          if ((info->shared
3927
               && (sec->flags & SEC_ALLOC) != 0
3928
               && ((   r_type != R_M32R_26_PCREL_RELA
3929
                    && r_type != R_M32R_18_PCREL_RELA
3930
                    && r_type != R_M32R_10_PCREL_RELA
3931
                    && r_type != R_M32R_REL32)
3932
                   || (h != NULL
3933
                       && (! info->symbolic
3934
                           || h->root.type == bfd_link_hash_defweak
3935
                           || !h->def_regular))))
3936
              || (!info->shared
3937
                  && (sec->flags & SEC_ALLOC) != 0
3938
                  && h != NULL
3939
                  && (h->root.type == bfd_link_hash_defweak
3940
                      || !h->def_regular)))
3941
            {
3942
              struct elf_m32r_dyn_relocs *p;
3943
              struct elf_m32r_dyn_relocs **head;
3944
 
3945
              if (dynobj == NULL)
3946
                htab->root.dynobj = dynobj = abfd;
3947
 
3948
              /* When creating a shared object, we must copy these
3949
                 relocs into the output file.  We create a reloc
3950
                 section in dynobj and make room for the reloc.  */
3951
              if (sreloc == NULL)
3952
                {
3953
                  const char *name;
3954
 
3955
                  name = (bfd_elf_string_from_elf_section
3956
                          (abfd,
3957
                           elf_elfheader (abfd)->e_shstrndx,
3958
                           elf_section_data (sec)->rel_hdr.sh_name));
3959
                  if (name == NULL)
3960
                    return FALSE;
3961
 
3962
                  BFD_ASSERT (CONST_STRNEQ (name, ".rela")
3963
                              && strcmp (bfd_get_section_name (abfd, sec),
3964
                                         name + 5) == 0);
3965
 
3966
                  sreloc = bfd_get_section_by_name (dynobj, name);
3967
                  if (sreloc == NULL)
3968
                    {
3969
                      flagword flags;
3970
 
3971
                      flags = (SEC_HAS_CONTENTS | SEC_READONLY
3972
                               | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3973
                      if ((sec->flags & SEC_ALLOC) != 0)
3974
                        flags |= SEC_ALLOC | SEC_LOAD;
3975
                      sreloc = bfd_make_section_with_flags (dynobj,
3976
                                                            name,
3977
                                                            flags);
3978
                      if (sreloc == NULL
3979
                          || ! bfd_set_section_alignment (dynobj, sreloc, 2))
3980
                        return FALSE;
3981
                    }
3982
                  elf_section_data (sec)->sreloc = sreloc;
3983
                }
3984
 
3985
              /* If this is a global symbol, we count the number of
3986
                 relocations we need for this symbol.  */
3987
              if (h != NULL)
3988
                head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3989
              else
3990
                {
3991
                  asection *s;
3992
                  void *vpp;
3993
 
3994
                  /* Track dynamic relocs needed for local syms too.  */
3995
                  s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
3996
                                                 sec, r_symndx);
3997
                  if (s == NULL)
3998
                    return FALSE;
3999
 
4000
                  vpp = &elf_section_data (s)->local_dynrel;
4001
                  head = (struct elf_m32r_dyn_relocs **) vpp;
4002
                }
4003
 
4004
              p = *head;
4005
              if (p == NULL || p->sec != sec)
4006
                {
4007
                  bfd_size_type amt = sizeof (*p);
4008
 
4009
                  p = bfd_alloc (dynobj, amt);
4010
                  if (p == NULL)
4011
                    return FALSE;
4012
                  p->next = *head;
4013
                  *head = p;
4014
                  p->sec = sec;
4015
                  p->count = 0;
4016
                  p->pc_count = 0;
4017
                }
4018
 
4019
              p->count += 1;
4020
              if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
4021
                  || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
4022
                  || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
4023
                  || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
4024
                p->pc_count += 1;
4025
            }
4026
          break;
4027
 
4028
        /* This relocation describes the C++ object vtable hierarchy.
4029
           Reconstruct it for later use during GC.  */
4030
        case R_M32R_RELA_GNU_VTINHERIT:
4031
        case R_M32R_GNU_VTINHERIT:
4032
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4033
            return FALSE;
4034
          break;
4035
 
4036
        /* This relocation describes which C++ vtable entries are actually
4037
           used.  Record for later use during GC.  */
4038
        case R_M32R_GNU_VTENTRY:
4039
          BFD_ASSERT (h != NULL);
4040
          if (h != NULL
4041
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4042
            return FALSE;
4043
          break;
4044
        case R_M32R_RELA_GNU_VTENTRY:
4045
          BFD_ASSERT (h != NULL);
4046
          if (h != NULL
4047
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4048
            return FALSE;
4049
          break;
4050
        }
4051
    }
4052
 
4053
  return TRUE;
4054
}
4055
 
4056
static const struct bfd_elf_special_section m32r_elf_special_sections[] =
4057
{
4058
  { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
4059
  { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
4060
  { NULL,                     0,  0, 0,            0 }
4061
};
4062
 
4063
static bfd_boolean
4064
m32r_elf_fake_sections (bfd *abfd,
4065
                        Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
4066
                        asection *sec)
4067
{
4068
  const char *name;
4069
 
4070
  name = bfd_get_section_name (abfd, sec);
4071
 
4072
  /* The generic elf_fake_sections will set up REL_HDR using the
4073
     default kind of relocations.  But, we may actually need both
4074
     kinds of relocations, so we set up the second header here.
4075
 
4076
     This is not necessary for the O32 ABI since that only uses Elf32_Rel
4077
     relocations (cf. System V ABI, MIPS RISC Processor Supplement,
4078
     3rd Edition, p. 4-17).  It breaks the IRIX 5/6 32-bit ld, since one
4079
     of the resulting empty .rela.<section> sections starts with
4080
     sh_offset == object size, and ld doesn't allow that.  While the check
4081
     is arguably bogus for empty or SHT_NOBITS sections, it can easily be
4082
     avoided by not emitting those useless sections in the first place.  */
4083
  if ((sec->flags & SEC_RELOC) != 0)
4084
    {
4085
      struct bfd_elf_section_data *esd;
4086
      bfd_size_type amt = sizeof (Elf_Internal_Shdr);
4087
 
4088
      esd = elf_section_data (sec);
4089
      BFD_ASSERT (esd->rel_hdr2 == NULL);
4090
      esd->rel_hdr2 = bfd_zalloc (abfd, amt);
4091
      if (!esd->rel_hdr2)
4092
        return FALSE;
4093
      _bfd_elf_init_reloc_shdr (abfd, esd->rel_hdr2, sec,
4094
                                !sec->use_rela_p);
4095
    }
4096
 
4097
  return TRUE;
4098
}
4099
 
4100
static enum elf_reloc_type_class
4101
m32r_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4102
{
4103
  switch ((int) ELF32_R_TYPE (rela->r_info))
4104
    {
4105
    case R_M32R_RELATIVE:  return reloc_class_relative;
4106
    case R_M32R_JMP_SLOT:  return reloc_class_plt;
4107
    case R_M32R_COPY:      return reloc_class_copy;
4108
    default:               return reloc_class_normal;
4109
    }
4110
}
4111
 
4112
#define ELF_ARCH                bfd_arch_m32r
4113
#define ELF_MACHINE_CODE        EM_M32R
4114
#define ELF_MACHINE_ALT1        EM_CYGNUS_M32R
4115
#define ELF_MAXPAGESIZE         0x1 /* Explicitly requested by Mitsubishi.  */
4116
 
4117
#define TARGET_BIG_SYM          bfd_elf32_m32r_vec
4118
#define TARGET_BIG_NAME         "elf32-m32r"
4119
#define TARGET_LITTLE_SYM       bfd_elf32_m32rle_vec
4120
#define TARGET_LITTLE_NAME      "elf32-m32rle"
4121
 
4122
#define elf_info_to_howto                       m32r_info_to_howto
4123
#define elf_info_to_howto_rel                   m32r_info_to_howto_rel
4124
#define elf_backend_section_from_bfd_section    _bfd_m32r_elf_section_from_bfd_section
4125
#define elf_backend_symbol_processing           _bfd_m32r_elf_symbol_processing
4126
#define elf_backend_add_symbol_hook             m32r_elf_add_symbol_hook
4127
#define elf_backend_relocate_section            m32r_elf_relocate_section
4128
#define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
4129
#define elf_backend_gc_sweep_hook               m32r_elf_gc_sweep_hook
4130
#define elf_backend_check_relocs                m32r_elf_check_relocs
4131
 
4132
#define elf_backend_create_dynamic_sections     m32r_elf_create_dynamic_sections
4133
#define bfd_elf32_bfd_link_hash_table_create    m32r_elf_link_hash_table_create
4134
#define elf_backend_size_dynamic_sections       m32r_elf_size_dynamic_sections
4135
#define elf_backend_omit_section_dynsym \
4136
  ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4137
#define elf_backend_finish_dynamic_sections     m32r_elf_finish_dynamic_sections
4138
#define elf_backend_adjust_dynamic_symbol       m32r_elf_adjust_dynamic_symbol
4139
#define elf_backend_finish_dynamic_symbol       m32r_elf_finish_dynamic_symbol
4140
#define elf_backend_reloc_type_class            m32r_elf_reloc_type_class
4141
#define elf_backend_copy_indirect_symbol        m32r_elf_copy_indirect_symbol
4142
 
4143
#define elf_backend_can_gc_sections             1
4144
/*#if !USE_REL
4145
#define elf_backend_rela_normal                 1
4146
#endif*/
4147
#define elf_backend_can_refcount 1
4148
#define elf_backend_want_got_plt 1
4149
#define elf_backend_plt_readonly 1
4150
#define elf_backend_want_plt_sym 0
4151
#define elf_backend_got_header_size 12
4152
 
4153
#define elf_backend_may_use_rel_p       1
4154
#ifdef USE_M32R_OLD_RELOC
4155
#define elf_backend_default_use_rela_p  0
4156
#define elf_backend_may_use_rela_p      0
4157
#else
4158
#define elf_backend_default_use_rela_p  1
4159
#define elf_backend_may_use_rela_p      1
4160
#define elf_backend_fake_sections       m32r_elf_fake_sections
4161
#endif
4162
 
4163
#define elf_backend_object_p                    m32r_elf_object_p
4164
#define elf_backend_final_write_processing      m32r_elf_final_write_processing
4165
#define bfd_elf32_bfd_merge_private_bfd_data    m32r_elf_merge_private_bfd_data
4166
#define bfd_elf32_bfd_set_private_flags         m32r_elf_set_private_flags
4167
#define bfd_elf32_bfd_print_private_bfd_data    m32r_elf_print_private_bfd_data
4168
#define elf_backend_special_sections            m32r_elf_special_sections
4169
 
4170
#include "elf32-target.h"
4171
 
4172
#undef  ELF_MAXPAGESIZE
4173
#define ELF_MAXPAGESIZE         0x1000
4174
 
4175
#undef  TARGET_BIG_SYM
4176
#define TARGET_BIG_SYM          bfd_elf32_m32rlin_vec
4177
#undef  TARGET_BIG_NAME
4178
#define TARGET_BIG_NAME         "elf32-m32r-linux"
4179
#undef  TARGET_LITTLE_SYM
4180
#define TARGET_LITTLE_SYM       bfd_elf32_m32rlelin_vec
4181
#undef  TARGET_LITTLE_NAME
4182
#define TARGET_LITTLE_NAME      "elf32-m32rle-linux"
4183
#undef  elf32_bed
4184
#define elf32_bed               elf32_m32r_lin_bed
4185
 
4186
#include "elf32-target.h"
4187
 

powered by: WebSVN 2.1.0

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