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