projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* opncls.c (bfd_alloc_by_size_t): Set bfd_error_no_memory if
[deliverable/binutils-gdb.git] / bfd / coff-sh.c
CommitLineData
46dd0622 1/* BFD back-end for Hitachi Super-H COFF binaries.
51fbf454 2 Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
46dd0622
SC		 3 Contributed by Cygnus Support.
4 Written by Steve Chamberlain, <sac@cygnus.com>.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
e0981b9b 20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
46dd0622
SC		 21
22#include "bfd.h"
23#include "sysdep.h"
46dd0622 24#include "obstack.h"
6812b607
ILT		 25#include "libbfd.h"
26#include "bfdlink.h"
46dd0622
SC		 27#include "coff/sh.h"
28#include "coff/internal.h"
29#include "libcoff.h"
46dd0622 30
e0981b9b
ILT		 31/* Internal functions. */
32static bfd_reloc_status_type sh_reloc
33 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
34static long get_symbol_value PARAMS ((asymbol *));
35static boolean sh_relax_section
36 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
37static boolean sh_relax_delete_bytes
38 PARAMS ((bfd *, asection *, bfd_vma, int));
39static boolean sh_relocate_section
40 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
41 struct internal_reloc *, struct internal_syment *, asection **));
42static bfd_byte *sh_coff_get_relocated_section_contents
43 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
44 bfd_byte *, boolean, asymbol **));
46dd0622 45
e0981b9b 46/* Default section alignment to 2**2. */
f6f350fe
KR		 47#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
48
e0981b9b
ILT		 49/* Generate long file names. */
50#define COFF_LONG_FILENAMES
46dd0622 51
e0981b9b
ILT		 52/* The supported relocations. There are a lot of relocations defined
53 in coff/internal.h which we do not expect to ever see. */
54static reloc_howto_type sh_coff_howtos[] =
55{
56 { 0 },
57 { 1 },
58 { 2 },
59 { 3 }, /* R_SH_PCREL8 */
60 { 4 }, /* R_SH_PCREL16 */
61 { 5 }, /* R_SH_HIGH8 */
62 { 6 }, /* R_SH_IMM24 */
63 { 7 }, /* R_SH_LOW16 */
64 { 8 },
65 { 9 }, /* R_SH_PCDISP8BY4 */
66
67 HOWTO (R_SH_PCDISP8BY2, /* type */
68 1, /* rightshift */
69 1, /* size (0 = byte, 1 = short, 2 = long) */
70 8, /* bitsize */
71 true, /* pc_relative */
72 0, /* bitpos */
73 complain_overflow_signed, /* complain_on_overflow */
74 sh_reloc, /* special_function */
75 "r_pcdisp8by2", /* name */
76 true, /* partial_inplace */
77 0xff, /* src_mask */
78 0xff, /* dst_mask */
79 true), /* pcrel_offset */
80
81 { 11 }, /* R_SH_PCDISP8 */
82
83 HOWTO (R_SH_PCDISP, /* type */
84 1, /* rightshift */
85 1, /* size (0 = byte, 1 = short, 2 = long) */
86 12, /* bitsize */
87 true, /* pc_relative */
88 0, /* bitpos */
89 complain_overflow_signed, /* complain_on_overflow */
90 sh_reloc, /* special_function */
91 "r_pcdisp12by2", /* name */
92 true, /* partial_inplace */
93 0xfff, /* src_mask */
94 0xfff, /* dst_mask */
95 true), /* pcrel_offset */
96
97 { 13 },
98
99 HOWTO (R_SH_IMM32, /* type */
100 0, /* rightshift */
101 2, /* size (0 = byte, 1 = short, 2 = long) */
102 32, /* bitsize */
103 false, /* pc_relative */
104 0, /* bitpos */
105 complain_overflow_bitfield, /* complain_on_overflow */
106 sh_reloc, /* special_function */
107 "r_imm32", /* name */
108 true, /* partial_inplace */
109 0xffffffff, /* src_mask */
110 0xffffffff, /* dst_mask */
111 false), /* pcrel_offset */
112
113 { 15 },
114 { 16 }, /* R_SH_IMM8 */
115 { 17 }, /* R_SH_IMM8BY2 */
116 { 18 }, /* R_SH_IMM8BY4 */
117 { 19 }, /* R_SH_IMM4 */
118 { 20 }, /* R_SH_IMM4BY2 */
119 { 21 }, /* R_SH_IMM4BY4 */
120
121 HOWTO (R_SH_PCRELIMM8BY2, /* type */
122 1, /* rightshift */
123 1, /* size (0 = byte, 1 = short, 2 = long) */
124 8, /* bitsize */
125 true, /* pc_relative */
126 0, /* bitpos */
127 complain_overflow_unsigned, /* complain_on_overflow */
128 sh_reloc, /* special_function */
129 "r_pcrelimm8by2", /* name */
130 true, /* partial_inplace */
131 0xff, /* src_mask */
132 0xff, /* dst_mask */
133 true), /* pcrel_offset */
134
135 HOWTO (R_SH_PCRELIMM8BY4, /* type */
136 2, /* rightshift */
137 1, /* size (0 = byte, 1 = short, 2 = long) */
138 8, /* bitsize */
139 true, /* pc_relative */
140 0, /* bitpos */
141 complain_overflow_unsigned, /* complain_on_overflow */
142 sh_reloc, /* special_function */
143 "r_pcrelimm8by4", /* name */
144 true, /* partial_inplace */
145 0xff, /* src_mask */
146 0xff, /* dst_mask */
147 true), /* pcrel_offset */
148
149 HOWTO (R_SH_IMM16, /* type */
150 0, /* rightshift */
151 1, /* size (0 = byte, 1 = short, 2 = long) */
152 16, /* bitsize */
153 false, /* pc_relative */
154 0, /* bitpos */
155 complain_overflow_bitfield, /* complain_on_overflow */
156 sh_reloc, /* special_function */
157 "r_imm16", /* name */
158 true, /* partial_inplace */
159 0xffff, /* src_mask */
160 0xffff, /* dst_mask */
161 false), /* pcrel_offset */
162
163 HOWTO (R_SH_SWITCH16, /* type */
164 0, /* rightshift */
165 1, /* size (0 = byte, 1 = short, 2 = long) */
166 16, /* bitsize */
167 false, /* pc_relative */
168 0, /* bitpos */
169 complain_overflow_bitfield, /* complain_on_overflow */
170 sh_reloc, /* special_function */
171 "r_switch16", /* name */
172 true, /* partial_inplace */
173 0xffff, /* src_mask */
174 0xffff, /* dst_mask */
175 false), /* pcrel_offset */
46dd0622 176
e0981b9b
ILT		 177 HOWTO (R_SH_SWITCH32, /* type */
178 0, /* rightshift */
179 2, /* size (0 = byte, 1 = short, 2 = long) */
180 32, /* bitsize */
181 false, /* pc_relative */
182 0, /* bitpos */
183 complain_overflow_bitfield, /* complain_on_overflow */
184 sh_reloc, /* special_function */
185 "r_switch32", /* name */
186 true, /* partial_inplace */
187 0xffffffff, /* src_mask */
188 0xffffffff, /* dst_mask */
189 false), /* pcrel_offset */
46dd0622 190
e0981b9b
ILT		 191 HOWTO (R_SH_USES, /* type */
192 0, /* rightshift */
193 1, /* size (0 = byte, 1 = short, 2 = long) */
194 16, /* bitsize */
195 false, /* pc_relative */
196 0, /* bitpos */
197 complain_overflow_bitfield, /* complain_on_overflow */
198 sh_reloc, /* special_function */
199 "r_uses", /* name */
200 true, /* partial_inplace */
201 0xffff, /* src_mask */
202 0xffff, /* dst_mask */
203 false), /* pcrel_offset */
204
205 HOWTO (R_SH_COUNT, /* type */
206 0, /* rightshift */
207 2, /* size (0 = byte, 1 = short, 2 = long) */
208 32, /* bitsize */
209 false, /* pc_relative */
210 0, /* bitpos */
211 complain_overflow_bitfield, /* complain_on_overflow */
212 sh_reloc, /* special_function */
213 "r_count", /* name */
214 true, /* partial_inplace */
215 0xffffffff, /* src_mask */
216 0xffffffff, /* dst_mask */
217 false), /* pcrel_offset */
218
219 HOWTO (R_SH_ALIGN, /* type */
220 0, /* rightshift */
221 2, /* size (0 = byte, 1 = short, 2 = long) */
222 32, /* bitsize */
223 false, /* pc_relative */
224 0, /* bitpos */
225 complain_overflow_bitfield, /* complain_on_overflow */
226 sh_reloc, /* special_function */
227 "r_align", /* name */
228 true, /* partial_inplace */
229 0xffffffff, /* src_mask */
230 0xffffffff, /* dst_mask */
231 false) /* pcrel_offset */
232};
233
234#define SH_COFF_HOWTO_COUNT (sizeof sh_coff_howtos / sizeof sh_coff_howtos[0])
235
236/* Check for a bad magic number. */
46dd0622 237#define BADMAG(x) SHBADMAG(x)
46dd0622 238
e0981b9b
ILT		 239/* Customize coffcode.h (this is not currently used). */
240#define SH 1
241
242/* FIXME: This should not be set here. */
46dd0622
SC		 243#define __A_MAGIC_SET__
244
e0981b9b
ILT		 245/* Swap the r_offset field in and out. */
246#define SWAP_IN_RELOC_OFFSET bfd_h_get_32
247#define SWAP_OUT_RELOC_OFFSET bfd_h_put_32
248
249/* Swap out extra information in the reloc structure. */
250#define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
251 do \
252 { \
253 dst->r_stuff[0] = 'S'; \
254 dst->r_stuff[1] = 'C'; \
255 } \
256 while (0)
257
258/* Get the value of a symbol, when performing a relocation. */
46dd0622 259
cf345e36
SC		 260static long
261get_symbol_value (symbol)
262 asymbol *symbol;
263{
e0981b9b 264 bfd_vma relocation;
cf345e36
SC		 265
266 if (bfd_is_com_section (symbol->section))
cf345e36 267 relocation = 0;
cf345e36 268 else
e0981b9b
ILT		 269 relocation = (symbol->value +
270 symbol->section->output_section->vma +
271 symbol->section->output_offset);
cf345e36 272
e0981b9b 273 return relocation;
cf345e36 274}
46dd0622 275
e0981b9b
ILT		 276/* This macro is used in coffcode.h to get the howto corresponding to
277 an internal reloc. */
278
279#define RTYPE2HOWTO(relent, internal) \
280 ((relent)->howto = \
281 ((internal)->r_type < SH_COFF_HOWTO_COUNT \
282 ? &sh_coff_howtos[(internal)->r_type] \
283 : (reloc_howto_type *) NULL))
284
285/* This is the same as the macro in coffcode.h, except that it copies
286 r_offset into reloc_entry->addend for some relocs. */
287#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
288 { \
289 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
290 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
291 coffsym = (obj_symbols (abfd) \
292 + (cache_ptr->sym_ptr_ptr - symbols)); \
293 else if (ptr) \
294 coffsym = coff_symbol_from (abfd, ptr); \
295 if (coffsym != (coff_symbol_type *) NULL \
296 && coffsym->native->u.syment.n_scnum == 0) \
297 cache_ptr->addend = 0; \
298 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
299 && ptr->section != (asection *) NULL) \
300 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
301 else \
302 cache_ptr->addend = 0; \
303 if ((reloc).r_type == R_SH_SWITCH16 \
304 || (reloc).r_type == R_SH_SWITCH32 \
305 || (reloc).r_type == R_SH_USES \
306 || (reloc).r_type == R_SH_COUNT \
307 || (reloc).r_type == R_SH_ALIGN) \
308 cache_ptr->addend = (reloc).r_offset; \
cf345e36
SC		 309 }
310
e0981b9b 311/* This is the howto function for the SH relocations. */
cf345e36
SC		 312
313static bfd_reloc_status_type
314sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
e0981b9b 315 error_message)
cf345e36
SC		 316 bfd *abfd;
317 arelent *reloc_entry;
318 asymbol *symbol_in;
319 PTR data;
320 asection *input_section;
321 bfd *output_bfd;
322 char **error_message;
323{
cf345e36 324 unsigned long insn;
e0981b9b 325 bfd_vma sym_value;
cf345e36 326 unsigned short r_type;
e0981b9b
ILT		 327 bfd_vma addr = reloc_entry->address;
328 bfd_byte *hit_data = addr + (bfd_byte *) data;
cf345e36 329
cf345e36
SC		 330 r_type = reloc_entry->howto->type;
331
e0981b9b
ILT		 332 if (output_bfd != NULL)
333 {
334 /* Partial linking--do nothing. */
335 reloc_entry->address += input_section->output_offset;
336 return bfd_reloc_ok;
337 }
338
339 /* Almost all relocs have to do with relaxing. If any work must be
340 done for them, it has been done in sh_relax_section. */
341 if (r_type != R_SH_IMM32
342 && (r_type != R_SH_PCDISP
343 || (symbol_in->flags & BSF_LOCAL) != 0))
cf345e36 344 return bfd_reloc_ok;
cf345e36
SC		 345
346 if (symbol_in != NULL
347 && bfd_is_und_section (symbol_in->section))
e0981b9b 348 return bfd_reloc_undefined;
cf345e36 349
e0981b9b 350 sym_value = get_symbol_value (symbol_in);
cf345e36 351
e0981b9b 352 switch (r_type)
cf345e36
SC		 353 {
354 case R_SH_IMM32:
e0981b9b
ILT		 355 insn = bfd_get_32 (abfd, hit_data);
356 insn += sym_value + reloc_entry->addend;
357 bfd_put_32 (abfd, insn, hit_data);
358 break;
359 case R_SH_PCDISP:
360 insn = bfd_get_16 (abfd, hit_data);
361 sym_value += reloc_entry->addend;
362 sym_value -= (input_section->output_section->vma
363 + input_section->output_offset
364 + addr
365 + 4);
366 sym_value += (insn & 0xfff) << 1;
367 if (insn & 0x800)
368 sym_value -= 0x1000;
369 insn = (insn & 0xf000) | (sym_value & 0xfff);
370 bfd_put_16 (abfd, insn, hit_data);
ae115e51 371 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
e0981b9b 372 return bfd_reloc_overflow;
cf345e36
SC		 373 break;
374 default:
e0981b9b
ILT		 375 abort ();
376 break;
cf345e36
SC		 377 }
378
e0981b9b
ILT		 379 return bfd_reloc_ok;
380}
381
382/* We can do relaxing. */
383#define coff_bfd_relax_section sh_relax_section
384
385/* We use the special COFF backend linker. */
386#define coff_relocate_section sh_relocate_section
387
388/* When relaxing, we need to use special code to get the relocated
389 section contents. */
390#define coff_bfd_get_relocated_section_contents \
391 sh_coff_get_relocated_section_contents
392
393#include "coffcode.h"
394
395/* This function handles relaxing on the SH.
396
397 Function calls on the SH look like this:
398
399 movl L1,r0
400 ...
401 jsr @r0
402 ...
403 L1:
404 .long function
405
406 The compiler and assembler will cooperate to create R_SH_USES
407 relocs on the jsr instructions. The r_offset field of the
408 R_SH_USES reloc is the PC relative offset to the instruction which
409 loads the register (the r_offset field is computed as though it
410 were a jump instruction, so the offset value is actually from four
411 bytes past the instruction). The linker can use this reloc to
412 determine just which function is being called, and thus decide
413 whether it is possible to replace the jsr with a bsr.
414
415 If multiple function calls are all based on a single register load
416 (i.e., the same function is called multiple times), the compiler
417 guarantees that each function call will have an R_SH_USES reloc.
418 Therefore, if the linker is able to convert each R_SH_USES reloc
419 which refers to that address, it can safely eliminate the register
420 load.
421
422 When the assembler creates an R_SH_USES reloc, it examines it to
423 determine which address is being loaded (L1 in the above example).
424 It then counts the number of references to that address, and
425 creates an R_SH_COUNT reloc at that address. The r_offset field of
426 the R_SH_COUNT reloc will be the number of references. If the
427 linker is able to eliminate a register load, it can use the
428 R_SH_COUNT reloc to see whether it can also eliminate the function
429 address. */
430
431static boolean
432sh_relax_section (abfd, sec, link_info, again)
433 bfd *abfd;
434 asection *sec;
435 struct bfd_link_info *link_info;
436 boolean *again;
437{
438 struct internal_reloc *internal_relocs;
439 struct internal_reloc *free_relocs = NULL;
440 struct internal_reloc *irel, *irelend;
441 bfd_byte *contents = NULL;
442 bfd_byte *free_contents = NULL;
443
444 *again = false;
445
446 if (link_info->relocateable
447 || (sec->flags & SEC_RELOC) == 0
448 || sec->reloc_count == 0)
449 return true;
450
451 /* If this is the first time we have been called for this section,
452 initialize the cooked size. */
453 if (sec->_cooked_size == 0)
454 sec->_cooked_size = sec->_raw_size;
455
456 internal_relocs = (_bfd_coff_read_internal_relocs
457 (abfd, sec, link_info->keep_memory,
458 (bfd_byte *) NULL, false,
459 (struct internal_reloc *) NULL));
460 if (internal_relocs == NULL)
461 goto error_return;
462 if (! link_info->keep_memory)
463 free_relocs = internal_relocs;
464
465 irelend = internal_relocs + sec->reloc_count;
466 for (irel = internal_relocs; irel < irelend; irel++)
467 {
468 bfd_vma laddr, paddr, symval;
469 unsigned short insn;
470 struct internal_reloc *irelfn, *irelscan, *irelcount;
471 struct internal_syment sym;
472 bfd_signed_vma foff;
473
474 if (irel->r_type != R_SH_USES)
475 continue;
476
477 /* Get the section contents. */
478 if (contents == NULL)
479 {
480 if (coff_section_data (abfd, sec) != NULL
481 && coff_section_data (abfd, sec)->contents != NULL)
482 contents = coff_section_data (abfd, sec)->contents;
483 else
484 {
485 contents = (bfd_byte *) malloc (sec->_raw_size);
486 if (contents == NULL)
487 {
488 bfd_set_error (bfd_error_no_memory);
489 goto error_return;
490 }
491 free_contents = contents;
492
493 if (! bfd_get_section_contents (abfd, sec, contents,
494 (file_ptr) 0, sec->_raw_size))
495 goto error_return;
496 }
497 }
498
499 /* The r_offset field of the R_SH_USES reloc will point us to
500 the register load. The 4 is because the r_offset field is
501 computed as though it were a jump offset, which are based
502 from 4 bytes after the jump instruction. */
503 laddr = irel->r_vaddr - sec->vma + 4 + irel->r_offset;
504 if (laddr >= sec->_raw_size)
505 {
506 (*_bfd_error_handler) ("%s: 0x%lx: warning: bad R_SH_USES offset",
507 bfd_get_filename (abfd),
508 (unsigned long) irel->r_vaddr);
509 continue;
510 }
511 insn = bfd_get_16 (abfd, contents + laddr);
512
513 /* If the instruction is not mov.l NN,rN, we don't know what to
514 do. */
515 if ((insn & 0xf000) != 0xd000)
516 {
517 ((*_bfd_error_handler)
518 ("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x",
519 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr, insn));
520 continue;
521 }
522
523 /* Get the address from which the register is being loaded. The
524 displacement in the mov.l instruction is quadrupled. It is a
525 displacement from four bytes after the movl instruction, but,
526 before adding in the PC address, two least significant bits
527 of the PC are cleared. We assume that the section is aligned
528 on a four byte boundary. */
529 paddr = insn & 0xff;
530 paddr *= 4;
531 paddr += (laddr + 4) &~ 3;
532 if (paddr >= sec->_raw_size)
533 {
534 ((*_bfd_error_handler)
535 ("%s: 0x%lx: warning: bad R_SH_USES load offset",
536 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr));
537 continue;
538 }
539
540 /* Get the reloc for the address from which the register is
541 being loaded. This reloc will tell us which function is
542 actually being called. */
543 paddr += sec->vma;
544 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
545 if (irelfn->r_vaddr == paddr
546 && irelfn->r_type == R_SH_IMM32)
547 break;
548 if (irelfn >= irelend)
549 {
550 ((*_bfd_error_handler)
551 ("%s: 0x%lx: warning: could not find expected reloc",
552 bfd_get_filename (abfd), (unsigned long) paddr));
553 continue;
554 }
555
556 /* Get the value of the symbol referred to by the reloc. */
557 if (! _bfd_coff_get_external_symbols (abfd))
558 goto error_return;
559 bfd_coff_swap_sym_in (abfd,
560 ((bfd_byte *) obj_coff_external_syms (abfd)
561 + (irelfn->r_symndx
562 * bfd_coff_symesz (abfd))),
563 &sym);
564 if (sym.n_scnum != 0 && sym.n_scnum != sec->target_index)
565 {
566 ((*_bfd_error_handler)
567 ("%s: 0x%lx: warning: symbol in unexpected section",
568 bfd_get_filename (abfd), (unsigned long) paddr));
569 continue;
570 }
571
572 if (sym.n_sclass != C_EXT)
573 {
574 symval = (sym.n_value
575 - sec->vma
576 + sec->output_section->vma
577 + sec->output_offset);
578 }
579 else
580 {
581 struct coff_link_hash_entry *h;
cf345e36 582
e0981b9b
ILT		 583 h = obj_coff_sym_hashes (abfd)[irelfn->r_symndx];
584 BFD_ASSERT (h != NULL);
585 if (h->root.type != bfd_link_hash_defined
586 && h->root.type != bfd_link_hash_defweak)
587 {
588 /* This appears to be a reference to an undefined
589 symbol. Just ignore it--it will be caught by the
590 regular reloc processing. */
591 continue;
592 }
593
594 symval = (h->root.u.def.value
595 + h->root.u.def.section->output_section->vma
596 + h->root.u.def.section->output_offset);
597 }
598
599 symval += bfd_get_32 (abfd, contents + paddr - sec->vma);
600
601 /* See if this function call can be shortened. */
602 foff = (symval
603 - (irel->r_vaddr
604 - sec->vma
605 + sec->output_section->vma
606 + sec->output_offset
607 + 4));
608 if (foff < -0x1000 || foff >= 0x1000)
609 {
610 /* After all that work, we can't shorten this function call. */
611 continue;
612 }
613
614 /* Shorten the function call. */
615
616 /* For simplicity of coding, we are going to modify the section
617 contents, the section relocs, and the BFD symbol table. We
618 must tell the rest of the code not to free up this
619 information. It would be possible to instead create a table
620 of changes which have to be made, as is done in coff-mips.c;
621 that would be more work, but would require less memory when
622 the linker is run. */
623
624 if (coff_section_data (abfd, sec) == NULL)
625 {
626 sec->used_by_bfd =
ae115e51 627 ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
e0981b9b 628 if (sec->used_by_bfd == NULL)
a9713b91 629 goto error_return;
e0981b9b
ILT		 630 }
631
632 coff_section_data (abfd, sec)->relocs = internal_relocs;
633 coff_section_data (abfd, sec)->keep_relocs = true;
634 free_relocs = NULL;
635
636 coff_section_data (abfd, sec)->contents = contents;
637 coff_section_data (abfd, sec)->keep_contents = true;
638 free_contents = NULL;
639
640 obj_coff_keep_syms (abfd) = true;
641
642 /* Replace the jsr with a bsr. */
643
644 /* Change the R_SH_USES reloc into an R_SH_PCDISP reloc, and
645 replace the jsr with a bsr. */
646 irel->r_type = R_SH_PCDISP;
647 irel->r_symndx = irelfn->r_symndx;
648 if (sym.n_sclass != C_EXT)
649 {
650 /* If this needs to be changed because of future relaxing,
651 it will be handled here like other internal PCDISP
652 relocs. */
653 bfd_put_16 (abfd,
654 0xb000 | ((foff >> 1) & 0xfff),
655 contents + irel->r_vaddr - sec->vma);
656 }
657 else
658 {
659 /* We can't fully resolve this yet, because the external
660 symbol value may be changed by future relaxing. We let
661 the final link phase handle it. */
662 bfd_put_16 (abfd, 0xb000, contents + irel->r_vaddr - sec->vma);
663 }
664
665 /* See if there is another R_SH_USES reloc referring to the same
666 register load. */
667 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
668 if (irelscan->r_type == R_SH_USES
669 && laddr == irelscan->r_vaddr - sec->vma + 4 + irelscan->r_offset)
670 break;
671 if (irelscan < irelend)
672 {
673 /* Some other function call depends upon this register load,
674 and we have not yet converted that function call.
675 Indeed, we may never be able to convert it. There is
676 nothing else we can do at this point. */
677 continue;
678 }
679
680 /* Look for a R_SH_COUNT reloc on the location where the
681 function address is stored. Do this before deleting any
682 bytes, to avoid confusion about the address. */
683 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
684 if (irelcount->r_vaddr == paddr
685 && irelcount->r_type == R_SH_COUNT)
686 break;
687
688 /* Delete the register load. */
689 if (! sh_relax_delete_bytes (abfd, sec, laddr, 2))
690 goto error_return;
691
692 /* That will change things, so, just in case it permits some
693 other function call to come within range, we should relax
694 again. Note that this is not required, and it may be slow. */
695 *again = true;
696
697 /* Now check whether we got a COUNT reloc. */
698 if (irelcount >= irelend)
699 {
700 ((*_bfd_error_handler)
701 ("%s: 0x%lx: warning: could not find expected COUNT reloc",
702 bfd_get_filename (abfd), (unsigned long) paddr));
703 continue;
704 }
705
706 /* The number of uses is stored in the r_offset field. We've
707 just deleted one. */
708 if (irelcount->r_offset == 0)
709 {
710 ((*_bfd_error_handler) ("%s: 0x%lx: warning: bad count",
711 bfd_get_filename (abfd),
712 (unsigned long) paddr));
713 continue;
714 }
715
716 --irelcount->r_offset;
717
718 /* If there are no more uses, we can delete the address. Reload
719 the address from irelfn, in case it was changed by the
720 previous call to sh_relax_delete_bytes. */
721 if (irelcount->r_offset == 0)
722 {
723 if (! sh_relax_delete_bytes (abfd, sec,
724 irelfn->r_vaddr - sec->vma, 4))
725 goto error_return;
726 }
727
728 /* We've done all we can with that function call. */
729 }
730
731 if (free_relocs != NULL)
732 {
733 free (free_relocs);
734 free_relocs = NULL;
735 }
736
737 if (free_contents != NULL)
738 {
739 if (! link_info->keep_memory)
740 free (free_contents);
741 else
742 {
743 /* Cache the section contents for coff_link_input_bfd. */
744 if (coff_section_data (abfd, sec) == NULL)
745 {
746 sec->used_by_bfd =
ae115e51 747 ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
e0981b9b 748 if (sec->used_by_bfd == NULL)
a9713b91 749 goto error_return;
e0981b9b
ILT		 750 coff_section_data (abfd, sec)->relocs = NULL;
751 }
752 coff_section_data (abfd, sec)->contents = contents;
753 }
754 }
755
756 return true;
757
758 error_return:
759 if (free_relocs != NULL)
760 free (free_relocs);
761 if (free_contents != NULL)
762 free (free_contents);
763 return false;
cf345e36
SC		 764}
765
e0981b9b 766/* Delete some bytes from a section while relaxing. */
cf345e36
SC		 767
768static boolean
e0981b9b
ILT		 769sh_relax_delete_bytes (abfd, sec, addr, count)
770 bfd *abfd;
771 asection *sec;
772 bfd_vma addr;
773 int count;
774{
775 bfd_byte *contents;
776 struct internal_reloc *irel, *irelend;
777 struct internal_reloc *irelalign;
778 bfd_vma toaddr;
779 bfd_byte *esym, *esymend;
780 bfd_size_type symesz;
781 struct coff_link_hash_entry **sym_hash;
782 asection *o;
783
784 contents = coff_section_data (abfd, sec)->contents;
785
786 /* The deletion must stop at the next ALIGN reloc for an aligment
787 power larger than the number of bytes we are deleting. */
788
789 irelalign = NULL;
790 toaddr = sec->_cooked_size;
791
792 irel = coff_section_data (abfd, sec)->relocs;
793 irelend = irel + sec->reloc_count;
794 for (; irel < irelend; irel++)
795 {
796 if (irel->r_type == R_SH_ALIGN
797 && irel->r_vaddr - sec->vma > addr
798 && count < (1 << irel->r_offset))
799 {
800 irelalign = irel;
801 toaddr = irel->r_vaddr - sec->vma;
802 break;
803 }
804 }
805
806 /* Actually delete the bytes. */
807 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
808 if (irelalign == NULL)
809 sec->_cooked_size -= count;
810 else
811 memset (contents + toaddr - count, 0, count);
812
813 /* Adjust all the relocs. */
814 for (irel = coff_section_data (abfd, sec)->relocs; irel < irelend; irel++)
815 {
816 bfd_vma nraddr, start, stop;
817 int insn = 0;
818 struct internal_syment sym;
819 int off, adjust, oinsn;
820 bfd_signed_vma voff;
821 boolean overflow;
822
823 /* Get the new reloc address. */
824 nraddr = irel->r_vaddr - sec->vma;
825 if ((irel->r_vaddr - sec->vma > addr
826 && irel->r_vaddr - sec->vma < toaddr)
827 || (irel->r_type == R_SH_ALIGN
828 && irel->r_vaddr - sec->vma == toaddr))
829 nraddr -= count;
830
831 /* See if this reloc was for the bytes we have deleted, in which
832 case we no longer care about it. */
833 if (irel->r_vaddr - sec->vma >= addr
834 && irel->r_vaddr - sec->vma < addr + count
835 && irel->r_type != R_SH_ALIGN)
836 irel->r_type = R_SH_UNUSED;
837
838 /* If this is a PC relative reloc, see if the range it covers
839 includes the bytes we have deleted. */
840 switch (irel->r_type)
841 {
842 default:
843 break;
844
845 case R_SH_PCDISP8BY2:
846 case R_SH_PCDISP:
847 case R_SH_PCRELIMM8BY2:
848 case R_SH_PCRELIMM8BY4:
849 start = irel->r_vaddr - sec->vma;
850 insn = bfd_get_16 (abfd, contents + nraddr);
851 break;
852 }
853
854 switch (irel->r_type)
855 {
856 default:
857 start = stop = addr;
858 break;
859
860 case R_SH_IMM32:
861 /* If this reloc is against a symbol defined in this
862 section, and the symbol will not be adjusted below, we
863 must check the addend to see it will put the value in
864 range to be adjusted, and hence must be changed. */
865 bfd_coff_swap_sym_in (abfd,
866 ((bfd_byte *) obj_coff_external_syms (abfd)
867 + (irel->r_symndx
868 * bfd_coff_symesz (abfd))),
869 &sym);
870 if (sym.n_sclass != C_EXT
871 && sym.n_scnum == sec->target_index
ae115e51
ILT		 872 && ((bfd_vma) sym.n_value <= addr
873 || (bfd_vma) sym.n_value >= toaddr))
e0981b9b
ILT		 874 {
875 bfd_vma val;
876
877 val = bfd_get_32 (abfd, contents + nraddr);
878 val += sym.n_value;
879 if (val >= addr && val < toaddr)
880 bfd_put_32 (abfd, val - count, contents + nraddr);
881 }
882 start = stop = addr;
883 break;
884
885 case R_SH_PCDISP8BY2:
886 off = insn & 0xff;
887 if (off & 0x80)
888 off -= 0x100;
889 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
890 break;
891
892 case R_SH_PCDISP:
893 bfd_coff_swap_sym_in (abfd,
894 ((bfd_byte *) obj_coff_external_syms (abfd)
895 + (irel->r_symndx
896 * bfd_coff_symesz (abfd))),
897 &sym);
898 if (sym.n_sclass == C_EXT)
899 start = stop = addr;
900 else
901 {
902 off = insn & 0xfff;
903 if (off & 0x800)
904 off -= 0x1000;
905 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
906 }
907 break;
908
909 case R_SH_PCRELIMM8BY2:
910 off = insn & 0xff;
911 stop = start + 4 + off * 2;
912 break;
913
914 case R_SH_PCRELIMM8BY4:
915 off = insn & 0xff;
916 stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
917 break;
918
919 case R_SH_SWITCH16:
920 case R_SH_SWITCH32:
921 /* These relocs types represent
922 .word L2-L1
923 The r_offset field holds the difference between the reloc
924 address and L1. That is the start of the reloc, and
925 adding in the contents gives us the top. We must adjust
926 both the r_offset field and the section contents. */
927
928 start = irel->r_vaddr - sec->vma;
929 stop = (bfd_vma) ((bfd_signed_vma) start - (long) irel->r_offset);
930
931 if (start > addr
932 && start < toaddr
933 && (stop <= addr || stop >= toaddr))
934 irel->r_offset += count;
935 else if (stop > addr
936 && stop < toaddr
937 && (start <= addr || start >= toaddr))
938 irel->r_offset -= count;
939
940 start = stop;
941
942 if (irel->r_type == R_SH_SWITCH16)
943 voff = bfd_get_signed_16 (abfd, contents + nraddr);
944 else
945 voff = bfd_get_signed_32 (abfd, contents + nraddr);
946 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
947
948 break;
949
950 case R_SH_USES:
951 start = irel->r_vaddr - sec->vma;
952 stop = (bfd_vma) ((bfd_signed_vma) start + (long) irel->r_offset);
953 break;
954 }
955
956 if (start > addr
957 && start < toaddr
958 && (stop <= addr || stop >= toaddr))
959 adjust = count;
960 else if (stop > addr
961 && stop < toaddr
962 && (start <= addr || start >= toaddr))
963 adjust = - count;
964 else
965 adjust = 0;
966
967 if (adjust != 0)
968 {
969 oinsn = insn;
970 overflow = false;
971 switch (irel->r_type)
972 {
973 default:
974 abort ();
975 break;
976
977 case R_SH_PCDISP8BY2:
978 case R_SH_PCRELIMM8BY2:
979 insn += adjust / 2;
980 if ((oinsn & 0xff00) != (insn & 0xff00))
981 overflow = true;
982 bfd_put_16 (abfd, insn, contents + nraddr);
983 break;
984
985 case R_SH_PCDISP:
986 insn += adjust / 2;
987 if ((oinsn & 0xf000) != (insn & 0xf000))
988 overflow = true;
989 bfd_put_16 (abfd, insn, contents + nraddr);
990 break;
991
992 case R_SH_PCRELIMM8BY4:
993 BFD_ASSERT (adjust == count || count >= 4);
994 if (count >= 4)
995 insn += adjust / 4;
996 else
997 {
998 if ((irel->r_vaddr & 3) == 0)
999 ++insn;
1000 }
1001 if ((oinsn & 0xff00) != (insn & 0xff00))
1002 overflow = true;
1003 bfd_put_16 (abfd, insn, contents + nraddr);
1004 break;
1005
1006 case R_SH_SWITCH16:
1007 voff += adjust;
1008 if (voff < - 0x8000 || voff >= 0x8000)
1009 overflow = true;
1010 bfd_put_signed_16 (abfd, voff, contents + nraddr);
1011 break;
1012
1013 case R_SH_SWITCH32:
1014 voff += adjust;
1015 bfd_put_signed_32 (abfd, voff, contents + nraddr);
1016 break;
1017
1018 case R_SH_USES:
1019 irel->r_offset += adjust;
1020 break;
1021 }
1022
1023 if (overflow)
1024 {
1025 ((*_bfd_error_handler)
1026 ("%s: 0x%lx: fatal: reloc overflow while relaxing",
1027 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr));
1028 bfd_set_error (bfd_error_bad_value);
1029 return false;
1030 }
1031 }
1032
1033 irel->r_vaddr = nraddr + sec->vma;
1034 }
1035
1036 /* Look through all the other sections. If there contain any IMM32
1037 relocs against internal symbols which we are not going to adjust
1038 below, we may need to adjust the addends. */
1039 for (o = abfd->sections; o != NULL; o = o->next)
1040 {
1041 struct internal_reloc *internal_relocs;
1042 struct internal_reloc *irelscan, *irelscanend;
1043 bfd_byte *ocontents;
1044
1045 if (o == sec
1046 || (o->flags & SEC_RELOC) == 0
1047 || o->reloc_count == 0)
1048 continue;
1049
1050 /* We always cache the relocs. Perhaps, if info->keep_memory is
1051 false, we should free them, if we are permitted to, when we
1052 leave sh_coff_relax_section. */
1053 internal_relocs = (_bfd_coff_read_internal_relocs
1054 (abfd, o, true, (bfd_byte *) NULL, false,
1055 (struct internal_reloc *) NULL));
1056 if (internal_relocs == NULL)
1057 return false;
1058
1059 ocontents = NULL;
1060 irelscanend = internal_relocs + o->reloc_count;
1061 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1062 {
1063 struct internal_syment sym;
1064
1065 if (irelscan->r_type != R_SH_IMM32)
1066 continue;
1067
1068 bfd_coff_swap_sym_in (abfd,
1069 ((bfd_byte *) obj_coff_external_syms (abfd)
1070 + (irelscan->r_symndx
1071 * bfd_coff_symesz (abfd))),
1072 &sym);
1073 if (sym.n_sclass != C_EXT
1074 && sym.n_scnum == sec->target_index
ae115e51
ILT		 1075 && ((bfd_vma) sym.n_value <= addr
1076 || (bfd_vma) sym.n_value >= toaddr))
e0981b9b
ILT		 1077 {
1078 bfd_vma val;
1079
1080 if (ocontents == NULL)
1081 {
1082 if (coff_section_data (abfd, o)->contents != NULL)
1083 ocontents = coff_section_data (abfd, o)->contents;
1084 else
1085 {
1086 /* We always cache the section contents.
1087 Perhaps, if info->keep_memory is false, we
1088 should free them, if we are permitted to,
1089 when we leave sh_coff_relax_section. */
1090 ocontents = (bfd_byte *) malloc (o->_raw_size);
1091 if (ocontents == NULL)
1092 {
1093 bfd_set_error (bfd_error_no_memory);
1094 return false;
1095 }
1096 if (! bfd_get_section_contents (abfd, o, ocontents,
1097 (file_ptr) 0,
1098 o->_raw_size))
1099 return false;
1100 coff_section_data (abfd, o)->contents = ocontents;
1101 }
1102 }
1103
1104 val = bfd_get_32 (abfd, ocontents + irelscan->r_vaddr - o->vma);
1105 val += sym.n_value;
1106 if (val >= addr && val < toaddr)
1107 bfd_put_32 (abfd, val - count,
1108 ocontents + irelscan->r_vaddr - o->vma);
1109
1110 coff_section_data (abfd, o)->keep_contents = true;
1111 }
1112 }
1113 }
1114
1115 /* Adjusting the internal symbols will not work if something has
1116 already retrieved the generic symbols. It would be possible to
1117 make this work by adjusting the generic symbols at the same time.
1118 However, this case should not arise in normal usage. */
1119 if (obj_symbols (abfd) != NULL
1120 || obj_raw_syments (abfd) != NULL)
1121 {
1122 ((*_bfd_error_handler)
1123 ("%s: fatal: generic symbols retrieved before relaxing",
1124 bfd_get_filename (abfd)));
1125 bfd_set_error (bfd_error_invalid_operation);
1126 return false;
1127 }
1128
1129 /* Adjust all the symbols. */
1130 sym_hash = obj_coff_sym_hashes (abfd);
1131 symesz = bfd_coff_symesz (abfd);
1132 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1133 esymend = esym + obj_raw_syment_count (abfd) * symesz;
1134 while (esym < esymend)
1135 {
1136 struct internal_syment isym;
1137
1138 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
1139
1140 if (isym.n_scnum == sec->target_index
ae115e51
ILT		 1141 && (bfd_vma) isym.n_value > addr
1142 && (bfd_vma) isym.n_value < toaddr)
e0981b9b
ILT		 1143 {
1144 isym.n_value -= count;
1145
1146 bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
1147
1148 if (*sym_hash != NULL)
1149 {
1150 BFD_ASSERT ((*sym_hash)->root.type == bfd_link_hash_defined
1151 || (*sym_hash)->root.type == bfd_link_hash_defweak);
1152 BFD_ASSERT ((*sym_hash)->root.u.def.value >= addr
1153 && (*sym_hash)->root.u.def.value < toaddr);
1154 (*sym_hash)->root.u.def.value -= count;
1155 }
1156 }
1157
1158 esym += (isym.n_numaux + 1) * symesz;
1159 sym_hash += isym.n_numaux + 1;
1160 }
1161
1162 /* See if we can move the ALIGN reloc forward. We have adjusted
1163 r_vaddr for it already. */
1164 if (irelalign != NULL)
1165 {
1166 bfd_vma alignaddr;
1167
1168 alignaddr = BFD_ALIGN (irelalign->r_vaddr - sec->vma,
1169 1 << irelalign->r_offset);
1170 if (alignaddr != toaddr)
1171 {
1172 /* Tail recursion. */
1173 return sh_relax_delete_bytes (abfd, sec,
1174 irelalign->r_vaddr - sec->vma,
1175 1 << irelalign->r_offset);
1176 }
1177 }
1178
1179 return true;
1180}
1181
1182/* This is a modification of _bfd_coff_generic_relocate_section, which
1183 will handle SH relaxing. */
1184
1185static boolean
1186sh_relocate_section (output_bfd, info, input_bfd, input_section, contents,
1187 relocs, syms, sections)
cf345e36
SC		 1188 bfd *output_bfd;
1189 struct bfd_link_info *info;
1190 bfd *input_bfd;
1191 asection *input_section;
1192 bfd_byte *contents;
1193 struct internal_reloc *relocs;
1194 struct internal_syment *syms;
1195 asection **sections;
1196{
1197 struct internal_reloc *rel;
1198 struct internal_reloc *relend;
1199
cf345e36
SC		 1200 rel = relocs;
1201 relend = rel + input_section->reloc_count;
1202 for (; rel < relend; rel++)
1203 {
1204 long symndx;
cf345e36
SC		 1205 struct coff_link_hash_entry *h;
1206 struct internal_syment *sym;
e0981b9b 1207 bfd_vma addend;
cf345e36 1208 bfd_vma val;
e0981b9b
ILT		 1209 reloc_howto_type *howto;
1210 bfd_reloc_status_type rstat;
1211
1212 /* Almost all relocs have to do with relaxing. If any work must
1213 be done for them, it has been done in sh_relax_section. */
1214 if (rel->r_type != R_SH_IMM32
1215 && rel->r_type != R_SH_PCDISP)
1216 continue;
cf345e36
SC		 1217
1218 symndx = rel->r_symndx;
cf345e36
SC		 1219
1220 if (symndx == -1)
e0981b9b
ILT		 1221 {
1222 h = NULL;
1223 sym = NULL;
1224 }
cf345e36 1225 else
e0981b9b
ILT		 1226 {
1227 h = obj_coff_sym_hashes (input_bfd)[symndx];
1228 sym = syms + symndx;
1229 }
cf345e36 1230
e0981b9b
ILT		 1231 if (sym != NULL && sym->n_scnum != 0)
1232 addend = - sym->n_value;
1233 else
1234 addend = 0;
cf345e36 1235
e0981b9b
ILT		 1236 if (rel->r_type == R_SH_PCDISP)
1237 addend -= 4;
1238
1239 if (rel->r_type >= SH_COFF_HOWTO_COUNT)
1240 howto = NULL;
1241 else
1242 howto = &sh_coff_howtos[rel->r_type];
1243
1244 if (howto == NULL)
1245 {
1246 bfd_set_error (bfd_error_bad_value);
1247 return false;
1248 }
1249
1250 val = 0;
cf345e36
SC		 1251
1252 if (h == NULL)
1253 {
e0981b9b
ILT		 1254 asection *sec;
1255
1256 /* There is nothing to do for an internal PCDISP reloc. */
1257 if (rel->r_type == R_SH_PCDISP)
1258 continue;
1259
cf345e36 1260 if (symndx == -1)
e0981b9b
ILT		 1261 {
1262 sec = bfd_abs_section_ptr;
1263 val = 0;
1264 }
cf345e36
SC		 1265 else
1266 {
cf345e36 1267 sec = sections[symndx];
e0981b9b 1268 val = (sec->output_section->vma
cf345e36
SC		 1269 + sec->output_offset
1270 + sym->n_value
cf345e36
SC		 1271 - sec->vma);
1272 }
1273 }
1274 else
1275 {
e0981b9b
ILT		 1276 if (h->root.type == bfd_link_hash_defined
1277 || h->root.type == bfd_link_hash_defweak)
cf345e36 1278 {
e0981b9b
ILT		 1279 asection *sec;
1280
cf345e36
SC		 1281 sec = h->root.u.def.section;
1282 val = (h->root.u.def.value
1283 + sec->output_section->vma
1284 + sec->output_offset);
1285 }
e0981b9b 1286 else if (! info->relocateable)
cf345e36
SC		 1287 {
1288 if (! ((*info->callbacks->undefined_symbol)
1289 (info, h->root.root.string, input_bfd, input_section,
1290 rel->r_vaddr - input_section->vma)))
1291 return false;
1292 }
1293 }
1294
e0981b9b
ILT		 1295 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
1296 contents,
1297 rel->r_vaddr - input_section->vma,
1298 val, addend);
1299
1300 switch (rstat)
cf345e36
SC		 1301 {
1302 default:
e0981b9b
ILT		 1303 abort ();
1304 case bfd_reloc_ok:
1305 break;
1306 case bfd_reloc_overflow:
cf345e36 1307 {
e0981b9b
ILT		 1308 const char *name;
1309 char buf[SYMNMLEN + 1];
cf345e36 1310
e0981b9b
ILT		 1311 if (symndx == -1)
1312 name = "*ABS*";
1313 else if (h != NULL)
1314 name = h->root.root.string;
1315 else if (sym->_n._n_n._n_zeroes == 0
1316 && sym->_n._n_n._n_offset != 0)
1317 name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1318 else
1319 {
1320 strncpy (buf, sym->_n._n_name, SYMNMLEN);
1321 buf[SYMNMLEN] = '\0';
1322 name = buf;
1323 }
cf345e36 1324
e0981b9b
ILT		 1325 if (! ((*info->callbacks->reloc_overflow)
1326 (info, name, howto->name, (bfd_vma) 0, input_bfd,
1327 input_section, rel->r_vaddr - input_section->vma)))
1328 return false;
1329 }
cf345e36 1330 }
e0981b9b 1331 }
cf345e36
SC		 1332
1333 return true;
1334}
46dd0622 1335
e0981b9b
ILT		 1336/* This is a version of bfd_generic_get_relocated_section_contents
1337 which uses sh_relocate_section. */
1338
1339static bfd_byte *
1340sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order,
1341 data, relocateable, symbols)
1342 bfd *output_bfd;
1343 struct bfd_link_info *link_info;
1344 struct bfd_link_order *link_order;
1345 bfd_byte *data;
1346 boolean relocateable;
1347 asymbol **symbols;
1348{
1349 asection *input_section = link_order->u.indirect.section;
1350 bfd *input_bfd = input_section->owner;
1351 asection **sections = NULL;
1352 struct internal_reloc *internal_relocs = NULL;
1353 struct internal_syment *internal_syms = NULL;
1354
1355 /* We only need to handle the case of relaxing, or of having a
1356 particular set of section contents, specially. */
1357 if (relocateable
1358 || coff_section_data (input_bfd, input_section) == NULL
1359 || coff_section_data (input_bfd, input_section)->contents == NULL)
1360 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1361 link_order, data,
1362 relocateable,
1363 symbols);
1364
1365 memcpy (data, coff_section_data (input_bfd, input_section)->contents,
1366 input_section->_raw_size);
1367
1368 if ((input_section->flags & SEC_RELOC) != 0
1369 && input_section->reloc_count > 0)
1370 {
1371 bfd_size_type symesz = bfd_coff_symesz (input_bfd);
1372 bfd_byte *esym, *esymend;
1373 struct internal_syment *isymp;
1374 asection **secpp;
1375
1376 if (! _bfd_coff_get_external_symbols (input_bfd))
1377 goto error_return;
1378
1379 internal_relocs = (_bfd_coff_read_internal_relocs
1380 (input_bfd, input_section, false, (bfd_byte *) NULL,
1381 false, (struct internal_reloc *) NULL));
1382 if (internal_relocs == NULL)
1383 goto error_return;
1384
1385 internal_syms = ((struct internal_syment *)
1386 malloc (obj_raw_syment_count (input_bfd)
1387 * sizeof (struct internal_syment)));
1388 if (internal_syms == NULL)
1389 {
1390 bfd_set_error (bfd_error_no_memory);
1391 goto error_return;
1392 }
1393
1394 sections = (asection **) malloc (obj_raw_syment_count (input_bfd)
1395 * sizeof (asection *));
1396 if (sections == NULL)
1397 {
1398 bfd_set_error (bfd_error_no_memory);
1399 goto error_return;
1400 }
1401
1402 isymp = internal_syms;
1403 secpp = sections;
1404 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1405 esymend = esym + obj_raw_syment_count (input_bfd) * symesz;
1406 while (esym < esymend)
1407 {
1408 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
1409
1410 if (isymp->n_scnum != 0)
1411 *secpp = coff_section_from_bfd_index (input_bfd, isymp->n_scnum);
1412 else
1413 {
1414 if (isymp->n_value == 0)
1415 *secpp = bfd_und_section_ptr;
1416 else
1417 *secpp = bfd_com_section_ptr;
1418 }
1419
1420 esym += (isymp->n_numaux + 1) * symesz;
1421 secpp += isymp->n_numaux + 1;
1422 isymp += isymp->n_numaux + 1;
1423 }
1424
1425 if (! sh_relocate_section (output_bfd, link_info, input_bfd,
1426 input_section, data, internal_relocs,
1427 internal_syms, sections))
1428 goto error_return;
1429
1430 free (sections);
1431 sections = NULL;
1432 free (internal_syms);
1433 internal_syms = NULL;
1434 free (internal_relocs);
1435 internal_relocs = NULL;
1436 }
1437
1438 return data;
1439
1440 error_return:
1441 if (internal_relocs != NULL)
1442 free (internal_relocs);
1443 if (internal_syms != NULL)
1444 free (internal_syms);
1445 if (sections != NULL)
1446 free (sections);
1447 return NULL;
1448}
1449
1450/* The target vectors. */
46dd0622 1451
2f3508ad 1452const bfd_target shcoff_vec =
46dd0622
SC		 1453{
1454 "coff-sh", /* name */
1455 bfd_target_coff_flavour,
1456 true, /* data byte order is big */
1457 true, /* header byte order is big */
1458
1459 (HAS_RELOC | EXEC_P | /* object flags */
1460 HAS_LINENO | HAS_DEBUG |
e0981b9b 1461 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
46dd0622 1462
e0981b9b 1463 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
46dd0622
SC		 1464 '_', /* leading symbol underscore */
1465 '/', /* ar_pad_char */
1466 15, /* ar_max_namelen */
e0981b9b
ILT		 1467 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1468 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1469 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1470 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1471 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1472 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
46dd0622
SC		 1473
1474 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1475 bfd_generic_archive_p, _bfd_dummy_target},
1476 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
1477 bfd_false},
e0981b9b 1478 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
46dd0622
SC		 1479 _bfd_write_archive_contents, bfd_false},
1480
e0981b9b
ILT		 1481 BFD_JUMP_TABLE_GENERIC (coff),
1482 BFD_JUMP_TABLE_COPY (coff),
1483 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1484 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
1485 BFD_JUMP_TABLE_SYMBOLS (coff),
1486 BFD_JUMP_TABLE_RELOCS (coff),
1487 BFD_JUMP_TABLE_WRITE (coff),
1488 BFD_JUMP_TABLE_LINK (coff),
1489 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1490
1491 COFF_SWAP_TABLE,
46dd0622 1492};
cf345e36 1493
7a1d4567
SC		 1494const bfd_target shlcoff_vec =
1495{
1496 "coff-shl", /* name */
1497 bfd_target_coff_flavour,
1498 false, /* data byte order is little */
1499 false, /* header byte order is little endian too*/
1500
1501 (HAS_RELOC | EXEC_P | /* object flags */
1502 HAS_LINENO | HAS_DEBUG |
e0981b9b 1503 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
7a1d4567 1504
e0981b9b 1505 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
7a1d4567
SC		 1506 '_', /* leading symbol underscore */
1507 '/', /* ar_pad_char */
1508 15, /* ar_max_namelen */
e0981b9b
ILT		 1509 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1510 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1511 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1512 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1513 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1514 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1515
7a1d4567 1516 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
a9713b91 1517 bfd_generic_archive_p, _bfd_dummy_target},
7a1d4567
SC		 1518 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
1519 bfd_false},
e0981b9b 1520 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
7a1d4567
SC		 1521 _bfd_write_archive_contents, bfd_false},
1522
e0981b9b
ILT		 1523 BFD_JUMP_TABLE_GENERIC (coff),
1524 BFD_JUMP_TABLE_COPY (coff),
1525 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1526 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
1527 BFD_JUMP_TABLE_SYMBOLS (coff),
1528 BFD_JUMP_TABLE_RELOCS (coff),
1529 BFD_JUMP_TABLE_WRITE (coff),
1530 BFD_JUMP_TABLE_LINK (coff),
1531 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
7a1d4567 1532
e0981b9b
ILT		 1533 COFF_SWAP_TABLE,
1534};
GDB Binutils - Deliverables
This page took 0.160094 seconds and 4 git commands to generate.