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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elf32-rl78.c] - Blame information for rev 299

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

Line No. Rev Author Line
1 163 khays
/* Renesas RL78 specific support for 32-bit ELF.
2
   Copyright (C) 2011
3
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
 
21
#include "sysdep.h"
22
#include "bfd.h"
23
#include "bfd_stdint.h"
24
#include "libbfd.h"
25
#include "elf-bfd.h"
26
#include "elf/rl78.h"
27
#include "libiberty.h"
28
 
29
#define valid_16bit_address(v) ((v) <= 0x0ffff || (v) >= 0xf0000)
30
 
31
#define RL78REL(n,sz,bit,shift,complain,pcrel)                               \
32
  HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
33
         bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
34
 
35
/* Note that the relocations around 0x7f are internal to this file;
36
   feel free to move them as needed to avoid conflicts with published
37
   relocation numbers.  */
38
 
39
static reloc_howto_type rl78_elf_howto_table [] =
40
{
41
  RL78REL (NONE,         0,  0, 0, dont,     FALSE),
42
  RL78REL (DIR32,        2, 32, 0, signed,   FALSE),
43
  RL78REL (DIR24S,       2, 24, 0, signed,   FALSE),
44
  RL78REL (DIR16,        1, 16, 0, dont,     FALSE),
45
  RL78REL (DIR16U,       1, 16, 0, unsigned, FALSE),
46
  RL78REL (DIR16S,       1, 16, 0, signed,   FALSE),
47
  RL78REL (DIR8,         0,  8, 0, dont,     FALSE),
48
  RL78REL (DIR8U,        0,  8, 0, unsigned, FALSE),
49
  RL78REL (DIR8S,        0,  8, 0, signed,   FALSE),
50
  RL78REL (DIR24S_PCREL, 2, 24, 0, signed,   TRUE),
51
  RL78REL (DIR16S_PCREL, 1, 16, 0, signed,   TRUE),
52
  RL78REL (DIR8S_PCREL,  0,  8, 0, signed,   TRUE),
53
  RL78REL (DIR16UL,      1, 16, 2, unsigned, FALSE),
54
  RL78REL (DIR16UW,      1, 16, 1, unsigned, FALSE),
55
  RL78REL (DIR8UL,       0,  8, 2, unsigned, FALSE),
56
  RL78REL (DIR8UW,       0,  8, 1, unsigned, FALSE),
57
  RL78REL (DIR32_REV,    1, 16, 0, dont,     FALSE),
58
  RL78REL (DIR16_REV,    1, 16, 0, dont,     FALSE),
59
  RL78REL (DIR3U_PCREL,  0,  3, 0, dont,     TRUE),
60
 
61
  EMPTY_HOWTO (0x13),
62
  EMPTY_HOWTO (0x14),
63
  EMPTY_HOWTO (0x15),
64
  EMPTY_HOWTO (0x16),
65
  EMPTY_HOWTO (0x17),
66
  EMPTY_HOWTO (0x18),
67
  EMPTY_HOWTO (0x19),
68
  EMPTY_HOWTO (0x1a),
69
  EMPTY_HOWTO (0x1b),
70
  EMPTY_HOWTO (0x1c),
71
  EMPTY_HOWTO (0x1d),
72
  EMPTY_HOWTO (0x1e),
73
  EMPTY_HOWTO (0x1f),
74
 
75
  EMPTY_HOWTO (0x20),
76
  EMPTY_HOWTO (0x21),
77
  EMPTY_HOWTO (0x22),
78
  EMPTY_HOWTO (0x23),
79
  EMPTY_HOWTO (0x24),
80
  EMPTY_HOWTO (0x25),
81
  EMPTY_HOWTO (0x26),
82
  EMPTY_HOWTO (0x27),
83
  EMPTY_HOWTO (0x28),
84
  EMPTY_HOWTO (0x29),
85
  EMPTY_HOWTO (0x2a),
86
  EMPTY_HOWTO (0x2b),
87
  EMPTY_HOWTO (0x2c),
88 166 khays
  RL78REL (RH_RELAX, 0,  0, 0, dont,     FALSE),
89 163 khays
 
90
  EMPTY_HOWTO (0x2e),
91
  EMPTY_HOWTO (0x2f),
92
  EMPTY_HOWTO (0x30),
93
  EMPTY_HOWTO (0x31),
94
  EMPTY_HOWTO (0x32),
95
  EMPTY_HOWTO (0x33),
96
  EMPTY_HOWTO (0x34),
97
  EMPTY_HOWTO (0x35),
98
  EMPTY_HOWTO (0x36),
99
  EMPTY_HOWTO (0x37),
100
  EMPTY_HOWTO (0x38),
101
  EMPTY_HOWTO (0x39),
102
  EMPTY_HOWTO (0x3a),
103
  EMPTY_HOWTO (0x3b),
104
  EMPTY_HOWTO (0x3c),
105
  EMPTY_HOWTO (0x3d),
106
  EMPTY_HOWTO (0x3e),
107
  EMPTY_HOWTO (0x3f),
108
  EMPTY_HOWTO (0x40),
109
 
110
  RL78REL (ABS32,        2, 32, 0, dont,     FALSE),
111
  RL78REL (ABS24S,       2, 24, 0, signed,   FALSE),
112
  RL78REL (ABS16,        1, 16, 0, dont,     FALSE),
113
  RL78REL (ABS16U,       1, 16, 0, unsigned, FALSE),
114
  RL78REL (ABS16S,       1, 16, 0, signed,   FALSE),
115
  RL78REL (ABS8,         0,  8, 0, dont,     FALSE),
116
  RL78REL (ABS8U,        0,  8, 0, unsigned, FALSE),
117
  RL78REL (ABS8S,        0,  8, 0, signed,   FALSE),
118
  RL78REL (ABS24S_PCREL, 2, 24, 0, signed,   TRUE),
119
  RL78REL (ABS16S_PCREL, 1, 16, 0, signed,   TRUE),
120
  RL78REL (ABS8S_PCREL,  0,  8, 0, signed,   TRUE),
121
  RL78REL (ABS16UL,      1, 16, 0, unsigned, FALSE),
122
  RL78REL (ABS16UW,      1, 16, 0, unsigned, FALSE),
123
  RL78REL (ABS8UL,       0,  8, 0, unsigned, FALSE),
124
  RL78REL (ABS8UW,       0,  8, 0, unsigned, FALSE),
125
  RL78REL (ABS32_REV,    2, 32, 0, dont,     FALSE),
126
  RL78REL (ABS16_REV,    1, 16, 0, dont,     FALSE),
127
 
128
#define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
129
 
130
  EMPTY_HOWTO (0x52),
131
  EMPTY_HOWTO (0x53),
132
  EMPTY_HOWTO (0x54),
133
  EMPTY_HOWTO (0x55),
134
  EMPTY_HOWTO (0x56),
135
  EMPTY_HOWTO (0x57),
136
  EMPTY_HOWTO (0x58),
137
  EMPTY_HOWTO (0x59),
138
  EMPTY_HOWTO (0x5a),
139
  EMPTY_HOWTO (0x5b),
140
  EMPTY_HOWTO (0x5c),
141
  EMPTY_HOWTO (0x5d),
142
  EMPTY_HOWTO (0x5e),
143
  EMPTY_HOWTO (0x5f),
144
  EMPTY_HOWTO (0x60),
145
  EMPTY_HOWTO (0x61),
146
  EMPTY_HOWTO (0x62),
147
  EMPTY_HOWTO (0x63),
148
  EMPTY_HOWTO (0x64),
149
  EMPTY_HOWTO (0x65),
150
  EMPTY_HOWTO (0x66),
151
  EMPTY_HOWTO (0x67),
152
  EMPTY_HOWTO (0x68),
153
  EMPTY_HOWTO (0x69),
154
  EMPTY_HOWTO (0x6a),
155
  EMPTY_HOWTO (0x6b),
156
  EMPTY_HOWTO (0x6c),
157
  EMPTY_HOWTO (0x6d),
158
  EMPTY_HOWTO (0x6e),
159
  EMPTY_HOWTO (0x6f),
160
  EMPTY_HOWTO (0x70),
161
  EMPTY_HOWTO (0x71),
162
  EMPTY_HOWTO (0x72),
163
  EMPTY_HOWTO (0x73),
164
  EMPTY_HOWTO (0x74),
165
  EMPTY_HOWTO (0x75),
166
  EMPTY_HOWTO (0x76),
167
  EMPTY_HOWTO (0x77),
168
 
169
  EMPTY_HOWTO (0x78),
170
  EMPTY_HOWTO (0x79),
171
  EMPTY_HOWTO (0x7a),
172
  EMPTY_HOWTO (0x7b),
173
  EMPTY_HOWTO (0x7c),
174
  EMPTY_HOWTO (0x7d),
175
  EMPTY_HOWTO (0x7e),
176
  EMPTY_HOWTO (0x7f),
177
 
178
  RL78REL (SYM,       2, 32, 0, dont, FALSE),
179
  RL78REL (OPneg,     2, 32, 0, dont, FALSE),
180
  RL78REL (OPadd,     2, 32, 0, dont, FALSE),
181
  RL78REL (OPsub,     2, 32, 0, dont, FALSE),
182
  RL78REL (OPmul,     2, 32, 0, dont, FALSE),
183
  RL78REL (OPdiv,     2, 32, 0, dont, FALSE),
184
  RL78REL (OPshla,    2, 32, 0, dont, FALSE),
185
  RL78REL (OPshra,    2, 32, 0, dont, FALSE),
186
  RL78REL (OPsctsize, 2, 32, 0, dont, FALSE),
187
  EMPTY_HOWTO (0x89),
188
  EMPTY_HOWTO (0x8a),
189
  EMPTY_HOWTO (0x8b),
190
  EMPTY_HOWTO (0x8c),
191
  RL78REL (OPscttop,  2, 32, 0, dont, FALSE),
192
  EMPTY_HOWTO (0x8e),
193
  EMPTY_HOWTO (0x8f),
194
  RL78REL (OPand,     2, 32, 0, dont, FALSE),
195
  RL78REL (OPor,      2, 32, 0, dont, FALSE),
196
  RL78REL (OPxor,     2, 32, 0, dont, FALSE),
197
  RL78REL (OPnot,     2, 32, 0, dont, FALSE),
198
  RL78REL (OPmod,     2, 32, 0, dont, FALSE),
199
  RL78REL (OPromtop,  2, 32, 0, dont, FALSE),
200
  RL78REL (OPramtop,  2, 32, 0, dont, FALSE)
201
};
202
 
203
/* Map BFD reloc types to RL78 ELF reloc types.  */
204
 
205
struct rl78_reloc_map
206
{
207
  bfd_reloc_code_real_type  bfd_reloc_val;
208
  unsigned int              rl78_reloc_val;
209
};
210
 
