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