projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* section.c (bfd_get_linker_section): New function.
[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
782 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
783 }
784 break;
785
786 case R_RL78_OPneg:
787 {
788 int32_t tmp;
789
790 RL78_STACK_POP (tmp);
791 tmp = - tmp;
792 RL78_STACK_PUSH (tmp);
793 }
794 break;
795
796 case R_RL78_OPadd:
797 {
798 int32_t tmp1, tmp2;
799
800 RL78_STACK_POP (tmp2);
801 RL78_STACK_POP (tmp1);
802 tmp1 += tmp2;
803 RL78_STACK_PUSH (tmp1);
804 }
805 break;
806
807 case R_RL78_OPsub:
808 {
809 int32_t tmp1, tmp2;
810
811 RL78_STACK_POP (tmp2);
812 RL78_STACK_POP (tmp1);
813 tmp2 -= tmp1;
814 RL78_STACK_PUSH (tmp2);
815 }
816 break;
817
818 case R_RL78_OPmul:
819 {
820 int32_t tmp1, tmp2;
821
822 RL78_STACK_POP (tmp2);
823 RL78_STACK_POP (tmp1);
824 tmp1 *= tmp2;
825 RL78_STACK_PUSH (tmp1);
826 }
827 break;
828
829 case R_RL78_OPdiv:
830 {
831 int32_t tmp1, tmp2;
832
833 RL78_STACK_POP (tmp2);
834 RL78_STACK_POP (tmp1);
835 tmp1 /= tmp2;
836 RL78_STACK_PUSH (tmp1);
837 }
838 break;
839
840 case R_RL78_OPshla:
841 {
842 int32_t tmp1, tmp2;
843
844 RL78_STACK_POP (tmp2);
845 RL78_STACK_POP (tmp1);
846 tmp1 <<= tmp2;
847 RL78_STACK_PUSH (tmp1);
848 }
849 break;
850
851 case R_RL78_OPshra:
852 {
853 int32_t tmp1, tmp2;
854
855 RL78_STACK_POP (tmp2);
856 RL78_STACK_POP (tmp1);
857 tmp1 >>= tmp2;
858 RL78_STACK_PUSH (tmp1);
859 }
860 break;
861
862 case R_RL78_OPsctsize:
863 RL78_STACK_PUSH (input_section->size);
864 break;
865
866 case R_RL78_OPscttop:
867 RL78_STACK_PUSH (input_section->output_section->vma);
868 break;
869
870 case R_RL78_OPand:
871 {
872 int32_t tmp1, tmp2;
873
874 RL78_STACK_POP (tmp2);
875 RL78_STACK_POP (tmp1);
876 tmp1 &= tmp2;
877 RL78_STACK_PUSH (tmp1);
878 }
879 break;
880
881 case R_RL78_OPor:
882 {
883 int32_t tmp1, tmp2;
884
885 RL78_STACK_POP (tmp2);
886 RL78_STACK_POP (tmp1);
887 tmp1 |= tmp2;
888 RL78_STACK_PUSH (tmp1);
889 }
890 break;
891
892 case R_RL78_OPxor:
893 {
894 int32_t tmp1, tmp2;
895
896 RL78_STACK_POP (tmp2);
897 RL78_STACK_POP (tmp1);
898 tmp1 ^= tmp2;
899 RL78_STACK_PUSH (tmp1);
900 }
901 break;
902
903 case R_RL78_OPnot:
904 {
905 int32_t tmp;
906
907 RL78_STACK_POP (tmp);
908 tmp = ~ tmp;
909 RL78_STACK_PUSH (tmp);
910 }
911 break;
912
913 case R_RL78_OPmod:
914 {
915 int32_t tmp1, tmp2;
916
917 RL78_STACK_POP (tmp2);
918 RL78_STACK_POP (tmp1);
919 tmp1 %= tmp2;
920 RL78_STACK_PUSH (tmp1);
921 }
922 break;
923
924 case R_RL78_OPromtop:
925 RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
926 break;
927
928 case R_RL78_OPramtop:
929 RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
930 break;
931
932 default:
933 r = bfd_reloc_notsupported;
934 break;
935 }
936
937 if (r != bfd_reloc_ok)
938 {
939 const char * msg = NULL;
940
941 switch (r)
942 {
943 case bfd_reloc_overflow:
944 /* Catch the case of a missing function declaration
945 and emit a more helpful error message. */
946 if (r_type == R_RL78_DIR24S_PCREL)
947 msg = _("%B(%A): error: call to undefined function '%s'");
948 else
949 r = info->callbacks->reloc_overflow
950 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
951 input_bfd, input_section, rel->r_offset);
952 break;
953
954 case bfd_reloc_undefined:
955 r = info->callbacks->undefined_symbol
956 (info, name, input_bfd, input_section, rel->r_offset,
957 TRUE);
958 break;
959
960 case bfd_reloc_other:
961 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
962 break;
963
964 case bfd_reloc_outofrange:
965 msg = _("%B(%A): internal error: out of range error");
966 break;
967
968 case bfd_reloc_notsupported:
969 msg = _("%B(%A): internal error: unsupported relocation error");
970 break;
971
972 case bfd_reloc_dangerous:
973 msg = _("%B(%A): internal error: dangerous relocation");
974 break;
975
976 default:
977 msg = _("%B(%A): internal error: unknown error");
978 break;
979 }
980
981 if (msg)
982 _bfd_error_handler (msg, input_bfd, input_section, name);
983
984 if (! r)
985 return FALSE;
986 }
987 }
988
989 return TRUE;
990 }
991 \f
992 /* Function to set the ELF flag bits. */
993
994 static bfd_boolean
995 rl78_elf_set_private_flags (bfd * abfd, flagword flags)
996 {
997 elf_elfheader (abfd)->e_flags = flags;
998 elf_flags_init (abfd) = TRUE;
999 return TRUE;
1000 }
1001
1002 static bfd_boolean no_warn_mismatch = FALSE;
1003
1004 void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1005
1006 void
1007 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1008 {
1009 no_warn_mismatch = user_no_warn_mismatch;
1010 }
1011
1012 /* Merge backend specific data from an object file to the output
1013 object file when linking. */
1014
1015 static bfd_boolean
1016 rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1017 {
1018 flagword new_flags;
1019 bfd_boolean error = FALSE;
1020
1021 new_flags = elf_elfheader (ibfd)->e_flags;
1022
1023 if (!elf_flags_init (obfd))
1024 {
1025 /* First call, no flags set. */
1026 elf_flags_init (obfd) = TRUE;
1027 elf_elfheader (obfd)->e_flags = new_flags;
1028 }
1029
1030 return !error;
1031 }
1032 \f
1033 static bfd_boolean
1034 rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1035 {
1036 FILE * file = (FILE *) ptr;
1037 flagword flags;
1038
1039 BFD_ASSERT (abfd != NULL && ptr != NULL);
1040
1041 /* Print normal ELF private data. */
1042 _bfd_elf_print_private_bfd_data (abfd, ptr);
1043
1044 flags = elf_elfheader (abfd)->e_flags;
1045 fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1046
1047 fputc ('\n', file);
1048 return TRUE;
1049 }
1050
1051 /* Return the MACH for an e_flags value. */
1052
1053 static int
1054 elf32_rl78_machine (bfd * abfd)
1055 {
1056 if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
1057 return bfd_mach_rl78;
1058
1059 return 0;
1060 }
1061
1062 static bfd_boolean
1063 rl78_elf_object_p (bfd * abfd)
1064 {
1065 bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1066 elf32_rl78_machine (abfd));
1067 return TRUE;
1068 }
1069 \f
1070 #ifdef DEBUG
1071 void
1072 rl78_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
1073 {
1074 size_t locsymcount;
1075 Elf_Internal_Sym * isymbuf;
1076 Elf_Internal_Sym * isymend;
1077 Elf_Internal_Sym * isym;
1078 Elf_Internal_Shdr * symtab_hdr;
1079 bfd_boolean free_internal = FALSE, free_external = FALSE;
1080 char * st_info_str;
1081 char * st_info_stb_str;
1082 char * st_other_str;
1083 char * st_shndx_str;
1084
1085 if (! internal_syms)
1086 {
1087 internal_syms = bfd_malloc (1000);
1088 free_internal = 1;
1089 }
1090 if (! external_syms)
1091 {
1092 external_syms = bfd_malloc (1000);
1093 free_external = 1;
1094 }
1095
1096 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1097 locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
1098 if (free_internal)
1099 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1100 symtab_hdr->sh_info, 0,
1101 internal_syms, external_syms, NULL);
1102 else
1103 isymbuf = internal_syms;
1104 isymend = isymbuf + locsymcount;
1105
1106 for (isym = isymbuf ; isym < isymend ; isym++)
1107 {
1108 switch (ELF_ST_TYPE (isym->st_info))
1109 {
1110 case STT_FUNC: st_info_str = "STT_FUNC";
1111 case STT_SECTION: st_info_str = "STT_SECTION";
1112 case STT_FILE: st_info_str = "STT_FILE";
1113 case STT_OBJECT: st_info_str = "STT_OBJECT";
1114 case STT_TLS: st_info_str = "STT_TLS";
1115 default: st_info_str = "";
1116 }
1117 switch (ELF_ST_BIND (isym->st_info))
1118 {
1119 case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
1120 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
1121 default: st_info_stb_str = "";
1122 }
1123 switch (ELF_ST_VISIBILITY (isym->st_other))
1124 {
1125 case STV_DEFAULT: st_other_str = "STV_DEFAULT";
1126 case STV_INTERNAL: st_other_str = "STV_INTERNAL";
1127 case STV_PROTECTED: st_other_str = "STV_PROTECTED";
1128 default: st_other_str = "";
1129 }
1130 switch (isym->st_shndx)
1131 {
1132 case SHN_ABS: st_shndx_str = "SHN_ABS";
1133 case SHN_COMMON: st_shndx_str = "SHN_COMMON";
1134 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
1135 default: st_shndx_str = "";
1136 }
1137 }
1138 if (free_internal)
1139 free (internal_syms);
1140 if (free_external)
1141 free (external_syms);
1142 }
1143
1144 char *
1145 rl78_get_reloc (long reloc)
1146 {
1147 if (0 <= reloc && reloc < R_RL78_max)
1148 return rl78_elf_howto_table[reloc].name;
1149 return "";
1150 }
1151 #endif /* DEBUG */
1152
1153 \f
1154 /* support PLT for 16-bit references to 24-bit functions. */
1155
1156 /* We support 16-bit pointers to code above 64k by generating a thunk
1157 below 64k containing a JMP instruction to the final address. */
1158
1159 static bfd_boolean
1160 rl78_elf_check_relocs
1161 (bfd * abfd,
1162 struct bfd_link_info * info,
1163 asection * sec,
1164 const Elf_Internal_Rela * relocs)
1165 {
1166 Elf_Internal_Shdr * symtab_hdr;
1167 struct elf_link_hash_entry ** sym_hashes;
1168 const Elf_Internal_Rela * rel;
1169 const Elf_Internal_Rela * rel_end;
1170 bfd_vma *local_plt_offsets;
1171 asection *splt;
1172 bfd *dynobj;
1173
1174 if (info->relocatable)
1175 return TRUE;
1176
1177 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1178 sym_hashes = elf_sym_hashes (abfd);
1179 local_plt_offsets = elf_local_got_offsets (abfd);
1180 splt = NULL;
1181 dynobj = elf_hash_table(info)->dynobj;
1182
1183 rel_end = relocs + sec->reloc_count;
1184 for (rel = relocs; rel < rel_end; rel++)
1185 {
1186 struct elf_link_hash_entry *h;
1187 unsigned long r_symndx;
1188 bfd_vma *offset;
1189
1190 r_symndx = ELF32_R_SYM (rel->r_info);
1191 if (r_symndx < symtab_hdr->sh_info)
1192 h = NULL;
1193 else
1194 {
1195 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1196 while (h->root.type == bfd_link_hash_indirect
1197 || h->root.type == bfd_link_hash_warning)
1198 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1199 }
1200
1201 switch (ELF32_R_TYPE (rel->r_info))
1202 {
1203 /* This relocation describes a 16-bit pointer to a function.
1204 We may need to allocate a thunk in low memory; reserve memory
1205 for it now. */
1206 case R_RL78_DIR16S:
1207 if (dynobj == NULL)
1208 elf_hash_table (info)->dynobj = dynobj = abfd;
1209 if (splt == NULL)
1210 {
1211 splt = bfd_get_linker_section (dynobj, ".plt");
1212 if (splt == NULL)
1213 {
1214 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1215 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1216 | SEC_READONLY | SEC_CODE);
1217 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1218 flags);
1219 if (splt == NULL
1220 || ! bfd_set_section_alignment (dynobj, splt, 1))
1221 return FALSE;
1222 }
1223 }
1224
1225 if (h != NULL)
1226 offset = &h->plt.offset;
1227 else
1228 {
1229 if (local_plt_offsets == NULL)
1230 {
1231 size_t size;
1232 unsigned int i;
1233
1234 size = symtab_hdr->sh_info * sizeof (bfd_vma);
1235 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1236 if (local_plt_offsets == NULL)
1237 return FALSE;
1238 elf_local_got_offsets (abfd) = local_plt_offsets;
1239
1240 for (i = 0; i < symtab_hdr->sh_info; i++)
1241 local_plt_offsets[i] = (bfd_vma) -1;
1242 }
1243 offset = &local_plt_offsets[r_symndx];
1244 }
1245
1246 if (*offset == (bfd_vma) -1)
1247 {
1248 *offset = splt->size;
1249 splt->size += 4;
1250 }
1251 break;
1252 }
1253 }
1254
1255 return TRUE;
1256 }
1257
1258 /* This must exist if dynobj is ever set. */
1259
1260 static bfd_boolean
1261 rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1262 struct bfd_link_info *info)
1263 {
1264 bfd *dynobj;
1265 asection *splt;
1266
1267 /* As an extra sanity check, verify that all plt entries have been
1268 filled in. However, relaxing might have changed the relocs so
1269 that some plt entries don't get filled in, so we have to skip
1270 this check if we're relaxing. Unfortunately, check_relocs is
1271 called before relaxation. */
1272
1273 if (info->relax_trip > 0)
1274 {
1275 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1276 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
1277 {
1278 bfd_byte *contents = splt->contents;
1279 unsigned int i, size = splt->size;
1280 for (i = 0; i < size; i += 4)
1281 {
1282 unsigned int x = bfd_get_32 (dynobj, contents + i);
1283 BFD_ASSERT (x != 0);
1284 }
1285 }
1286 }
1287
1288 return TRUE;
1289 }
1290
1291 static bfd_boolean
1292 rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1293 struct bfd_link_info *info)
1294 {
1295 bfd *dynobj;
1296 asection *splt;
1297
1298 if (info->relocatable)
1299 return TRUE;
1300
1301 dynobj = elf_hash_table (info)->dynobj;
1302 if (dynobj == NULL)
1303 return TRUE;
1304
1305 splt = bfd_get_linker_section (dynobj, ".plt");
1306 BFD_ASSERT (splt != NULL);
1307
1308 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1309 if (splt->contents == NULL)
1310 return FALSE;
1311
1312 return TRUE;
1313 }
1314
1315 \f
1316
1317 /* Handle relaxing. */
1318
1319 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1320 is within the low 64k, remove any entry for it in the plt. */
1321
1322 struct relax_plt_data
1323 {
1324 asection *splt;
1325 bfd_boolean *again;
1326 };
1327
1328 static bfd_boolean
1329 rl78_relax_plt_check (struct elf_link_hash_entry *h,
1330 PTR xdata)
1331 {
1332 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1333
1334 if (h->plt.offset != (bfd_vma) -1)
1335 {
1336 bfd_vma address;
1337
1338 if (h->root.type == bfd_link_hash_undefined
1339 || h->root.type == bfd_link_hash_undefweak)
1340 address = 0;
1341 else
1342 address = (h->root.u.def.section->output_section->vma
1343 + h->root.u.def.section->output_offset
1344 + h->root.u.def.value);
1345
1346 if (valid_16bit_address (address))
1347 {
1348 h->plt.offset = -1;
1349 data->splt->size -= 4;
1350 *data->again = TRUE;
1351 }
1352 }
1353
1354 return TRUE;
1355 }
1356
1357 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1358 previously had a plt entry, give it a new entry offset. */
1359
1360 static bfd_boolean
1361 rl78_relax_plt_realloc (struct elf_link_hash_entry *h,
1362 PTR xdata)
1363 {
1364 bfd_vma *entry = (bfd_vma *) xdata;
1365
1366 if (h->plt.offset != (bfd_vma) -1)
1367 {
1368 h->plt.offset = *entry;
1369 *entry += 4;
1370 }
1371
1372 return TRUE;
1373 }
1374
1375 static bfd_boolean
1376 rl78_elf_relax_plt_section (bfd *dynobj,
1377 asection *splt,
1378 struct bfd_link_info *info,
1379 bfd_boolean *again)
1380 {
1381 struct relax_plt_data relax_plt_data;
1382 bfd *ibfd;
1383
1384 /* Assume nothing changes. */
1385 *again = FALSE;
1386
1387 if (info->relocatable)
1388 return TRUE;
1389
1390 /* We only relax the .plt section at the moment. */
1391 if (dynobj != elf_hash_table (info)->dynobj
1392 || strcmp (splt->name, ".plt") != 0)
1393 return TRUE;
1394
1395 /* Quick check for an empty plt. */
1396 if (splt->size == 0)
1397 return TRUE;
1398
1399 /* Map across all global symbols; see which ones happen to
1400 fall in the low 64k. */
1401 relax_plt_data.splt = splt;
1402 relax_plt_data.again = again;
1403 elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1404 &relax_plt_data);
1405
1406 /* Likewise for local symbols, though that's somewhat less convenient
1407 as we have to walk the list of input bfds and swap in symbol data. */
1408 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1409 {
1410 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1411 Elf_Internal_Shdr *symtab_hdr;
1412 Elf_Internal_Sym *isymbuf = NULL;
1413 unsigned int idx;
1414
1415 if (! local_plt_offsets)
1416 continue;
1417
1418 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1419 if (symtab_hdr->sh_info != 0)
1420 {
1421 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1422 if (isymbuf == NULL)
1423 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1424 symtab_hdr->sh_info, 0,
1425 NULL, NULL, NULL);
1426 if (isymbuf == NULL)
1427 return FALSE;
1428 }
1429
1430 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1431 {
1432 Elf_Internal_Sym *isym;
1433 asection *tsec;
1434 bfd_vma address;
1435
1436 if (local_plt_offsets[idx] == (bfd_vma) -1)
1437 continue;
1438
1439 isym = &isymbuf[idx];
1440 if (isym->st_shndx == SHN_UNDEF)
1441 continue;
1442 else if (isym->st_shndx == SHN_ABS)
1443 tsec = bfd_abs_section_ptr;
1444 else if (isym->st_shndx == SHN_COMMON)
1445 tsec = bfd_com_section_ptr;
1446 else
1447 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1448
1449 address = (tsec->output_section->vma
1450 + tsec->output_offset
1451 + isym->st_value);
1452 if (valid_16bit_address (address))
1453 {
1454 local_plt_offsets[idx] = -1;
1455 splt->size -= 4;
1456 *again = TRUE;
1457 }
1458 }
1459
1460 if (isymbuf != NULL
1461 && symtab_hdr->contents != (unsigned char *) isymbuf)
1462 {
1463 if (! info->keep_memory)
1464 free (isymbuf);
1465 else
1466 {
1467 /* Cache the symbols for elf_link_input_bfd. */
1468 symtab_hdr->contents = (unsigned char *) isymbuf;
1469 }
1470 }
1471 }
1472
1473 /* If we changed anything, walk the symbols again to reallocate
1474 .plt entry addresses. */
1475 if (*again && splt->size > 0)
1476 {
1477 bfd_vma entry = 0;
1478
1479 elf_link_hash_traverse (elf_hash_table (info),
1480 rl78_relax_plt_realloc, &entry);
1481
1482 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1483 {
1484 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1485 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1486 unsigned int idx;
1487
1488 if (! local_plt_offsets)
1489 continue;
1490
1491 for (idx = 0; idx < nlocals; ++idx)
1492 if (local_plt_offsets[idx] != (bfd_vma) -1)
1493 {
1494 local_plt_offsets[idx] = entry;
1495 entry += 4;
1496 }
1497 }
1498 }
1499
1500 return TRUE;
1501 }
1502
1503 /* Delete some bytes from a section while relaxing. */
1504
1505 static bfd_boolean
1506 elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1507 Elf_Internal_Rela *alignment_rel, int force_snip)
1508 {
1509 Elf_Internal_Shdr * symtab_hdr;
1510 unsigned int sec_shndx;
1511 bfd_byte * contents;
1512 Elf_Internal_Rela * irel;
1513 Elf_Internal_Rela * irelend;
1514 Elf_Internal_Sym * isym;
1515 Elf_Internal_Sym * isymend;
1516 bfd_vma toaddr;
1517 unsigned int symcount;
1518 struct elf_link_hash_entry ** sym_hashes;
1519 struct elf_link_hash_entry ** end_hashes;
1520
1521 if (!alignment_rel)
1522 force_snip = 1;
1523
1524 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1525
1526 contents = elf_section_data (sec)->this_hdr.contents;
1527
1528 /* The deletion must stop at the next alignment boundary, if
1529 ALIGNMENT_REL is non-NULL. */
1530 toaddr = sec->size;
1531 if (alignment_rel)
1532 toaddr = alignment_rel->r_offset;
1533
1534 irel = elf_section_data (sec)->relocs;
1535 irelend = irel + sec->reloc_count;
1536
1537 /* Actually delete the bytes. */
1538 memmove (contents + addr, contents + addr + count,
1539 (size_t) (toaddr - addr - count));
1540
1541 /* If we don't have an alignment marker to worry about, we can just
1542 shrink the section. Otherwise, we have to fill in the newly
1543 created gap with NOP insns (0x03). */
1544 if (force_snip)
1545 sec->size -= count;
1546 else
1547 memset (contents + toaddr - count, 0x03, count);
1548
1549 /* Adjust all the relocs. */
1550 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1551 {
1552 /* Get the new reloc address. */
1553 if (irel->r_offset > addr
1554 && (irel->r_offset < toaddr
1555 || (force_snip && irel->r_offset == toaddr)))
1556 irel->r_offset -= count;
1557
1558 /* If we see an ALIGN marker at the end of the gap, we move it
1559 to the beginning of the gap, since marking these gaps is what
1560 they're for. */
1561 if (irel->r_offset == toaddr
1562 && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1563 && irel->r_addend & RL78_RELAXA_ALIGN)
1564 irel->r_offset -= count;
1565 }
1566
1567 /* Adjust the local symbols defined in this section. */
1568 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1569 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1570 isymend = isym + symtab_hdr->sh_info;
1571
1572 for (; isym < isymend; isym++)
1573 {
1574 /* If the symbol is in the range of memory we just moved, we
1575 have to adjust its value. */
1576 if (isym->st_shndx == sec_shndx
1577 && isym->st_value > addr
1578 && isym->st_value < toaddr)
1579 isym->st_value -= count;
1580
1581 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1582 *end* is in the moved bytes but it's *start* isn't), then we
1583 must adjust its size. */
1584 if (isym->st_shndx == sec_shndx
1585 && isym->st_value < addr
1586 && isym->st_value + isym->st_size > addr
1587 && isym->st_value + isym->st_size < toaddr)
1588 isym->st_size -= count;
1589 }
1590
1591 /* Now adjust the global symbols defined in this section. */
1592 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1593 - symtab_hdr->sh_info);
1594 sym_hashes = elf_sym_hashes (abfd);
1595 end_hashes = sym_hashes + symcount;
1596
1597 for (; sym_hashes < end_hashes; sym_hashes++)
1598 {
1599 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1600
1601 if ((sym_hash->root.type == bfd_link_hash_defined
1602 || sym_hash->root.type == bfd_link_hash_defweak)
1603 && sym_hash->root.u.def.section == sec)
1604 {
1605 /* As above, adjust the value if needed. */
1606 if (sym_hash->root.u.def.value > addr
1607 && sym_hash->root.u.def.value < toaddr)
1608 sym_hash->root.u.def.value -= count;
1609
1610 /* As above, adjust the size if needed. */
1611 if (sym_hash->root.u.def.value < addr
1612 && sym_hash->root.u.def.value + sym_hash->size > addr
1613 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1614 sym_hash->size -= count;
1615 }
1616 }
1617
1618 return TRUE;
1619 }
1620
1621 /* Used to sort relocs by address. If relocs have the same address,
1622 we maintain their relative order, except that R_RL78_RH_RELAX
1623 alignment relocs must be the first reloc for any given address. */
1624
1625 static void
1626 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1627 {
1628 int i;
1629 bfd_boolean again;
1630 bfd_boolean swappit;
1631
1632 /* This is almost a classic bubblesort. It's the slowest sort, but
1633 we're taking advantage of the fact that the relocations are
1634 mostly in order already (the assembler emits them that way) and
1635 we need relocs with the same address to remain in the same
1636 relative order. */
1637 again = TRUE;
1638 while (again)
1639 {
1640 again = FALSE;
1641 for (i = 0; i < count - 1; i ++)
1642 {
1643 if (r[i].r_offset > r[i + 1].r_offset)
1644 swappit = TRUE;
1645 else if (r[i].r_offset < r[i + 1].r_offset)
1646 swappit = FALSE;
1647 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1648 && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1649 swappit = TRUE;
1650 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1651 && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1652 && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1653 && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1654 swappit = TRUE;
1655 else
1656 swappit = FALSE;
1657
1658 if (swappit)
1659 {
1660 Elf_Internal_Rela tmp;
1661
1662 tmp = r[i];
1663 r[i] = r[i + 1];
1664 r[i + 1] = tmp;
1665 /* If we do move a reloc back, re-scan to see if it
1666 needs to be moved even further back. This avoids
1667 most of the O(n^2) behavior for our cases. */
1668 if (i > 0)
1669 i -= 2;
1670 again = TRUE;
1671 }
1672 }
1673 }
1674 }
1675
1676
1677 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1678 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1679 lrel, abfd, sec, link_info, scale)
1680
1681 static bfd_vma
1682 rl78_offset_for_reloc (bfd * abfd,
1683 Elf_Internal_Rela * rel,
1684 Elf_Internal_Shdr * symtab_hdr,
1685 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1686 Elf_Internal_Sym * intsyms,
1687 Elf_Internal_Rela ** lrel,
1688 bfd * input_bfd,
1689 asection * input_section,
1690 struct bfd_link_info * info,
1691 int * scale)
1692 {
1693 bfd_vma symval;
1694 bfd_reloc_status_type r;
1695
1696 *scale = 1;
1697
1698 /* REL is the first of 1..N relocations. We compute the symbol
1699 value for each relocation, then combine them if needed. LREL
1700 gets a pointer to the last relocation used. */
1701 while (1)
1702 {
1703 int32_t tmp1, tmp2;
1704
1705 /* Get the value of the symbol referred to by the reloc. */
1706 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1707 {
1708 /* A local symbol. */
1709 Elf_Internal_Sym *isym;
1710 asection *ssec;
1711
1712 isym = intsyms + ELF32_R_SYM (rel->r_info);
1713
1714 if (isym->st_shndx == SHN_UNDEF)
1715 ssec = bfd_und_section_ptr;
1716 else if (isym->st_shndx == SHN_ABS)
1717 ssec = bfd_abs_section_ptr;
1718 else if (isym->st_shndx == SHN_COMMON)
1719 ssec = bfd_com_section_ptr;
1720 else
1721 ssec = bfd_section_from_elf_index (abfd,
1722 isym->st_shndx);
1723
1724 /* Initial symbol value. */
1725 symval = isym->st_value;
1726
1727 /* GAS may have made this symbol relative to a section, in
1728 which case, we have to add the addend to find the
1729 symbol. */
1730 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1731 symval += rel->r_addend;
1732
1733 if (ssec)
1734 {
1735 if ((ssec->flags & SEC_MERGE)
1736 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1737 symval = _bfd_merged_section_offset (abfd, & ssec,
1738 elf_section_data (ssec)->sec_info,
1739 symval);
1740 }
1741
1742 /* Now make the offset relative to where the linker is putting it. */
1743 if (ssec)
1744 symval +=
1745 ssec->output_section->vma + ssec->output_offset;
1746
1747 symval += rel->r_addend;
1748 }
1749 else
1750 {
1751 unsigned long indx;
1752 struct elf_link_hash_entry * h;
1753
1754 /* An external symbol. */
1755 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1756 h = elf_sym_hashes (abfd)[indx];
1757 BFD_ASSERT (h != NULL);
1758
1759 if (h->root.type != bfd_link_hash_defined
1760 && h->root.type != bfd_link_hash_defweak)
1761 {
1762 /* This appears to be a reference to an undefined
1763 symbol. Just ignore it--it will be caught by the
1764 regular reloc processing. */
1765 if (lrel)
1766 *lrel = rel;
1767 return 0;
1768 }
1769
1770 symval = (h->root.u.def.value
1771 + h->root.u.def.section->output_section->vma
1772 + h->root.u.def.section->output_offset);
1773
1774 symval += rel->r_addend;
1775 }
1776
1777 switch (ELF32_R_TYPE (rel->r_info))
1778 {
1779 case R_RL78_SYM:
1780 RL78_STACK_PUSH (symval);
1781 break;
1782
1783 case R_RL78_OPneg:
1784 RL78_STACK_POP (tmp1);
1785 tmp1 = - tmp1;
1786 RL78_STACK_PUSH (tmp1);
1787 break;
1788
1789 case R_RL78_OPadd:
1790 RL78_STACK_POP (tmp1);
1791 RL78_STACK_POP (tmp2);
1792 tmp1 += tmp2;
1793 RL78_STACK_PUSH (tmp1);
1794 break;
1795
1796 case R_RL78_OPsub:
1797 RL78_STACK_POP (tmp1);
1798 RL78_STACK_POP (tmp2);
1799 tmp2 -= tmp1;
1800 RL78_STACK_PUSH (tmp2);
1801 break;
1802
1803 case R_RL78_OPmul:
1804 RL78_STACK_POP (tmp1);
1805 RL78_STACK_POP (tmp2);
1806 tmp1 *= tmp2;
1807 RL78_STACK_PUSH (tmp1);
1808 break;
1809
1810 case R_RL78_OPdiv:
1811 RL78_STACK_POP (tmp1);
1812 RL78_STACK_POP (tmp2);
1813 tmp1 /= tmp2;
1814 RL78_STACK_PUSH (tmp1);
1815 break;
1816
1817 case R_RL78_OPshla:
1818 RL78_STACK_POP (tmp1);
1819 RL78_STACK_POP (tmp2);
1820 tmp1 <<= tmp2;
1821 RL78_STACK_PUSH (tmp1);
1822 break;
1823
1824 case R_RL78_OPshra:
1825 RL78_STACK_POP (tmp1);
1826 RL78_STACK_POP (tmp2);
1827 tmp1 >>= tmp2;
1828 RL78_STACK_PUSH (tmp1);
1829 break;
1830
1831 case R_RL78_OPsctsize:
1832 RL78_STACK_PUSH (input_section->size);
1833 break;
1834
1835 case R_RL78_OPscttop:
1836 RL78_STACK_PUSH (input_section->output_section->vma);
1837 break;
1838
1839 case R_RL78_OPand:
1840 RL78_STACK_POP (tmp1);
1841 RL78_STACK_POP (tmp2);
1842 tmp1 &= tmp2;
1843 RL78_STACK_PUSH (tmp1);
1844 break;
1845
1846 case R_RL78_OPor:
1847 RL78_STACK_POP (tmp1);
1848 RL78_STACK_POP (tmp2);
1849 tmp1 |= tmp2;
1850 RL78_STACK_PUSH (tmp1);
1851 break;
1852
1853 case R_RL78_OPxor:
1854 RL78_STACK_POP (tmp1);
1855 RL78_STACK_POP (tmp2);
1856 tmp1 ^= tmp2;
1857 RL78_STACK_PUSH (tmp1);
1858 break;
1859
1860 case R_RL78_OPnot:
1861 RL78_STACK_POP (tmp1);
1862 tmp1 = ~ tmp1;
1863 RL78_STACK_PUSH (tmp1);
1864 break;
1865
1866 case R_RL78_OPmod:
1867 RL78_STACK_POP (tmp1);
1868 RL78_STACK_POP (tmp2);
1869 tmp1 %= tmp2;
1870 RL78_STACK_PUSH (tmp1);
1871 break;
1872
1873 case R_RL78_OPromtop:
1874 RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1875 break;
1876
1877 case R_RL78_OPramtop:
1878 RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1879 break;
1880
1881 case R_RL78_DIR16UL:
1882 case R_RL78_DIR8UL:
1883 case R_RL78_ABS16UL:
1884 case R_RL78_ABS8UL:
1885 if (rl78_stack_top)
1886 RL78_STACK_POP (symval);
1887 if (lrel)
1888 *lrel = rel;
1889 *scale = 4;
1890 return symval;
1891
1892 case R_RL78_DIR16UW:
1893 case R_RL78_DIR8UW:
1894 case R_RL78_ABS16UW:
1895 case R_RL78_ABS8UW:
1896 if (rl78_stack_top)
1897 RL78_STACK_POP (symval);
1898 if (lrel)
1899 *lrel = rel;
1900 *scale = 2;
1901 return symval;
1902
1903 default:
1904 if (rl78_stack_top)
1905 RL78_STACK_POP (symval);
1906 if (lrel)
1907 *lrel = rel;
1908 return symval;
1909 }
1910
1911 rel ++;
1912 }
1913 }
1914
1915 struct {
1916 int prefix; /* or -1 for "no prefix" */
1917 int insn; /* or -1 for "end of list" */
1918 int insn_for_saddr; /* or -1 for "no alternative" */
1919 int insn_for_sfr; /* or -1 for "no alternative" */
1920 } relax_addr16[] = {
1921 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1922 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1923 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1924 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1925
1926 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1927 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1928 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1929 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
1930 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
1931 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
1932 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
1933 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
1934
1935 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
1936 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
1937 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
1938 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
1939 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
1940
1941 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
1942 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
1943 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
1944 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
1945
1946 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
1947 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
1948 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
1949
1950 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
1951 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
1952 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
1953 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
1954 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
1955 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
1956
1957 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
1958
1959 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
1960 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
1961 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
1962 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
1963 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
1964 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
1965 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
1966 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
1967
1968 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
1969 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
1970 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
1971 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
1972 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
1973 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
1974 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
1975 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
1976
1977 { -1, -1, -1, -1 }
1978 };
1979
1980 /* Relax one section. */
1981
1982 static bfd_boolean
1983 rl78_elf_relax_section
1984 (bfd * abfd,
1985 asection * sec,
1986 struct bfd_link_info * link_info,
1987 bfd_boolean * again)
1988 {
1989 Elf_Internal_Shdr * symtab_hdr;
1990 Elf_Internal_Shdr * shndx_hdr;
1991 Elf_Internal_Rela * internal_relocs;
1992 Elf_Internal_Rela * free_relocs = NULL;
1993 Elf_Internal_Rela * irel;
1994 Elf_Internal_Rela * srel;
1995 Elf_Internal_Rela * irelend;
1996 Elf_Internal_Rela * next_alignment;
1997 bfd_byte * contents = NULL;
1998 bfd_byte * free_contents = NULL;
1999 Elf_Internal_Sym * intsyms = NULL;
2000 Elf_Internal_Sym * free_intsyms = NULL;
2001 Elf_External_Sym_Shndx * shndx_buf = NULL;
2002 bfd_vma pc;
2003 bfd_vma symval ATTRIBUTE_UNUSED = 0;
2004 int pcrel ATTRIBUTE_UNUSED = 0;
2005 int code ATTRIBUTE_UNUSED = 0;
2006 int section_alignment_glue;
2007 int scale;
2008
2009 if (abfd == elf_hash_table (link_info)->dynobj
2010 && strcmp (sec->name, ".plt") == 0)
2011 return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
2012
2013 /* Assume nothing changes. */
2014 *again = FALSE;
2015
2016 /* We don't have to do anything for a relocatable link, if
2017 this section does not have relocs, or if this is not a
2018 code section. */
2019 if (link_info->relocatable
2020 || (sec->flags & SEC_RELOC) == 0
2021 || sec->reloc_count == 0
2022 || (sec->flags & SEC_CODE) == 0)
2023 return TRUE;
2024
2025 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2026 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2027
2028 /* Get the section contents. */
2029 if (elf_section_data (sec)->this_hdr.contents != NULL)
2030 contents = elf_section_data (sec)->this_hdr.contents;
2031 /* Go get them off disk. */
2032 else
2033 {
2034 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2035 goto error_return;
2036 elf_section_data (sec)->this_hdr.contents = contents;
2037 }
2038
2039 /* Read this BFD's symbols. */
2040 /* Get cached copy if it exists. */
2041 if (symtab_hdr->contents != NULL)
2042 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2043 else
2044 {
2045 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2046 symtab_hdr->contents = (bfd_byte *) intsyms;
2047 }
2048
2049 if (shndx_hdr->sh_size != 0)
2050 {
2051 bfd_size_type amt;
2052
2053 amt = symtab_hdr->sh_info;
2054 amt *= sizeof (Elf_External_Sym_Shndx);
2055 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2056 if (shndx_buf == NULL)
2057 goto error_return;
2058 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2059 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
2060 goto error_return;
2061 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2062 }
2063
2064 /* Get a copy of the native relocations. */
2065 internal_relocs = (_bfd_elf_link_read_relocs
2066 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2067 link_info->keep_memory));
2068 if (internal_relocs == NULL)
2069 goto error_return;
2070 if (! link_info->keep_memory)
2071 free_relocs = internal_relocs;
2072
2073 /* The RL_ relocs must be just before the operand relocs they go
2074 with, so we must sort them to guarantee this. We use bubblesort
2075 instead of qsort so we can guarantee that relocs with the same
2076 address remain in the same relative order. */
2077 reloc_bubblesort (internal_relocs, sec->reloc_count);
2078
2079 /* Walk through them looking for relaxing opportunities. */
2080 irelend = internal_relocs + sec->reloc_count;
2081
2082
2083 /* This will either be NULL or a pointer to the next alignment
2084 relocation. */
2085 next_alignment = internal_relocs;
2086
2087 /* We calculate worst case shrinkage caused by alignment directives.
2088 No fool-proof, but better than either ignoring the problem or
2089 doing heavy duty analysis of all the alignment markers in all
2090 input sections. */
2091 section_alignment_glue = 0;
2092 for (irel = internal_relocs; irel < irelend; irel++)
2093 if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2094 && irel->r_addend & RL78_RELAXA_ALIGN)
2095 {
2096 int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2097
2098 if (section_alignment_glue < this_glue)
2099 section_alignment_glue = this_glue;
2100 }
2101 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2102 shrinkage. */
2103 section_alignment_glue *= 2;
2104
2105 for (irel = internal_relocs; irel < irelend; irel++)
2106 {
2107 unsigned char *insn;
2108 int nrelocs;
2109
2110 /* The insns we care about are all marked with one of these. */
2111 if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2112 continue;
2113
2114 if (irel->r_addend & RL78_RELAXA_ALIGN
2115 || next_alignment == internal_relocs)
2116 {
2117 /* When we delete bytes, we need to maintain all the alignments
2118 indicated. In addition, we need to be careful about relaxing
2119 jumps across alignment boundaries - these displacements
2120 *grow* when we delete bytes. For now, don't shrink
2121 displacements across an alignment boundary, just in case.
2122 Note that this only affects relocations to the same
2123 section. */
2124 next_alignment += 2;
2125 while (next_alignment < irelend
2126 && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2127 || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2128 next_alignment ++;
2129 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2130 next_alignment = NULL;
2131 }
2132
2133 /* When we hit alignment markers, see if we've shrunk enough
2134 before them to reduce the gap without violating the alignment
2135 requirements. */
2136 if (irel->r_addend & RL78_RELAXA_ALIGN)
2137 {
2138 /* At this point, the next relocation *should* be the ELIGN
2139 end marker. */
2140 Elf_Internal_Rela *erel = irel + 1;
2141 unsigned int alignment, nbytes;
2142
2143 if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2144 continue;
2145 if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2146 continue;
2147
2148 alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2149
2150 if (erel->r_offset - irel->r_offset < alignment)
2151 continue;
2152
2153 nbytes = erel->r_offset - irel->r_offset;
2154 nbytes /= alignment;
2155 nbytes *= alignment;
2156
2157 elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2158 erel->r_offset == sec->size);
2159 *again = TRUE;
2160
2161 continue;
2162 }
2163
2164 if (irel->r_addend & RL78_RELAXA_ELIGN)
2165 continue;
2166
2167 insn = contents + irel->r_offset;
2168
2169 nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2170
2171 /* At this point, we have an insn that is a candidate for linker
2172 relaxation. There are NRELOCS relocs following that may be
2173 relaxed, although each reloc may be made of more than one
2174 reloc entry (such as gp-rel symbols). */
2175
2176 /* Get the value of the symbol referred to by the reloc. Just
2177 in case this is the last reloc in the list, use the RL's
2178 addend to choose between this reloc (no addend) or the next
2179 (yes addend, which means at least one following reloc). */
2180
2181 /* srel points to the "current" reloction for this insn -
2182 actually the last reloc for a given operand, which is the one
2183 we need to update. We check the relaxations in the same
2184 order that the relocations happen, so we'll just push it
2185 along as we go. */
2186 srel = irel;
2187
2188 pc = sec->output_section->vma + sec->output_offset
2189 + srel->r_offset;
2190
2191 #define GET_RELOC \
2192 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2193 pcrel = symval - pc + srel->r_addend; \
2194 nrelocs --;
2195
2196 #define SNIPNR(offset, nbytes) \
2197 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2198 #define SNIP(offset, nbytes, newtype) \
2199 SNIPNR (offset, nbytes); \
2200 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2201
2202 /* The order of these bit tests must match the order that the
2203 relocs appear in. Since we sorted those by offset, we can
2204 predict them. */
2205
2206 /*----------------------------------------------------------------------*/
2207 /* EF ad BR $rel8 pcrel
2208 ED al ah BR !abs16 abs
2209 EE al ah BR $!rel16 pcrel
2210 EC al ah as BR !!abs20 abs
2211
2212 FD al ah CALL !abs16 abs
2213 FE al ah CALL $!rel16 pcrel
2214 FC al ah as CALL !!abs20 abs
2215
2216 DC ad BC $rel8
2217 DE ad BNC $rel8
2218 DD ad BZ $rel8
2219 DF ad BNZ $rel8
2220 61 C3 ad BH $rel8
2221 61 D3 ad BNH $rel8
2222 61 C8 EF ad SKC ; BR $rel8
2223 61 D8 EF ad SKNC ; BR $rel8
2224 61 E8 EF ad SKZ ; BR $rel8
2225 61 F8 EF ad SKNZ ; BR $rel8
2226 61 E3 EF ad SKH ; BR $rel8
2227 61 F3 EF ad SKNH ; BR $rel8
2228 */
2229
2230 if (irel->r_addend & RL78_RELAXA_BRA)
2231 {
2232 GET_RELOC;
2233
2234 switch (insn[0])
2235 {
2236 case 0xec: /* BR !!abs20 */
2237
2238 if (pcrel < 127
2239 && pcrel > -127)
2240 {
2241 insn[0] = 0xef;
2242 insn[1] = pcrel;
2243 SNIP (2, 2, R_RL78_DIR8S_PCREL);
2244 *again = TRUE;
2245 }
2246 else if (symval < 65536)
2247 {
2248 insn[0] = 0xed;
2249 insn[1] = symval & 0xff;
2250 insn[2] = symval >> 8;
2251 SNIP (2, 1, R_RL78_DIR16S);
2252 *again = TRUE;
2253 }
2254 else if (pcrel < 32767
2255 && pcrel > -32767)
2256 {
2257 insn[0] = 0xee;
2258 insn[1] = pcrel & 0xff;
2259 insn[2] = pcrel >> 8;
2260 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2261 *again = TRUE;
2262 }
2263 break;
2264
2265 case 0xee: /* BR $!pcrel16 */
2266 case 0xed: /* BR $!abs16 */
2267 if (pcrel < 127
2268 && pcrel > -127)
2269 {
2270 insn[0] = 0xef;
2271 insn[1] = pcrel;
2272 SNIP (2, 1, R_RL78_DIR8S_PCREL);
2273 *again = TRUE;
2274 }
2275 break;
2276
2277 case 0xfc: /* CALL !!abs20 */
2278 if (symval < 65536)
2279 {
2280 insn[0] = 0xfd;
2281 insn[1] = symval & 0xff;
2282 insn[2] = symval >> 8;
2283 SNIP (2, 1, R_RL78_DIR16S);
2284 *again = TRUE;
2285 }
2286 else if (pcrel < 32767
2287 && pcrel > -32767)
2288 {
2289 insn[0] = 0xfe;
2290 insn[1] = pcrel & 0xff;
2291 insn[2] = pcrel >> 8;
2292 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2293 *again = TRUE;
2294 }
2295 break;
2296
2297 case 0x61: /* PREFIX */
2298 /* For SKIP/BR, we change the BR opcode and delete the
2299 SKIP. That way, we don't have to find and change the
2300 relocation for the BR. */
2301 switch (insn[1])
2302 {
2303 case 0xc8: /* SKC */
2304 if (insn[2] == 0xef)
2305 {
2306 insn[2] = 0xde; /* BNC */
2307 SNIPNR (0, 2);
2308 }
2309 break;
2310
2311 case 0xd8: /* SKNC */
2312 if (insn[2] == 0xef)
2313 {
2314 insn[2] = 0xdc; /* BC */
2315 SNIPNR (0, 2);
2316 }
2317 break;
2318
2319 case 0xe8: /* SKZ */
2320 if (insn[2] == 0xef)
2321 {
2322 insn[2] = 0xdf; /* BNZ */
2323 SNIPNR (0, 2);
2324 }
2325 break;
2326
2327 case 0xf8: /* SKNZ */
2328 if (insn[2] == 0xef)
2329 {
2330 insn[2] = 0xdd; /* BZ */
2331 SNIPNR (0, 2);
2332 }
2333 break;
2334
2335 case 0xe3: /* SKH */
2336 if (insn[2] == 0xef)
2337 {
2338 insn[2] = 0xd3; /* BNH */
2339 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2340 }
2341 break;
2342
2343 case 0xf3: /* SKNH */
2344 if (insn[2] == 0xef)
2345 {
2346 insn[2] = 0xc3; /* BH */
2347 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2348 }
2349 break;
2350 }
2351 break;
2352 }
2353
2354 }
2355
2356 if (irel->r_addend & RL78_RELAXA_ADDR16)
2357 {
2358 /*----------------------------------------------------------------------*/
2359 /* Some insns have both a 16-bit address operand and an 8-bit
2360 variant if the address is within a special range:
2361
2362 Address 16-bit operand SADDR range SFR range
2363 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2364 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2365
2366 The RELAX_ADDR16[] array has the insn encodings for the
2367 16-bit operand version, as well as the SFR and SADDR
2368 variants. We only need to replace the encodings and
2369 adjust the operand.
2370
2371 Note: we intentionally do not attempt to decode and skip
2372 any ES: prefix, as adding ES: means the addr16 (likely)
2373 no longer points to saddr/sfr space.
2374 */
2375
2376 int is_sfr;
2377 int is_saddr;
2378 int idx;
2379 int poff;
2380
2381 GET_RELOC;
2382
2383 if (0xffe20 <= symval && symval <= 0xfffff)
2384 {
2385
2386 is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2387 is_sfr = (0xfff00 <= symval && symval <= 0xfffff);
2388
2389 for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2390 {
2391 if (relax_addr16[idx].prefix != -1
2392 && insn[0] == relax_addr16[idx].prefix
2393 && insn[1] == relax_addr16[idx].insn)
2394 {
2395 poff = 1;
2396 }
2397 else if (relax_addr16[idx].prefix == -1
2398 && insn[0] == relax_addr16[idx].insn)
2399 {
2400 poff = 0;
2401 }
2402 else
2403 continue;
2404
2405 /* We have a matched insn, and poff is 0 or 1 depending
2406 on the base pattern size. */
2407
2408 if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2409 {
2410 insn[poff] = relax_addr16[idx].insn_for_sfr;
2411 SNIP (poff+2, 1, R_RL78_RH_SFR);
2412 }
2413
2414 else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2415 {
2416 insn[poff] = relax_addr16[idx].insn_for_saddr;
2417 SNIP (poff+2, 1, R_RL78_RH_SADDR);
2418 }
2419
2420 }
2421 }
2422 }
2423
2424 /*----------------------------------------------------------------------*/
2425
2426 }
2427
2428 return TRUE;
2429
2430 error_return:
2431 if (free_relocs != NULL)
2432 free (free_relocs);
2433
2434 if (free_contents != NULL)
2435 free (free_contents);
2436
2437 if (shndx_buf != NULL)
2438 {
2439 shndx_hdr->contents = NULL;
2440 free (shndx_buf);
2441 }
2442
2443 if (free_intsyms != NULL)
2444 free (free_intsyms);
2445
2446 return TRUE;
2447 }
2448
2449 \f
2450
2451 #define ELF_ARCH bfd_arch_rl78
2452 #define ELF_MACHINE_CODE EM_RL78
2453 #define ELF_MAXPAGESIZE 0x1000
2454
2455 #define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
2456 #define TARGET_LITTLE_NAME "elf32-rl78"
2457
2458 #define elf_info_to_howto_rel NULL
2459 #define elf_info_to_howto rl78_info_to_howto_rela
2460 #define elf_backend_object_p rl78_elf_object_p
2461 #define elf_backend_relocate_section rl78_elf_relocate_section
2462 #define elf_symbol_leading_char ('_')
2463 #define elf_backend_can_gc_sections 1
2464
2465 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2466 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2467 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2468 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2469 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2470
2471 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2472 #define elf_backend_check_relocs rl78_elf_check_relocs
2473 #define elf_backend_always_size_sections \
2474 rl78_elf_always_size_sections
2475 #define elf_backend_finish_dynamic_sections \
2476 rl78_elf_finish_dynamic_sections
2477
2478 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.11664 seconds and 5 git commands to generate.