211
static const struct rl78_reloc_map rl78_reloc_map [] =
212
{
213
  { BFD_RELOC_NONE,             R_RL78_NONE },
214
  { BFD_RELOC_8,                R_RL78_DIR8S },
215
  { BFD_RELOC_16,               R_RL78_DIR16S },
216
  { BFD_RELOC_24,               R_RL78_DIR24S },
217
  { BFD_RELOC_32,               R_RL78_DIR32 },
218
  { BFD_RELOC_RL78_16_OP,       R_RL78_DIR16 },
219
  { BFD_RELOC_RL78_DIR3U_PCREL, R_RL78_DIR3U_PCREL },
220
  { BFD_RELOC_8_PCREL,          R_RL78_DIR8S_PCREL },
221
  { BFD_RELOC_16_PCREL,         R_RL78_DIR16S_PCREL },
222
  { BFD_RELOC_24_PCREL,         R_RL78_DIR24S_PCREL },
223
  { BFD_RELOC_RL78_8U,          R_RL78_DIR8U },
224
  { BFD_RELOC_RL78_16U,         R_RL78_DIR16U },
225
  { BFD_RELOC_RL78_SYM,         R_RL78_SYM },
226
  { BFD_RELOC_RL78_OP_SUBTRACT, R_RL78_OPsub },
227
  { BFD_RELOC_RL78_OP_NEG,      R_RL78_OPneg },
228
  { BFD_RELOC_RL78_OP_AND,      R_RL78_OPand },
229
  { BFD_RELOC_RL78_OP_SHRA,     R_RL78_OPshra },
230
  { BFD_RELOC_RL78_ABS8,        R_RL78_ABS8 },
231
  { BFD_RELOC_RL78_ABS16,       R_RL78_ABS16 },
232
  { BFD_RELOC_RL78_ABS16_REV,   R_RL78_ABS16_REV },
233
  { BFD_RELOC_RL78_ABS32,       R_RL78_ABS32 },
234
  { BFD_RELOC_RL78_ABS32_REV,   R_RL78_ABS32_REV },
235
  { BFD_RELOC_RL78_ABS16UL,     R_RL78_ABS16UL },
236
  { BFD_RELOC_RL78_ABS16UW,     R_RL78_ABS16UW },
237 166 khays
  { BFD_RELOC_RL78_ABS16U,      R_RL78_ABS16U },
238
  { BFD_RELOC_RL78_RELAX,       R_RL78_RH_RELAX }
239 163 khays
};
240
 
241
static reloc_howto_type *
242
rl78_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
243
                        bfd_reloc_code_real_type code)
244
{
245
  unsigned int i;
246
 
247
  if (code == BFD_RELOC_RL78_32_OP)
248
    return rl78_elf_howto_table + R_RL78_DIR32;
249
 
250
  for (i = ARRAY_SIZE (rl78_reloc_map); --i;)
251
    if (rl78_reloc_map [i].bfd_reloc_val == code)
252
      return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
253
 
254
  return NULL;
255
}
256
 
257
static reloc_howto_type *
258
rl78_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
259
{
260
  unsigned int i;
261
 
262
  for (i = 0; i < ARRAY_SIZE (rl78_elf_howto_table); i++)
263
    if (rl78_elf_howto_table[i].name != NULL
264
        && strcasecmp (rl78_elf_howto_table[i].name, r_name) == 0)
265
      return rl78_elf_howto_table + i;
266
 
267
  return NULL;
268
}
269
 
270
/* Set the howto pointer for an RL78 ELF reloc.  */
271
 
272
static void
273
rl78_info_to_howto_rela (bfd *               abfd ATTRIBUTE_UNUSED,
274
                         arelent *           cache_ptr,
275
                         Elf_Internal_Rela * dst)
276
{
277
  unsigned int r_type;
278
 
279
  r_type = ELF32_R_TYPE (dst->r_info);
280
  BFD_ASSERT (r_type < (unsigned int) R_RL78_max);
281
  cache_ptr->howto = rl78_elf_howto_table + r_type;
282
}
283
 
284
static bfd_vma
285
get_symbol_value (const char *            name,
286
                  bfd_reloc_status_type * status,
287
                  struct bfd_link_info *  info,
288
                  bfd *                   input_bfd,
289
                  asection *              input_section,
290
                  int                     offset)
291
{
292
  bfd_vma value = 0;
293
  struct bfd_link_hash_entry * h;
294
 
295
  h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
296
 
297
  if (h == NULL
298
      || (h->type != bfd_link_hash_defined
299
          && h->type != bfd_link_hash_defweak))
300
    * status = info->callbacks->undefined_symbol
301
      (info, name, input_bfd, input_section, offset, TRUE);
302
  else
303
    value = (h->u.def.value
304
             + h->u.def.section->output_section->vma
305
             + h->u.def.section->output_offset);
306
 
307
  return value;
308
}
309
 
310
static bfd_vma
311
get_romstart (bfd_reloc_status_type * status,
312
              struct bfd_link_info *  info,
313
              bfd *                   abfd,
314
              asection *              sec,
315
              int                     offset)
316
{
317
  static bfd_boolean cached = FALSE;
318
  static bfd_vma     cached_value = 0;
319
 
320
  if (!cached)
321
    {
322
      cached_value = get_symbol_value ("_start", status, info, abfd, sec, offset);
323
      cached = TRUE;
324
    }
325
  return cached_value;
326
}
327
 
328
static bfd_vma
329
get_ramstart (bfd_reloc_status_type * status,
330
              struct bfd_link_info *  info,
331
              bfd *                   abfd,
332
              asection *              sec,
333
              int                     offset)
334
{
335
  static bfd_boolean cached = FALSE;
336
  static bfd_vma     cached_value = 0;
337
 
338
  if (!cached)
339
    {
340
      cached_value = get_symbol_value ("__datastart", status, info, abfd, sec, offset);
341
      cached = TRUE;
342
    }
343
  return cached_value;
344
}
345
 
346
#define NUM_STACK_ENTRIES 16
347
static int32_t rl78_stack [ NUM_STACK_ENTRIES ];
348
static unsigned int rl78_stack_top;
349
 
350
#define RL78_STACK_PUSH(val)                    \
351
  do                                            \
352
    {                                           \
353
      if (rl78_stack_top < NUM_STACK_ENTRIES)   \
354
        rl78_stack [rl78_stack_top ++] = (val); \
355
      else                                      \
356
        r = bfd_reloc_dangerous;                \
357
    }                                           \
358
  while (0)
359
 
360
#define RL78_STACK_POP(dest)                    \
361
  do                                            \
362
    {                                           \
363
      if (rl78_stack_top > 0)                    \
364
        (dest) = rl78_stack [-- rl78_stack_top];        \
365
      else                                      \
366
        (dest) = 0, r = bfd_reloc_dangerous;     \
367
    }                                           \
368
  while (0)
369
 
370
/* Relocate an RL78 ELF section.
371
   There is some attempt to make this function usable for many architectures,
372
   both USE_REL and USE_RELA ['twould be nice if such a critter existed],
373
   if only to serve as a learning tool.
374
 
375
   The RELOCATE_SECTION function is called by the new ELF backend linker
376
   to handle the relocations for a section.
377
 
378
   The relocs are always passed as Rela structures; if the section
379
   actually uses Rel structures, the r_addend field will always be
380
   zero.
381
 
382
   This function is responsible for adjusting the section contents as
383
   necessary, and (if using Rela relocs and generating a relocatable
384
   output file) adjusting the reloc addend as necessary.
385
 
386
   This function does not have to worry about setting the reloc
387
   address or the reloc symbol index.
388
 
389
   LOCAL_SYMS is a pointer to the swapped in local symbols.
390
 
391
   LOCAL_SECTIONS is an array giving the section in the input file
392
   corresponding to the st_shndx field of each local symbol.
393
 
394
   The global hash table entry for the global symbols can be found
395
   via elf_sym_hashes (input_bfd).
396
 
397
   When generating relocatable output, this function must handle
398
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
399
   going to be the section symbol corresponding to the output
400
   section, which means that the addend must be adjusted
401
   accordingly.  */
402
 
403
static bfd_boolean
404
rl78_elf_relocate_section
405
    (bfd *                   output_bfd,
406
     struct bfd_link_info *  info,
407
     bfd *                   input_bfd,
408
     asection *              input_section,
409
     bfd_byte *              contents,
410
     Elf_Internal_Rela *     relocs,
411
     Elf_Internal_Sym *      local_syms,
412
     asection **             local_sections)
413
{
414
  Elf_Internal_Shdr *           symtab_hdr;
415
  struct elf_link_hash_entry ** sym_hashes;
416
  Elf_Internal_Rela *           rel;
417
  Elf_Internal_Rela *           relend;
418
  bfd *dynobj;
419
  asection *splt;
420
 
421
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
422
  sym_hashes = elf_sym_hashes (input_bfd);
423
  relend     = relocs + input_section->reloc_count;
424
 
425
  dynobj = elf_hash_table (info)->dynobj;
426
  splt = NULL;
427
  if (dynobj != NULL)
428
    splt = bfd_get_section_by_name (dynobj, ".plt");
429
 
430
  for (rel = relocs; rel < relend; rel ++)
431
    {
432
      reloc_howto_type *           howto;
433
      unsigned long                r_symndx;
434
      Elf_Internal_Sym *           sym;
435
      asection *                   sec;
436
      struct elf_link_hash_entry * h;
437
      bfd_vma                      relocation;
438
      bfd_reloc_status_type        r;
439
      const char *                 name = NULL;
440
      bfd_boolean                  unresolved_reloc = TRUE;
441
      int                          r_type;
442
 
443
      r_type = ELF32_R_TYPE (rel->r_info);
444
      r_symndx = ELF32_R_SYM (rel->r_info);
445
 
446
      howto  = rl78_elf_howto_table + ELF32_R_TYPE (rel->r_info);
447
      h      = NULL;
448
      sym    = NULL;
449
      sec    = NULL;
450
      relocation = 0;
451
 
452
      if (r_symndx < symtab_hdr->sh_info)
453
        {
454
          sym = local_syms + r_symndx;
455
          sec = local_sections [r_symndx];
456
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
457
 
458
          name = bfd_elf_string_from_elf_section
459
            (input_bfd, symtab_hdr->sh_link, sym->st_name);
460
          name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
461
        }
462
      else
463
        {
464
          bfd_boolean warned;
465
 
466
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
467
                                   r_symndx, symtab_hdr, sym_hashes, h,
468
                                   sec, relocation, unresolved_reloc,
469
                                   warned);
470
 
471
          name = h->root.root.string;
472
        }
473
 
474
      if (sec != NULL && elf_discarded_section (sec))
475
        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
476
                                         rel, relend, howto, contents);
477
 
478
      if (info->relocatable)
479
        {
480
          /* This is a relocatable link.  We don't have to change
481
             anything, unless the reloc is against a section symbol,
482
             in which case we have to adjust according to where the
483
             section symbol winds up in the output section.  */
484
          if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
485
            rel->r_addend += sec->output_offset;
486
          continue;
487
        }
488
 
489
      switch (ELF32_R_TYPE (rel->r_info))
490
        {
491
        case R_RL78_DIR16S:
492
          {
493
            bfd_vma *plt_offset;
494
 
495
            if (h != NULL)
496
              plt_offset = &h->plt.offset;
497
            else
498
              plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
499
 
500 166 khays
            if (! valid_16bit_address (relocation))
501 163 khays
              {
502
                /* If this is the first time we've processed this symbol,
503
                   fill in the plt entry with the correct symbol address.  */
504
                if ((*plt_offset & 1) == 0)
505
                  {
506
                    unsigned int x;
507
 
508
                    x = 0x000000ec;  /* br !!abs24 */
509
                    x |= (relocation << 8) & 0xffffff00;
510
                    bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
511
                    *plt_offset |= 1;
512
                  }
513
 
514
                relocation = (splt->output_section->vma
515
                              + splt->output_offset
516
                              + (*plt_offset & -2));
517
                if (name)
518
                {
519
                  char *newname = bfd_malloc (strlen(name)+5);
520
                  strcpy (newname, name);
521
                  strcat(newname, ".plt");
522
                  _bfd_generic_link_add_one_symbol (info,
523
                                                    input_bfd,
524
                                                    newname,
525
                                                    BSF_FUNCTION | BSF_WEAK,
526
                                                    splt,
527
                                                    (*plt_offset & -2),
528
                                                    0,
529
                                                    1,
530
                                                    0,
531
                                                    0);
532
                }
533
              }
534
          }
535
          break;
536
        }
537
 
538
      if (h != NULL && h->root.type == bfd_link_hash_undefweak)
