projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd:
[deliverable/binutils-gdb.git] / bfd / coff-sh.c
1 /* BFD back-end for Hitachi Super-H COFF binaries.
2 Copyright 1993, 94, 95, 96, 97, 98, 1999, 2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
4 Written by Steve Chamberlain, <sac@cygnus.com>.
5 Relaxing code written by Ian Lance Taylor, <ian@cygnus.com>.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
26 #include "bfdlink.h"
27 #include "coff/sh.h"
28 #include "coff/internal.h"
29 #include "libcoff.h"
30
31 /* Internal functions. */
32 static bfd_reloc_status_type sh_reloc
33 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
34 static long get_symbol_value PARAMS ((asymbol *));
35 static boolean sh_relax_section
36 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
37 static boolean sh_relax_delete_bytes
38 PARAMS ((bfd *, asection *, bfd_vma, int));
39 static const struct sh_opcode *sh_insn_info PARAMS ((unsigned int));
40 static boolean sh_align_loads
41 PARAMS ((bfd *, asection *, struct internal_reloc *, bfd_byte *, boolean *));
42 static boolean sh_swap_insns
43 PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
44 static boolean sh_relocate_section
45 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
46 struct internal_reloc *, struct internal_syment *, asection **));
47 static bfd_byte *sh_coff_get_relocated_section_contents
48 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
49 bfd_byte *, boolean, asymbol **));
50
51 /* Default section alignment to 2**4. */
52 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (4)
53
54 /* Generate long file names. */
55 #define COFF_LONG_FILENAMES
56
57 /* The supported relocations. There are a lot of relocations defined
58 in coff/internal.h which we do not expect to ever see. */
59 static reloc_howto_type sh_coff_howtos[] =
60 {
61 EMPTY_HOWTO (0),
62 EMPTY_HOWTO (1),
63 EMPTY_HOWTO (2),
64 EMPTY_HOWTO (3), /* R_SH_PCREL8 */
65 EMPTY_HOWTO (4), /* R_SH_PCREL16 */
66 EMPTY_HOWTO (5), /* R_SH_HIGH8 */
67 EMPTY_HOWTO (6), /* R_SH_IMM24 */
68 EMPTY_HOWTO (7), /* R_SH_LOW16 */
69 EMPTY_HOWTO (8),
70 EMPTY_HOWTO (9), /* R_SH_PCDISP8BY4 */
71
72 HOWTO (R_SH_PCDISP8BY2, /* type */
73 1, /* rightshift */
74 1, /* size (0 = byte, 1 = short, 2 = long) */
75 8, /* bitsize */
76 true, /* pc_relative */
77 0, /* bitpos */
78 complain_overflow_signed, /* complain_on_overflow */
79 sh_reloc, /* special_function */
80 "r_pcdisp8by2", /* name */
81 true, /* partial_inplace */
82 0xff, /* src_mask */
83 0xff, /* dst_mask */
84 true), /* pcrel_offset */
85
86 EMPTY_HOWTO (11), /* R_SH_PCDISP8 */
87
88 HOWTO (R_SH_PCDISP, /* type */
89 1, /* rightshift */
90 1, /* size (0 = byte, 1 = short, 2 = long) */
91 12, /* bitsize */
92 true, /* pc_relative */
93 0, /* bitpos */
94 complain_overflow_signed, /* complain_on_overflow */
95 sh_reloc, /* special_function */
96 "r_pcdisp12by2", /* name */
97 true, /* partial_inplace */
98 0xfff, /* src_mask */
99 0xfff, /* dst_mask */
100 true), /* pcrel_offset */
101
102 EMPTY_HOWTO (13),
103
104 HOWTO (R_SH_IMM32, /* type */
105 0, /* rightshift */
106 2, /* size (0 = byte, 1 = short, 2 = long) */
107 32, /* bitsize */
108 false, /* pc_relative */
109 0, /* bitpos */
110 complain_overflow_bitfield, /* complain_on_overflow */
111 sh_reloc, /* special_function */
112 "r_imm32", /* name */
113 true, /* partial_inplace */
114 0xffffffff, /* src_mask */
115 0xffffffff, /* dst_mask */
116 false), /* pcrel_offset */
117
118 EMPTY_HOWTO (15),
119 EMPTY_HOWTO (16), /* R_SH_IMM8 */
120 EMPTY_HOWTO (17), /* R_SH_IMM8BY2 */
121 EMPTY_HOWTO (18), /* R_SH_IMM8BY4 */
122 EMPTY_HOWTO (19), /* R_SH_IMM4 */
123 EMPTY_HOWTO (20), /* R_SH_IMM4BY2 */
124 EMPTY_HOWTO (21), /* R_SH_IMM4BY4 */
125
126 HOWTO (R_SH_PCRELIMM8BY2, /* type */
127 1, /* rightshift */
128 1, /* size (0 = byte, 1 = short, 2 = long) */
129 8, /* bitsize */
130 true, /* pc_relative */
131 0, /* bitpos */
132 complain_overflow_unsigned, /* complain_on_overflow */
133 sh_reloc, /* special_function */
134 "r_pcrelimm8by2", /* name */
135 true, /* partial_inplace */
136 0xff, /* src_mask */
137 0xff, /* dst_mask */
138 true), /* pcrel_offset */
139
140 HOWTO (R_SH_PCRELIMM8BY4, /* type */
141 2, /* rightshift */
142 1, /* size (0 = byte, 1 = short, 2 = long) */
143 8, /* bitsize */
144 true, /* pc_relative */
145 0, /* bitpos */
146 complain_overflow_unsigned, /* complain_on_overflow */
147 sh_reloc, /* special_function */
148 "r_pcrelimm8by4", /* name */
149 true, /* partial_inplace */
150 0xff, /* src_mask */
151 0xff, /* dst_mask */
152 true), /* pcrel_offset */
153
154 HOWTO (R_SH_IMM16, /* type */
155 0, /* rightshift */
156 1, /* size (0 = byte, 1 = short, 2 = long) */
157 16, /* bitsize */
158 false, /* pc_relative */
159 0, /* bitpos */
160 complain_overflow_bitfield, /* complain_on_overflow */
161 sh_reloc, /* special_function */
162 "r_imm16", /* name */
163 true, /* partial_inplace */
164 0xffff, /* src_mask */
165 0xffff, /* dst_mask */
166 false), /* pcrel_offset */
167
168 HOWTO (R_SH_SWITCH16, /* type */
169 0, /* rightshift */
170 1, /* size (0 = byte, 1 = short, 2 = long) */
171 16, /* bitsize */
172 false, /* pc_relative */
173 0, /* bitpos */
174 complain_overflow_bitfield, /* complain_on_overflow */
175 sh_reloc, /* special_function */
176 "r_switch16", /* name */
177 true, /* partial_inplace */
178 0xffff, /* src_mask */
179 0xffff, /* dst_mask */
180 false), /* pcrel_offset */
181
182 HOWTO (R_SH_SWITCH32, /* type */
183 0, /* rightshift */
184 2, /* size (0 = byte, 1 = short, 2 = long) */
185 32, /* bitsize */
186 false, /* pc_relative */
187 0, /* bitpos */
188 complain_overflow_bitfield, /* complain_on_overflow */
189 sh_reloc, /* special_function */
190 "r_switch32", /* name */
191 true, /* partial_inplace */
192 0xffffffff, /* src_mask */
193 0xffffffff, /* dst_mask */
194 false), /* pcrel_offset */
195
196 HOWTO (R_SH_USES, /* type */
197 0, /* rightshift */
198 1, /* size (0 = byte, 1 = short, 2 = long) */
199 16, /* bitsize */
200 false, /* pc_relative */
201 0, /* bitpos */
202 complain_overflow_bitfield, /* complain_on_overflow */
203 sh_reloc, /* special_function */
204 "r_uses", /* name */
205 true, /* partial_inplace */
206 0xffff, /* src_mask */
207 0xffff, /* dst_mask */
208 false), /* pcrel_offset */
209
210 HOWTO (R_SH_COUNT, /* type */
211 0, /* rightshift */
212 2, /* size (0 = byte, 1 = short, 2 = long) */
213 32, /* bitsize */
214 false, /* pc_relative */
215 0, /* bitpos */
216 complain_overflow_bitfield, /* complain_on_overflow */
217 sh_reloc, /* special_function */
218 "r_count", /* name */
219 true, /* partial_inplace */
220 0xffffffff, /* src_mask */
221 0xffffffff, /* dst_mask */
222 false), /* pcrel_offset */
223
224 HOWTO (R_SH_ALIGN, /* type */
225 0, /* rightshift */
226 2, /* size (0 = byte, 1 = short, 2 = long) */
227 32, /* bitsize */
228 false, /* pc_relative */
229 0, /* bitpos */
230 complain_overflow_bitfield, /* complain_on_overflow */
231 sh_reloc, /* special_function */
232 "r_align", /* name */
233 true, /* partial_inplace */
234 0xffffffff, /* src_mask */
235 0xffffffff, /* dst_mask */
236 false), /* pcrel_offset */
237
238 HOWTO (R_SH_CODE, /* type */
239 0, /* rightshift */
240 2, /* size (0 = byte, 1 = short, 2 = long) */
241 32, /* bitsize */
242 false, /* pc_relative */
243 0, /* bitpos */
244 complain_overflow_bitfield, /* complain_on_overflow */
245 sh_reloc, /* special_function */
246 "r_code", /* name */
247 true, /* partial_inplace */
248 0xffffffff, /* src_mask */
249 0xffffffff, /* dst_mask */
250 false), /* pcrel_offset */
251
252 HOWTO (R_SH_DATA, /* type */
253 0, /* rightshift */
254 2, /* size (0 = byte, 1 = short, 2 = long) */
255 32, /* bitsize */
256 false, /* pc_relative */
257 0, /* bitpos */
258 complain_overflow_bitfield, /* complain_on_overflow */
259 sh_reloc, /* special_function */
260 "r_data", /* name */
261 true, /* partial_inplace */
262 0xffffffff, /* src_mask */
263 0xffffffff, /* dst_mask */
264 false), /* pcrel_offset */
265
266 HOWTO (R_SH_LABEL, /* type */
267 0, /* rightshift */
268 2, /* size (0 = byte, 1 = short, 2 = long) */
269 32, /* bitsize */
270 false, /* pc_relative */
271 0, /* bitpos */
272 complain_overflow_bitfield, /* complain_on_overflow */
273 sh_reloc, /* special_function */
274 "r_label", /* name */
275 true, /* partial_inplace */
276 0xffffffff, /* src_mask */
277 0xffffffff, /* dst_mask */
278 false), /* pcrel_offset */
279
280 HOWTO (R_SH_SWITCH8, /* type */
281 0, /* rightshift */
282 0, /* size (0 = byte, 1 = short, 2 = long) */
283 8, /* bitsize */
284 false, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_bitfield, /* complain_on_overflow */
287 sh_reloc, /* special_function */
288 "r_switch8", /* name */
289 true, /* partial_inplace */
290 0xff, /* src_mask */
291 0xff, /* dst_mask */
292 false) /* pcrel_offset */
293 };
294
295 #define SH_COFF_HOWTO_COUNT (sizeof sh_coff_howtos / sizeof sh_coff_howtos[0])
296
297 /* Check for a bad magic number. */
298 #define BADMAG(x) SHBADMAG(x)
299
300 /* Customize coffcode.h (this is not currently used). */
301 #define SH 1
302
303 /* FIXME: This should not be set here. */
304 #define __A_MAGIC_SET__
305
306 /* Swap the r_offset field in and out. */
307 #define SWAP_IN_RELOC_OFFSET bfd_h_get_32
308 #define SWAP_OUT_RELOC_OFFSET bfd_h_put_32
309
310 /* Swap out extra information in the reloc structure. */
311 #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
312 do \
313 { \
314 dst->r_stuff[0] = 'S'; \
315 dst->r_stuff[1] = 'C'; \
316 } \
317 while (0)
318
319 /* Get the value of a symbol, when performing a relocation. */
320
321 static long
322 get_symbol_value (symbol)
323 asymbol *symbol;
324 {
325 bfd_vma relocation;
326
327 if (bfd_is_com_section (symbol->section))
328 relocation = 0;
329 else
330 relocation = (symbol->value +
331 symbol->section->output_section->vma +
332 symbol->section->output_offset);
333
334 return relocation;
335 }
336
337 /* This macro is used in coffcode.h to get the howto corresponding to
338 an internal reloc. */
339
340 #define RTYPE2HOWTO(relent, internal) \
341 ((relent)->howto = \
342 ((internal)->r_type < SH_COFF_HOWTO_COUNT \
343 ? &sh_coff_howtos[(internal)->r_type] \
344 : (reloc_howto_type *) NULL))
345
346 /* This is the same as the macro in coffcode.h, except that it copies
347 r_offset into reloc_entry->addend for some relocs. */
348 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
349 { \
350 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
351 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
352 coffsym = (obj_symbols (abfd) \
353 + (cache_ptr->sym_ptr_ptr - symbols)); \
354 else if (ptr) \
355 coffsym = coff_symbol_from (abfd, ptr); \
356 if (coffsym != (coff_symbol_type *) NULL \
357 && coffsym->native->u.syment.n_scnum == 0) \
358 cache_ptr->addend = 0; \
359 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
360 && ptr->section != (asection *) NULL) \
361 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
362 else \
363 cache_ptr->addend = 0; \
364 if ((reloc).r_type == R_SH_SWITCH8 \
365 || (reloc).r_type == R_SH_SWITCH16 \
366 || (reloc).r_type == R_SH_SWITCH32 \
367 || (reloc).r_type == R_SH_USES \
368 || (reloc).r_type == R_SH_COUNT \
369 || (reloc).r_type == R_SH_ALIGN) \
370 cache_ptr->addend = (reloc).r_offset; \
371 }
372
373 /* This is the howto function for the SH relocations. */
374
375 static bfd_reloc_status_type
376 sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
377 error_message)
378 bfd *abfd;
379 arelent *reloc_entry;
380 asymbol *symbol_in;
381 PTR data;
382 asection *input_section;
383 bfd *output_bfd;
384 char **error_message ATTRIBUTE_UNUSED;
385 {
386 unsigned long insn;
387 bfd_vma sym_value;
388 unsigned short r_type;
389 bfd_vma addr = reloc_entry->address;
390 bfd_byte *hit_data = addr + (bfd_byte *) data;
391
392 r_type = reloc_entry->howto->type;
393
394 if (output_bfd != NULL)
395 {
396 /* Partial linking--do nothing. */
397 reloc_entry->address += input_section->output_offset;
398 return bfd_reloc_ok;
399 }
400
401 /* Almost all relocs have to do with relaxing. If any work must be
402 done for them, it has been done in sh_relax_section. */
403 if (r_type != R_SH_IMM32
404 && (r_type != R_SH_PCDISP
405 || (symbol_in->flags & BSF_LOCAL) != 0))
406 return bfd_reloc_ok;
407
408 if (symbol_in != NULL
409 && bfd_is_und_section (symbol_in->section))
410 return bfd_reloc_undefined;
411
412 sym_value = get_symbol_value (symbol_in);
413
414 switch (r_type)
415 {
416 case R_SH_IMM32:
417 insn = bfd_get_32 (abfd, hit_data);
418 insn += sym_value + reloc_entry->addend;
419 bfd_put_32 (abfd, insn, hit_data);
420 break;
421 case R_SH_PCDISP:
422 insn = bfd_get_16 (abfd, hit_data);
423 sym_value += reloc_entry->addend;
424 sym_value -= (input_section->output_section->vma
425 + input_section->output_offset
426 + addr
427 + 4);
428 sym_value += (insn & 0xfff) << 1;
429 if (insn & 0x800)
430 sym_value -= 0x1000;
431 insn = (insn & 0xf000) | (sym_value & 0xfff);
432 bfd_put_16 (abfd, insn, hit_data);
433 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
434 return bfd_reloc_overflow;
435 break;
436 default:
437 abort ();
438 break;
439 }
440
441 return bfd_reloc_ok;
442 }
443
444 #define coff_bfd_merge_private_bfd_data _bfd_generic_verify_endian_match
445
446 /* We can do relaxing. */
447 #define coff_bfd_relax_section sh_relax_section
448
449 /* We use the special COFF backend linker. */
450 #define coff_relocate_section sh_relocate_section
451
452 /* When relaxing, we need to use special code to get the relocated
453 section contents. */
454 #define coff_bfd_get_relocated_section_contents \
455 sh_coff_get_relocated_section_contents
456
457 #include "coffcode.h"
458 \f
459 /* This function handles relaxing on the SH.
460
461 Function calls on the SH look like this:
462
463 movl L1,r0
464 ...
465 jsr @r0
466 ...
467 L1:
468 .long function
469
470 The compiler and assembler will cooperate to create R_SH_USES
471 relocs on the jsr instructions. The r_offset field of the
472 R_SH_USES reloc is the PC relative offset to the instruction which
473 loads the register (the r_offset field is computed as though it
474 were a jump instruction, so the offset value is actually from four
475 bytes past the instruction). The linker can use this reloc to
476 determine just which function is being called, and thus decide
477 whether it is possible to replace the jsr with a bsr.
478
479 If multiple function calls are all based on a single register load
480 (i.e., the same function is called multiple times), the compiler
481 guarantees that each function call will have an R_SH_USES reloc.
482 Therefore, if the linker is able to convert each R_SH_USES reloc
483 which refers to that address, it can safely eliminate the register
484 load.
485
486 When the assembler creates an R_SH_USES reloc, it examines it to
487 determine which address is being loaded (L1 in the above example).
488 It then counts the number of references to that address, and
489 creates an R_SH_COUNT reloc at that address. The r_offset field of
490 the R_SH_COUNT reloc will be the number of references. If the
491 linker is able to eliminate a register load, it can use the
492 R_SH_COUNT reloc to see whether it can also eliminate the function
493 address.
494
495 SH relaxing also handles another, unrelated, matter. On the SH, if
496 a load or store instruction is not aligned on a four byte boundary,
497 the memory cycle interferes with the 32 bit instruction fetch,
498 causing a one cycle bubble in the pipeline. Therefore, we try to
499 align load and store instructions on four byte boundaries if we
500 can, by swapping them with one of the adjacent instructions. */
501
502 static boolean
503 sh_relax_section (abfd, sec, link_info, again)
504 bfd *abfd;
505 asection *sec;
506 struct bfd_link_info *link_info;
507 boolean *again;
508 {
509 struct internal_reloc *internal_relocs;
510 struct internal_reloc *free_relocs = NULL;
511 boolean have_code;
512 struct internal_reloc *irel, *irelend;
513 bfd_byte *contents = NULL;
514 bfd_byte *free_contents = NULL;
515
516 *again = false;
517
518 if (link_info->relocateable
519 || (sec->flags & SEC_RELOC) == 0
520 || sec->reloc_count == 0)
521 return true;
522
523 /* If this is the first time we have been called for this section,
524 initialize the cooked size. */
525 if (sec->_cooked_size == 0)
526 sec->_cooked_size = sec->_raw_size;
527
528 internal_relocs = (_bfd_coff_read_internal_relocs
529 (abfd, sec, link_info->keep_memory,
530 (bfd_byte *) NULL, false,
531 (struct internal_reloc *) NULL));
532 if (internal_relocs == NULL)
533 goto error_return;
534 if (! link_info->keep_memory)
535 free_relocs = internal_relocs;
536
537 have_code = false;
538
539 irelend = internal_relocs + sec->reloc_count;
540 for (irel = internal_relocs; irel < irelend; irel++)
541 {
542 bfd_vma laddr, paddr, symval;
543 unsigned short insn;
544 struct internal_reloc *irelfn, *irelscan, *irelcount;
545 struct internal_syment sym;
546 bfd_signed_vma foff;
547
548 if (irel->r_type == R_SH_CODE)
549 have_code = true;
550
551 if (irel->r_type != R_SH_USES)
552 continue;
553
554 /* Get the section contents. */
555 if (contents == NULL)
556 {
557 if (coff_section_data (abfd, sec) != NULL
558 && coff_section_data (abfd, sec)->contents != NULL)
559 contents = coff_section_data (abfd, sec)->contents;
560 else
561 {
562 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
563 if (contents == NULL)
564 goto error_return;
565 free_contents = contents;
566
567 if (! bfd_get_section_contents (abfd, sec, contents,
568 (file_ptr) 0, sec->_raw_size))
569 goto error_return;
570 }
571 }
572
573 /* The r_offset field of the R_SH_USES reloc will point us to
574 the register load. The 4 is because the r_offset field is
575 computed as though it were a jump offset, which are based
576 from 4 bytes after the jump instruction. */
577 laddr = irel->r_vaddr - sec->vma + 4;
578 /* Careful to sign extend the 32-bit offset. */
579 laddr += ((irel->r_offset & 0xffffffff) ^ 0x80000000) - 0x80000000;
580 if (laddr >= sec->_raw_size)
581 {
582 (*_bfd_error_handler) ("%s: 0x%lx: warning: bad R_SH_USES offset",
583 bfd_get_filename (abfd),
584 (unsigned long) irel->r_vaddr);
585 continue;
586 }
587 insn = bfd_get_16 (abfd, contents + laddr);
588
589 /* If the instruction is not mov.l NN,rN, we don't know what to do. */
590 if ((insn & 0xf000) != 0xd000)
591 {
592 ((*_bfd_error_handler)
593 ("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x",
594 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr, insn));
595 continue;
596 }
597
598 /* Get the address from which the register is being loaded. The
599 displacement in the mov.l instruction is quadrupled. It is a
600 displacement from four bytes after the movl instruction, but,
601 before adding in the PC address, two least significant bits
602 of the PC are cleared. We assume that the section is aligned
603 on a four byte boundary. */
604 paddr = insn & 0xff;
605 paddr *= 4;
606 paddr += (laddr + 4) &~ 3;
607 if (paddr >= sec->_raw_size)
608 {
609 ((*_bfd_error_handler)
610 ("%s: 0x%lx: warning: bad R_SH_USES load offset",
611 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr));
612 continue;
613 }
614
615 /* Get the reloc for the address from which the register is
616 being loaded. This reloc will tell us which function is
617 actually being called. */
618 paddr += sec->vma;
619 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
620 if (irelfn->r_vaddr == paddr
621 && irelfn->r_type == R_SH_IMM32)
622 break;
623 if (irelfn >= irelend)
624 {
625 ((*_bfd_error_handler)
626 ("%s: 0x%lx: warning: could not find expected reloc",
627 bfd_get_filename (abfd), (unsigned long) paddr));
628 continue;
629 }
630
631 /* Get the value of the symbol referred to by the reloc. */
632 if (! _bfd_coff_get_external_symbols (abfd))
633 goto error_return;
634 bfd_coff_swap_sym_in (abfd,
635 ((bfd_byte *) obj_coff_external_syms (abfd)
636 + (irelfn->r_symndx
637 * bfd_coff_symesz (abfd))),
638 &sym);
639 if (sym.n_scnum != 0 && sym.n_scnum != sec->target_index)
640 {
641 ((*_bfd_error_handler)
642 ("%s: 0x%lx: warning: symbol in unexpected section",
643 bfd_get_filename (abfd), (unsigned long) paddr));
644 continue;
645 }
646
647 if (sym.n_sclass != C_EXT)
648 {
649 symval = (sym.n_value
650 - sec->vma
651 + sec->output_section->vma
652 + sec->output_offset);
653 }
654 else
655 {
656 struct coff_link_hash_entry *h;
657
658 h = obj_coff_sym_hashes (abfd)[irelfn->r_symndx];
659 BFD_ASSERT (h != NULL);
660 if (h->root.type != bfd_link_hash_defined
661 && h->root.type != bfd_link_hash_defweak)
662 {
663 /* This appears to be a reference to an undefined
664 symbol. Just ignore it--it will be caught by the
665 regular reloc processing. */
666 continue;
667 }
668
669 symval = (h->root.u.def.value
670 + h->root.u.def.section->output_section->vma
671 + h->root.u.def.section->output_offset);
672 }
673
674 symval += bfd_get_32 (abfd, contents + paddr - sec->vma);
675
676 /* See if this function call can be shortened. */
677 foff = (symval
678 - (irel->r_vaddr
679 - sec->vma
680 + sec->output_section->vma
681 + sec->output_offset
682 + 4));
683 if (foff < -0x1000 || foff >= 0x1000)
684 {
685 /* After all that work, we can't shorten this function call. */
686 continue;
687 }
688
689 /* Shorten the function call. */
690
691 /* For simplicity of coding, we are going to modify the section
692 contents, the section relocs, and the BFD symbol table. We
693 must tell the rest of the code not to free up this
694 information. It would be possible to instead create a table
695 of changes which have to be made, as is done in coff-mips.c;
696 that would be more work, but would require less memory when
697 the linker is run. */
698
699 if (coff_section_data (abfd, sec) == NULL)
700 {
701 sec->used_by_bfd =
702 ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
703 if (sec->used_by_bfd == NULL)
704 goto error_return;
705 }
706
707 coff_section_data (abfd, sec)->relocs = internal_relocs;
708 coff_section_data (abfd, sec)->keep_relocs = true;
709 free_relocs = NULL;
710
711 coff_section_data (abfd, sec)->contents = contents;
712 coff_section_data (abfd, sec)->keep_contents = true;
713 free_contents = NULL;
714
715 obj_coff_keep_syms (abfd) = true;
716
717 /* Replace the jsr with a bsr. */
718
719 /* Change the R_SH_USES reloc into an R_SH_PCDISP reloc, and
720 replace the jsr with a bsr. */
721 irel->r_type = R_SH_PCDISP;
722 irel->r_symndx = irelfn->r_symndx;
723 if (sym.n_sclass != C_EXT)
724 {
725 /* If this needs to be changed because of future relaxing,
726 it will be handled here like other internal PCDISP
727 relocs. */
728 bfd_put_16 (abfd,
729 0xb000 | ((foff >> 1) & 0xfff),
730 contents + irel->r_vaddr - sec->vma);
731 }
732 else
733 {
734 /* We can't fully resolve this yet, because the external
735 symbol value may be changed by future relaxing. We let
736 the final link phase handle it. */
737 bfd_put_16 (abfd, 0xb000, contents + irel->r_vaddr - sec->vma);
738 }
739
740 /* See if there is another R_SH_USES reloc referring to the same
741 register load. */
742 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
743 if (irelscan->r_type == R_SH_USES
744 && laddr == irelscan->r_vaddr - sec->vma + 4 + irelscan->r_offset)
745 break;
746 if (irelscan < irelend)
747 {
748 /* Some other function call depends upon this register load,
749 and we have not yet converted that function call.
750 Indeed, we may never be able to convert it. There is
751 nothing else we can do at this point. */
752 continue;
753 }
754
755 /* Look for a R_SH_COUNT reloc on the location where the
756 function address is stored. Do this before deleting any
757 bytes, to avoid confusion about the address. */
758 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
759 if (irelcount->r_vaddr == paddr
760 && irelcount->r_type == R_SH_COUNT)
761 break;
762
763 /* Delete the register load. */
764 if (! sh_relax_delete_bytes (abfd, sec, laddr, 2))
765 goto error_return;
766
767 /* That will change things, so, just in case it permits some
768 other function call to come within range, we should relax
769 again. Note that this is not required, and it may be slow. */
770 *again = true;
771
772 /* Now check whether we got a COUNT reloc. */
773 if (irelcount >= irelend)
774 {
775 ((*_bfd_error_handler)
776 ("%s: 0x%lx: warning: could not find expected COUNT reloc",
777 bfd_get_filename (abfd), (unsigned long) paddr));
778 continue;
779 }
780
781 /* The number of uses is stored in the r_offset field. We've
782 just deleted one. */
783 if (irelcount->r_offset == 0)
784 {
785 ((*_bfd_error_handler) ("%s: 0x%lx: warning: bad count",
786 bfd_get_filename (abfd),
787 (unsigned long) paddr));
788 continue;
789 }
790
791 --irelcount->r_offset;
792
793 /* If there are no more uses, we can delete the address. Reload
794 the address from irelfn, in case it was changed by the
795 previous call to sh_relax_delete_bytes. */
796 if (irelcount->r_offset == 0)
797 {
798 if (! sh_relax_delete_bytes (abfd, sec,
799 irelfn->r_vaddr - sec->vma, 4))
800 goto error_return;
801 }
802
803 /* We've done all we can with that function call. */
804 }
805
806 /* Look for load and store instructions that we can align on four
807 byte boundaries. */
808 if (have_code)
809 {
810 boolean swapped;
811
812 /* Get the section contents. */
813 if (contents == NULL)
814 {
815 if (coff_section_data (abfd, sec) != NULL
816 && coff_section_data (abfd, sec)->contents != NULL)
817 contents = coff_section_data (abfd, sec)->contents;
818 else
819 {
820 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
821 if (contents == NULL)
822 goto error_return;
823 free_contents = contents;
824
825 if (! bfd_get_section_contents (abfd, sec, contents,
826 (file_ptr) 0, sec->_raw_size))
827 goto error_return;
828 }
829 }
830
831 if (! sh_align_loads (abfd, sec, internal_relocs, contents, &swapped))
832 goto error_return;
833
834 if (swapped)
835 {
836 if (coff_section_data (abfd, sec) == NULL)
837 {
838 sec->used_by_bfd =
839 ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
840 if (sec->used_by_bfd == NULL)
841 goto error_return;
842 }
843
844 coff_section_data (abfd, sec)->relocs = internal_relocs;
845 coff_section_data (abfd, sec)->keep_relocs = true;
846 free_relocs = NULL;
847
848 coff_section_data (abfd, sec)->contents = contents;
849 coff_section_data (abfd, sec)->keep_contents = true;
850 free_contents = NULL;
851
852 obj_coff_keep_syms (abfd) = true;
853 }
854 }
855
856 if (free_relocs != NULL)
857 {
858 free (free_relocs);
859 free_relocs = NULL;
860 }
861
862 if (free_contents != NULL)
863 {
864 if (! link_info->keep_memory)
865 free (free_contents);
866 else
867 {
868 /* Cache the section contents for coff_link_input_bfd. */
869 if (coff_section_data (abfd, sec) == NULL)
870 {
871 sec->used_by_bfd =
872 ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
873 if (sec->used_by_bfd == NULL)
874 goto error_return;
875 coff_section_data (abfd, sec)->relocs = NULL;
876 }
877 coff_section_data (abfd, sec)->contents = contents;
878 }
879 }
880
881 return true;
882
883 error_return:
884 if (free_relocs != NULL)
885 free (free_relocs);
886 if (free_contents != NULL)
887 free (free_contents);
888 return false;
889 }
890
891 /* Delete some bytes from a section while relaxing. */
892
893 static boolean
894 sh_relax_delete_bytes (abfd, sec, addr, count)
895 bfd *abfd;
896 asection *sec;
897 bfd_vma addr;
898 int count;
899 {
900 bfd_byte *contents;
901 struct internal_reloc *irel, *irelend;
902 struct internal_reloc *irelalign;
903 bfd_vma toaddr;
904 bfd_byte *esym, *esymend;
905 bfd_size_type symesz;
906 struct coff_link_hash_entry **sym_hash;
907 asection *o;
908
909 contents = coff_section_data (abfd, sec)->contents;
910
911 /* The deletion must stop at the next ALIGN reloc for an aligment
912 power larger than the number of bytes we are deleting. */
913
914 irelalign = NULL;
915 toaddr = sec->_cooked_size;
916
917 irel = coff_section_data (abfd, sec)->relocs;
918 irelend = irel + sec->reloc_count;
919 for (; irel < irelend; irel++)
920 {
921 if (irel->r_type == R_SH_ALIGN
922 && irel->r_vaddr - sec->vma > addr
923 && count < (1 << irel->r_offset))
924 {
925 irelalign = irel;
926 toaddr = irel->r_vaddr - sec->vma;
927 break;
928 }
929 }
930
931 /* Actually delete the bytes. */
932 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
933 if (irelalign == NULL)
934 sec->_cooked_size -= count;
935 else
936 {
937 int i;
938
939 #define NOP_OPCODE (0x0009)
940
941 BFD_ASSERT ((count & 1) == 0);
942 for (i = 0; i < count; i += 2)
943 bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i);
944 }
945
946 /* Adjust all the relocs. */
947 for (irel = coff_section_data (abfd, sec)->relocs; irel < irelend; irel++)
948 {
949 bfd_vma nraddr, stop;
950 bfd_vma start = 0;
951 int insn = 0;
952 struct internal_syment sym;
953 int off, adjust, oinsn;
954 bfd_signed_vma voff = 0;
955 boolean overflow;
956
957 /* Get the new reloc address. */
958 nraddr = irel->r_vaddr - sec->vma;
959 if ((irel->r_vaddr - sec->vma > addr
960 && irel->r_vaddr - sec->vma < toaddr)
961 || (irel->r_type == R_SH_ALIGN
962 && irel->r_vaddr - sec->vma == toaddr))
963 nraddr -= count;
964
965 /* See if this reloc was for the bytes we have deleted, in which
966 case we no longer care about it. Don't delete relocs which
967 represent addresses, though. */
968 if (irel->r_vaddr - sec->vma >= addr
969 && irel->r_vaddr - sec->vma < addr + count
970 && irel->r_type != R_SH_ALIGN
971 && irel->r_type != R_SH_CODE
972 && irel->r_type != R_SH_DATA
973 && irel->r_type != R_SH_LABEL)
974 irel->r_type = R_SH_UNUSED;
975
976 /* If this is a PC relative reloc, see if the range it covers
977 includes the bytes we have deleted. */
978 switch (irel->r_type)
979 {
980 default:
981 break;
982
983 case R_SH_PCDISP8BY2:
984 case R_SH_PCDISP:
985 case R_SH_PCRELIMM8BY2:
986 case R_SH_PCRELIMM8BY4:
987 start = irel->r_vaddr - sec->vma;
988 insn = bfd_get_16 (abfd, contents + nraddr);
989 break;
990 }
991
992 switch (irel->r_type)
993 {
994 default:
995 start = stop = addr;
996 break;
997
998 case R_SH_IMM32:
999 /* If this reloc is against a symbol defined in this
1000 section, and the symbol will not be adjusted below, we
1001 must check the addend to see it will put the value in
1002 range to be adjusted, and hence must be changed. */
1003 bfd_coff_swap_sym_in (abfd,
1004 ((bfd_byte *) obj_coff_external_syms (abfd)
1005 + (irel->r_symndx
1006 * bfd_coff_symesz (abfd))),
1007 &sym);
1008 if (sym.n_sclass != C_EXT
1009 && sym.n_scnum == sec->target_index
1010 && ((bfd_vma) sym.n_value <= addr
1011 || (bfd_vma) sym.n_value >= toaddr))
1012 {
1013 bfd_vma val;
1014
1015 val = bfd_get_32 (abfd, contents + nraddr);
1016 val += sym.n_value;
1017 if (val > addr && val < toaddr)
1018 bfd_put_32 (abfd, val - count, contents + nraddr);
1019 }
1020 start = stop = addr;
1021 break;
1022
1023 case R_SH_PCDISP8BY2:
1024 off = insn & 0xff;
1025 if (off & 0x80)
1026 off -= 0x100;
1027 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1028 break;
1029
1030 case R_SH_PCDISP:
1031 bfd_coff_swap_sym_in (abfd,
1032 ((bfd_byte *) obj_coff_external_syms (abfd)
1033 + (irel->r_symndx
1034 * bfd_coff_symesz (abfd))),
1035 &sym);
1036 if (sym.n_sclass == C_EXT)
1037 start = stop = addr;
1038 else
1039 {
1040 off = insn & 0xfff;
1041 if (off & 0x800)
1042 off -= 0x1000;
1043 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1044 }
1045 break;
1046
1047 case R_SH_PCRELIMM8BY2:
1048 off = insn & 0xff;
1049 stop = start + 4 + off * 2;
1050 break;
1051
1052 case R_SH_PCRELIMM8BY4:
1053 off = insn & 0xff;
1054 stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
1055 break;
1056
1057 case R_SH_SWITCH8:
1058 case R_SH_SWITCH16:
1059 case R_SH_SWITCH32:
1060 /* These relocs types represent
1061 .word L2-L1
1062 The r_offset field holds the difference between the reloc
1063 address and L1. That is the start of the reloc, and
1064 adding in the contents gives us the top. We must adjust
1065 both the r_offset field and the section contents. */
1066
1067 start = irel->r_vaddr - sec->vma;
1068 stop = (bfd_vma) ((bfd_signed_vma) start - (long) irel->r_offset);
1069
1070 if (start > addr
1071 && start < toaddr
1072 && (stop <= addr || stop >= toaddr))
1073 irel->r_offset += count;
1074 else if (stop > addr
1075 && stop < toaddr
1076 && (start <= addr || start >= toaddr))
1077 irel->r_offset -= count;
1078
1079 start = stop;
1080
1081 if (irel->r_type == R_SH_SWITCH16)
1082 voff = bfd_get_signed_16 (abfd, contents + nraddr);
1083 else if (irel->r_type == R_SH_SWITCH8)
1084 voff = bfd_get_8 (abfd, contents + nraddr);
1085 else
1086 voff = bfd_get_signed_32 (abfd, contents + nraddr);
1087 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1088
1089 break;
1090
1091 case R_SH_USES:
1092 start = irel->r_vaddr - sec->vma;
1093 stop = (bfd_vma) ((bfd_signed_vma) start
1094 + (long) irel->r_offset
1095 + 4);
1096 break;
1097 }
1098
1099 if (start > addr
1100 && start < toaddr
1101 && (stop <= addr || stop >= toaddr))
1102 adjust = count;
1103 else if (stop > addr
1104 && stop < toaddr
1105 && (start <= addr || start >= toaddr))
1106 adjust = - count;
1107 else
1108 adjust = 0;
1109
1110 if (adjust != 0)
1111 {
1112 oinsn = insn;
1113 overflow = false;
1114 switch (irel->r_type)
1115 {
1116 default:
1117 abort ();
1118 break;
1119
1120 case R_SH_PCDISP8BY2:
1121 case R_SH_PCRELIMM8BY2:
1122 insn += adjust / 2;
1123 if ((oinsn & 0xff00) != (insn & 0xff00))
1124 overflow = true;
1125 bfd_put_16 (abfd, insn, contents + nraddr);
1126 break;
1127
1128 case R_SH_PCDISP:
1129 insn += adjust / 2;
1130 if ((oinsn & 0xf000) != (insn & 0xf000))
1131 overflow = true;
1132 bfd_put_16 (abfd, insn, contents + nraddr);
1133 break;
1134
1135 case R_SH_PCRELIMM8BY4:
1136 BFD_ASSERT (adjust == count || count >= 4);
1137 if (count >= 4)
1138 insn += adjust / 4;
1139 else
1140 {
1141 if ((irel->r_vaddr & 3) == 0)
1142 ++insn;
1143 }
1144 if ((oinsn & 0xff00) != (insn & 0xff00))
1145 overflow = true;
1146 bfd_put_16 (abfd, insn, contents + nraddr);
1147 break;
1148
1149 case R_SH_SWITCH8:
1150 voff += adjust;
1151 if (voff < 0 || voff >= 0xff)
1152 overflow = true;
1153 bfd_put_8 (abfd, voff, contents + nraddr);
1154 break;
1155
1156 case R_SH_SWITCH16:
1157 voff += adjust;
1158 if (voff < - 0x8000 || voff >= 0x8000)
1159 overflow = true;
1160 bfd_put_signed_16 (abfd, voff, contents + nraddr);
1161 break;
1162
1163 case R_SH_SWITCH32:
1164 voff += adjust;
1165 bfd_put_signed_32 (abfd, voff, contents + nraddr);
1166 break;
1167
1168 case R_SH_USES:
1169 irel->r_offset += adjust;
1170 break;
1171 }
1172
1173 if (overflow)
1174 {
1175 ((*_bfd_error_handler)
1176 ("%s: 0x%lx: fatal: reloc overflow while relaxing",
1177 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr));
1178 bfd_set_error (bfd_error_bad_value);
1179 return false;
1180 }
1181 }
1182
1183 irel->r_vaddr = nraddr + sec->vma;
1184 }
1185
1186 /* Look through all the other sections. If there contain any IMM32
1187 relocs against internal symbols which we are not going to adjust
1188 below, we may need to adjust the addends. */
1189 for (o = abfd->sections; o != NULL; o = o->next)
1190 {
1191 struct internal_reloc *internal_relocs;
1192 struct internal_reloc *irelscan, *irelscanend;
1193 bfd_byte *ocontents;
1194
1195 if (o == sec
1196 || (o->flags & SEC_RELOC) == 0
1197 || o->reloc_count == 0)
1198 continue;
1199
1200 /* We always cache the relocs. Perhaps, if info->keep_memory is
1201 false, we should free them, if we are permitted to, when we
1202 leave sh_coff_relax_section. */
1203 internal_relocs = (_bfd_coff_read_internal_relocs
1204 (abfd, o, true, (bfd_byte *) NULL, false,
1205 (struct internal_reloc *) NULL));
1206 if (internal_relocs == NULL)
1207 return false;
1208
1209 ocontents = NULL;
1210 irelscanend = internal_relocs + o->reloc_count;
1211 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1212 {
1213 struct internal_syment sym;
1214
1215 if (irelscan->r_type != R_SH_IMM32)
1216 continue;
1217
1218 bfd_coff_swap_sym_in (abfd,
1219 ((bfd_byte *) obj_coff_external_syms (abfd)
1220 + (irelscan->r_symndx
1221 * bfd_coff_symesz (abfd))),
1222 &sym);
1223 if (sym.n_sclass != C_EXT
1224 && sym.n_scnum == sec->target_index
1225 && ((bfd_vma) sym.n_value <= addr
1226 || (bfd_vma) sym.n_value >= toaddr))
1227 {
1228 bfd_vma val;
1229
1230 if (ocontents == NULL)
1231 {
1232 if (coff_section_data (abfd, o)->contents != NULL)
1233 ocontents = coff_section_data (abfd, o)->contents;
1234 else
1235 {
1236 /* We always cache the section contents.
1237 Perhaps, if info->keep_memory is false, we
1238 should free them, if we are permitted to,
1239 when we leave sh_coff_relax_section. */
1240 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1241 if (ocontents == NULL)
1242 return false;
1243 if (! bfd_get_section_contents (abfd, o, ocontents,
1244 (file_ptr) 0,
1245 o->_raw_size))
1246 return false;
1247 coff_section_data (abfd, o)->contents = ocontents;
1248 }
1249 }
1250
1251 val = bfd_get_32 (abfd, ocontents + irelscan->r_vaddr - o->vma);
1252 val += sym.n_value;
1253 if (val > addr && val < toaddr)
1254 bfd_put_32 (abfd, val - count,
1255 ocontents + irelscan->r_vaddr - o->vma);
1256
1257 coff_section_data (abfd, o)->keep_contents = true;
1258 }
1259 }
1260 }
1261
1262 /* Adjusting the internal symbols will not work if something has
1263 already retrieved the generic symbols. It would be possible to
1264 make this work by adjusting the generic symbols at the same time.
1265 However, this case should not arise in normal usage. */
1266 if (obj_symbols (abfd) != NULL
1267 || obj_raw_syments (abfd) != NULL)
1268 {
1269 ((*_bfd_error_handler)
1270 ("%s: fatal: generic symbols retrieved before relaxing",
1271 bfd_get_filename (abfd)));
1272 bfd_set_error (bfd_error_invalid_operation);
1273 return false;
1274 }
1275
1276 /* Adjust all the symbols. */
1277 sym_hash = obj_coff_sym_hashes (abfd);
1278 symesz = bfd_coff_symesz (abfd);
1279 esym = (bfd_byte *) obj_coff_external_syms (abfd);
1280 esymend = esym + obj_raw_syment_count (abfd) * symesz;
1281 while (esym < esymend)
1282 {
1283 struct internal_syment isym;
1284
1285 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
1286
1287 if (isym.n_scnum == sec->target_index
1288 && (bfd_vma) isym.n_value > addr
1289 && (bfd_vma) isym.n_value < toaddr)
1290 {
1291 isym.n_value -= count;
1292
1293 bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
1294
1295 if (*sym_hash != NULL)
1296 {
1297 BFD_ASSERT ((*sym_hash)->root.type == bfd_link_hash_defined
1298 || (*sym_hash)->root.type == bfd_link_hash_defweak);
1299 BFD_ASSERT ((*sym_hash)->root.u.def.value >= addr
1300 && (*sym_hash)->root.u.def.value < toaddr);
1301 (*sym_hash)->root.u.def.value -= count;
1302 }
1303 }
1304
1305 esym += (isym.n_numaux + 1) * symesz;
1306 sym_hash += isym.n_numaux + 1;
1307 }
1308
1309 /* See if we can move the ALIGN reloc forward. We have adjusted
1310 r_vaddr for it already. */
1311 if (irelalign != NULL)
1312 {
1313 bfd_vma alignto, alignaddr;
1314
1315 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_offset);
1316 alignaddr = BFD_ALIGN (irelalign->r_vaddr - sec->vma,
1317 1 << irelalign->r_offset);
1318 if (alignto != alignaddr)
1319 {
1320 /* Tail recursion. */
1321 return sh_relax_delete_bytes (abfd, sec, alignaddr,
1322 alignto - alignaddr);
1323 }
1324 }
1325
1326 return true;
1327 }
1328 \f
1329 /* This is yet another version of the SH opcode table, used to rapidly
1330 get information about a particular instruction. */
1331
1332 /* The opcode map is represented by an array of these structures. The
1333 array is indexed by the high order four bits in the instruction. */
1334
1335 struct sh_major_opcode
1336 {
1337 /* A pointer to the instruction list. This is an array which
1338 contains all the instructions with this major opcode. */
1339 const struct sh_minor_opcode *minor_opcodes;
1340 /* The number of elements in minor_opcodes. */
1341 unsigned short count;
1342 };
1343
1344 /* This structure holds information for a set of SH opcodes. The
1345 instruction code is anded with the mask value, and the resulting
1346 value is used to search the order opcode list. */
1347
1348 struct sh_minor_opcode
1349 {
1350 /* The sorted opcode list. */
1351 const struct sh_opcode *opcodes;
1352 /* The number of elements in opcodes. */
1353 unsigned short count;
1354 /* The mask value to use when searching the opcode list. */
1355 unsigned short mask;
1356 };
1357
1358 /* This structure holds information for an SH instruction. An array
1359 of these structures is sorted in order by opcode. */
1360
1361 struct sh_opcode
1362 {
1363 /* The code for this instruction, after it has been anded with the
1364 mask value in the sh_major_opcode structure. */
1365 unsigned short opcode;
1366 /* Flags for this instruction. */
1367 unsigned flags;
1368 };
1369
1370 /* Flag which appear in the sh_opcode structure. */
1371
1372 /* This instruction loads a value from memory. */
1373 #define LOAD (0x1)
1374
1375 /* This instruction stores a value to memory. */
1376 #define STORE (0x2)
1377
1378 /* This instruction is a branch. */
1379 #define BRANCH (0x4)
1380
1381 /* This instruction has a delay slot. */
1382 #define DELAY (0x8)
1383
1384 /* This instruction uses the value in the register in the field at
1385 mask 0x0f00 of the instruction. */
1386 #define USES1 (0x10)
1387 #define USES1_REG(x) ((x & 0x0f00) >> 8)
1388
1389 /* This instruction uses the value in the register in the field at
1390 mask 0x00f0 of the instruction. */
1391 #define USES2 (0x20)
1392 #define USES2_REG(x) ((x & 0x00f0) >> 4)
1393
1394 /* This instruction uses the value in register 0. */
1395 #define USESR0 (0x40)
1396
1397 /* This instruction sets the value in the register in the field at
1398 mask 0x0f00 of the instruction. */
1399 #define SETS1 (0x80)
1400 #define SETS1_REG(x) ((x & 0x0f00) >> 8)
1401
1402 /* This instruction sets the value in the register in the field at
1403 mask 0x00f0 of the instruction. */
1404 #define SETS2 (0x100)
1405 #define SETS2_REG(x) ((x & 0x00f0) >> 4)
1406
1407 /* This instruction sets register 0. */
1408 #define SETSR0 (0x200)
1409
1410 /* This instruction sets a special register. */
1411 #define SETSSP (0x400)
1412
1413 /* This instruction uses a special register. */
1414 #define USESSP (0x800)
1415
1416 /* This instruction uses the floating point register in the field at
1417 mask 0x0f00 of the instruction. */
1418 #define USESF1 (0x1000)
1419 #define USESF1_REG(x) ((x & 0x0f00) >> 8)
1420
1421 /* This instruction uses the floating point register in the field at
1422 mask 0x00f0 of the instruction. */
1423 #define USESF2 (0x2000)
1424 #define USESF2_REG(x) ((x & 0x00f0) >> 4)
1425
1426 /* This instruction uses floating point register 0. */
1427 #define USESF0 (0x4000)
1428
1429 /* This instruction sets the floating point register in the field at
1430 mask 0x0f00 of the instruction. */
1431 #define SETSF1 (0x8000)
1432 #define SETSF1_REG(x) ((x & 0x0f00) >> 8)
1433
1434 #define USESAS (0x10000)
1435 #define USESAS_REG(x) (((((x) >> 8) - 2) & 3) + 2)
1436 #define USESR8 (0x20000)
1437 #define SETSAS (0x40000)
1438 #define SETSAS_REG(x) USESAS_REG (x)
1439
1440 static boolean sh_insn_uses_reg
1441 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
1442 static boolean sh_insn_sets_reg
1443 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
1444 static boolean sh_insn_uses_or_sets_reg
1445 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
1446 static boolean sh_insn_uses_freg
1447 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
1448 static boolean sh_insn_sets_freg
1449 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
1450 static boolean sh_insn_uses_or_sets_freg
1451 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
1452 static boolean sh_insns_conflict
1453 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int,
1454 const struct sh_opcode *));
1455 static boolean sh_load_use
1456 PARAMS ((unsigned int, const struct sh_opcode *, unsigned int,
1457 const struct sh_opcode *));
1458
1459 /* The opcode maps. */
1460
1461 #define MAP(a) a, sizeof a / sizeof a[0]
1462
1463 static const struct sh_opcode sh_opcode00[] =
1464 {
1465 { 0x0008, SETSSP }, /* clrt */
1466 { 0x0009, 0 }, /* nop */
1467 { 0x000b, BRANCH | DELAY | USESSP }, /* rts */
1468 { 0x0018, SETSSP }, /* sett */
1469 { 0x0019, SETSSP }, /* div0u */
1470 { 0x001b, 0 }, /* sleep */
1471 { 0x0028, SETSSP }, /* clrmac */
1472 { 0x002b, BRANCH | DELAY | SETSSP }, /* rte */
1473 { 0x0038, USESSP | SETSSP }, /* ldtlb */
1474 { 0x0048, SETSSP }, /* clrs */
1475 { 0x0058, SETSSP } /* sets */
1476 };
1477
1478 static const struct sh_opcode sh_opcode01[] =
1479 {
1480 { 0x0003, BRANCH | DELAY | USES1 | SETSSP }, /* bsrf rn */
1481 { 0x000a, SETS1 | USESSP }, /* sts mach,rn */
1482 { 0x001a, SETS1 | USESSP }, /* sts macl,rn */
1483 { 0x0023, BRANCH | DELAY | USES1 }, /* braf rn */
1484 { 0x0029, SETS1 | USESSP }, /* movt rn */
1485 { 0x002a, SETS1 | USESSP }, /* sts pr,rn */
1486 { 0x005a, SETS1 | USESSP }, /* sts fpul,rn */
1487 { 0x006a, SETS1 | USESSP }, /* sts fpscr,rn / sts dsr,rn */
1488 { 0x0083, LOAD | USES1 }, /* pref @rn */
1489 { 0x007a, SETS1 | USESSP }, /* sts a0,rn */
1490 { 0x008a, SETS1 | USESSP }, /* sts x0,rn */
1491 { 0x009a, SETS1 | USESSP }, /* sts x1,rn */
1492 { 0x00aa, SETS1 | USESSP }, /* sts y0,rn */
1493 { 0x00ba, SETS1 | USESSP } /* sts y1,rn */
1494 };
1495
1496 /* These sixteen instructions can be handled with one table entry below. */
1497 #if 0
1498 { 0x0002, SETS1 | USESSP }, /* stc sr,rn */
1499 { 0x0012, SETS1 | USESSP }, /* stc gbr,rn */
1500 { 0x0022, SETS1 | USESSP }, /* stc vbr,rn */
1501 { 0x0032, SETS1 | USESSP }, /* stc ssr,rn */
1502 { 0x0042, SETS1 | USESSP }, /* stc spc,rn */
1503 { 0x0052, SETS1 | USESSP }, /* stc mod,rn */
1504 { 0x0062, SETS1 | USESSP }, /* stc rs,rn */
1505 { 0x0072, SETS1 | USESSP }, /* stc re,rn */
1506 { 0x0082, SETS1 | USESSP }, /* stc r0_bank,rn */
1507 { 0x0092, SETS1 | USESSP }, /* stc r1_bank,rn */
1508 { 0x00a2, SETS1 | USESSP }, /* stc r2_bank,rn */
1509 { 0x00b2, SETS1 | USESSP }, /* stc r3_bank,rn */
1510 { 0x00c2, SETS1 | USESSP }, /* stc r4_bank,rn */
1511 { 0x00d2, SETS1 | USESSP }, /* stc r5_bank,rn */
1512 { 0x00e2, SETS1 | USESSP }, /* stc r6_bank,rn */
1513 { 0x00f2, SETS1 | USESSP } /* stc r7_bank,rn */
1514 #endif
1515
1516 static const struct sh_opcode sh_opcode02[] =
1517 {
1518 { 0x0002, SETS1 | USESSP }, /* stc <special_reg>,rn */
1519 { 0x0004, STORE | USES1 | USES2 | USESR0 }, /* mov.b rm,@(r0,rn) */
1520 { 0x0005, STORE | USES1 | USES2 | USESR0 }, /* mov.w rm,@(r0,rn) */
1521 { 0x0006, STORE | USES1 | USES2 | USESR0 }, /* mov.l rm,@(r0,rn) */
1522 { 0x0007, SETSSP | USES1 | USES2 }, /* mul.l rm,rn */
1523 { 0x000c, LOAD | SETS1 | USES2 | USESR0 }, /* mov.b @(r0,rm),rn */
1524 { 0x000d, LOAD | SETS1 | USES2 | USESR0 }, /* mov.w @(r0,rm),rn */
1525 { 0x000e, LOAD | SETS1 | USES2 | USESR0 }, /* mov.l @(r0,rm),rn */
1526 { 0x000f, LOAD|SETS1|SETS2|SETSSP|USES1|USES2|USESSP }, /* mac.l @rm+,@rn+ */
1527 };
1528
1529 static const struct sh_minor_opcode sh_opcode0[] =
1530 {
1531 { MAP (sh_opcode00), 0xffff },
1532 { MAP (sh_opcode01), 0xf0ff },
1533 { MAP (sh_opcode02), 0xf00f }
1534 };
1535
1536 static const struct sh_opcode sh_opcode10[] =
1537 {
1538 { 0x1000, STORE | USES1 | USES2 } /* mov.l rm,@(disp,rn) */
1539 };
1540
1541 static const struct sh_minor_opcode sh_opcode1[] =
1542 {
1543 { MAP (sh_opcode10), 0xf000 }
1544 };
1545
1546 static const struct sh_opcode sh_opcode20[] =
1547 {
1548 { 0x2000, STORE | USES1 | USES2 }, /* mov.b rm,@rn */
1549 { 0x2001, STORE | USES1 | USES2 }, /* mov.w rm,@rn */
1550 { 0x2002, STORE | USES1 | USES2 }, /* mov.l rm,@rn */
1551 { 0x2004, STORE | SETS1 | USES1 | USES2 }, /* mov.b rm,@-rn */
1552 { 0x2005, STORE | SETS1 | USES1 | USES2 }, /* mov.w rm,@-rn */
1553 { 0x2006, STORE | SETS1 | USES1 | USES2 }, /* mov.l rm,@-rn */
1554 { 0x2007, SETSSP | USES1 | USES2 | USESSP }, /* div0s */
1555 { 0x2008, SETSSP | USES1 | USES2 }, /* tst rm,rn */
1556 { 0x2009, SETS1 | USES1 | USES2 }, /* and rm,rn */
1557 { 0x200a, SETS1 | USES1 | USES2 }, /* xor rm,rn */
1558 { 0x200b, SETS1 | USES1 | USES2 }, /* or rm,rn */
1559 { 0x200c, SETSSP | USES1 | USES2 }, /* cmp/str rm,rn */
1560 { 0x200d, SETS1 | USES1 | USES2 }, /* xtrct rm,rn */
1561 { 0x200e, SETSSP | USES1 | USES2 }, /* mulu.w rm,rn */
1562 { 0x200f, SETSSP | USES1 | USES2 } /* muls.w rm,rn */
1563 };
1564
1565 static const struct sh_minor_opcode sh_opcode2[] =
1566 {
1567 { MAP (sh_opcode20), 0xf00f }
1568 };
1569
1570 static const struct sh_opcode sh_opcode30[] =
1571 {
1572 { 0x3000, SETSSP | USES1 | USES2 }, /* cmp/eq rm,rn */
1573 { 0x3002, SETSSP | USES1 | USES2 }, /* cmp/hs rm,rn */
1574 { 0x3003, SETSSP | USES1 | USES2 }, /* cmp/ge rm,rn */
1575 { 0x3004, SETSSP | USESSP | USES1 | USES2 }, /* div1 rm,rn */
1576 { 0x3005, SETSSP | USES1 | USES2 }, /* dmulu.l rm,rn */
1577 { 0x3006, SETSSP | USES1 | USES2 }, /* cmp/hi rm,rn */
1578 { 0x3007, SETSSP | USES1 | USES2 }, /* cmp/gt rm,rn */
1579 { 0x3008, SETS1 | USES1 | USES2 }, /* sub rm,rn */
1580 { 0x300a, SETS1 | SETSSP | USES1 | USES2 | USESSP }, /* subc rm,rn */
1581 { 0x300b, SETS1 | SETSSP | USES1 | USES2 }, /* subv rm,rn */
1582 { 0x300c, SETS1 | USES1 | USES2 }, /* add rm,rn */
1583 { 0x300d, SETSSP | USES1 | USES2 }, /* dmuls.l rm,rn */
1584 { 0x300e, SETS1 | SETSSP | USES1 | USES2 | USESSP }, /* addc rm,rn */
1585 { 0x300f, SETS1 | SETSSP | USES1 | USES2 } /* addv rm,rn */
1586 };
1587
1588 static const struct sh_minor_opcode sh_opcode3[] =
1589 {
1590 { MAP (sh_opcode30), 0xf00f }
1591 };
1592
1593 static const struct sh_opcode sh_opcode40[] =
1594 {
1595 { 0x4000, SETS1 | SETSSP | USES1 }, /* shll rn */
1596 { 0x4001, SETS1 | SETSSP | USES1 }, /* shlr rn */
1597 { 0x4002, STORE | SETS1 | USES1 | USESSP }, /* sts.l mach,@-rn */
1598 { 0x4004, SETS1 | SETSSP | USES1 }, /* rotl rn */
1599 { 0x4005, SETS1 | SETSSP | USES1 }, /* rotr rn */
1600 { 0x4006, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,mach */
1601 { 0x4008, SETS1 | USES1 }, /* shll2 rn */
1602 { 0x4009, SETS1 | USES1 }, /* shlr2 rn */
1603 { 0x400a, SETSSP | USES1 }, /* lds rm,mach */
1604 { 0x400b, BRANCH | DELAY | USES1 }, /* jsr @rn */
1605 { 0x4010, SETS1 | SETSSP | USES1 }, /* dt rn */
1606 { 0x4011, SETSSP | USES1 }, /* cmp/pz rn */
1607 { 0x4012, STORE | SETS1 | USES1 | USESSP }, /* sts.l macl,@-rn */
1608 { 0x4014, SETSSP | USES1 }, /* setrc rm */
1609 { 0x4015, SETSSP | USES1 }, /* cmp/pl rn */
1610 { 0x4016, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,macl */
1611 { 0x4018, SETS1 | USES1 }, /* shll8 rn */
1612 { 0x4019, SETS1 | USES1 }, /* shlr8 rn */
1613 { 0x401a, SETSSP | USES1 }, /* lds rm,macl */
1614 { 0x401b, LOAD | SETSSP | USES1 }, /* tas.b @rn */
1615 { 0x4020, SETS1 | SETSSP | USES1 }, /* shal rn */
1616 { 0x4021, SETS1 | SETSSP | USES1 }, /* shar rn */
1617 { 0x4022, STORE | SETS1 | USES1 | USESSP }, /* sts.l pr,@-rn */
1618 { 0x4024, SETS1 | SETSSP | USES1 | USESSP }, /* rotcl rn */
1619 { 0x4025, SETS1 | SETSSP | USES1 | USESSP }, /* rotcr rn */
1620 { 0x4026, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,pr */
1621 { 0x4028, SETS1 | USES1 }, /* shll16 rn */
1622 { 0x4029, SETS1 | USES1 }, /* shlr16 rn */
1623 { 0x402a, SETSSP | USES1 }, /* lds rm,pr */
1624 { 0x402b, BRANCH | DELAY | USES1 }, /* jmp @rn */
1625 { 0x4052, STORE | SETS1 | USES1 | USESSP }, /* sts.l fpul,@-rn */
1626 { 0x4056, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,fpul */
1627 { 0x405a, SETSSP | USES1 }, /* lds.l rm,fpul */
1628 { 0x4062, STORE | SETS1 | USES1 | USESSP }, /* sts.l fpscr / dsr,@-rn */
1629 { 0x4066, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,fpscr / dsr */
1630 { 0x406a, SETSSP | USES1 }, /* lds rm,fpscr / lds rm,dsr */
1631 { 0x4072, STORE | SETS1 | USES1 | USESSP }, /* sts.l a0,@-rn */
1632 { 0x4076, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,a0 */
1633 { 0x407a, SETSSP | USES1 }, /* lds.l rm,a0 */
1634 { 0x4082, STORE | SETS1 | USES1 | USESSP }, /* sts.l x0,@-rn */
1635 { 0x4086, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,x0 */
1636 { 0x408a, SETSSP | USES1 }, /* lds.l rm,x0 */
1637 { 0x4092, STORE | SETS1 | USES1 | USESSP }, /* sts.l x1,@-rn */
1638 { 0x4096, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,x1 */
1639 { 0x409a, SETSSP | USES1 }, /* lds.l rm,x1 */
1640 { 0x40a2, STORE | SETS1 | USES1 | USESSP }, /* sts.l y0,@-rn */
1641 { 0x40a6, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,y0 */
1642 { 0x40aa, SETSSP | USES1 }, /* lds.l rm,y0 */
1643 { 0x40b2, STORE | SETS1 | USES1 | USESSP }, /* sts.l y1,@-rn */
1644 { 0x40b6, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,y1 */
1645 { 0x40ba, SETSSP | USES1 } /* lds.l rm,y1 */
1646 #if 0 /* These groups sixteen insns can be
1647 handled with one table entry each below. */
1648 { 0x4003, STORE | SETS1 | USES1 | USESSP }, /* stc.l sr,@-rn */
1649 { 0x4013, STORE | SETS1 | USES1 | USESSP }, /* stc.l gbr,@-rn */
1650 { 0x4023, STORE | SETS1 | USES1 | USESSP }, /* stc.l vbr,@-rn */
1651 { 0x4033, STORE | SETS1 | USES1 | USESSP }, /* stc.l ssr,@-rn */
1652 { 0x4043, STORE | SETS1 | USES1 | USESSP }, /* stc.l spc,@-rn */
1653 { 0x4053, STORE | SETS1 | USES1 | USESSP }, /* stc.l mod,@-rn */
1654 { 0x4063, STORE | SETS1 | USES1 | USESSP }, /* stc.l rs,@-rn */
1655 { 0x4073, STORE | SETS1 | USES1 | USESSP }, /* stc.l re,@-rn */
1656 { 0x4083, STORE | SETS1 | USES1 | USESSP }, /* stc.l r0_bank,@-rn */
1657 ..
1658 { 0x40f3, STORE | SETS1 | USES1 | USESSP }, /* stc.l r7_bank,@-rn */
1659
1660 { 0x4007, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,sr */
1661 { 0x4017, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,gbr */
1662 { 0x4027, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,vbr */
1663 { 0x4037, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,ssr */
1664 { 0x4047, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,spc */
1665 { 0x4057, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,mod */
1666 { 0x4067, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,rs */
1667 { 0x4077, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,re */
1668 { 0x4087, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,r0_bank */
1669 ..
1670 { 0x40f7, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,r7_bank */
1671
1672 { 0x400e, SETSSP | USES1 }, /* ldc rm,sr */
1673 { 0x401e, SETSSP | USES1 }, /* ldc rm,gbr */
1674 { 0x402e, SETSSP | USES1 }, /* ldc rm,vbr */
1675 { 0x403e, SETSSP | USES1 }, /* ldc rm,ssr */
1676 { 0x404e, SETSSP | USES1 }, /* ldc rm,spc */
1677 { 0x405e, SETSSP | USES1 }, /* ldc rm,mod */
1678 { 0x406e, SETSSP | USES1 }, /* ldc rm,rs */
1679 { 0x407e, SETSSP | USES1 } /* ldc rm,re */
1680 { 0x408e, SETSSP | USES1 } /* ldc rm,r0_bank */
1681 ..
1682 { 0x40fe, SETSSP | USES1 } /* ldc rm,r7_bank */
1683 #endif
1684 };
1685
1686 static const struct sh_opcode sh_opcode41[] =
1687 {
1688 { 0x4003, STORE | SETS1 | USES1 | USESSP }, /* stc.l <special_reg>,@-rn */
1689 { 0x4007, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,<special_reg> */
1690 { 0x400c, SETS1 | USES1 | USES2 }, /* shad rm,rn */
1691 { 0x400d, SETS1 | USES1 | USES2 }, /* shld rm,rn */
1692 { 0x400e, SETSSP | USES1 }, /* ldc rm,<special_reg> */
1693 { 0x400f, LOAD|SETS1|SETS2|SETSSP|USES1|USES2|USESSP }, /* mac.w @rm+,@rn+ */
1694 };
1695
1696 static const struct sh_minor_opcode sh_opcode4[] =
1697 {
1698 { MAP (sh_opcode40), 0xf0ff },
1699 { MAP (sh_opcode41), 0xf00f }
1700 };
1701
1702 static const struct sh_opcode sh_opcode50[] =
1703 {
1704 { 0x5000, LOAD | SETS1 | USES2 } /* mov.l @(disp,rm),rn */
1705 };
1706
1707 static const struct sh_minor_opcode sh_opcode5[] =
1708 {
1709 { MAP (sh_opcode50), 0xf000 }
1710 };
1711
1712 static const struct sh_opcode sh_opcode60[] =
1713 {
1714 { 0x6000, LOAD | SETS1 | USES2 }, /* mov.b @rm,rn */
1715 { 0x6001, LOAD | SETS1 | USES2 }, /* mov.w @rm,rn */
1716 { 0x6002, LOAD | SETS1 | USES2 }, /* mov.l @rm,rn */
1717 { 0x6003, SETS1 | USES2 }, /* mov rm,rn */
1718 { 0x6004, LOAD | SETS1 | SETS2 | USES2 }, /* mov.b @rm+,rn */
1719 { 0x6005, LOAD | SETS1 | SETS2 | USES2 }, /* mov.w @rm+,rn */
1720 { 0x6006, LOAD | SETS1 | SETS2 | USES2 }, /* mov.l @rm+,rn */
1721 { 0x6007, SETS1 | USES2 }, /* not rm,rn */
1722 { 0x6008, SETS1 | USES2 }, /* swap.b rm,rn */
1723 { 0x6009, SETS1 | USES2 }, /* swap.w rm,rn */
1724 { 0x600a, SETS1 | SETSSP | USES2 | USESSP }, /* negc rm,rn */
1725 { 0x600b, SETS1 | USES2 }, /* neg rm,rn */
1726 { 0x600c, SETS1 | USES2 }, /* extu.b rm,rn */
1727 { 0x600d, SETS1 | USES2 }, /* extu.w rm,rn */
1728 { 0x600e, SETS1 | USES2 }, /* exts.b rm,rn */
1729 { 0x600f, SETS1 | USES2 } /* exts.w rm,rn */
1730 };
1731
1732 static const struct sh_minor_opcode sh_opcode6[] =
1733 {
1734 { MAP (sh_opcode60), 0xf00f }
1735 };
1736
1737 static const struct sh_opcode sh_opcode70[] =
1738 {
1739 { 0x7000, SETS1 | USES1 } /* add #imm,rn */
1740 };
1741
1742 static const struct sh_minor_opcode sh_opcode7[] =
1743 {
1744 { MAP (sh_opcode70), 0xf000 }
1745 };
1746
1747 static const struct sh_opcode sh_opcode80[] =
1748 {
1749 { 0x8000, STORE | USES2 | USESR0 }, /* mov.b r0,@(disp,rn) */
1750 { 0x8100, STORE | USES2 | USESR0 }, /* mov.w r0,@(disp,rn) */
1751 { 0x8200, SETSSP }, /* setrc #imm */
1752 { 0x8400, LOAD | SETSR0 | USES2 }, /* mov.b @(disp,rm),r0 */
1753 { 0x8500, LOAD | SETSR0 | USES2 }, /* mov.w @(disp,rn),r0 */
1754 { 0x8800, SETSSP | USESR0 }, /* cmp/eq #imm,r0 */
1755 { 0x8900, BRANCH | USESSP }, /* bt label */
1756 { 0x8b00, BRANCH | USESSP }, /* bf label */
1757 { 0x8c00, SETSSP }, /* ldrs @(disp,pc) */
1758 { 0x8d00, BRANCH | DELAY | USESSP }, /* bt/s label */
1759 { 0x8e00, SETSSP }, /* ldre @(disp,pc) */
1760 { 0x8f00, BRANCH | DELAY | USESSP } /* bf/s label */
1761 };
1762
1763 static const struct sh_minor_opcode sh_opcode8[] =
1764 {
1765 { MAP (sh_opcode80), 0xff00 }
1766 };
1767
1768 static const struct sh_opcode sh_opcode90[] =
1769 {
1770 { 0x9000, LOAD | SETS1 } /* mov.w @(disp,pc),rn */
1771 };
1772
1773 static const struct sh_minor_opcode sh_opcode9[] =
1774 {
1775 { MAP (sh_opcode90), 0xf000 }
1776 };
1777
1778 static const struct sh_opcode sh_opcodea0[] =
1779 {
1780 { 0xa000, BRANCH | DELAY } /* bra label */
1781 };
1782
1783 static const struct sh_minor_opcode sh_opcodea[] =
1784 {
1785 { MAP (sh_opcodea0), 0xf000 }
1786 };
1787
1788 static const struct sh_opcode sh_opcodeb0[] =
1789 {
1790 { 0xb000, BRANCH | DELAY } /* bsr label */
1791 };
1792
1793 static const struct sh_minor_opcode sh_opcodeb[] =
1794 {
1795 { MAP (sh_opcodeb0), 0xf000 }
1796 };
1797
1798 static const struct sh_opcode sh_opcodec0[] =
1799 {
1800 { 0xc000, STORE | USESR0 | USESSP }, /* mov.b r0,@(disp,gbr) */
1801 { 0xc100, STORE | USESR0 | USESSP }, /* mov.w r0,@(disp,gbr) */
1802 { 0xc200, STORE | USESR0 | USESSP }, /* mov.l r0,@(disp,gbr) */
1803 { 0xc300, BRANCH | USESSP }, /* trapa #imm */
1804 { 0xc400, LOAD | SETSR0 | USESSP }, /* mov.b @(disp,gbr),r0 */
1805 { 0xc500, LOAD | SETSR0 | USESSP }, /* mov.w @(disp,gbr),r0 */
1806 { 0xc600, LOAD | SETSR0 | USESSP }, /* mov.l @(disp,gbr),r0 */
1807 { 0xc700, SETSR0 }, /* mova @(disp,pc),r0 */
1808 { 0xc800, SETSSP | USESR0 }, /* tst #imm,r0 */
1809 { 0xc900, SETSR0 | USESR0 }, /* and #imm,r0 */
1810 { 0xca00, SETSR0 | USESR0 }, /* xor #imm,r0 */
1811 { 0xcb00, SETSR0 | USESR0 }, /* or #imm,r0 */
1812 { 0xcc00, LOAD | SETSSP | USESR0 | USESSP }, /* tst.b #imm,@(r0,gbr) */
1813 { 0xcd00, LOAD | STORE | USESR0 | USESSP }, /* and.b #imm,@(r0,gbr) */
1814 { 0xce00, LOAD | STORE | USESR0 | USESSP }, /* xor.b #imm,@(r0,gbr) */
1815 { 0xcf00, LOAD | STORE | USESR0 | USESSP } /* or.b #imm,@(r0,gbr) */
1816 };
1817
1818 static const struct sh_minor_opcode sh_opcodec[] =
1819 {
1820 { MAP (sh_opcodec0), 0xff00 }
1821 };
1822
1823 static const struct sh_opcode sh_opcoded0[] =
1824 {
1825 { 0xd000, LOAD | SETS1 } /* mov.l @(disp,pc),rn */
1826 };
1827
1828 static const struct sh_minor_opcode sh_opcoded[] =
1829 {
1830 { MAP (sh_opcoded0), 0xf000 }
1831 };
1832
1833 static const struct sh_opcode sh_opcodee0[] =
1834 {
1835 { 0xe000, SETS1 } /* mov #imm,rn */
1836 };
1837
1838 static const struct sh_minor_opcode sh_opcodee[] =
1839 {
1840 { MAP (sh_opcodee0), 0xf000 }
1841 };
1842
1843 static const struct sh_opcode sh_opcodef0[] =
1844 {
1845 { 0xf000, SETSF1 | USESF1 | USESF2 }, /* fadd fm,fn */
1846 { 0xf001, SETSF1 | USESF1 | USESF2 }, /* fsub fm,fn */
1847 { 0xf002, SETSF1 | USESF1 | USESF2 }, /* fmul fm,fn */
1848 { 0xf003, SETSF1 | USESF1 | USESF2 }, /* fdiv fm,fn */
1849 { 0xf004, SETSSP | USESF1 | USESF2 }, /* fcmp/eq fm,fn */
1850 { 0xf005, SETSSP | USESF1 | USESF2 }, /* fcmp/gt fm,fn */
1851 { 0xf006, LOAD | SETSF1 | USES2 | USESR0 }, /* fmov.s @(r0,rm),fn */
1852 { 0xf007, STORE | USES1 | USESF2 | USESR0 }, /* fmov.s fm,@(r0,rn) */
1853 { 0xf008, LOAD | SETSF1 | USES2 }, /* fmov.s @rm,fn */
1854 { 0xf009, LOAD | SETS2 | SETSF1 | USES2 }, /* fmov.s @rm+,fn */
1855 { 0xf00a, STORE | USES1 | USESF2 }, /* fmov.s fm,@rn */
1856 { 0xf00b, STORE | SETS1 | USES1 | USESF2 }, /* fmov.s fm,@-rn */
1857 { 0xf00c, SETSF1 | USESF2 }, /* fmov fm,fn */
1858 { 0xf00e, SETSF1 | USESF1 | USESF2 | USESF0 } /* fmac f0,fm,fn */
1859 };
1860
1861 static const struct sh_opcode sh_opcodef1[] =
1862 {
1863 { 0xf00d, SETSF1 | USESSP }, /* fsts fpul,fn */
1864 { 0xf01d, SETSSP | USESF1 }, /* flds fn,fpul */
1865 { 0xf02d, SETSF1 | USESSP }, /* float fpul,fn */
1866 { 0xf03d, SETSSP | USESF1 }, /* ftrc fn,fpul */
1867 { 0xf04d, SETSF1 | USESF1 }, /* fneg fn */
1868 { 0xf05d, SETSF1 | USESF1 }, /* fabs fn */
1869 { 0xf06d, SETSF1 | USESF1 }, /* fsqrt fn */
1870 { 0xf07d, SETSSP | USESF1 }, /* ftst/nan fn */
1871 { 0xf08d, SETSF1 }, /* fldi0 fn */
1872 { 0xf09d, SETSF1 } /* fldi1 fn */
1873 };
1874
1875 static const struct sh_minor_opcode sh_opcodef[] =
1876 {
1877 { MAP (sh_opcodef0), 0xf00f },
1878 { MAP (sh_opcodef1), 0xf0ff }
1879 };
1880
1881 static struct sh_major_opcode sh_opcodes[] =
1882 {
1883 { MAP (sh_opcode0) },
1884 { MAP (sh_opcode1) },
1885 { MAP (sh_opcode2) },
1886 { MAP (sh_opcode3) },
1887 { MAP (sh_opcode4) },
1888 { MAP (sh_opcode5) },
1889 { MAP (sh_opcode6) },
1890 { MAP (sh_opcode7) },
1891 { MAP (sh_opcode8) },
1892 { MAP (sh_opcode9) },
1893 { MAP (sh_opcodea) },
1894 { MAP (sh_opcodeb) },
1895 { MAP (sh_opcodec) },
1896 { MAP (sh_opcoded) },
1897 { MAP (sh_opcodee) },
1898 { MAP (sh_opcodef) }
1899 };
1900
1901 /* The double data transfer / parallel processing insns are not
1902 described here. This will cause sh_align_load_span to leave them alone. */
1903
1904 static const struct sh_opcode sh_dsp_opcodef0[] =
1905 {
1906 { 0xf400, USESAS | SETSAS | LOAD | SETSSP }, /* movs.x @-as,ds */
1907 { 0xf401, USESAS | SETSAS | STORE | USESSP }, /* movs.x ds,@-as */
1908 { 0xf404, USESAS | LOAD | SETSSP }, /* movs.x @as,ds */
1909 { 0xf405, USESAS | STORE | USESSP }, /* movs.x ds,@as */
1910 { 0xf408, USESAS | SETSAS | LOAD | SETSSP }, /* movs.x @as+,ds */
1911 { 0xf409, USESAS | SETSAS | STORE | USESSP }, /* movs.x ds,@as+ */
1912 { 0xf40c, USESAS | SETSAS | LOAD | SETSSP | USESR8 }, /* movs.x @as+r8,ds */
1913 { 0xf40d, USESAS | SETSAS | STORE | USESSP | USESR8 } /* movs.x ds,@as+r8 */
1914 };
1915
1916 static const struct sh_minor_opcode sh_dsp_opcodef[] =
1917 {
1918 { MAP (sh_dsp_opcodef0), 0xfc0d }
1919 };
1920
1921 /* Given an instruction, return a pointer to the corresponding
1922 sh_opcode structure. Return NULL if the instruction is not
1923 recognized. */
1924
1925 static const struct sh_opcode *
1926 sh_insn_info (insn)
1927 unsigned int insn;
1928 {
1929 const struct sh_major_opcode *maj;
1930 const struct sh_minor_opcode *min, *minend;
1931
1932 maj = &sh_opcodes[(insn & 0xf000) >> 12];
1933 min = maj->minor_opcodes;
1934 minend = min + maj->count;
1935 for (; min < minend; min++)
1936 {
1937 unsigned int l;
1938 const struct sh_opcode *op, *opend;
1939
1940 l = insn & min->mask;
1941 op = min->opcodes;
1942 opend = op + min->count;
1943
1944 /* Since the opcodes tables are sorted, we could use a binary
1945 search here if the count were above some cutoff value. */
1946 for (; op < opend; op++)
1947 if (op->opcode == l)
1948 return op;
1949 }
1950
1951 return NULL;
1952 }
1953
1954 /* See whether an instruction uses or sets a general purpose register */
1955
1956 static boolean
1957 sh_insn_uses_or_sets_reg (insn, op, reg)
1958 unsigned int insn;
1959 const struct sh_opcode *op;
1960 unsigned int reg;
1961 {
1962 if (sh_insn_uses_reg (insn, op, reg))
1963 return true;
1964
1965 return sh_insn_sets_reg (insn, op, reg);
1966 }
1967
1968 /* See whether an instruction uses a general purpose register. */
1969
1970 static boolean
1971 sh_insn_uses_reg (insn, op, reg)
1972 unsigned int insn;
1973 const struct sh_opcode *op;
1974 unsigned int reg;
1975 {
1976 unsigned int f;
1977
1978 f = op->flags;
1979
1980 if ((f & USES1) != 0
1981 && USES1_REG (insn) == reg)
1982 return true;
1983 if ((f & USES2) != 0
1984 && USES2_REG (insn) == reg)
1985 return true;
1986 if ((f & USESR0) != 0
1987 && reg == 0)
1988 return true;
1989 if ((f & USESAS) && reg == USESAS_REG (insn))
1990 return true;
1991 if ((f & USESR8) && reg == 8)
1992 return true;
1993
1994 return false;
1995 }
1996 /* See whether an instruction sets a general purpose register. */
1997
1998 static boolean
1999 sh_insn_sets_reg (insn, op, reg)
2000 unsigned int insn;
2001 const struct sh_opcode *op;
2002 unsigned int reg;
2003 {
2004 unsigned int f;
2005
2006 f = op->flags;
2007
2008 if ((f & SETS1) != 0
2009 && SETS1_REG (insn) == reg)
2010 return true;
2011 if ((f & SETS2) != 0
2012 && SETS2_REG (insn) == reg)
2013 return true;
2014 if ((f & SETSR0) != 0
2015 && reg == 0)
2016 return true;
2017 if ((f & SETSAS) && reg == SETSAS_REG (insn))
2018 return true;
2019
2020 return false;
2021 }
2022
2023 /* See whether an instruction uses or sets a floating point register */
2024
2025 static boolean
2026 sh_insn_uses_or_sets_freg (insn, op, reg)
2027 unsigned int insn;
2028 const struct sh_opcode *op;
2029 unsigned int reg;
2030 {
2031 if (sh_insn_uses_freg (insn, op, reg))
2032 return true;
2033
2034 return sh_insn_sets_freg (insn, op, reg);
2035 }
2036
2037 /* See whether an instruction uses a floating point register. */
2038
2039 static boolean
2040 sh_insn_uses_freg (insn, op, freg)
2041 unsigned int insn;
2042 const struct sh_opcode *op;
2043 unsigned int freg;
2044 {
2045 unsigned int f;
2046
2047 f = op->flags;
2048
2049 /* We can't tell if this is a double-precision insn, so just play safe
2050 and assume that it might be. So not only have we test FREG against
2051 itself, but also even FREG against FREG+1 - if the using insn uses
2052 just the low part of a double precision value - but also an odd
2053 FREG against FREG-1 - if the setting insn sets just the low part
2054 of a double precision value.
2055 So what this all boils down to is that we have to ignore the lowest
2056 bit of the register number. */
2057
2058 if ((f & USESF1) != 0
2059 && (USESF1_REG (insn) & 0xe) == (freg & 0xe))
2060 return true;
2061 if ((f & USESF2) != 0
2062 && (USESF2_REG (insn) & 0xe) == (freg & 0xe))
2063 return true;
2064 if ((f & USESF0) != 0
2065 && freg == 0)
2066 return true;
2067
2068 return false;
2069 }
2070
2071 /* See whether an instruction sets a floating point register. */
2072
2073 static boolean
2074 sh_insn_sets_freg (insn, op, freg)
2075 unsigned int insn;
2076 const struct sh_opcode *op;
2077 unsigned int freg;
2078 {
2079 unsigned int f;
2080
2081 f = op->flags;
2082
2083 /* We can't tell if this is a double-precision insn, so just play safe
2084 and assume that it might be. So not only have we test FREG against
2085 itself, but also even FREG against FREG+1 - if the using insn uses
2086 just the low part of a double precision value - but also an odd
2087 FREG against FREG-1 - if the setting insn sets just the low part
2088 of a double precision value.
2089 So what this all boils down to is that we have to ignore the lowest
2090 bit of the register number. */
2091
2092 if ((f & SETSF1) != 0
2093 && (SETSF1_REG (insn) & 0xe) == (freg & 0xe))
2094 return true;
2095
2096 return false;
2097 }
2098
2099 /* See whether instructions I1 and I2 conflict, assuming I1 comes
2100 before I2. OP1 and OP2 are the corresponding sh_opcode structures.
2101 This should return true if there is a conflict, or false if the
2102 instructions can be swapped safely. */
2103
2104 static boolean
2105 sh_insns_conflict (i1, op1, i2, op2)
2106 unsigned int i1;
2107 const struct sh_opcode *op1;
2108 unsigned int i2;
2109 const struct sh_opcode *op2;
2110 {
2111 unsigned int f1, f2;
2112
2113 f1 = op1->flags;
2114 f2 = op2->flags;
2115
2116 /* Load of fpscr conflicts with floating point operations.
2117 FIXME: shouldn't test raw opcodes here. */
2118 if (((i1 & 0xf0ff) == 0x4066 && (i2 & 0xf000) == 0xf000)
2119 || ((i2 & 0xf0ff) == 0x4066 && (i1 & 0xf000) == 0xf000))
2120 return true;
2121
2122 if ((f1 & (BRANCH | DELAY)) != 0
2123 || (f2 & (BRANCH | DELAY)) != 0)
2124 return true;
2125
2126 if (((f1 | f2) & SETSSP)
2127 && (f1 & (SETSSP | USESSP))
2128 && (f2 & (SETSSP | USESSP)))
2129 return true;
2130
2131 if ((f1 & SETS1) != 0
2132 && sh_insn_uses_or_sets_reg (i2, op2, SETS1_REG (i1)))
2133 return true;
2134 if ((f1 & SETS2) != 0
2135 && sh_insn_uses_or_sets_reg (i2, op2, SETS2_REG (i1)))
2136 return true;
2137 if ((f1 & SETSR0) != 0
2138 && sh_insn_uses_or_sets_reg (i2, op2, 0))
2139 return true;
2140 if ((f1 & SETSAS)
2141 && sh_insn_uses_or_sets_reg (i2, op2, SETSAS_REG (i1)))
2142 return true;
2143 if ((f1 & SETSF1) != 0
2144 && sh_insn_uses_or_sets_freg (i2, op2, SETSF1_REG (i1)))
2145 return true;
2146
2147 if ((f2 & SETS1) != 0
2148 && sh_insn_uses_or_sets_reg (i1, op1, SETS1_REG (i2)))
2149 return true;
2150 if ((f2 & SETS2) != 0
2151 && sh_insn_uses_or_sets_reg (i1, op1, SETS2_REG (i2)))
2152 return true;
2153 if ((f2 & SETSR0) != 0
2154 && sh_insn_uses_or_sets_reg (i1, op1, 0))
2155 return true;
2156 if ((f2 & SETSAS)
2157 && sh_insn_uses_or_sets_reg (i1, op1, SETSAS_REG (i2)))
2158 return true;
2159 if ((f2 & SETSF1) != 0
2160 && sh_insn_uses_or_sets_freg (i1, op1, SETSF1_REG (i2)))
2161 return true;
2162
2163 /* The instructions do not conflict. */
2164 return false;
2165 }
2166
2167 /* I1 is a load instruction, and I2 is some other instruction. Return
2168 true if I1 loads a register which I2 uses. */
2169
2170 static boolean
2171 sh_load_use (i1, op1, i2, op2)
2172 unsigned int i1;
2173 const struct sh_opcode *op1;
2174 unsigned int i2;
2175 const struct sh_opcode *op2;
2176 {
2177 unsigned int f1;
2178
2179 f1 = op1->flags;
2180
2181 if ((f1 & LOAD) == 0)
2182 return false;
2183
2184 /* If both SETS1 and SETSSP are set, that means a load to a special
2185 register using postincrement addressing mode, which we don't care
2186 about here. */
2187 if ((f1 & SETS1) != 0
2188 && (f1 & SETSSP) == 0
2189 && sh_insn_uses_reg (i2, op2, (i1 & 0x0f00) >> 8))
2190 return true;
2191
2192 if ((f1 & SETSR0) != 0
2193 && sh_insn_uses_reg (i2, op2, 0))
2194 return true;
2195
2196 if ((f1 & SETSF1) != 0
2197 && sh_insn_uses_freg (i2, op2, (i1 & 0x0f00) >> 8))
2198 return true;
2199
2200 return false;
2201 }
2202
2203 /* Try to align loads and stores within a span of memory. This is
2204 called by both the ELF and the COFF sh targets. ABFD and SEC are
2205 the BFD and section we are examining. CONTENTS is the contents of
2206 the section. SWAP is the routine to call to swap two instructions.
2207 RELOCS is a pointer to the internal relocation information, to be
2208 passed to SWAP. PLABEL is a pointer to the current label in a
2209 sorted list of labels; LABEL_END is the end of the list. START and
2210 STOP are the range of memory to examine. If a swap is made,
2211 *PSWAPPED is set to true. */
2212
2213 boolean
2214 _bfd_sh_align_load_span (abfd, sec, contents, swap, relocs,
2215 plabel, label_end, start, stop, pswapped)
2216 bfd *abfd;
2217 asection *sec;
2218 bfd_byte *contents;
2219 boolean (*swap) PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
2220 PTR relocs;
2221 bfd_vma **plabel;
2222 bfd_vma *label_end;
2223 bfd_vma start;
2224 bfd_vma stop;
2225 boolean *pswapped;
2226 {
2227 int dsp = (abfd->arch_info->mach == bfd_mach_sh_dsp
2228 || abfd->arch_info->mach == bfd_mach_sh3_dsp);
2229 bfd_vma i;
2230
2231 /* The SH4 has a Harvard architecture, hence aligning loads is not
2232 desirable. In fact, it is counter-productive, since it interferes
2233 with the schedules generated by the compiler. */
2234 if (abfd->arch_info->mach == bfd_mach_sh4)
2235 return true;
2236
2237 /* If we are linking sh[3]-dsp code, swap the FPU instructions for DSP
2238 instructions. */
2239 if (dsp)
2240 {
2241 sh_opcodes[0xf].minor_opcodes = sh_dsp_opcodef;
2242 sh_opcodes[0xf].count = sizeof sh_dsp_opcodef / sizeof sh_dsp_opcodef;
2243 }
2244
2245 /* Instructions should be aligned on 2 byte boundaries. */
2246 if ((start & 1) == 1)
2247 ++start;
2248
2249 /* Now look through the unaligned addresses. */
2250 i = start;
2251 if ((i & 2) == 0)
2252 i += 2;
2253 for (; i < stop; i += 4)
2254 {
2255 unsigned int insn;
2256 const struct sh_opcode *op;
2257 unsigned int prev_insn = 0;
2258 const struct sh_opcode *prev_op = NULL;
2259
2260 insn = bfd_get_16 (abfd, contents + i);
2261 op = sh_insn_info (insn);
2262 if (op == NULL
2263 || (op->flags & (LOAD | STORE)) == 0)
2264 continue;
2265
2266 /* This is a load or store which is not on a four byte boundary. */
2267
2268 while (*plabel < label_end && **plabel < i)
2269 ++*plabel;
2270
2271 if (i > start)
2272 {
2273 prev_insn = bfd_get_16 (abfd, contents + i - 2);
2274 /* If INSN is the field b of a parallel processing insn, it is not
2275 a load / store after all. Note that the test here might mistake
2276 the field_b of a pcopy insn for the starting code of a parallel
2277 processing insn; this might miss a swapping opportunity, but at
2278 least we're on the safe side. */
2279 if (dsp && (prev_insn & 0xfc00) == 0xf800)
2280 continue;
2281
2282 /* Check if prev_insn is actually the field b of a parallel
2283 processing insn. Again, this can give a spurious match
2284 after a pcopy. */
2285 if (dsp && i - 2 > start)
2286 {
2287 unsigned pprev_insn = bfd_get_16 (abfd, contents + i - 4);
2288
2289 if ((pprev_insn & 0xfc00) == 0xf800)
2290 prev_op = NULL;
2291 else
2292 prev_op = sh_insn_info (prev_insn);
2293 }
2294 else
2295 prev_op = sh_insn_info (prev_insn);
2296
2297 /* If the load/store instruction is in a delay slot, we
2298 can't swap. */
2299 if (prev_op == NULL
2300 || (prev_op->flags & DELAY) != 0)
2301 continue;
2302 }
2303 if (i > start
2304 && (*plabel >= label_end || **plabel != i)
2305 && prev_op != NULL
2306 && (prev_op->flags & (LOAD | STORE)) == 0
2307 && ! sh_insns_conflict (prev_insn, prev_op, insn, op))
2308 {
2309 boolean ok;
2310
2311 /* The load/store instruction does not have a label, and
2312 there is a previous instruction; PREV_INSN is not
2313 itself a load/store instruction, and PREV_INSN and
2314 INSN do not conflict. */
2315
2316 ok = true;
2317
2318 if (i >= start + 4)
2319 {
2320 unsigned int prev2_insn;
2321 const struct sh_opcode *prev2_op;
2322
2323 prev2_insn = bfd_get_16 (abfd, contents + i - 4);
2324 prev2_op = sh_insn_info (prev2_insn);
2325
2326 /* If the instruction before PREV_INSN has a delay
2327 slot--that is, PREV_INSN is in a delay slot--we
2328 can not swap. */
2329 if (prev2_op == NULL
2330 || (prev2_op->flags & DELAY) != 0)
2331 ok = false;
2332
2333 /* If the instruction before PREV_INSN is a load,
2334 and it sets a register which INSN uses, then
2335 putting INSN immediately after PREV_INSN will
2336 cause a pipeline bubble, so there is no point to
2337 making the swap. */
2338 if (ok
2339 && (prev2_op->flags & LOAD) != 0
2340 && sh_load_use (prev2_insn, prev2_op, insn, op))
2341 ok = false;
2342 }
2343
2344 if (ok)
2345 {
2346 if (! (*swap) (abfd, sec, relocs, contents, i - 2))
2347 return false;
2348 *pswapped = true;
2349 continue;
2350 }
2351 }
2352
2353 while (*plabel < label_end && **plabel < i + 2)
2354 ++*plabel;
2355
2356 if (i + 2 < stop
2357 && (*plabel >= label_end || **plabel != i + 2))
2358 {
2359 unsigned int next_insn;
2360 const struct sh_opcode *next_op;
2361
2362 /* There is an instruction after the load/store
2363 instruction, and it does not have a label. */
2364 next_insn = bfd_get_16 (abfd, contents + i + 2);
2365 next_op = sh_insn_info (next_insn);
2366 if (next_op != NULL
2367 && (next_op->flags & (LOAD | STORE)) == 0
2368 && ! sh_insns_conflict (insn, op, next_insn, next_op))
2369 {
2370 boolean ok;
2371
2372 /* NEXT_INSN is not itself a load/store instruction,
2373 and it does not conflict with INSN. */
2374
2375 ok = true;
2376
2377 /* If PREV_INSN is a load, and it sets a register
2378 which NEXT_INSN uses, then putting NEXT_INSN
2379 immediately after PREV_INSN will cause a pipeline
2380 bubble, so there is no reason to make this swap. */
2381 if (prev_op != NULL
2382 && (prev_op->flags & LOAD) != 0
2383 && sh_load_use (prev_insn, prev_op, next_insn, next_op))
2384 ok = false;
2385
2386 /* If INSN is a load, and it sets a register which
2387 the insn after NEXT_INSN uses, then doing the
2388 swap will cause a pipeline bubble, so there is no
2389 reason to make the swap. However, if the insn
2390 after NEXT_INSN is itself a load or store
2391 instruction, then it is misaligned, so
2392 optimistically hope that it will be swapped
2393 itself, and just live with the pipeline bubble if
2394 it isn't. */
2395 if (ok
2396 && i + 4 < stop
2397 && (op->flags & LOAD) != 0)
2398 {
2399 unsigned int next2_insn;
2400 const struct sh_opcode *next2_op;
2401
2402 next2_insn = bfd_get_16 (abfd, contents + i + 4);
2403 next2_op = sh_insn_info (next2_insn);
2404 if ((next2_op->flags & (LOAD | STORE)) == 0
2405 && sh_load_use (insn, op, next2_insn, next2_op))
2406 ok = false;
2407 }
2408
2409 if (ok)
2410 {
2411 if (! (*swap) (abfd, sec, relocs, contents, i))
2412 return false;
2413 *pswapped = true;
2414 continue;
2415 }
2416 }
2417 }
2418 }
2419
2420 return true;
2421 }
2422
2423 /* Look for loads and stores which we can align to four byte
2424 boundaries. See the longer comment above sh_relax_section for why
2425 this is desirable. This sets *PSWAPPED if some instruction was
2426 swapped. */
2427
2428 static boolean
2429 sh_align_loads (abfd, sec, internal_relocs, contents, pswapped)
2430 bfd *abfd;
2431 asection *sec;
2432 struct internal_reloc *internal_relocs;
2433 bfd_byte *contents;
2434 boolean *pswapped;
2435 {
2436 struct internal_reloc *irel, *irelend;
2437 bfd_vma *labels = NULL;
2438 bfd_vma *label, *label_end;
2439
2440 *pswapped = false;
2441
2442 irelend = internal_relocs + sec->reloc_count;
2443
2444 /* Get all the addresses with labels on them. */
2445 labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma));
2446 if (labels == NULL)
2447 goto error_return;
2448 label_end = labels;
2449 for (irel = internal_relocs; irel < irelend; irel++)
2450 {
2451 if (irel->r_type == R_SH_LABEL)
2452 {
2453 *label_end = irel->r_vaddr - sec->vma;
2454 ++label_end;
2455 }
2456 }
2457
2458 /* Note that the assembler currently always outputs relocs in
2459 address order. If that ever changes, this code will need to sort
2460 the label values and the relocs. */
2461
2462 label = labels;
2463
2464 for (irel = internal_relocs; irel < irelend; irel++)
2465 {
2466 bfd_vma start, stop;
2467
2468 if (irel->r_type != R_SH_CODE)
2469 continue;
2470
2471 start = irel->r_vaddr - sec->vma;
2472
2473 for (irel++; irel < irelend; irel++)
2474 if (irel->r_type == R_SH_DATA)
2475 break;
2476 if (irel < irelend)
2477 stop = irel->r_vaddr - sec->vma;
2478 else
2479 stop = sec->_cooked_size;
2480
2481 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_swap_insns,
2482 (PTR) internal_relocs, &label,
2483 label_end, start, stop, pswapped))
2484 goto error_return;
2485 }
2486
2487 free (labels);
2488
2489 return true;
2490
2491 error_return:
2492 if (labels != NULL)
2493 free (labels);
2494 return false;
2495 }
2496
2497 /* Swap two SH instructions. */
2498
2499 static boolean
2500 sh_swap_insns (abfd, sec, relocs, contents, addr)
2501 bfd *abfd;
2502 asection *sec;
2503 PTR relocs;
2504 bfd_byte *contents;
2505 bfd_vma addr;
2506 {
2507 struct internal_reloc *internal_relocs = (struct internal_reloc *) relocs;
2508 unsigned short i1, i2;
2509 struct internal_reloc *irel, *irelend;
2510
2511 /* Swap the instructions themselves. */
2512 i1 = bfd_get_16 (abfd, contents + addr);
2513 i2 = bfd_get_16 (abfd, contents + addr + 2);
2514 bfd_put_16 (abfd, i2, contents + addr);
2515 bfd_put_16 (abfd, i1, contents + addr + 2);
2516
2517 /* Adjust all reloc addresses. */
2518 irelend = internal_relocs + sec->reloc_count;
2519 for (irel = internal_relocs; irel < irelend; irel++)
2520 {
2521 int type, add;
2522
2523 /* There are a few special types of relocs that we don't want to
2524 adjust. These relocs do not apply to the instruction itself,
2525 but are only associated with the address. */
2526 type = irel->r_type;
2527 if (type == R_SH_ALIGN
2528 || type == R_SH_CODE
2529 || type == R_SH_DATA
2530 || type == R_SH_LABEL)
2531 continue;
2532
2533 /* If an R_SH_USES reloc points to one of the addresses being
2534 swapped, we must adjust it. It would be incorrect to do this
2535 for a jump, though, since we want to execute both
2536 instructions after the jump. (We have avoided swapping
2537 around a label, so the jump will not wind up executing an
2538 instruction it shouldn't). */
2539 if (type == R_SH_USES)
2540 {
2541 bfd_vma off;
2542
2543 off = irel->r_vaddr - sec->vma + 4 + irel->r_offset;
2544 if (off == addr)
2545 irel->r_offset += 2;
2546 else if (off == addr + 2)
2547 irel->r_offset -= 2;
2548 }
2549
2550 if (irel->r_vaddr - sec->vma == addr)
2551 {
2552 irel->r_vaddr += 2;
2553 add = -2;
2554 }
2555 else if (irel->r_vaddr - sec->vma == addr + 2)
2556 {
2557 irel->r_vaddr -= 2;
2558 add = 2;
2559 }
2560 else
2561 add = 0;
2562
2563 if (add != 0)
2564 {
2565 bfd_byte *loc;
2566 unsigned short insn, oinsn;
2567 boolean overflow;
2568
2569 loc = contents + irel->r_vaddr - sec->vma;
2570 overflow = false;
2571 switch (type)
2572 {
2573 default:
2574 break;
2575
2576 case R_SH_PCDISP8BY2:
2577 case R_SH_PCRELIMM8BY2:
2578 insn = bfd_get_16 (abfd, loc);
2579 oinsn = insn;
2580 insn += add / 2;
2581 if ((oinsn & 0xff00) != (insn & 0xff00))
2582 overflow = true;
2583 bfd_put_16 (abfd, insn, loc);
2584 break;
2585
2586 case R_SH_PCDISP:
2587 insn = bfd_get_16 (abfd, loc);
2588 oinsn = insn;
2589 insn += add / 2;
2590 if ((oinsn & 0xf000) != (insn & 0xf000))
2591 overflow = true;
2592 bfd_put_16 (abfd, insn, loc);
2593 break;
2594
2595 case R_SH_PCRELIMM8BY4:
2596 /* This reloc ignores the least significant 3 bits of
2597 the program counter before adding in the offset.
2598 This means that if ADDR is at an even address, the
2599 swap will not affect the offset. If ADDR is an at an
2600 odd address, then the instruction will be crossing a
2601 four byte boundary, and must be adjusted. */
2602 if ((addr & 3) != 0)
2603 {
2604 insn = bfd_get_16 (abfd, loc);
2605 oinsn = insn;
2606 insn += add / 2;
2607 if ((oinsn & 0xff00) != (insn & 0xff00))
2608 overflow = true;
2609 bfd_put_16 (abfd, insn, loc);
2610 }
2611
2612 break;
2613 }
2614
2615 if (overflow)
2616 {
2617 ((*_bfd_error_handler)
2618 ("%s: 0x%lx: fatal: reloc overflow while relaxing",
2619 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr));
2620 bfd_set_error (bfd_error_bad_value);
2621 return false;
2622 }
2623 }
2624 }
2625
2626 return true;
2627 }
2628 \f
2629 /* This is a modification of _bfd_coff_generic_relocate_section, which
2630 will handle SH relaxing. */
2631
2632 static boolean
2633 sh_relocate_section (output_bfd, info, input_bfd, input_section, contents,
2634 relocs, syms, sections)
2635 bfd *output_bfd ATTRIBUTE_UNUSED;
2636 struct bfd_link_info *info;
2637 bfd *input_bfd;
2638 asection *input_section;
2639 bfd_byte *contents;
2640 struct internal_reloc *relocs;
2641 struct internal_syment *syms;
2642 asection **sections;
2643 {
2644 struct internal_reloc *rel;
2645 struct internal_reloc *relend;
2646
2647 rel = relocs;
2648 relend = rel + input_section->reloc_count;
2649 for (; rel < relend; rel++)
2650 {
2651 long symndx;
2652 struct coff_link_hash_entry *h;
2653 struct internal_syment *sym;
2654 bfd_vma addend;
2655 bfd_vma val;
2656 reloc_howto_type *howto;
2657 bfd_reloc_status_type rstat;
2658
2659 /* Almost all relocs have to do with relaxing. If any work must
2660 be done for them, it has been done in sh_relax_section. */
2661 if (rel->r_type != R_SH_IMM32
2662 && rel->r_type != R_SH_PCDISP)
2663 continue;
2664
2665 symndx = rel->r_symndx;
2666
2667 if (symndx == -1)
2668 {
2669 h = NULL;
2670 sym = NULL;
2671 }
2672 else
2673 {
2674 if (symndx < 0
2675 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2676 {
2677 (*_bfd_error_handler)
2678 ("%s: illegal symbol index %ld in relocs",
2679 bfd_get_filename (input_bfd), symndx);
2680 bfd_set_error (bfd_error_bad_value);
2681 return false;
2682 }
2683 h = obj_coff_sym_hashes (input_bfd)[symndx];
2684 sym = syms + symndx;
2685 }
2686
2687 if (sym != NULL && sym->n_scnum != 0)
2688 addend = - sym->n_value;
2689 else
2690 addend = 0;
2691
2692 if (rel->r_type == R_SH_PCDISP)
2693 addend -= 4;
2694
2695 if (rel->r_type >= SH_COFF_HOWTO_COUNT)
2696 howto = NULL;
2697 else
2698 howto = &sh_coff_howtos[rel->r_type];
2699
2700 if (howto == NULL)
2701 {
2702 bfd_set_error (bfd_error_bad_value);
2703 return false;
2704 }
2705
2706 val = 0;
2707
2708 if (h == NULL)
2709 {
2710 asection *sec;
2711
2712 /* There is nothing to do for an internal PCDISP reloc. */
2713 if (rel->r_type == R_SH_PCDISP)
2714 continue;
2715
2716 if (symndx == -1)
2717 {
2718 sec = bfd_abs_section_ptr;
2719 val = 0;
2720 }
2721 else
2722 {
2723 sec = sections[symndx];
2724 val = (sec->output_section->vma
2725 + sec->output_offset
2726 + sym->n_value
2727 - sec->vma);
2728 }
2729 }
2730 else
2731 {
2732 if (h->root.type == bfd_link_hash_defined
2733 || h->root.type == bfd_link_hash_defweak)
2734 {
2735 asection *sec;
2736
2737 sec = h->root.u.def.section;
2738 val = (h->root.u.def.value
2739 + sec->output_section->vma
2740 + sec->output_offset);
2741 }
2742 else if (! info->relocateable)
2743 {
2744 if (! ((*info->callbacks->undefined_symbol)
2745 (info, h->root.root.string, input_bfd, input_section,
2746 rel->r_vaddr - input_section->vma)))
2747 return false;
2748 }
2749 }
2750
2751 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
2752 contents,
2753 rel->r_vaddr - input_section->vma,
2754 val, addend);
2755
2756 switch (rstat)
2757 {
2758 default:
2759 abort ();
2760 case bfd_reloc_ok:
2761 break;
2762 case bfd_reloc_overflow:
2763 {
2764 const char *name;
2765 char buf[SYMNMLEN + 1];
2766
2767 if (symndx == -1)
2768 name = "*ABS*";
2769 else if (h != NULL)
2770 name = h->root.root.string;
2771 else if (sym->_n._n_n._n_zeroes == 0
2772 && sym->_n._n_n._n_offset != 0)
2773 name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
2774 else
2775 {
2776 strncpy (buf, sym->_n._n_name, SYMNMLEN);
2777 buf[SYMNMLEN] = '\0';
2778 name = buf;
2779 }
2780
2781 if (! ((*info->callbacks->reloc_overflow)
2782 (info, name, howto->name, (bfd_vma) 0, input_bfd,
2783 input_section, rel->r_vaddr - input_section->vma)))
2784 return false;
2785 }
2786 }
2787 }
2788
2789 return true;
2790 }
2791
2792 /* This is a version of bfd_generic_get_relocated_section_contents
2793 which uses sh_relocate_section. */
2794
2795 static bfd_byte *
2796 sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order,
2797 data, relocateable, symbols)
2798 bfd *output_bfd;
2799 struct bfd_link_info *link_info;
2800 struct bfd_link_order *link_order;
2801 bfd_byte *data;
2802 boolean relocateable;
2803 asymbol **symbols;
2804 {
2805 asection *input_section = link_order->u.indirect.section;
2806 bfd *input_bfd = input_section->owner;
2807 asection **sections = NULL;
2808 struct internal_reloc *internal_relocs = NULL;
2809 struct internal_syment *internal_syms = NULL;
2810
2811 /* We only need to handle the case of relaxing, or of having a
2812 particular set of section contents, specially. */
2813 if (relocateable
2814 || coff_section_data (input_bfd, input_section) == NULL
2815 || coff_section_data (input_bfd, input_section)->contents == NULL)
2816 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2817 link_order, data,
2818 relocateable,
2819 symbols);
2820
2821 memcpy (data, coff_section_data (input_bfd, input_section)->contents,
2822 input_section->_raw_size);
2823
2824 if ((input_section->flags & SEC_RELOC) != 0
2825 && input_section->reloc_count > 0)
2826 {
2827 bfd_size_type symesz = bfd_coff_symesz (input_bfd);
2828 bfd_byte *esym, *esymend;
2829 struct internal_syment *isymp;
2830 asection **secpp;
2831
2832 if (! _bfd_coff_get_external_symbols (input_bfd))
2833 goto error_return;
2834
2835 internal_relocs = (_bfd_coff_read_internal_relocs
2836 (input_bfd, input_section, false, (bfd_byte *) NULL,
2837 false, (struct internal_reloc *) NULL));
2838 if (internal_relocs == NULL)
2839 goto error_return;
2840
2841 internal_syms = ((struct internal_syment *)
2842 bfd_malloc (obj_raw_syment_count (input_bfd)
2843 * sizeof (struct internal_syment)));
2844 if (internal_syms == NULL)
2845 goto error_return;
2846
2847 sections = (asection **) bfd_malloc (obj_raw_syment_count (input_bfd)
2848 * sizeof (asection *));
2849 if (sections == NULL)
2850 goto error_return;
2851
2852 isymp = internal_syms;
2853 secpp = sections;
2854 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
2855 esymend = esym + obj_raw_syment_count (input_bfd) * symesz;
2856 while (esym < esymend)
2857 {
2858 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
2859
2860 if (isymp->n_scnum != 0)
2861 *secpp = coff_section_from_bfd_index (input_bfd, isymp->n_scnum);
2862 else
2863 {
2864 if (isymp->n_value == 0)
2865 *secpp = bfd_und_section_ptr;
2866 else
2867 *secpp = bfd_com_section_ptr;
2868 }
2869
2870 esym += (isymp->n_numaux + 1) * symesz;
2871 secpp += isymp->n_numaux + 1;
2872 isymp += isymp->n_numaux + 1;
2873 }
2874
2875 if (! sh_relocate_section (output_bfd, link_info, input_bfd,
2876 input_section, data, internal_relocs,
2877 internal_syms, sections))
2878 goto error_return;
2879
2880 free (sections);
2881 sections = NULL;
2882 free (internal_syms);
2883 internal_syms = NULL;
2884 free (internal_relocs);
2885 internal_relocs = NULL;
2886 }
2887
2888 return data;
2889
2890 error_return:
2891 if (internal_relocs != NULL)
2892 free (internal_relocs);
2893 if (internal_syms != NULL)
2894 free (internal_syms);
2895 if (sections != NULL)
2896 free (sections);
2897 return NULL;
2898 }
2899
2900 /* The target vectors. */
2901
2902 CREATE_BIG_COFF_TARGET_VEC (shcoff_vec, "coff-sh", BFD_IS_RELAXABLE, 0, '_', NULL)
2903
2904 #ifdef TARGET_SHL_SYM
2905 #define TARGET_SYM TARGET_SHL_SYM
2906 #else
2907 #define TARGET_SYM shlcoff_vec
2908 #endif
2909
2910 #ifndef TARGET_SHL_NAME
2911 #define TARGET_SHL_NAME "coff-shl"
2912 #endif
2913
2914 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_SYM, TARGET_SHL_NAME, BFD_IS_RELAXABLE, 0, '_', NULL)
2915
2916
2917 /* Some people want versions of the SH COFF target which do not align
2918 to 16 byte boundaries. We implement that by adding a couple of new
2919 target vectors. These are just like the ones above, but they
2920 change the default section alignment. To generate them in the
2921 assembler, use -small. To use them in the linker, use -b
2922 coff-sh{l}-small and -oformat coff-sh{l}-small.
2923
2924 Yes, this is a horrible hack. A general solution for setting
2925 section alignment in COFF is rather complex. ELF handles this
2926 correctly. */
2927
2928 /* Only recognize the small versions if the target was not defaulted.
2929 Otherwise we won't recognize the non default endianness. */
2930
2931 static const bfd_target *
2932 coff_small_object_p (abfd)
2933 bfd *abfd;
2934 {
2935 if (abfd->target_defaulted)
2936 {
2937 bfd_set_error (bfd_error_wrong_format);
2938 return NULL;
2939 }
2940 return coff_object_p (abfd);
2941 }
2942
2943 /* Set the section alignment for the small versions. */
2944
2945 static boolean
2946 coff_small_new_section_hook (abfd, section)
2947 bfd *abfd;
2948 asection *section;
2949 {
2950 if (! coff_new_section_hook (abfd, section))
2951 return false;
2952
2953 /* We must align to at least a four byte boundary, because longword
2954 accesses must be on a four byte boundary. */
2955 if (section->alignment_power == COFF_DEFAULT_SECTION_ALIGNMENT_POWER)
2956 section->alignment_power = 2;
2957
2958 return true;
2959 }
2960
2961 /* This is copied from bfd_coff_std_swap_table so that we can change
2962 the default section alignment power. */
2963
2964 static const bfd_coff_backend_data bfd_coff_small_swap_table =
2965 {
2966 coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
2967 coff_swap_aux_out, coff_swap_sym_out,
2968 coff_swap_lineno_out, coff_swap_reloc_out,
2969 coff_swap_filehdr_out, coff_swap_aouthdr_out,
2970 coff_swap_scnhdr_out,
2971 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
2972 #ifdef COFF_LONG_FILENAMES
2973 true,
2974 #else
2975 false,
2976 #endif
2977 #ifdef COFF_LONG_SECTION_NAMES
2978 true,
2979 #else
2980 false,
2981 #endif
2982 2,
2983 coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
2984 coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
2985 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
2986 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
2987 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
2988 coff_classify_symbol, coff_compute_section_file_positions,
2989 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
2990 coff_adjust_symndx, coff_link_add_one_symbol,
2991 coff_link_output_has_begun, coff_final_link_postscript
2992 };
2993
2994 #define coff_small_close_and_cleanup \
2995 coff_close_and_cleanup
2996 #define coff_small_bfd_free_cached_info \
2997 coff_bfd_free_cached_info
2998 #define coff_small_get_section_contents \
2999 coff_get_section_contents
3000 #define coff_small_get_section_contents_in_window \
3001 coff_get_section_contents_in_window
3002
3003 extern const bfd_target shlcoff_small_vec;
3004
3005 const bfd_target shcoff_small_vec =
3006 {
3007 "coff-sh-small", /* name */
3008 bfd_target_coff_flavour,
3009 BFD_ENDIAN_BIG, /* data byte order is big */
3010 BFD_ENDIAN_BIG, /* header byte order is big */
3011
3012 (HAS_RELOC | EXEC_P | /* object flags */
3013 HAS_LINENO | HAS_DEBUG |
3014 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
3015
3016 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
3017 '_', /* leading symbol underscore */
3018 '/', /* ar_pad_char */
3019 15, /* ar_max_namelen */
3020 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3021 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3022 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
3023 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3024 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3025 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
3026
3027 {_bfd_dummy_target, coff_small_object_p, /* bfd_check_format */
3028 bfd_generic_archive_p, _bfd_dummy_target},
3029 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
3030 bfd_false},
3031 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
3032 _bfd_write_archive_contents, bfd_false},
3033
3034 BFD_JUMP_TABLE_GENERIC (coff_small),
3035 BFD_JUMP_TABLE_COPY (coff),
3036 BFD_JUMP_TABLE_CORE (_bfd_nocore),
3037 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
3038 BFD_JUMP_TABLE_SYMBOLS (coff),
3039 BFD_JUMP_TABLE_RELOCS (coff),
3040 BFD_JUMP_TABLE_WRITE (coff),
3041 BFD_JUMP_TABLE_LINK (coff),
3042 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3043
3044 & shlcoff_small_vec,
3045
3046 (PTR) &bfd_coff_small_swap_table
3047 };
3048
3049 const bfd_target shlcoff_small_vec =
3050 {
3051 "coff-shl-small", /* name */
3052 bfd_target_coff_flavour,
3053 BFD_ENDIAN_LITTLE, /* data byte order is little */
3054 BFD_ENDIAN_LITTLE, /* header byte order is little endian too*/
3055
3056 (HAS_RELOC | EXEC_P | /* object flags */
3057 HAS_LINENO | HAS_DEBUG |
3058 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
3059
3060 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
3061 '_', /* leading symbol underscore */
3062 '/', /* ar_pad_char */
3063 15, /* ar_max_namelen */
3064 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
3065 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
3066 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
3067 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
3068 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
3069 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
3070
3071 {_bfd_dummy_target, coff_small_object_p, /* bfd_check_format */
3072 bfd_generic_archive_p, _bfd_dummy_target},
3073 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
3074 bfd_false},
3075 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
3076 _bfd_write_archive_contents, bfd_false},
3077
3078 BFD_JUMP_TABLE_GENERIC (coff_small),
3079 BFD_JUMP_TABLE_COPY (coff),
3080 BFD_JUMP_TABLE_CORE (_bfd_nocore),
3081 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
3082 BFD_JUMP_TABLE_SYMBOLS (coff),
3083 BFD_JUMP_TABLE_RELOCS (coff),
3084 BFD_JUMP_TABLE_WRITE (coff),
3085 BFD_JUMP_TABLE_LINK (coff),
3086 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3087
3088 & shcoff_small_vec,
3089
3090 (PTR) &bfd_coff_small_swap_table
3091 };
GDB Binutils - Deliverables
This page took 0.141737 seconds and 4 git commands to generate.