?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Mach-O: add objdump -P function_starts to display function starts.
[binutils-gdb.git] / bfd / elf32-rl78.c
blob533f493f0b7db1fdf7232d9149a4bde4709cdd1b
1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011-2014 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 if (irel == NULL)
1485 {
1486 _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
1487 irel = elf_section_data (sec)->relocs;
1488 }
1489
1490 irelend = irel + sec->reloc_count;
1491
1492 /* Actually delete the bytes. */
1493 memmove (contents + addr, contents + addr + count,
1494 (size_t) (toaddr - addr - count));
1495
1496 /* If we don't have an alignment marker to worry about, we can just
1497 shrink the section. Otherwise, we have to fill in the newly
1498 created gap with NOP insns (0x03). */
1499 if (force_snip)
1500 sec->size -= count;
1501 else
1502 memset (contents + toaddr - count, 0x03, count);
1503
1504 /* Adjust all the relocs. */
1505 for (; irel && irel < irelend; irel++)
1506 {
1507 /* Get the new reloc address. */
1508 if (irel->r_offset > addr
1509 && (irel->r_offset < toaddr
1510 || (force_snip && irel->r_offset == toaddr)))
1511 irel->r_offset -= count;
1512
1513 /* If we see an ALIGN marker at the end of the gap, we move it
1514 to the beginning of the gap, since marking these gaps is what
1515 they're for. */
1516 if (irel->r_offset == toaddr
1517 && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1518 && irel->r_addend & RL78_RELAXA_ALIGN)
1519 irel->r_offset -= count;
1520 }
1521
1522 /* Adjust the local symbols defined in this section. */
1523 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1524 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1525 isymend = isym + symtab_hdr->sh_info;
1526
1527 for (; isym < isymend; isym++)
1528 {
1529 /* If the symbol is in the range of memory we just moved, we
1530 have to adjust its value. */
1531 if (isym->st_shndx == sec_shndx
1532 && isym->st_value > addr
1533 && isym->st_value < toaddr)
1534 isym->st_value -= count;
1535
1536 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1537 *end* is in the moved bytes but it's *start* isn't), then we
1538 must adjust its size. */
1539 if (isym->st_shndx == sec_shndx
1540 && isym->st_value < addr
1541 && isym->st_value + isym->st_size > addr
1542 && isym->st_value + isym->st_size < toaddr)
1543 isym->st_size -= count;
1544 }
1545
1546 /* Now adjust the global symbols defined in this section. */
1547 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1548 - symtab_hdr->sh_info);
1549 sym_hashes = elf_sym_hashes (abfd);
1550 end_hashes = sym_hashes + symcount;
1551
1552 for (; sym_hashes < end_hashes; sym_hashes++)
1553 {
1554 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1555
1556 if ((sym_hash->root.type == bfd_link_hash_defined
1557 || sym_hash->root.type == bfd_link_hash_defweak)
1558 && sym_hash->root.u.def.section == sec)
1559 {
1560 /* As above, adjust the value if needed. */
1561 if (sym_hash->root.u.def.value > addr
1562 && sym_hash->root.u.def.value < toaddr)
1563 sym_hash->root.u.def.value -= count;
1564
1565 /* As above, adjust the size if needed. */
1566 if (sym_hash->root.u.def.value < addr
1567 && sym_hash->root.u.def.value + sym_hash->size > addr
1568 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1569 sym_hash->size -= count;
1570 }
1571 }
1572
1573 return TRUE;
1574 }
1575
1576 /* Used to sort relocs by address. If relocs have the same address,
1577 we maintain their relative order, except that R_RL78_RH_RELAX
1578 alignment relocs must be the first reloc for any given address. */
1579
1580 static void
1581 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1582 {
1583 int i;
1584 bfd_boolean again;
1585 bfd_boolean swappit;
1586
1587 /* This is almost a classic bubblesort. It's the slowest sort, but
1588 we're taking advantage of the fact that the relocations are
1589 mostly in order already (the assembler emits them that way) and
1590 we need relocs with the same address to remain in the same
1591 relative order. */
1592 again = TRUE;
1593 while (again)
1594 {
1595 again = FALSE;
1596 for (i = 0; i < count - 1; i ++)
1597 {
1598 if (r[i].r_offset > r[i + 1].r_offset)
1599 swappit = TRUE;
1600 else if (r[i].r_offset < r[i + 1].r_offset)
1601 swappit = FALSE;
1602 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1603 && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1604 swappit = TRUE;
1605 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1606 && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1607 && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1608 && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1609 swappit = TRUE;
1610 else
1611 swappit = FALSE;
1612
1613 if (swappit)
1614 {
1615 Elf_Internal_Rela tmp;
1616
1617 tmp = r[i];
1618 r[i] = r[i + 1];
1619 r[i + 1] = tmp;
1620 /* If we do move a reloc back, re-scan to see if it
1621 needs to be moved even further back. This avoids
1622 most of the O(n^2) behavior for our cases. */
1623 if (i > 0)
1624 i -= 2;
1625 again = TRUE;
1626 }
1627 }
1628 }
1629 }
1630
1631
1632 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1633 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1634 lrel, abfd, sec, link_info, scale)
1635
1636 static bfd_vma
1637 rl78_offset_for_reloc (bfd * abfd,
1638 Elf_Internal_Rela * rel,
1639 Elf_Internal_Shdr * symtab_hdr,
1640 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1641 Elf_Internal_Sym * intsyms,
1642 Elf_Internal_Rela ** lrel,
1643 bfd * input_bfd,
1644 asection * input_section,
1645 struct bfd_link_info * info,
1646 int * scale)
1647 {
1648 bfd_vma symval;
1649 bfd_reloc_status_type r;
1650
1651 *scale = 1;
1652
1653 /* REL is the first of 1..N relocations. We compute the symbol
1654 value for each relocation, then combine them if needed. LREL
1655 gets a pointer to the last relocation used. */
1656 while (1)
1657 {
1658 int32_t tmp1, tmp2;
1659
1660 /* Get the value of the symbol referred to by the reloc. */
1661 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1662 {
1663 /* A local symbol. */
1664 Elf_Internal_Sym *isym;
1665 asection *ssec;
1666
1667 isym = intsyms + ELF32_R_SYM (rel->r_info);
1668
1669 if (isym->st_shndx == SHN_UNDEF)
1670 ssec = bfd_und_section_ptr;
1671 else if (isym->st_shndx == SHN_ABS)
1672 ssec = bfd_abs_section_ptr;
1673 else if (isym->st_shndx == SHN_COMMON)
1674 ssec = bfd_com_section_ptr;
1675 else
1676 ssec = bfd_section_from_elf_index (abfd,
1677 isym->st_shndx);
1678
1679 /* Initial symbol value. */
1680 symval = isym->st_value;
1681
1682 /* GAS may have made this symbol relative to a section, in
1683 which case, we have to add the addend to find the
1684 symbol. */
1685 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1686 symval += rel->r_addend;
1687
1688 if (ssec)
1689 {
1690 if ((ssec->flags & SEC_MERGE)
1691 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1692 symval = _bfd_merged_section_offset (abfd, & ssec,
1693 elf_section_data (ssec)->sec_info,
1694 symval);
1695 }
1696
1697 /* Now make the offset relative to where the linker is putting it. */
1698 if (ssec)
1699 symval +=
1700 ssec->output_section->vma + ssec->output_offset;
1701
1702 symval += rel->r_addend;
1703 }
1704 else
1705 {
1706 unsigned long indx;
1707 struct elf_link_hash_entry * h;
1708
1709 /* An external symbol. */
1710 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1711 h = elf_sym_hashes (abfd)[indx];
1712 BFD_ASSERT (h != NULL);
1713
1714 if (h->root.type != bfd_link_hash_defined
1715 && h->root.type != bfd_link_hash_defweak)
1716 {
1717 /* This appears to be a reference to an undefined
1718 symbol. Just ignore it--it will be caught by the
1719 regular reloc processing. */
1720 if (lrel)
1721 *lrel = rel;
1722 return 0;
1723 }
1724
1725 symval = (h->root.u.def.value
1726 + h->root.u.def.section->output_section->vma
1727 + h->root.u.def.section->output_offset);
1728
1729 symval += rel->r_addend;
1730 }
1731
1732 switch (ELF32_R_TYPE (rel->r_info))
1733 {
1734 case R_RL78_SYM:
1735 RL78_STACK_PUSH (symval);
1736 break;
1737
1738 case R_RL78_OPneg:
1739 RL78_STACK_POP (tmp1);
1740 tmp1 = - tmp1;
1741 RL78_STACK_PUSH (tmp1);
1742 break;
1743
1744 case R_RL78_OPadd:
1745 RL78_STACK_POP (tmp1);
1746 RL78_STACK_POP (tmp2);
1747 tmp1 += tmp2;
1748 RL78_STACK_PUSH (tmp1);
1749 break;
1750
1751 case R_RL78_OPsub:
1752 RL78_STACK_POP (tmp1);
1753 RL78_STACK_POP (tmp2);
1754 tmp2 -= tmp1;
1755 RL78_STACK_PUSH (tmp2);
1756 break;
1757
1758 case R_RL78_OPmul:
1759 RL78_STACK_POP (tmp1);
1760 RL78_STACK_POP (tmp2);
1761 tmp1 *= tmp2;
1762 RL78_STACK_PUSH (tmp1);
1763 break;
1764
1765 case R_RL78_OPdiv:
1766 RL78_STACK_POP (tmp1);
1767 RL78_STACK_POP (tmp2);
1768 tmp1 /= tmp2;
1769 RL78_STACK_PUSH (tmp1);
1770 break;
1771
1772 case R_RL78_OPshla:
1773 RL78_STACK_POP (tmp1);
1774 RL78_STACK_POP (tmp2);
1775 tmp1 <<= tmp2;
1776 RL78_STACK_PUSH (tmp1);
1777 break;
1778
1779 case R_RL78_OPshra:
1780 RL78_STACK_POP (tmp1);
1781 RL78_STACK_POP (tmp2);
1782 tmp1 >>= tmp2;
1783 RL78_STACK_PUSH (tmp1);
1784 break;
1785
1786 case R_RL78_OPsctsize:
1787 RL78_STACK_PUSH (input_section->size);
1788 break;
1789
1790 case R_RL78_OPscttop:
1791 RL78_STACK_PUSH (input_section->output_section->vma);
1792 break;
1793
1794 case R_RL78_OPand:
1795 RL78_STACK_POP (tmp1);
1796 RL78_STACK_POP (tmp2);
1797 tmp1 &= tmp2;
1798 RL78_STACK_PUSH (tmp1);
1799 break;
1800
1801 case R_RL78_OPor:
1802 RL78_STACK_POP (tmp1);
1803 RL78_STACK_POP (tmp2);
1804 tmp1 |= tmp2;
1805 RL78_STACK_PUSH (tmp1);
1806 break;
1807
1808 case R_RL78_OPxor:
1809 RL78_STACK_POP (tmp1);
1810 RL78_STACK_POP (tmp2);
1811 tmp1 ^= tmp2;
1812 RL78_STACK_PUSH (tmp1);
1813 break;
1814
1815 case R_RL78_OPnot:
1816 RL78_STACK_POP (tmp1);
1817 tmp1 = ~ tmp1;
1818 RL78_STACK_PUSH (tmp1);
1819 break;
1820
1821 case R_RL78_OPmod:
1822 RL78_STACK_POP (tmp1);
1823 RL78_STACK_POP (tmp2);
1824 tmp1 %= tmp2;
1825 RL78_STACK_PUSH (tmp1);
1826 break;
1827
1828 case R_RL78_OPromtop:
1829 RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1830 break;
1831
1832 case R_RL78_OPramtop:
1833 RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1834 break;
1835
1836 case R_RL78_DIR16UL:
1837 case R_RL78_DIR8UL:
1838 case R_RL78_ABS16UL:
1839 case R_RL78_ABS8UL:
1840 if (rl78_stack_top)
1841 RL78_STACK_POP (symval);
1842 if (lrel)
1843 *lrel = rel;
1844 *scale = 4;
1845 return symval;
1846
1847 case R_RL78_DIR16UW:
1848 case R_RL78_DIR8UW:
1849 case R_RL78_ABS16UW:
1850 case R_RL78_ABS8UW:
1851 if (rl78_stack_top)
1852 RL78_STACK_POP (symval);
1853 if (lrel)
1854 *lrel = rel;
1855 *scale = 2;
1856 return symval;
1857
1858 default:
1859 if (rl78_stack_top)
1860 RL78_STACK_POP (symval);
1861 if (lrel)
1862 *lrel = rel;
1863 return symval;
1864 }
1865
1866 rel ++;
1867 }
1868 }
1869
1870 struct {
1871 int prefix; /* or -1 for "no prefix" */
1872 int insn; /* or -1 for "end of list" */
1873 int insn_for_saddr; /* or -1 for "no alternative" */
1874 int insn_for_sfr; /* or -1 for "no alternative" */
1875 } relax_addr16[] = {
1876 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1877 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1878 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1879 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1880
1881 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1882 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1883 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1884 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
1885 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
1886 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
1887 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
1888 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
1889
1890 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
1891 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
1892 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
1893 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
1894 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
1895
1896 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
1897 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
1898 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
1899 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
1900
1901 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
1902 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
1903 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
1904
1905 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
1906 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
1907 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
1908 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
1909 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
1910 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
1911
1912 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
1913
1914 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
1915 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
1916 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
1917 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
1918 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
1919 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
1920 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
1921 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
1922
1923 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
1924 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
1925 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
1926 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
1927 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
1928 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
1929 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
1930 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
1931
1932 { -1, -1, -1, -1 }
1933 };
1934
1935 /* Relax one section. */
1936
1937 static bfd_boolean
1938 rl78_elf_relax_section
1939 (bfd * abfd,
1940 asection * sec,
1941 struct bfd_link_info * link_info,
1942 bfd_boolean * again)
1943 {
1944 Elf_Internal_Shdr * symtab_hdr;
1945 Elf_Internal_Shdr * shndx_hdr;
1946 Elf_Internal_Rela * internal_relocs;
1947 Elf_Internal_Rela * free_relocs = NULL;
1948 Elf_Internal_Rela * irel;
1949 Elf_Internal_Rela * srel;
1950 Elf_Internal_Rela * irelend;
1951 Elf_Internal_Rela * next_alignment;
1952 bfd_byte * contents = NULL;
1953 bfd_byte * free_contents = NULL;
1954 Elf_Internal_Sym * intsyms = NULL;
1955 Elf_Internal_Sym * free_intsyms = NULL;
1956 Elf_External_Sym_Shndx * shndx_buf = NULL;
1957 bfd_vma pc;
1958 bfd_vma symval ATTRIBUTE_UNUSED = 0;
1959 int pcrel ATTRIBUTE_UNUSED = 0;
1960 int code ATTRIBUTE_UNUSED = 0;
1961 int section_alignment_glue;
1962 int scale;
1963
1964 if (abfd == elf_hash_table (link_info)->dynobj
1965 && strcmp (sec->name, ".plt") == 0)
1966 return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
1967
1968 /* Assume nothing changes. */
1969 *again = FALSE;
1970
1971 /* We don't have to do anything for a relocatable link, if
1972 this section does not have relocs, or if this is not a
1973 code section. */
1974 if (link_info->relocatable
1975 || (sec->flags & SEC_RELOC) == 0
1976 || sec->reloc_count == 0
1977 || (sec->flags & SEC_CODE) == 0)
1978 return TRUE;
1979
1980 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1981 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1982
1983 /* Get the section contents. */
1984 if (elf_section_data (sec)->this_hdr.contents != NULL)
1985 contents = elf_section_data (sec)->this_hdr.contents;
1986 /* Go get them off disk. */
1987 else
1988 {
1989 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1990 goto error_return;
1991 elf_section_data (sec)->this_hdr.contents = contents;
1992 }
1993
1994 /* Read this BFD's symbols. */
1995 /* Get cached copy if it exists. */
1996 if (symtab_hdr->contents != NULL)
1997 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1998 else
1999 {
2000 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2001 symtab_hdr->contents = (bfd_byte *) intsyms;
2002 }
2003
2004 if (shndx_hdr->sh_size != 0)
2005 {
2006 bfd_size_type amt;
2007
2008 amt = symtab_hdr->sh_info;
2009 amt *= sizeof (Elf_External_Sym_Shndx);
2010 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2011 if (shndx_buf == NULL)
2012 goto error_return;
2013 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2014 || bfd_bread (shndx_buf, amt, abfd) != amt)
2015 goto error_return;
2016 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2017 }
2018
2019 /* Get a copy of the native relocations. */
2020 internal_relocs = (_bfd_elf_link_read_relocs
2021 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2022 link_info->keep_memory));
2023 if (internal_relocs == NULL)
2024 goto error_return;
2025 if (! link_info->keep_memory)
2026 free_relocs = internal_relocs;
2027
2028 /* The RL_ relocs must be just before the operand relocs they go
2029 with, so we must sort them to guarantee this. We use bubblesort
2030 instead of qsort so we can guarantee that relocs with the same
2031 address remain in the same relative order. */
2032 reloc_bubblesort (internal_relocs, sec->reloc_count);
2033
2034 /* Walk through them looking for relaxing opportunities. */
2035 irelend = internal_relocs + sec->reloc_count;
2036
2037
2038 /* This will either be NULL or a pointer to the next alignment
2039 relocation. */
2040 next_alignment = internal_relocs;
2041
2042 /* We calculate worst case shrinkage caused by alignment directives.
2043 No fool-proof, but better than either ignoring the problem or
2044 doing heavy duty analysis of all the alignment markers in all
2045 input sections. */
2046 section_alignment_glue = 0;
2047 for (irel = internal_relocs; irel < irelend; irel++)
2048 if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2049 && irel->r_addend & RL78_RELAXA_ALIGN)
2050 {
2051 int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2052
2053 if (section_alignment_glue < this_glue)
2054 section_alignment_glue = this_glue;
2055 }
2056 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2057 shrinkage. */
2058 section_alignment_glue *= 2;
2059
2060 for (irel = internal_relocs; irel < irelend; irel++)
2061 {
2062 unsigned char *insn;
2063 int nrelocs;
2064
2065 /* The insns we care about are all marked with one of these. */
2066 if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2067 continue;
2068
2069 if (irel->r_addend & RL78_RELAXA_ALIGN
2070 || next_alignment == internal_relocs)
2071 {
2072 /* When we delete bytes, we need to maintain all the alignments
2073 indicated. In addition, we need to be careful about relaxing
2074 jumps across alignment boundaries - these displacements
2075 *grow* when we delete bytes. For now, don't shrink
2076 displacements across an alignment boundary, just in case.
2077 Note that this only affects relocations to the same
2078 section. */
2079 next_alignment += 2;
2080 while (next_alignment < irelend
2081 && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2082 || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2083 next_alignment ++;
2084 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2085 next_alignment = NULL;
2086 }
2087
2088 /* When we hit alignment markers, see if we've shrunk enough
2089 before them to reduce the gap without violating the alignment
2090 requirements. */
2091 if (irel->r_addend & RL78_RELAXA_ALIGN)
2092 {
2093 /* At this point, the next relocation *should* be the ELIGN
2094 end marker. */
2095 Elf_Internal_Rela *erel = irel + 1;
2096 unsigned int alignment, nbytes;
2097
2098 if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2099 continue;
2100 if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2101 continue;
2102
2103 alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2104
2105 if (erel->r_offset - irel->r_offset < alignment)
2106 continue;
2107
2108 nbytes = erel->r_offset - irel->r_offset;
2109 nbytes /= alignment;
2110 nbytes *= alignment;
2111
2112 elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2113 erel->r_offset == sec->size);
2114 *again = TRUE;
2115
2116 continue;
2117 }
2118
2119 if (irel->r_addend & RL78_RELAXA_ELIGN)
2120 continue;
2121
2122 insn = contents + irel->r_offset;
2123
2124 nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2125
2126 /* At this point, we have an insn that is a candidate for linker
2127 relaxation. There are NRELOCS relocs following that may be
2128 relaxed, although each reloc may be made of more than one
2129 reloc entry (such as gp-rel symbols). */
2130
2131 /* Get the value of the symbol referred to by the reloc. Just
2132 in case this is the last reloc in the list, use the RL's
2133 addend to choose between this reloc (no addend) or the next
2134 (yes addend, which means at least one following reloc). */
2135
2136 /* srel points to the "current" reloction for this insn -
2137 actually the last reloc for a given operand, which is the one
2138 we need to update. We check the relaxations in the same
2139 order that the relocations happen, so we'll just push it
2140 along as we go. */
2141 srel = irel;
2142
2143 pc = sec->output_section->vma + sec->output_offset
2144 + srel->r_offset;
2145
2146 #define GET_RELOC \
2147 BFD_ASSERT (nrelocs > 0); \
2148 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2149 pcrel = symval - pc + srel->r_addend; \
2150 nrelocs --;
2151
2152 #define SNIPNR(offset, nbytes) \
2153 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2154 #define SNIP(offset, nbytes, newtype) \
2155 SNIPNR (offset, nbytes); \
2156 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2157
2158 /* The order of these bit tests must match the order that the
2159 relocs appear in. Since we sorted those by offset, we can
2160 predict them. */
2161
2162 /*----------------------------------------------------------------------*/
2163 /* EF ad BR $rel8 pcrel
2164 ED al ah BR !abs16 abs
2165 EE al ah BR $!rel16 pcrel
2166 EC al ah as BR !!abs20 abs
2167
2168 FD al ah CALL !abs16 abs
2169 FE al ah CALL $!rel16 pcrel
2170 FC al ah as CALL !!abs20 abs
2171
2172 DC ad BC $rel8
2173 DE ad BNC $rel8
2174 DD ad BZ $rel8
2175 DF ad BNZ $rel8
2176 61 C3 ad BH $rel8
2177 61 D3 ad BNH $rel8
2178 61 C8 EF ad SKC ; BR $rel8
2179 61 D8 EF ad SKNC ; BR $rel8
2180 61 E8 EF ad SKZ ; BR $rel8
2181 61 F8 EF ad SKNZ ; BR $rel8
2182 61 E3 EF ad SKH ; BR $rel8
2183 61 F3 EF ad SKNH ; BR $rel8
2184 */
2185
2186 if (irel->r_addend & RL78_RELAXA_BRA)
2187 {
2188 /* SKIP opcodes that skip non-branches will have a relax tag
2189 but no corresponding symbol to relax against; we just
2190 skip those. */
2191 if (irel->r_addend & RL78_RELAXA_RNUM)
2192 {
2193 GET_RELOC;
2194 }
2195
2196 switch (insn[0])
2197 {
2198 case 0xec: /* BR !!abs20 */
2199
2200 if (pcrel < 127
2201 && pcrel > -127)
2202 {
2203 insn[0] = 0xef;
2204 insn[1] = pcrel;
2205 SNIP (2, 2, R_RL78_DIR8S_PCREL);
2206 *again = TRUE;
2207 }
2208 else if (symval < 65536)
2209 {
2210 insn[0] = 0xed;
2211 insn[1] = symval & 0xff;
2212 insn[2] = symval >> 8;
2213 SNIP (2, 1, R_RL78_DIR16S);
2214 *again = TRUE;
2215 }
2216 else if (pcrel < 32767
2217 && pcrel > -32767)
2218 {
2219 insn[0] = 0xee;
2220 insn[1] = pcrel & 0xff;
2221 insn[2] = pcrel >> 8;
2222 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2223 *again = TRUE;
2224 }
2225 break;
2226
2227 case 0xee: /* BR $!pcrel16 */
2228 case 0xed: /* BR $!abs16 */
2229 if (pcrel < 127
2230 && pcrel > -127)
2231 {
2232 insn[0] = 0xef;
2233 insn[1] = pcrel;
2234 SNIP (2, 1, R_RL78_DIR8S_PCREL);
2235 *again = TRUE;
2236 }
2237 break;
2238
2239 case 0xfc: /* CALL !!abs20 */
2240 if (symval < 65536)
2241 {
2242 insn[0] = 0xfd;
2243 insn[1] = symval & 0xff;
2244 insn[2] = symval >> 8;
2245 SNIP (2, 1, R_RL78_DIR16S);
2246 *again = TRUE;
2247 }
2248 else if (pcrel < 32767
2249 && pcrel > -32767)
2250 {
2251 insn[0] = 0xfe;
2252 insn[1] = pcrel & 0xff;
2253 insn[2] = pcrel >> 8;
2254 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2255 *again = TRUE;
2256 }
2257 break;
2258
2259 case 0x61: /* PREFIX */
2260 /* For SKIP/BR, we change the BR opcode and delete the
2261 SKIP. That way, we don't have to find and change the
2262 relocation for the BR. */
2263 /* Note that, for the case where we're skipping some
2264 other insn, we have no "other" reloc but that's safe
2265 here anyway. */
2266 switch (insn[1])
2267 {
2268 case 0xc8: /* SKC */
2269 if (insn[2] == 0xef)
2270 {
2271 insn[2] = 0xde; /* BNC */
2272 SNIPNR (0, 2);
2273 }
2274 break;
2275
2276 case 0xd8: /* SKNC */
2277 if (insn[2] == 0xef)
2278 {
2279 insn[2] = 0xdc; /* BC */
2280 SNIPNR (0, 2);
2281 }
2282 break;
2283
2284 case 0xe8: /* SKZ */
2285 if (insn[2] == 0xef)
2286 {
2287 insn[2] = 0xdf; /* BNZ */
2288 SNIPNR (0, 2);
2289 }
2290 break;
2291
2292 case 0xf8: /* SKNZ */
2293 if (insn[2] == 0xef)
2294 {
2295 insn[2] = 0xdd; /* BZ */
2296 SNIPNR (0, 2);
2297 }
2298 break;
2299
2300 case 0xe3: /* SKH */
2301 if (insn[2] == 0xef)
2302 {
2303 insn[2] = 0xd3; /* BNH */
2304 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2305 }
2306 break;
2307
2308 case 0xf3: /* SKNH */
2309 if (insn[2] == 0xef)
2310 {
2311 insn[2] = 0xc3; /* BH */
2312 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2313 }
2314 break;
2315 }
2316 break;
2317 }
2318
2319 }
2320
2321 if (irel->r_addend & RL78_RELAXA_ADDR16)
2322 {
2323 /*----------------------------------------------------------------------*/
2324 /* Some insns have both a 16-bit address operand and an 8-bit
2325 variant if the address is within a special range:
2326
2327 Address 16-bit operand SADDR range SFR range
2328 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2329 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2330
2331 The RELAX_ADDR16[] array has the insn encodings for the
2332 16-bit operand version, as well as the SFR and SADDR
2333 variants. We only need to replace the encodings and
2334 adjust the operand.
2335
2336 Note: we intentionally do not attempt to decode and skip
2337 any ES: prefix, as adding ES: means the addr16 (likely)
2338 no longer points to saddr/sfr space.
2339 */
2340
2341 int is_sfr;
2342 int is_saddr;
2343 int idx;
2344 int poff;
2345
2346 GET_RELOC;
2347
2348 if (0xffe20 <= symval && symval <= 0xfffff)
2349 {
2350
2351 is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2352 is_sfr = (0xfff00 <= symval && symval <= 0xfffff);
2353
2354 for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2355 {
2356 if (relax_addr16[idx].prefix != -1
2357 && insn[0] == relax_addr16[idx].prefix
2358 && insn[1] == relax_addr16[idx].insn)
2359 {
2360 poff = 1;
2361 }
2362 else if (relax_addr16[idx].prefix == -1
2363 && insn[0] == relax_addr16[idx].insn)
2364 {
2365 poff = 0;
2366 }
2367 else
2368 continue;
2369
2370 /* We have a matched insn, and poff is 0 or 1 depending
2371 on the base pattern size. */
2372
2373 if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2374 {
2375 insn[poff] = relax_addr16[idx].insn_for_sfr;
2376 SNIP (poff+2, 1, R_RL78_RH_SFR);
2377 }
2378
2379 else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2380 {
2381 insn[poff] = relax_addr16[idx].insn_for_saddr;
2382 SNIP (poff+2, 1, R_RL78_RH_SADDR);
2383 }
2384
2385 }
2386 }
2387 }
2388
2389 /*----------------------------------------------------------------------*/
2390
2391 }
2392
2393 return TRUE;
2394
2395 error_return:
2396 if (free_relocs != NULL)
2397 free (free_relocs);
2398
2399 if (free_contents != NULL)
2400 free (free_contents);
2401
2402 if (shndx_buf != NULL)
2403 {
2404 shndx_hdr->contents = NULL;
2405 free (shndx_buf);
2406 }
2407
2408 if (free_intsyms != NULL)
2409 free (free_intsyms);
2410
2411 return TRUE;
2412 }
2413
2414 \f
2415
2416 #define ELF_ARCH bfd_arch_rl78
2417 #define ELF_MACHINE_CODE EM_RL78
2418 #define ELF_MAXPAGESIZE 0x1000
2419
2420 #define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
2421 #define TARGET_LITTLE_NAME "elf32-rl78"
2422
2423 #define elf_info_to_howto_rel NULL
2424 #define elf_info_to_howto rl78_info_to_howto_rela
2425 #define elf_backend_object_p rl78_elf_object_p
2426 #define elf_backend_relocate_section rl78_elf_relocate_section
2427 #define elf_symbol_leading_char ('_')
2428 #define elf_backend_can_gc_sections 1
2429
2430 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2431 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2432 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2433 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2434 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2435
2436 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2437 #define elf_backend_check_relocs rl78_elf_check_relocs
2438 #define elf_backend_always_size_sections \
2439 rl78_elf_always_size_sections
2440 #define elf_backend_finish_dynamic_sections \
2441 rl78_elf_finish_dynamic_sections
2442
2443 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.