539
        /* If the symbol is undefined and weak
540
           then the relocation resolves to zero.  */
541
        relocation = 0;
542
      else
543
        {
544
          if (howto->pc_relative)
545
            {
546
              relocation -= (input_section->output_section->vma
547
                             + input_section->output_offset
548
                             + rel->r_offset);
549
              relocation -= bfd_get_reloc_size (howto);
550
            }
551
 
552
          relocation += rel->r_addend;
553
        }
554
 
555
      r = bfd_reloc_ok;
556
 
557
#define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
558
#define ALIGN(m)   if (relocation & m) r = bfd_reloc_other;
559
#define OP(i)      (contents[rel->r_offset + (i)])
560
 
561
      /* Opcode relocs are always big endian.  Data relocs are bi-endian.  */
562
      switch (r_type)
563
        {
564
        case R_RL78_NONE:
565
          break;
566
 
567 166 khays
        case R_RL78_RH_RELAX:
568
          break;
569
 
570 163 khays
        case R_RL78_DIR8S_PCREL:
571
          RANGE (-128, 127);
572
          OP (0) = relocation;
573
          break;
574
 
575
        case R_RL78_DIR8S:
576
          RANGE (-128, 255);
577
          OP (0) = relocation;
578
          break;
579
 
580
        case R_RL78_DIR8U:
581
          RANGE (0, 255);
582
          OP (0) = relocation;
583
          break;
584
 
585
        case R_RL78_DIR16S_PCREL:
586
          RANGE (-32768, 32767);
587
          OP (0) = relocation;
588
          OP (1) = relocation >> 8;
589
          break;
590
 
591
        case R_RL78_DIR16S:
592
          if ((relocation & 0xf0000) == 0xf0000)
593
            relocation &= 0xffff;
594
          RANGE (-32768, 65535);
595
          OP (0) = relocation;
596
          OP (1) = relocation >> 8;
597
          break;
598
 
599
        case R_RL78_DIR16U:
600
          RANGE (0, 65536);
601
          OP (0) = relocation;
602
          OP (1) = relocation >> 8;
603
          break;
604
 
605
        case R_RL78_DIR16:
606
          RANGE (-32768, 65536);
607
          OP (0) = relocation;
608
          OP (1) = relocation >> 8;
609
          break;
610
 
611
        case R_RL78_DIR16_REV:
612
          RANGE (-32768, 65536);
613
          OP (1) = relocation;
614
          OP (0) = relocation >> 8;
615
          break;
616
 
617
        case R_RL78_DIR3U_PCREL:
618
          RANGE (3, 10);
619
          OP (0) &= 0xf8;
620
          OP (0) |= relocation & 0x07;
621
          break;
622
 
623
        case R_RL78_DIR24S_PCREL:
624
          RANGE (-0x800000, 0x7fffff);
625
          OP (0) = relocation;
626
          OP (1) = relocation >> 8;
627
          OP (2) = relocation >> 16;
628
          break;
629
 
630
        case R_RL78_DIR24S:
631
          RANGE (-0x800000, 0x7fffff);
632
          OP (0) = relocation;
633
          OP (1) = relocation >> 8;
634
          OP (2) = relocation >> 16;
635
          break;
636
 
637
        case R_RL78_DIR32:
638
          OP (0) = relocation;
639
          OP (1) = relocation >> 8;
640
          OP (2) = relocation >> 16;
641
          OP (3) = relocation >> 24;
642
          break;
643
 
644
        case R_RL78_DIR32_REV:
645
          OP (3) = relocation;
646
          OP (2) = relocation >> 8;
647
          OP (1) = relocation >> 16;
648
          OP (0) = relocation >> 24;
649
          break;
650
 
651 166 khays
        case R_RL78_RH_SFR:
652
          RANGE (0xfff00, 0xfffff);
653
          OP (0) = relocation & 0xff;
654
          break;
655
 
656
        case R_RL78_RH_SADDR:
657
          RANGE (0xffe20, 0xfff1f);
658
          OP (0) = relocation & 0xff;
659
          break;
660
 
661 163 khays
          /* Complex reloc handling:  */
662
 
663
        case R_RL78_ABS32:
664
          RL78_STACK_POP (relocation);
665
          OP (0) = relocation;
666
          OP (1) = relocation >> 8;
667
          OP (2) = relocation >> 16;
668
          OP (3) = relocation >> 24;
669
          break;
670
 
671
        case R_RL78_ABS32_REV:
672
          RL78_STACK_POP (relocation);
673
          OP (3) = relocation;
674
          OP (2) = relocation >> 8;
675
          OP (1) = relocation >> 16;
676
          OP (0) = relocation >> 24;
677
          break;
678
 
679
        case R_RL78_ABS24S_PCREL:
680
        case R_RL78_ABS24S:
681
          RL78_STACK_POP (relocation);
682
          RANGE (-0x800000, 0x7fffff);
683
          OP (0) = relocation;
684
          OP (1) = relocation >> 8;
685
          OP (2) = relocation >> 16;
686
          break;
687
 
688
        case R_RL78_ABS16:
689
          RL78_STACK_POP (relocation);
690
          RANGE (-32768, 65535);
691
          OP (0) = relocation;
692
          OP (1) = relocation >> 8;
693
          break;
694
 
695
        case R_RL78_ABS16_REV:
696
          RL78_STACK_POP (relocation);
697
          RANGE (-32768, 65535);
698
          OP (1) = relocation;
699
          OP (0) = relocation >> 8;
700
          break;
701
 
702
        case R_RL78_ABS16S_PCREL:
703
        case R_RL78_ABS16S:
704
          RL78_STACK_POP (relocation);
705
          RANGE (-32768, 32767);
706
          OP (0) = relocation;
707
          OP (1) = relocation >> 8;
708
          break;
709
 
710
        case R_RL78_ABS16U:
711
          RL78_STACK_POP (relocation);
712
          RANGE (0, 65536);
713
          OP (0) = relocation;
714
          OP (1) = relocation >> 8;
715
          break;
716
 
717
        case R_RL78_ABS16UL:
718
          RL78_STACK_POP (relocation);
719
          relocation >>= 2;
720
          RANGE (0, 65536);
721
          OP (0) = relocation;
722
          OP (1) = relocation >> 8;
723
          break;
724
 
725
        case R_RL78_ABS16UW:
726
          RL78_STACK_POP (relocation);
727
          relocation >>= 1;
728
          RANGE (0, 65536);
729
          OP (0) = relocation;
730
          OP (1) = relocation >> 8;
731
          break;
732
 
733
        case R_RL78_ABS8:
734
          RL78_STACK_POP (relocation);
735
          RANGE (-128, 255);
736
          OP (0) = relocation;
737
          break;
738
 
739
        case R_RL78_ABS8U:
740
          RL78_STACK_POP (relocation);
741
          RANGE (0, 255);
742
          OP (0) = relocation;
743
          break;
744
 
745
        case R_RL78_ABS8UL:
746
          RL78_STACK_POP (relocation);
747
          relocation >>= 2;
748
          RANGE (0, 255);
749
          OP (0) = relocation;
750
          break;
751
 
752
        case R_RL78_ABS8UW:
753
          RL78_STACK_POP (relocation);
754
          relocation >>= 1;
755
          RANGE (0, 255);
756
          OP (0) = relocation;
757
          break;
758
 
759
        case R_RL78_ABS8S_PCREL:
760
        case R_RL78_ABS8S:
761
          RL78_STACK_POP (relocation);
762
          RANGE (-128, 127);
763
          OP (0) = relocation;
764
          break;
765
 
766
        case R_RL78_SYM:
767
          if (r_symndx < symtab_hdr->sh_info)
768
            RL78_STACK_PUSH (sec->output_section->vma
769
                           + sec->output_offset
770
                           + sym->st_value
771
                           + rel->r_addend);
772
          else
773
            {
774
              if (h != NULL
775
                  && (h->root.type == bfd_link_hash_defined
776
                      || h->root.type == bfd_link_hash_defweak))
777
                RL78_STACK_PUSH (h->root.u.def.value
778
                               + sec->output_section->vma
779
                               + sec->output_offset
780
                               + rel->r_addend);
781
              else
782
                _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
783
            }
784
          break;
785
 
786
        case R_RL78_OPneg:
787
          {
788
            int32_t tmp;
789
 
790
            RL78_STACK_POP (tmp);
791
            tmp = - tmp;
792
            RL78_STACK_PUSH (tmp);
793
          }
794
          break;
795
 
796
        case R_RL78_OPadd:
797
          {
798
            int32_t tmp1, tmp2;
799
 
800
            RL78_STACK_POP (tmp2);
801
            RL78_STACK_POP (tmp1);
802
            tmp1 += tmp2;
803
            RL78_STACK_PUSH (tmp1);
804
          }
805
          break;
806
 
807
        case R_RL78_OPsub:
808
          {
809
            int32_t tmp1, tmp2;
810
 
811
            RL78_STACK_POP (tmp2);
812
            RL78_STACK_POP (tmp1);
813
            tmp2 -= tmp1;
814
            RL78_STACK_PUSH (tmp2);
815
          }
816
          break;
817
 
818
        case R_RL78_OPmul:
819
          {
820
            int32_t tmp1, tmp2;
821
 
822
            RL78_STACK_POP (tmp2);
823
            RL78_STACK_POP (tmp1);
824
            tmp1 *= tmp2;
825
            RL78_STACK_PUSH (tmp1);
826
          }
827
          break;
828
 
829
        case R_RL78_OPdiv:
830
          {
831
            int32_t tmp1, tmp2;
832
 
833
            RL78_STACK_POP (tmp2);
834
            RL78_STACK_POP (tmp1);
835
            tmp1 /= tmp2;
836
            RL78_STACK_PUSH (tmp1);
837
          }
838
          break;
839
 
840
        case R_RL78_OPshla:
841
          {
842
            int32_t tmp1, tmp2;
843
 
844
            RL78_STACK_POP (tmp2);
845
            RL78_STACK_POP (tmp1);
846
            tmp1 <<= tmp2;
847
            RL78_STACK_PUSH (tmp1);
848
          }
849
          break;
850
 
851
        case R_RL78_OPshra:
852
          {
853
            int32_t tmp1, tmp2;
854
 
855
            RL78_STACK_POP (tmp2);
856
            RL78_STACK_POP (tmp1);
857
            tmp1 >>= tmp2;
858
            RL78_STACK_PUSH (tmp1);
859
          }
860
          break;
861
 
862
        case R_RL78_OPsctsize:
863
          RL78_STACK_PUSH (input_section->size);
864
          break;
865
 
866
        case R_RL78_OPscttop:
867
          RL78_STACK_PUSH (input_section->output_section->vma);
868
          break;
869
 
870
        case R_RL78_OPand:
871
          {
872
            int32_t tmp1, tmp2;
873
 
874
            RL78_STACK_POP (tmp2);
875
            RL78_STACK_POP (tmp1);
876
            tmp1 &= tmp2;
877
            RL78_STACK_PUSH (tmp1);
878
          }
879
          break;
880
 
881
        case R_RL78_OPor:
882
          {
883
            int32_t tmp1, tmp2;
884
 
885
            RL78_STACK_POP (tmp2);
886
            RL78_STACK_POP (tmp1);
887
            tmp1 |= tmp2;
888
            RL78_STACK_PUSH (tmp1);
889
          }
890
          break;
891
 
892
        case R_RL78_OPxor:
893
          {
894
            int32_t tmp1, tmp2;
895
 
896
            RL78_STACK_POP (tmp2);
897
            RL78_STACK_POP (tmp1);
898
            tmp1 ^= tmp2;
899
            RL78_STACK_PUSH (tmp1);
900
          }
901
          break;
902
 
903
        case R_RL78_OPnot:
904
          {
905
            int32_t tmp;
906
 
907
            RL78_STACK_POP (tmp);
908
            tmp = ~ tmp;
909
            RL78_STACK_PUSH (tmp);
910
          }
911
          break;
912
 
913
        case R_RL78_OPmod:
914
          {
915
            int32_t tmp1, tmp2;
916
 
917
            RL78_STACK_POP (tmp2);
918
            RL78_STACK_POP (tmp1);
919
            tmp1 %= tmp2;
920
            RL78_STACK_PUSH (tmp1);
921
          }
922
          break;
923
 
924
        case R_RL78_OPromtop:
925
          RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
926
          break;
927
 
928
        case R_RL78_OPramtop:
929
          RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
930
          break;
931
 
932
        default:
933
          r = bfd_reloc_notsupported;
934
          break;
935
        }
936
 
937
      if (r != bfd_reloc_ok)
938
        {
939
          const char * msg = NULL;
940
 
941
          switch (r)
942
            {
943
            case bfd_reloc_overflow:
944
              /* Catch the case of a missing function declaration
945
                 and emit a more helpful error message.  */
946
              if (r_type == R_RL78_DIR24S_PCREL)
947
                msg = _("%B(%A): error: call to undefined function '%s'");
948
              else
949
                r = info->callbacks->reloc_overflow
950
                  (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
951
                   input_bfd, input_section, rel->r_offset);
952
              break;
953
 
954
            case bfd_reloc_undefined:
955
              r = info->callbacks->undefined_symbol
956
                (info, name, input_bfd, input_section, rel->r_offset,
957
                 TRUE);
958
              break;
959
 
960
            case bfd_reloc_other:
961
              msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
962
              break;
963
 
964
            case bfd_reloc_outofrange:
965
              msg = _("%B(%A): internal error: out of range error");
966
              break;
967
 
968
            case bfd_reloc_notsupported:
969
              msg = _("%B(%A): internal error: unsupported relocation error");
970
              break;
971
 
972
            case bfd_reloc_dangerous:
973
              msg = _("%B(%A): internal error: dangerous relocation");
974
              break;
975
 
976
            default:
977
              msg = _("%B(%A): internal error: unknown error");
978
              break;
979
            }
980
 
981
          if (msg)
982
            _bfd_error_handler (msg, input_bfd, input_section, name);
983
 
984
          if (! r)
985
            return FALSE;
986
        }
987
    }
988
 
989
  return TRUE;
990
}
991
 
992
/* Function to set the ELF flag bits.  */
993
 
994
static bfd_boolean
995
rl78_elf_set_private_flags (bfd * abfd, flagword flags)
996
{
997
  elf_elfheader (abfd)->e_flags = flags;
998
  elf_flags_init (abfd) = TRUE;
999
  return TRUE;
1000
}
1001
 
1002
static bfd_boolean no_warn_mismatch = FALSE;
1003
 
1004
void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1005
 
1006
void
1007
bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1008
{
1009
  no_warn_mismatch = user_no_warn_mismatch;
1010
}
1011
 
1012
/* Merge backend specific data from an object file to the output
1013
   object file when linking.  */
1014
 
1015
static bfd_boolean
1016
rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1017
{
1018
  flagword new_flags;
1019
  bfd_boolean error = FALSE;
1020
 
1021
  new_flags = elf_elfheader (ibfd)->e_flags;
1022
 
1023
  if (!elf_flags_init (obfd))
1024
    {
1025
      /* First call, no flags set.  */
1026
      elf_flags_init (obfd) = TRUE;
1027
      elf_elfheader (obfd)->e_flags = new_flags;
1028
    }
1029
 
1030
  return !error;
1031
}
1032
 
1033
static bfd_boolean
1034
rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1035
{
1036
  FILE * file = (FILE *) ptr;
1037
  flagword flags;
1038
 
1039
  BFD_ASSERT (abfd != NULL && ptr != NULL);
1040
 
1041
  /* Print normal ELF private data.  */
1042
  _bfd_elf_print_private_bfd_data (abfd, ptr);
1043
 
1044
  flags = elf_elfheader (abfd)->e_flags;
1045
  fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1046
 
1047
  fputc ('\n', file);
1048
  return TRUE;
1049
}
1050
 
1051
/* Return the MACH for an e_flags value.  */
1052
 
1053
static int
1054
elf32_rl78_machine (bfd * abfd)
1055
{
1056
  if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
1057
    return bfd_mach_rl78;
1058
 
1059
  return 0;
1060
}
1061
 
1062
static bfd_boolean
1063
rl78_elf_object_p (bfd * abfd)
1064
{
1065
  bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1066
                             elf32_rl78_machine (abfd));
1067
  return TRUE;
1068
}
1069
 
1070
#ifdef DEBUG
1071
void
1072
rl78_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
1073
{
1074
  size_t locsymcount;
1075
  Elf_Internal_Sym * isymbuf;
1076
  Elf_Internal_Sym * isymend;
1077
  Elf_Internal_Sym * isym;
1078
  Elf_Internal_Shdr * symtab_hdr;
1079
  bfd_boolean free_internal = FALSE, free_external = FALSE;
1080
  char * st_info_str;
1081
  char * st_info_stb_str;
1082
  char * st_other_str;
1083
  char * st_shndx_str;
1084
 
1085
  if (! internal_syms)
1086
    {
1087
      internal_syms = bfd_malloc (1000);
1088
      free_internal = 1;
1089
    }
1090
  if (! external_syms)
1091
    {
1092
      external_syms = bfd_malloc (1000);
1093
      free_external = 1;
1094
    }
1095
 
1096
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1097
  locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
1098
  if (free_internal)
1099
    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1100
                                    symtab_hdr->sh_info, 0,
1101
                                    internal_syms, external_syms, NULL);
1102
  else
1103
    isymbuf = internal_syms;
1104
  isymend = isymbuf + locsymcount;
1105
 
1106
  for (isym = isymbuf ; isym < isymend ; isym++)
1107
    {
1108
      switch (ELF_ST_TYPE (isym->st_info))
1109
        {
1110
        case STT_FUNC: st_info_str = "STT_FUNC";
1111
        case STT_SECTION: st_info_str = "STT_SECTION";
1112
        case STT_FILE: st_info_str = "STT_FILE";
1113
        case STT_OBJECT: st_info_str = "STT_OBJECT";
1114
        case STT_TLS: st_info_str = "STT_TLS";
1115
        default: st_info_str = "";
1116
        }
1117
      switch (ELF_ST_BIND (isym->st_info))
1118
        {
1119
        case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
1120
        case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
1121
        default: st_info_stb_str = "";
1122
        }
1123
      switch (ELF_ST_VISIBILITY (isym->st_other))
1124
        {
1125
        case STV_DEFAULT: st_other_str = "STV_DEFAULT";
1126
        case STV_INTERNAL: st_other_str = "STV_INTERNAL";
1127
        case STV_PROTECTED: st_other_str = "STV_PROTECTED";
1128
        default: st_other_str = "";
1129
        }
1130
      switch (isym->st_shndx)
1131
        {
1132
        case SHN_ABS: st_shndx_str = "SHN_ABS";
1133
        case SHN_COMMON: st_shndx_str = "SHN_COMMON";
1134
        case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
1135
        default: st_shndx_str = "";
1136
        }
1137
    }
1138
  if (free_internal)
1139
    free (internal_syms);
1140
  if (free_external)
1141
    free (external_syms);
1142
}
1143
 
1144
char *
1145
rl78_get_reloc (long reloc)
1146
{
1147
  if (0 <= reloc && reloc < R_RL78_max)
1148
    return rl78_elf_howto_table[reloc].name;
1149
  return "";
1150
}
1151
#endif /* DEBUG */
1152
 
1153
 
1154
/* support PLT for 16-bit references to 24-bit functions.  */
1155
 
1156
/* We support 16-bit pointers to code above 64k by generating a thunk
1157
   below 64k containing a JMP instruction to the final address.  */
1158
 
1159
static bfd_boolean
1160
rl78_elf_check_relocs
1161
    (bfd *                     abfd,
1162
     struct bfd_link_info *    info,
1163
     asection *                sec,
1164
     const Elf_Internal_Rela * relocs)
1165
{
1166
  Elf_Internal_Shdr *           symtab_hdr;
1167
  struct elf_link_hash_entry ** sym_hashes;
1168
  const Elf_Internal_Rela *     rel;
1169
  const Elf_Internal_Rela *     rel_end;
1170
  bfd_vma *local_plt_offsets;
1171
  asection *splt;
1172
  bfd *dynobj;
1173
 
1174
  if (info->relocatable)
1175
    return TRUE;
1176
 
1177
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1178
  sym_hashes = elf_sym_hashes (abfd);
1179
  local_plt_offsets = elf_local_got_offsets (abfd);
1180
  splt = NULL;
1181
  dynobj = elf_hash_table(info)->dynobj;
1182
 
1183
  rel_end = relocs + sec->reloc_count;
1184
  for (rel = relocs; rel < rel_end; rel++)
1185
    {
1186
      struct elf_link_hash_entry *h;
1187
      unsigned long r_symndx;
1188
      bfd_vma *offset;
1189
 
1190
      r_symndx = ELF32_R_SYM (rel->r_info);
1191
      if (r_symndx < symtab_hdr->sh_info)
1192
        h = NULL;
1193
      else
1194
        {
1195
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1196
          while (h->root.type == bfd_link_hash_indirect
1197
                 || h->root.type == bfd_link_hash_warning)
1198
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1199
        }
1200
 
1201
      switch (ELF32_R_TYPE (rel->r_info))
1202
        {
1203
          /* This relocation describes a 16-bit pointer to a function.
1204
             We may need to allocate a thunk in low memory; reserve memory
1205
             for it now.  */
1206
        case R_RL78_DIR16S:
1207
          if (dynobj == NULL)
1208
            elf_hash_table (info)->dynobj = dynobj = abfd;
1209
          if (splt == NULL)
1210
            {
1211
              splt = bfd_get_section_by_name (dynobj, ".plt");
1212
              if (splt == NULL)
1213
                {
1214
                  flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1215
                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
1216
                                    | SEC_READONLY | SEC_CODE);
1217
                  splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
1218
                  if (splt == NULL
1219
                      || ! bfd_set_section_alignment (dynobj, splt, 1))
1220
                    return FALSE;
1221
                }
1222
            }
1223
 
1224
          if (h != NULL)
1225
            offset = &h->plt.offset;
1226
          else
1227
            {
1228
              if (local_plt_offsets == NULL)
1229
                {
1230
                  size_t size;
1231
                  unsigned int i;
1232
 
1233
                  size = symtab_hdr->sh_info * sizeof (bfd_vma);
1234
                  local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1235
                  if (local_plt_offsets == NULL)
1236
                    return FALSE;
1237
                  elf_local_got_offsets (abfd) = local_plt_offsets;
1238
 
1239
                  for (i = 0; i < symtab_hdr->sh_info; i++)
1240
                    local_plt_offsets[i] = (bfd_vma) -1;
1241
                }
1242
              offset = &local_plt_offsets[r_symndx];
1243
            }
1244
 
1245
          if (*offset == (bfd_vma) -1)
1246
            {
1247
              *offset = splt->size;
1248
              splt->size += 4;
1249
            }
1250
          break;
1251
        }
1252
    }
1253
 
1254
  return TRUE;
1255
}
1256
 
1257
/* This must exist if dynobj is ever set.  */
1258
 
1259
static bfd_boolean
1260
rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1261
                                  struct bfd_link_info *info)
1262
{
1263
  bfd *dynobj;
1264
  asection *splt;
1265
 
1266 166 khays
  /* As an extra sanity check, verify that all plt entries have been
1267
     filled in.  However, relaxing might have changed the relocs so
1268
     that some plt entries don't get filled in, so we have to skip
1269
     this check if we're relaxing.  Unfortunately, check_relocs is
1270
     called before relaxation.  */
1271 163 khays
 
1272 166 khays
  if (info->relax_trip > 0)
1273 163 khays
    {
1274 166 khays
      if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1275
          && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
1276 163 khays
        {
1277 166 khays
          bfd_byte *contents = splt->contents;
1278
          unsigned int i, size = splt->size;
1279
          for (i = 0; i < size; i += 4)
1280
            {
1281
              unsigned int x = bfd_get_32 (dynobj, contents + i);
1282
              BFD_ASSERT (x != 0);
1283
            }
1284 163 khays
        }
1285
    }
1286
 
1287
  return TRUE;
1288
}
1289
 
1290
static bfd_boolean
1291
rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1292
                               struct bfd_link_info *info)
1293
{
1294
  bfd *dynobj;
1295
  asection *splt;
1296
 
1297
  if (info->relocatable)
1298
    return TRUE;
1299
 
1300
  dynobj = elf_hash_table (info)->dynobj;
1301
  if (dynobj == NULL)
1302
    return TRUE;
1303
 
1304
  splt = bfd_get_section_by_name (dynobj, ".plt");
1305
  BFD_ASSERT (splt != NULL);
1306
 
1307
  splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1308
  if (splt->contents == NULL)
1309
    return FALSE;
1310
 
1311
  return TRUE;
1312
}
1313
 
1314
 
1315
 
1316
/* Handle relaxing.  */
1317
 
1318
/* A subroutine of rl78_elf_relax_section.  If the global symbol H
1319
   is within the low 64k, remove any entry for it in the plt.  */
1320
 
1321
struct relax_plt_data
1322
{
1323
  asection *splt;
1324
  bfd_boolean *again;
1325
};
1326
 
1327
static bfd_boolean
1328
rl78_relax_plt_check (struct elf_link_hash_entry *h,
1329
                      PTR xdata)
1330
{
1331
  struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1332
 
1333
  if (h->plt.offset != (bfd_vma) -1)
1334
    {
1335
      bfd_vma address;
1336
 
1337
      if (h->root.type == bfd_link_hash_undefined
1338
          || h->root.type == bfd_link_hash_undefweak)
1339
        address = 0;
1340
      else
1341
        address = (h->root.u.def.section->output_section->vma
1342
                   + h->root.u.def.section->output_offset
1343
                   + h->root.u.def.value);
1344
 
1345
      if (valid_16bit_address (address))
1346
        {
1347
          h->plt.offset = -1;
1348
          data->splt->size -= 4;
1349
          *data->again = TRUE;
1350
        }
1351
    }
1352
 
1353
  return TRUE;
1354
}
1355
 
1356
/* A subroutine of rl78_elf_relax_section.  If the global symbol H
1357
   previously had a plt entry, give it a new entry offset.  */
1358
 
1359
static bfd_boolean
1360
rl78_relax_plt_realloc (struct elf_link_hash_entry *h,
1361
                        PTR xdata)
1362
{
1363
  bfd_vma *entry = (bfd_vma *) xdata;
1364
 
1365
  if (h->plt.offset != (bfd_vma) -1)
1366
    {
1367
      h->plt.offset = *entry;
1368
      *entry += 4;
1369
    }
1370
 
1371
  return TRUE;
1372
}
1373
 
1374
static bfd_boolean
1375
rl78_elf_relax_plt_section (bfd *dynobj,
1376
                            asection *splt,
1377
                            struct bfd_link_info *info,
1378
                            bfd_boolean *again)
1379
{
1380
  struct relax_plt_data relax_plt_data;
1381
  bfd *ibfd;
1382
 
1383
  /* Assume nothing changes.  */
1384
  *again = FALSE;
1385
 
1386
  if (info->relocatable)
1387
    return TRUE;
1388
 
1389
  /* We only relax the .plt section at the moment.  */
1390
  if (dynobj != elf_hash_table (info)->dynobj
1391
      || strcmp (splt->name, ".plt") != 0)
1392
    return TRUE;
1393
 
1394
  /* Quick check for an empty plt.  */
1395
  if (splt->size == 0)
1396
    return TRUE;
1397
 
1398
  /* Map across all global symbols; see which ones happen to
1399
     fall in the low 64k.  */
1400
  relax_plt_data.splt = splt;
1401
  relax_plt_data.again = again;
1402
  elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1403
                          &relax_plt_data);
1404
 
1405
  /* Likewise for local symbols, though that's somewhat less convenient
1406
     as we have to walk the list of input bfds and swap in symbol data.  */
1407
  for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1408
    {
1409
      bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1410
      Elf_Internal_Shdr *symtab_hdr;
1411
      Elf_Internal_Sym *isymbuf = NULL;
1412
      unsigned int idx;
1413
 
1414
      if (! local_plt_offsets)
1415
        continue;
1416
 
1417
      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1418
      if (symtab_hdr->sh_info != 0)
1419
        {
1420
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1421
          if (isymbuf == NULL)
1422
            isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1423
                                            symtab_hdr->sh_info, 0,
1424
                                            NULL, NULL, NULL);
1425
          if (isymbuf == NULL)
1426
            return FALSE;
1427
        }
1428
 
1429
      for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1430
        {
1431
          Elf_Internal_Sym *isym;
1432
          asection *tsec;
1433
          bfd_vma address;
1434
 
1435
          if (local_plt_offsets[idx] == (bfd_vma) -1)
1436
            continue;
1437
 
1438
          isym = &isymbuf[idx];
1439
          if (isym->st_shndx == SHN_UNDEF)
1440
            continue;
1441
          else if (isym->st_shndx == SHN_ABS)
1442
            tsec = bfd_abs_section_ptr;
1443
          else if (isym->st_shndx == SHN_COMMON)
1444
            tsec = bfd_com_section_ptr;
1445
          else
1446
            tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1447
 
1448
          address = (tsec->output_section->vma
1449
                     + tsec->output_offset
1450
                     + isym->st_value);
1451
          if (valid_16bit_address (address))
1452
            {
1453
              local_plt_offsets[idx] = -1;
1454
              splt->size -= 4;
1455
              *again = TRUE;
1456
            }
1457
        }
1458
 
1459
      if (isymbuf != NULL
1460
          && symtab_hdr->contents != (unsigned char *) isymbuf)
1461
        {
1462
          if (! info->keep_memory)
1463
            free (isymbuf);
1464
          else
1465
            {
1466
              /* Cache the symbols for elf_link_input_bfd.  */
1467
              symtab_hdr->contents = (unsigned char *) isymbuf;
1468
            }
1469
        }
1470
    }
1471
 
1472
  /* If we changed anything, walk the symbols again to reallocate
1473
     .plt entry addresses.  */
1474
  if (*again && splt->size > 0)
1475
    {
1476
      bfd_vma entry = 0;
1477
 
1478
      elf_link_hash_traverse (elf_hash_table (info),
1479
                              rl78_relax_plt_realloc, &entry);
1480
 
1481
      for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1482
        {
1483
          bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1484
          unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1485
          unsigned int idx;
1486
 
1487
          if (! local_plt_offsets)
1488
            continue;
1489
 
1490
          for (idx = 0; idx < nlocals; ++idx)
1491
            if (local_plt_offsets[idx] != (bfd_vma) -1)
1492
              {
1493
                local_plt_offsets[idx] = entry;
1494
                entry += 4;
1495
              }
1496
        }
1497
    }
1498
 
1499
  return TRUE;
1500
}
1501
 
1502 166 khays
/* Delete some bytes from a section while relaxing.  */
1503
 
1504 163 khays
static bfd_boolean
1505 166 khays
elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1506
                             Elf_Internal_Rela *alignment_rel, int force_snip)
1507
{
1508
  Elf_Internal_Shdr * symtab_hdr;
1509
  unsigned int        sec_shndx;
1510
  bfd_byte *          contents;
1511
  Elf_Internal_Rela * irel;
1512
  Elf_Internal_Rela * irelend;
1513
  Elf_Internal_Sym *  isym;
1514
  Elf_Internal_Sym *  isymend;
1515
  bfd_vma             toaddr;
1516
  unsigned int        symcount;
1517
  struct elf_link_hash_entry ** sym_hashes;
1518
  struct elf_link_hash_entry ** end_hashes;
1519
 
1520
  if (!alignment_rel)
1521
    force_snip = 1;
1522
 
1523
  sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1524
 
1525
  contents = elf_section_data (sec)->this_hdr.contents;
1526
 
1527
  /* The deletion must stop at the next alignment boundary, if
1528
     ALIGNMENT_REL is non-NULL.  */
1529
  toaddr = sec->size;
1530
  if (alignment_rel)
1531
    toaddr = alignment_rel->r_offset;
1532
 
1533
  irel = elf_section_data (sec)->relocs;
1534
  irelend = irel + sec->reloc_count;
1535
 
1536
  /* Actually delete the bytes.  */
1537
  memmove (contents + addr, contents + addr + count,
1538
           (size_t) (toaddr - addr - count));
1539
 
1540
  /* If we don't have an alignment marker to worry about, we can just
1541
     shrink the section.  Otherwise, we have to fill in the newly
1542
     created gap with NOP insns (0x03).  */
1543
  if (force_snip)
1544
    sec->size -= count;
1545
  else
1546
    memset (contents + toaddr - count, 0x03, count);
1547
 
1548
  /* Adjust all the relocs.  */
1549
  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1550
    {
1551
      /* Get the new reloc address.  */
1552
      if (irel->r_offset > addr
1553
          && (irel->r_offset < toaddr
1554
              || (force_snip && irel->r_offset == toaddr)))
1555
        irel->r_offset -= count;
1556
 
1557
      /* If we see an ALIGN marker at the end of the gap, we move it
1558
         to the beginning of the gap, since marking these gaps is what
1559
         they're for.  */
1560
      if (irel->r_offset == toaddr
1561
          && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1562
          && irel->r_addend & RL78_RELAXA_ALIGN)
1563
        irel->r_offset -= count;
1564
    }
1565
 
1566
  /* Adjust the local symbols defined in this section.  */
1567
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1568
  isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1569
  isymend = isym + symtab_hdr->sh_info;
1570
 
1571
  for (; isym < isymend; isym++)
1572
    {
1573
      /* If the symbol is in the range of memory we just moved, we
1574
         have to adjust its value.  */
1575
      if (isym->st_shndx == sec_shndx
1576
          && isym->st_value > addr
1577
          && isym->st_value < toaddr)
1578
        isym->st_value -= count;
1579
 
1580
      /* If the symbol *spans* the bytes we just deleted (i.e. it's
1581
         *end* is in the moved bytes but it's *start* isn't), then we
1582
         must adjust its size.  */
1583
      if (isym->st_shndx == sec_shndx
1584
          && isym->st_value < addr
1585
          && isym->st_value + isym->st_size > addr
1586
          && isym->st_value + isym->st_size < toaddr)
1587
        isym->st_size -= count;
1588
    }
1589
 
1590
  /* Now adjust the global symbols defined in this section.  */
1591
  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1592
              - symtab_hdr->sh_info);
1593
  sym_hashes = elf_sym_hashes (abfd);
1594
  end_hashes = sym_hashes + symcount;
1595
 
1596
  for (; sym_hashes < end_hashes; sym_hashes++)
1597
    {
1598
      struct elf_link_hash_entry *sym_hash = *sym_hashes;
1599
 
1600
      if ((sym_hash->root.type == bfd_link_hash_defined
1601
           || sym_hash->root.type == bfd_link_hash_defweak)
1602
          && sym_hash->root.u.def.section == sec)
1603
        {
1604
          /* As above, adjust the value if needed.  */
1605
          if (sym_hash->root.u.def.value > addr
1606
              && sym_hash->root.u.def.value < toaddr)
1607
            sym_hash->root.u.def.value -= count;
1608
 
1609
          /* As above, adjust the size if needed.  */
1610
          if (sym_hash->root.u.def.value < addr
1611
              && sym_hash->root.u.def.value + sym_hash->size > addr
1612
              && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1613
            sym_hash->size -= count;
1614
        }
1615
    }
1616
 
1617
  return TRUE;
1618
}
1619
 
1620
/* Used to sort relocs by address.  If relocs have the same address,
1621
   we maintain their relative order, except that R_RL78_RH_RELAX
1622
   alignment relocs must be the first reloc for any given address.  */
1623
 
1624
static void
1625
reloc_bubblesort (Elf_Internal_Rela * r, int count)
1626
{
1627
  int i;
1628
  bfd_boolean again;
1629
  bfd_boolean swappit;
1630
 
1631
  /* This is almost a classic bubblesort.  It's the slowest sort, but
1632
     we're taking advantage of the fact that the relocations are
1633
     mostly in order already (the assembler emits them that way) and
1634
     we need relocs with the same address to remain in the same
1635
     relative order.  */
1636
  again = TRUE;
1637
  while (again)
1638
    {
1639
      again = FALSE;
1640
      for (i = 0; i < count - 1; i ++)
1641
        {
1642
          if (r[i].r_offset > r[i + 1].r_offset)
1643
            swappit = TRUE;
1644
          else if (r[i].r_offset < r[i + 1].r_offset)
1645
            swappit = FALSE;
1646
          else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1647
                   && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1648
            swappit = TRUE;
1649
          else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1650
                   && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1651
                   && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1652
                        && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1653
            swappit = TRUE;
1654
          else
1655
            swappit = FALSE;
1656
 
1657
          if (swappit)
1658
            {
1659
              Elf_Internal_Rela tmp;
1660
 
1661
              tmp = r[i];
1662
              r[i] = r[i + 1];
1663
              r[i + 1] = tmp;
1664
              /* If we do move a reloc back, re-scan to see if it
1665
                 needs to be moved even further back.  This avoids
1666
                 most of the O(n^2) behavior for our cases.  */
1667
              if (i > 0)
1668
                i -= 2;
1669
              again = TRUE;
1670
            }
1671
        }
1672
    }
1673
}
1674
 
1675
 
1676
#define OFFSET_FOR_RELOC(rel, lrel, scale) \
1677
  rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1678
                       lrel, abfd, sec, link_info, scale)
1679
 
1680
static bfd_vma
1681
rl78_offset_for_reloc (bfd *                    abfd,
1682
                     Elf_Internal_Rela *      rel,
1683
                     Elf_Internal_Shdr *      symtab_hdr,
1684
                     Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1685
                     Elf_Internal_Sym *       intsyms,
1686
                     Elf_Internal_Rela **     lrel,
1687
                     bfd *                    input_bfd,
1688
                     asection *               input_section,
1689
                     struct bfd_link_info *   info,
1690
                     int *                    scale)
1691
{
1692
  bfd_vma symval;
1693
  bfd_reloc_status_type r;
1694
 
1695
  *scale = 1;
1696
 
1697
  /* REL is the first of 1..N relocations.  We compute the symbol
1698
     value for each relocation, then combine them if needed.  LREL
1699
     gets a pointer to the last relocation used.  */
1700
  while (1)
1701
    {
1702
      int32_t tmp1, tmp2;
1703
 
1704
      /* Get the value of the symbol referred to by the reloc.  */
1705
      if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1706
        {
1707
          /* A local symbol.  */
1708
          Elf_Internal_Sym *isym;
1709
          asection *ssec;
1710
 
1711
          isym = intsyms + ELF32_R_SYM (rel->r_info);
1712
 
1713
          if (isym->st_shndx == SHN_UNDEF)
1714
            ssec = bfd_und_section_ptr;
1715
          else if (isym->st_shndx == SHN_ABS)
1716
            ssec = bfd_abs_section_ptr;
1717
          else if (isym->st_shndx == SHN_COMMON)
1718
            ssec = bfd_com_section_ptr;
1719
          else
1720
            ssec = bfd_section_from_elf_index (abfd,
1721
                                               isym->st_shndx);
1722
 
1723
          /* Initial symbol value.  */
1724
          symval = isym->st_value;
1725
 
1726
          /* GAS may have made this symbol relative to a section, in
1727
             which case, we have to add the addend to find the
1728
             symbol.  */
1729
          if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1730
            symval += rel->r_addend;
1731
 
1732
          if (ssec)
1733
            {
1734
              if ((ssec->flags & SEC_MERGE)
1735
                  && ssec->sec_info_type == ELF_INFO_TYPE_MERGE)
1736
                symval = _bfd_merged_section_offset (abfd, & ssec,
1737
                                                     elf_section_data (ssec)->sec_info,
1738
                                                     symval);
1739
            }
1740
 
1741
          /* Now make the offset relative to where the linker is putting it.  */
1742
          if (ssec)
1743
            symval +=
1744
              ssec->output_section->vma + ssec->output_offset;
1745
 
1746
          symval += rel->r_addend;
1747
        }
1748
      else
1749
        {
1750
          unsigned long indx;
1751
          struct elf_link_hash_entry * h;
1752
 
1753
          /* An external symbol.  */
1754
          indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1755
          h = elf_sym_hashes (abfd)[indx];
1756
          BFD_ASSERT (h != NULL);
1757
 
1758
          if (h->root.type != bfd_link_hash_defined
1759
              && h->root.type != bfd_link_hash_defweak)
1760
            {
1761
              /* This appears to be a reference to an undefined
1762
                 symbol.  Just ignore it--it will be caught by the
1763
                 regular reloc processing.  */
1764
              if (lrel)
1765
                *lrel = rel;
1766
              return 0;
1767
            }
1768
 
1769
          symval = (h->root.u.def.value
1770
                    + h->root.u.def.section->output_section->vma
1771
                    + h->root.u.def.section->output_offset);
1772
 
1773
          symval += rel->r_addend;
1774
        }
1775
 
1776
      switch (ELF32_R_TYPE (rel->r_info))
1777
        {
1778
        case R_RL78_SYM:
1779
          RL78_STACK_PUSH (symval);
1780
          break;
1781
 
1782
        case R_RL78_OPneg:
1783
          RL78_STACK_POP (tmp1);
1784
          tmp1 = - tmp1;
1785
          RL78_STACK_PUSH (tmp1);
1786
          break;
1787
 
1788
        case R_RL78_OPadd:
1789
          RL78_STACK_POP (tmp1);
1790
          RL78_STACK_POP (tmp2);
1791
          tmp1 += tmp2;
1792
          RL78_STACK_PUSH (tmp1);
1793
          break;
1794
 
1795
        case R_RL78_OPsub:
1796
          RL78_STACK_POP (tmp1);
1797
          RL78_STACK_POP (tmp2);
1798
          tmp2 -= tmp1;
1799
          RL78_STACK_PUSH (tmp2);
1800
          break;
1801
 
1802
        case R_RL78_OPmul:
1803
          RL78_STACK_POP (tmp1);
1804
          RL78_STACK_POP (tmp2);
1805
          tmp1 *= tmp2;
1806
          RL78_STACK_PUSH (tmp1);
1807
          break;
1808
 
1809
        case R_RL78_OPdiv:
1810
          RL78_STACK_POP (tmp1);
1811
          RL78_STACK_POP (tmp2);
1812
          tmp1 /= tmp2;
1813
          RL78_STACK_PUSH (tmp1);
1814
          break;
1815
 
1816
        case R_RL78_OPshla:
1817
          RL78_STACK_POP (tmp1);
1818
          RL78_STACK_POP (tmp2);
1819
          tmp1 <<= tmp2;
1820
          RL78_STACK_PUSH (tmp1);
1821
          break;
1822
 
1823
        case R_RL78_OPshra:
1824
          RL78_STACK_POP (tmp1);
1825
          RL78_STACK_POP (tmp2);
1826
          tmp1 >>= tmp2;
1827
          RL78_STACK_PUSH (tmp1);
1828
          break;
1829
 
1830
        case R_RL78_OPsctsize:
1831
          RL78_STACK_PUSH (input_section->size);
1832
          break;
1833
 
1834
        case R_RL78_OPscttop:
1835
          RL78_STACK_PUSH (input_section->output_section->vma);
1836
          break;
1837
 
1838
        case R_RL78_OPand:
1839
          RL78_STACK_POP (tmp1);
1840
          RL78_STACK_POP (tmp2);
1841
          tmp1 &= tmp2;
1842
          RL78_STACK_PUSH (tmp1);
1843
          break;
1844
 
1845
        case R_RL78_OPor:
1846
          RL78_STACK_POP (tmp1);
1847
          RL78_STACK_POP (tmp2);
1848
          tmp1 |= tmp2;
1849
          RL78_STACK_PUSH (tmp1);
1850
          break;
1851
 
1852
        case R_RL78_OPxor:
1853
          RL78_STACK_POP (tmp1);
1854
          RL78_STACK_POP (tmp2);
1855
          tmp1 ^= tmp2;
1856
          RL78_STACK_PUSH (tmp1);
1857
          break;
1858
 
1859
        case R_RL78_OPnot:
1860
          RL78_STACK_POP (tmp1);
1861
          tmp1 = ~ tmp1;
1862
          RL78_STACK_PUSH (tmp1);
1863
          break;
1864
 
1865
        case R_RL78_OPmod:
1866
          RL78_STACK_POP (tmp1);
1867
          RL78_STACK_POP (tmp2);
1868
          tmp1 %= tmp2;
1869
          RL78_STACK_PUSH (tmp1);
1870
          break;
1871
 
1872
        case R_RL78_OPromtop:
1873
          RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1874
          break;
1875
 
1876
        case R_RL78_OPramtop:
1877
          RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1878
          break;
1879
 
1880
        case R_RL78_DIR16UL:
1881
        case R_RL78_DIR8UL:
1882
        case R_RL78_ABS16UL:
1883
        case R_RL78_ABS8UL:
1884
          if (rl78_stack_top)
1885
            RL78_STACK_POP (symval);
1886
          if (lrel)
1887
            *lrel = rel;
1888
          *scale = 4;
1889
          return symval;
1890
 
1891
        case R_RL78_DIR16UW:
1892
        case R_RL78_DIR8UW:
1893
        case R_RL78_ABS16UW:
1894
        case R_RL78_ABS8UW:
1895
          if (rl78_stack_top)
1896
            RL78_STACK_POP (symval);
1897
          if (lrel)
1898
            *lrel = rel;
1899
          *scale = 2;
1900
          return symval;
1901
 
1902
        default:
1903
          if (rl78_stack_top)
1904
            RL78_STACK_POP (symval);
1905
          if (lrel)
1906
            *lrel = rel;
1907
          return symval;
1908
        }
1909
 
1910
      rel ++;
1911
    }
1912
}
1913
 
1914
struct {
1915
  int prefix;           /* or -1 for "no prefix" */
1916
  int insn;             /* or -1 for "end of list" */
1917
  int insn_for_saddr;   /* or -1 for "no alternative" */
1918
  int insn_for_sfr;     /* or -1 for "no alternative" */
1919
} relax_addr16[] = {
1920
  { -1, 0x02, 0x06, -1 },       /* ADDW AX, !addr16 */
1921
  { -1, 0x22, 0x26, -1 },       /* SUBW AX, !addr16 */
1922
  { -1, 0x42, 0x46, -1 },       /* CMPW AX, !addr16 */
1923
  { -1, 0x40, 0x4a, -1 },       /* CMP  !addr16, #byte */
1924
 
1925
  { -1, 0x0f, 0x0b, -1 },       /* ADD  A, !addr16 */
1926
  { -1, 0x1f, 0x1b, -1 },       /* ADDC A, !addr16 */
1927
  { -1, 0x2f, 0x2b, -1 },       /* SUB  A, !addr16 */
1928
  { -1, 0x3f, 0x3b, -1 },       /* SUBC A, !addr16 */
1929
  { -1, 0x4f, 0x4b, -1 },       /* CMP  A, !addr16 */
1930
  { -1, 0x5f, 0x5b, -1 },       /* AND  A, !addr16 */
1931
  { -1, 0x6f, 0x6b, -1 },       /* OR   A, !addr16 */
1932
  { -1, 0x7f, 0x7b, -1 },       /* XOR  A, !addr16 */
1933
 
1934
  { -1, 0x8f, 0x8d, 0x8e },     /* MOV  A, !addr16 */
1935
  { -1, 0x9f, 0x9d, 0x9e },     /* MOV  !addr16, A */
1936
  { -1, 0xaf, 0xad, 0xae },     /* MOVW AX, !addr16 */
1937
  { -1, 0xbf, 0xbd, 0xbe },     /* MOVW !addr16, AX */
1938
  { -1, 0xcf, 0xcd, 0xce },     /* MOVW !addr16, #word */
1939
 
1940
  { -1, 0xa0, 0xa4, -1 },       /* INC  !addr16 */
1941
  { -1, 0xa2, 0xa6, -1 },       /* INCW !addr16 */
1942
  { -1, 0xb0, 0xb4, -1 },       /* DEC  !addr16 */
1943
  { -1, 0xb2, 0xb6, -1 },       /* DECW !addr16 */
1944
 
1945
  { -1, 0xd5, 0xd4, -1 },       /* CMP0 !addr16 */
1946
  { -1, 0xe5, 0xe4, -1 },       /* ONEB !addr16 */
1947
  { -1, 0xf5, 0xf4, -1 },       /* CLRB !addr16 */
1948
 
1949
  { -1, 0xd9, 0xd8, -1 },       /* MOV  X, !addr16 */
1950
  { -1, 0xe9, 0xe8, -1 },       /* MOV  B, !addr16 */
1951
  { -1, 0xf9, 0xf8, -1 },       /* MOV  C, !addr16 */
1952
  { -1, 0xdb, 0xda, -1 },       /* MOVW BC, !addr16 */
1953
  { -1, 0xeb, 0xea, -1 },       /* MOVW DE, !addr16 */
1954
  { -1, 0xfb, 0xfa, -1 },       /* MOVW HL, !addr16 */
1955
 
1956
  { 0x61, 0xaa, 0xa8, -1 },     /* XCH  A, !addr16 */
1957
 
1958
  { 0x71, 0x00, 0x02, 0x0a },   /* SET1 !addr16.0 */
1959
  { 0x71, 0x10, 0x12, 0x1a },   /* SET1 !addr16.0 */
1960
  { 0x71, 0x20, 0x22, 0x2a },   /* SET1 !addr16.0 */
1961
  { 0x71, 0x30, 0x32, 0x3a },   /* SET1 !addr16.0 */
1962
  { 0x71, 0x40, 0x42, 0x4a },   /* SET1 !addr16.0 */
1963
  { 0x71, 0x50, 0x52, 0x5a },   /* SET1 !addr16.0 */
1964
  { 0x71, 0x60, 0x62, 0x6a },   /* SET1 !addr16.0 */
1965
  { 0x71, 0x70, 0x72, 0x7a },   /* SET1 !addr16.0 */
1966
 
1967
  { 0x71, 0x08, 0x03, 0x0b },   /* CLR1 !addr16.0 */
1968
  { 0x71, 0x18, 0x13, 0x1b },   /* CLR1 !addr16.0 */
1969
  { 0x71, 0x28, 0x23, 0x2b },   /* CLR1 !addr16.0 */
1970
  { 0x71, 0x38, 0x33, 0x3b },   /* CLR1 !addr16.0 */
1971
  { 0x71, 0x48, 0x43, 0x4b },   /* CLR1 !addr16.0 */
1972
  { 0x71, 0x58, 0x53, 0x5b },   /* CLR1 !addr16.0 */
1973
  { 0x71, 0x68, 0x63, 0x6b },   /* CLR1 !addr16.0 */
1974
  { 0x71, 0x78, 0x73, 0x7b },   /* CLR1 !addr16.0 */
1975
 
1976
  { -1, -1, -1, -1 }
1977
};
1978
 
1979
/* Relax one section.  */
1980
 
1981
static bfd_boolean
1982 163 khays
rl78_elf_relax_section
1983
    (bfd *                  abfd,
1984
     asection *             sec,
1985
     struct bfd_link_info * link_info,
1986
     bfd_boolean *          again)
1987
{
1988 166 khays
  Elf_Internal_Shdr * symtab_hdr;
1989
  Elf_Internal_Shdr * shndx_hdr;
1990
  Elf_Internal_Rela * internal_relocs;
1991
  Elf_Internal_Rela * free_relocs = NULL;
1992
  Elf_Internal_Rela * irel;
1993
  Elf_Internal_Rela * srel;
1994
  Elf_Internal_Rela * irelend;
1995
  Elf_Internal_Rela * next_alignment;
1996
  bfd_byte *          contents = NULL;
1997
  bfd_byte *          free_contents = NULL;
1998
  Elf_Internal_Sym *  intsyms = NULL;
1999
  Elf_Internal_Sym *  free_intsyms = NULL;
2000
  Elf_External_Sym_Shndx * shndx_buf = NULL;
2001
  bfd_vma pc;
2002
  bfd_vma symval ATTRIBUTE_UNUSED = 0;
2003
  int pcrel ATTRIBUTE_UNUSED = 0;
2004
  int code ATTRIBUTE_UNUSED = 0;
2005
  int section_alignment_glue;
2006
  int scale;
2007
 
2008 163 khays
  if (abfd == elf_hash_table (link_info)->dynobj
2009
      && strcmp (sec->name, ".plt") == 0)
2010
    return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
2011
 
2012
  /* Assume nothing changes.  */
2013
  *again = FALSE;
2014 166 khays
 
2015
  /* We don't have to do anything for a relocatable link, if
2016
     this section does not have relocs, or if this is not a
2017
     code section.  */
2018
  if (link_info->relocatable
2019
      || (sec->flags & SEC_RELOC) == 0
2020
      || sec->reloc_count == 0
2021
      || (sec->flags & SEC_CODE) == 0)
2022
    return TRUE;
2023
 
2024
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2025
  shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2026
 
2027
  /* Get the section contents.  */
2028
  if (elf_section_data (sec)->this_hdr.contents != NULL)
2029
    contents = elf_section_data (sec)->this_hdr.contents;
2030
  /* Go get them off disk.  */
2031
  else
2032
    {
2033
      if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2034
        goto error_return;
2035
      elf_section_data (sec)->this_hdr.contents = contents;
2036
    }
2037
 
2038
  /* Read this BFD's symbols.  */
2039
  /* Get cached copy if it exists.  */
2040
  if (symtab_hdr->contents != NULL)
2041
    intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2042
  else
2043
    {
2044
      intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2045
      symtab_hdr->contents = (bfd_byte *) intsyms;
2046
    }
2047
 
2048
  if (shndx_hdr->sh_size != 0)
2049
    {
2050
      bfd_size_type amt;
2051
 
2052
      amt = symtab_hdr->sh_info;
2053
      amt *= sizeof (Elf_External_Sym_Shndx);
2054
      shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2055
      if (shndx_buf == NULL)
2056
        goto error_return;
2057
      if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2058
          || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
2059
        goto error_return;
2060
      shndx_hdr->contents = (bfd_byte *) shndx_buf;
2061
    }
2062
 
2063
  /* Get a copy of the native relocations.  */
2064
  internal_relocs = (_bfd_elf_link_read_relocs
2065
                     (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2066
                      link_info->keep_memory));
2067
  if (internal_relocs == NULL)
2068
    goto error_return;
2069
  if (! link_info->keep_memory)
2070
    free_relocs = internal_relocs;
2071
 
2072
  /* The RL_ relocs must be just before the operand relocs they go
2073
     with, so we must sort them to guarantee this.  We use bubblesort
2074
     instead of qsort so we can guarantee that relocs with the same
2075
     address remain in the same relative order.  */
2076
  reloc_bubblesort (internal_relocs, sec->reloc_count);
2077
 
2078
  /* Walk through them looking for relaxing opportunities.  */
2079
  irelend = internal_relocs + sec->reloc_count;
2080
 
2081
 
2082
  /* This will either be NULL or a pointer to the next alignment
2083
     relocation.  */
2084
  next_alignment = internal_relocs;
2085
 
2086
  /* We calculate worst case shrinkage caused by alignment directives.
2087
     No fool-proof, but better than either ignoring the problem or
2088
     doing heavy duty analysis of all the alignment markers in all
2089
     input sections.  */
2090
  section_alignment_glue = 0;
2091
  for (irel = internal_relocs; irel < irelend; irel++)
2092
      if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2093
          && irel->r_addend & RL78_RELAXA_ALIGN)
2094
        {
2095
          int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2096
 
2097
          if (section_alignment_glue < this_glue)
2098
            section_alignment_glue = this_glue;
2099
        }
2100
  /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2101
     shrinkage.  */
2102
  section_alignment_glue *= 2;
2103
 
2104
  for (irel = internal_relocs; irel < irelend; irel++)
2105
    {
2106
      unsigned char *insn;
2107
      int nrelocs;
2108
 
2109
      /* The insns we care about are all marked with one of these.  */
2110
      if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2111
        continue;
2112
 
2113
      if (irel->r_addend & RL78_RELAXA_ALIGN
2114
          || next_alignment == internal_relocs)
2115
        {
2116
          /* When we delete bytes, we need to maintain all the alignments
2117
             indicated.  In addition, we need to be careful about relaxing
2118
             jumps across alignment boundaries - these displacements
2119
             *grow* when we delete bytes.  For now, don't shrink
2120
             displacements across an alignment boundary, just in case.
2121
             Note that this only affects relocations to the same
2122
             section.  */
2123
          next_alignment += 2;
2124
          while (next_alignment < irelend
2125
                 && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2126
                     || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2127
            next_alignment ++;
2128
          if (next_alignment >= irelend || next_alignment->r_offset == 0)
2129
            next_alignment = NULL;
2130
        }
2131
 
2132
      /* When we hit alignment markers, see if we've shrunk enough
2133
         before them to reduce the gap without violating the alignment
2134
         requirements.  */
2135
      if (irel->r_addend & RL78_RELAXA_ALIGN)
2136
        {
2137
          /* At this point, the next relocation *should* be the ELIGN
2138
             end marker.  */
2139
          Elf_Internal_Rela *erel = irel + 1;
2140
          unsigned int alignment, nbytes;
2141
 
2142
          if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2143
            continue;
2144
          if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2145
            continue;
2146
 
2147
          alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2148
 
2149
          if (erel->r_offset - irel->r_offset < alignment)
2150
            continue;
2151
 
2152
          nbytes = erel->r_offset - irel->r_offset;
2153
          nbytes /= alignment;
2154
          nbytes *= alignment;
2155
 
2156
          elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2157
                                       erel->r_offset == sec->size);
2158
          *again = TRUE;
2159
 
2160
          continue;
2161
        }
2162
 
2163
      if (irel->r_addend & RL78_RELAXA_ELIGN)
2164
          continue;
2165
 
2166
      insn = contents + irel->r_offset;
2167
 
2168
      nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2169
 
2170
      /* At this point, we have an insn that is a candidate for linker
2171
         relaxation.  There are NRELOCS relocs following that may be
2172
         relaxed, although each reloc may be made of more than one
2173
         reloc entry (such as gp-rel symbols).  */
2174
 
2175
      /* Get the value of the symbol referred to by the reloc.  Just
2176
         in case this is the last reloc in the list, use the RL's
2177
         addend to choose between this reloc (no addend) or the next
2178
         (yes addend, which means at least one following reloc).  */
2179
 
2180
      /* srel points to the "current" reloction for this insn -
2181
         actually the last reloc for a given operand, which is the one
2182
         we need to update.  We check the relaxations in the same
2183
         order that the relocations happen, so we'll just push it
2184
         along as we go.  */
2185
      srel = irel;
2186
 
2187
      pc = sec->output_section->vma + sec->output_offset
2188
        + srel->r_offset;
2189
 
2190
#define GET_RELOC \
2191
      symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2192
      pcrel = symval - pc + srel->r_addend; \
2193
      nrelocs --;
2194
 
2195
#define SNIPNR(offset, nbytes) \
2196
        elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2197
#define SNIP(offset, nbytes, newtype) \
2198
        SNIPNR (offset, nbytes);                                                \
2199
        srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2200
 
2201
      /* The order of these bit tests must match the order that the
2202
         relocs appear in.  Since we sorted those by offset, we can
2203
         predict them.  */
2204
 
2205
      /*----------------------------------------------------------------------*/
2206
      /* EF ad          BR $rel8        pcrel
2207
         ED al ah       BR !abs16       abs
2208
         EE al ah       BR $!rel16      pcrel
2209
         EC al ah as    BR !!abs20      abs
2210
 
2211
         FD al ah       CALL !abs16     abs
2212
         FE al ah       CALL $!rel16    pcrel
2213
         FC al ah as    CALL !!abs20    abs
2214
 
2215
         DC ad          BC  $rel8
2216
         DE ad          BNC $rel8
2217
         DD ad          BZ  $rel8
2218
         DF ad          BNZ $rel8
2219
         61 C3 ad       BH  $rel8
2220
         61 D3 ad       BNH $rel8
2221
         61 C8 EF ad    SKC  ; BR $rel8
2222
         61 D8 EF ad    SKNC ; BR $rel8
2223
         61 E8 EF ad    SKZ  ; BR $rel8
2224
         61 F8 EF ad    SKNZ ; BR $rel8
2225
         61 E3 EF ad    SKH  ; BR $rel8
2226
         61 F3 EF ad    SKNH ; BR $rel8
2227
       */
2228
 
2229
      if (irel->r_addend & RL78_RELAXA_BRA)
2230
        {
2231
          GET_RELOC;
2232
 
2233
          switch (insn[0])
2234
            {
2235
            case 0xec: /* BR !!abs20 */
2236
 
2237
              if (pcrel < 127
2238
                  && pcrel > -127)
2239
                {
2240
                  insn[0] = 0xef;
2241
                  insn[1] = pcrel;
2242
                  SNIP (2, 2, R_RL78_DIR8S_PCREL);
2243
                  *again = TRUE;
2244
                }
2245
              else if (symval < 65536)
2246
                {
2247
                  insn[0] = 0xed;
2248
                  insn[1] = symval & 0xff;
2249
                  insn[2] = symval >> 8;
2250
                  SNIP (2, 1, R_RL78_DIR16S);
2251
                  *again = TRUE;
2252
                }
2253
              else if (pcrel < 32767
2254
                       && pcrel > -32767)
2255
                {
2256
                  insn[0] = 0xee;
2257
                  insn[1] = pcrel & 0xff;
2258
                  insn[2] = pcrel >> 8;
2259
                  SNIP (2, 1, R_RL78_DIR16S_PCREL);
2260
                  *again = TRUE;
2261
                }
2262
              break;
2263
 
2264
            case 0xee: /* BR $!pcrel16 */
2265
            case 0xed: /* BR $!abs16 */
2266
              if (pcrel < 127
2267
                  && pcrel > -127)
2268
                {
2269
                  insn[0] = 0xef;
2270
                  insn[1] = pcrel;
2271
                  SNIP (2, 1, R_RL78_DIR8S_PCREL);
2272
                  *again = TRUE;
2273
                }
2274
              break;
2275
 
2276
            case 0xfc: /* CALL !!abs20 */
2277
              if (symval < 65536)
2278
                {
2279
                  insn[0] = 0xfd;
2280
                  insn[1] = symval & 0xff;
2281
                  insn[2] = symval >> 8;
2282
                  SNIP (2, 1, R_RL78_DIR16S);
2283
                  *again = TRUE;
2284
                }
2285
              else if (pcrel < 32767
2286
                       && pcrel > -32767)
2287
                {
2288
                  insn[0] = 0xfe;
2289
                  insn[1] = pcrel & 0xff;
2290
                  insn[2] = pcrel >> 8;
2291
                  SNIP (2, 1, R_RL78_DIR16S_PCREL);
2292
                  *again = TRUE;
2293
                }
2294
              break;
2295
 
2296
            case 0x61: /* PREFIX */
2297
              /* For SKIP/BR, we change the BR opcode and delete the
2298
                 SKIP.  That way, we don't have to find and change the
2299
                 relocation for the BR.  */
2300
              switch (insn[1])
2301
                {
2302
                case 0xc8: /* SKC */
2303
                  if (insn[2] == 0xef)
2304
                    {
2305
                      insn[2] = 0xde; /* BNC */
2306
                      SNIPNR (0, 2);
2307
                    }
2308
                  break;
2309
 
2310
                case 0xd8: /* SKNC */
2311
                  if (insn[2] == 0xef)
2312
                    {
2313
                      insn[2] = 0xdc; /* BC */
2314
                      SNIPNR (0, 2);
2315
                    }
2316
                  break;
2317
 
2318
                case 0xe8: /* SKZ */
2319
                  if (insn[2] == 0xef)
2320
                    {
2321
                      insn[2] = 0xdf; /* BNZ */
2322
                      SNIPNR (0, 2);
2323
                    }
2324
                  break;
2325
 
2326
                case 0xf8: /* SKNZ */
2327
                  if (insn[2] == 0xef)
2328
                    {
2329
                      insn[2] = 0xdd; /* BZ */
2330
                      SNIPNR (0, 2);
2331
                    }
2332
                  break;
2333
 
2334
                case 0xe3: /* SKH */
2335
                  if (insn[2] == 0xef)
2336
                    {
2337
                      insn[2] = 0xd3; /* BNH */
2338
                      SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2339
                    }
2340
                  break;
2341
 
2342
                case 0xf3: /* SKNH */
2343
                  if (insn[2] == 0xef)
2344
                    {
2345
                      insn[2] = 0xc3; /* BH */
2346
                      SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2347
                    }
2348
                  break;
2349
                }
2350
              break;
2351
            }
2352
 
2353
        }
2354
 
2355
      if (irel->r_addend & RL78_RELAXA_ADDR16)
2356
        {
2357
          /*----------------------------------------------------------------------*/
2358
          /* Some insns have both a 16-bit address operand and an 8-bit
2359
             variant if the address is within a special range:
2360
 
2361
             Address            16-bit operand  SADDR range     SFR range
2362
             FFF00-FFFFF        0xff00-0xffff   0x00-0xff
2363
             FFE20-FFF1F        0xfe20-0xff1f                   0x00-0xff
2364
 
2365
             The RELAX_ADDR16[] array has the insn encodings for the
2366
             16-bit operand version, as well as the SFR and SADDR
2367
             variants.  We only need to replace the encodings and
2368
             adjust the operand.
2369
 
2370
             Note: we intentionally do not attempt to decode and skip
2371
             any ES: prefix, as adding ES: means the addr16 (likely)
2372
             no longer points to saddr/sfr space.
2373
          */
2374
 
2375
          int is_sfr;
2376
          int is_saddr;
2377
          int idx;
2378
          int poff;
2379
 
2380
          GET_RELOC;
2381
 
2382
          if (0xffe20 <= symval && symval <= 0xfffff)
2383
            {
2384
 
2385
              is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2386
              is_sfr   = (0xfff00 <= symval && symval <= 0xfffff);
2387
 
2388
              for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2389
                {
2390
                  if (relax_addr16[idx].prefix != -1
2391
                      && insn[0] == relax_addr16[idx].prefix
2392
                      && insn[1] == relax_addr16[idx].insn)
2393
                    {
2394
                      poff = 1;
2395
                    }
2396
                  else if (relax_addr16[idx].prefix == -1
2397
                           && insn[0] == relax_addr16[idx].insn)
2398
                    {
2399
                      poff = 0;
2400
                    }
2401
                  else
2402
                    continue;
2403
 
2404
                  /* We have a matched insn, and poff is 0 or 1 depending
2405
                     on the base pattern size.  */
2406
 
2407
                  if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2408
                    {
2409
                      insn[poff] = relax_addr16[idx].insn_for_sfr;
2410
                      SNIP (poff+2, 1, R_RL78_RH_SFR);
2411
                    }
2412
 
2413
                  else if  (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2414
                    {
2415
                      insn[poff] = relax_addr16[idx].insn_for_saddr;
2416
                      SNIP (poff+2, 1, R_RL78_RH_SADDR);
2417
                    }
2418
 
2419
                }
2420
            }
2421
        }
2422
 
2423
      /*----------------------------------------------------------------------*/
2424
 
2425
    }
2426
 
2427 163 khays
  return TRUE;
2428 166 khays
 
2429
 error_return:
2430
  if (free_relocs != NULL)
2431
    free (free_relocs);
2432
 
2433
  if (free_contents != NULL)
2434
    free (free_contents);
2435
 
2436
  if (shndx_buf != NULL)
2437
    {
2438
      shndx_hdr->contents = NULL;
2439
      free (shndx_buf);
2440
    }
2441
 
2442
  if (free_intsyms != NULL)
2443
    free (free_intsyms);
2444
 
2445
  return TRUE;
2446 163 khays
}
2447
 
2448
 
2449
 
2450
#define ELF_ARCH                bfd_arch_rl78
2451
#define ELF_MACHINE_CODE        EM_RL78
2452
#define ELF_MAXPAGESIZE         0x1000
2453
 
2454
#define TARGET_LITTLE_SYM       bfd_elf32_rl78_vec
2455
#define TARGET_LITTLE_NAME      "elf32-rl78"
2456
 
2457
#define elf_info_to_howto_rel                   NULL
2458
#define elf_info_to_howto                       rl78_info_to_howto_rela
2459
#define elf_backend_object_p                    rl78_elf_object_p
2460
#define elf_backend_relocate_section            rl78_elf_relocate_section
2461
#define elf_symbol_leading_char                 ('_')
2462
#define elf_backend_can_gc_sections             1
2463
 
2464
#define bfd_elf32_bfd_reloc_type_lookup         rl78_reloc_type_lookup
2465
#define bfd_elf32_bfd_reloc_name_lookup         rl78_reloc_name_lookup
2466
#define bfd_elf32_bfd_set_private_flags         rl78_elf_set_private_flags
2467
#define bfd_elf32_bfd_merge_private_bfd_data    rl78_elf_merge_private_bfd_data
2468
#define bfd_elf32_bfd_print_private_bfd_data    rl78_elf_print_private_bfd_data
2469
 
2470
#define bfd_elf32_bfd_relax_section             rl78_elf_relax_section
2471
#define elf_backend_check_relocs                rl78_elf_check_relocs
2472
#define elf_backend_always_size_sections \
2473
  rl78_elf_always_size_sections
2474
#define elf_backend_finish_dynamic_sections \
2475
  rl78_elf_finish_dynamic_sections
2476
 
2477
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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