1 /* tc-sh.c -- Assemble code for the Hitachi Super-H
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Written By Steve Chamberlain <sac@cygnus.com> */
29 #include "opcodes/sh-opc.h"
30 #include "safe-ctype.h"
31 #include "struc-symbol.h"
37 #include "dwarf2dbg.h"
43 expressionS immediate
;
47 const char comment_chars
[] = "!";
48 const char line_separator_chars
[] = ";";
49 const char line_comment_chars
[] = "!#";
51 static void s_uses
PARAMS ((int));
53 static void sh_count_relocs
PARAMS ((bfd
*, segT
, PTR
));
54 static void sh_frob_section
PARAMS ((bfd
*, segT
, PTR
));
56 static void s_uacons
PARAMS ((int));
57 static sh_opcode_info
*find_cooked_opcode
PARAMS ((char **));
58 static unsigned int assemble_ppi
PARAMS ((char *, sh_opcode_info
*));
59 static void little
PARAMS ((int));
60 static void big
PARAMS ((int));
61 static int parse_reg
PARAMS ((char *, int *, int *));
62 static char *parse_exp
PARAMS ((char *, sh_operand_info
*));
63 static char *parse_at
PARAMS ((char *, sh_operand_info
*));
64 static void get_operand
PARAMS ((char **, sh_operand_info
*));
65 static char *get_operands
66 PARAMS ((sh_opcode_info
*, char *, sh_operand_info
*));
67 static sh_opcode_info
*get_specific
68 PARAMS ((sh_opcode_info
*, sh_operand_info
*));
69 static void insert
PARAMS ((char *, int, int, sh_operand_info
*));
70 static void build_relax
PARAMS ((sh_opcode_info
*, sh_operand_info
*));
71 static char *insert_loop_bounds
PARAMS ((char *, sh_operand_info
*));
72 static unsigned int build_Mytes
73 PARAMS ((sh_opcode_info
*, sh_operand_info
*));
76 static void sh_elf_cons
PARAMS ((int));
78 inline static int sh_PIC_related_p
PARAMS ((symbolS
*));
79 static int sh_check_fixup
PARAMS ((expressionS
*, bfd_reloc_code_real_type
*));
80 inline static char *sh_end_of_match
PARAMS ((char *, char *));
82 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
87 int ignore ATTRIBUTE_UNUSED
;
89 if (! target_big_endian
)
90 as_bad (_("directive .big encountered when option -big required"));
92 /* Stop further messages. */
93 target_big_endian
= 1;
98 int ignore ATTRIBUTE_UNUSED
;
100 if (target_big_endian
)
101 as_bad (_("directive .little encountered when option -little required"));
103 /* Stop further messages. */
104 target_big_endian
= 0;
107 /* This table describes all the machine specific pseudo-ops the assembler
108 has to support. The fields are:
109 pseudo-op name without dot
110 function to call to execute this pseudo-op
111 Integer arg to pass to the function. */
113 const pseudo_typeS md_pseudo_table
[] =
116 {"long", sh_elf_cons
, 4},
117 {"int", sh_elf_cons
, 4},
118 {"word", sh_elf_cons
, 2},
119 {"short", sh_elf_cons
, 2},
125 {"form", listing_psize
, 0},
126 {"little", little
, 0},
127 {"heading", listing_title
, 0},
128 {"import", s_ignore
, 0},
129 {"page", listing_eject
, 0},
130 {"program", s_ignore
, 0},
132 {"uaword", s_uacons
, 2},
133 {"ualong", s_uacons
, 4},
134 {"uaquad", s_uacons
, 8},
135 {"2byte", s_uacons
, 2},
136 {"4byte", s_uacons
, 4},
137 {"8byte", s_uacons
, 8},
139 {"file", dwarf2_directive_file
, 0 },
140 {"loc", dwarf2_directive_loc
, 0 },
143 {"mode", s_sh64_mode
, 0 },
145 /* Have the old name too. */
146 {"isa", s_sh64_mode
, 0 },
148 /* Assert that the right ABI is used. */
149 {"abi", s_sh64_abi
, 0 },
151 { "vtable_inherit", sh64_vtable_inherit
, 0 },
152 { "vtable_entry", sh64_vtable_entry
, 0 },
153 #endif /* HAVE_SH64 */
157 /*int md_reloc_size; */
159 int sh_relax
; /* set if -relax seen */
161 /* Whether -small was seen. */
165 /* Whether -dsp was seen. */
169 /* The bit mask of architectures that could
170 accomodate the insns seen so far. */
171 static int valid_arch
;
173 const char EXP_CHARS
[] = "eE";
175 /* Chars that mean this number is a floating point constant. */
178 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
180 #define C(a,b) ENCODE_RELAX(a,b)
182 #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
183 #define GET_WHAT(x) ((x>>4))
185 /* These are the three types of relaxable instrction. */
186 /* These are the types of relaxable instructions; except for END which is
189 #define COND_JUMP_DELAY 2
190 #define UNCOND_JUMP 3
194 /* A 16-bit (times four) pc-relative operand, at most expanded to 32 bits. */
195 #define SH64PCREL16_32 4
196 /* A 16-bit (times four) pc-relative operand, at most expanded to 64 bits. */
197 #define SH64PCREL16_64 5
199 /* Variants of the above for adjusting the insn to PTA or PTB according to
201 #define SH64PCREL16PT_32 6
202 #define SH64PCREL16PT_64 7
204 /* A MOVI expansion, expanding to at most 32 or 64 bits. */
205 #define MOVI_IMM_32 8
206 #define MOVI_IMM_32_PCREL 9
207 #define MOVI_IMM_64 10
208 #define MOVI_IMM_64_PCREL 11
211 #else /* HAVE_SH64 */
215 #endif /* HAVE_SH64 */
221 #define UNDEF_WORD_DISP 4
227 #define UNDEF_SH64PCREL 0
228 #define SH64PCREL16 1
229 #define SH64PCREL32 2
230 #define SH64PCREL48 3
231 #define SH64PCREL64 4
232 #define SH64PCRELPLT 5
240 #define MOVI_GOTOFF 6
242 #endif /* HAVE_SH64 */
244 /* Branch displacements are from the address of the branch plus
245 four, thus all minimum and maximum values have 4 added to them. */
248 #define COND8_LENGTH 2
250 /* There is one extra instruction before the branch, so we must add
251 two more bytes to account for it. */
252 #define COND12_F 4100
253 #define COND12_M -4090
254 #define COND12_LENGTH 6
256 #define COND12_DELAY_LENGTH 4
258 /* ??? The minimum and maximum values are wrong, but this does not matter
259 since this relocation type is not supported yet. */
260 #define COND32_F (1<<30)
261 #define COND32_M -(1<<30)
262 #define COND32_LENGTH 14
264 #define UNCOND12_F 4098
265 #define UNCOND12_M -4092
266 #define UNCOND12_LENGTH 2
268 /* ??? The minimum and maximum values are wrong, but this does not matter
269 since this relocation type is not supported yet. */
270 #define UNCOND32_F (1<<30)
271 #define UNCOND32_M -(1<<30)
272 #define UNCOND32_LENGTH 14
275 /* The trivial expansion of a SH64PCREL16 relaxation is just a "PT label,
276 TRd" as is the current insn, so no extra length. Note that the "reach"
277 is calculated from the address *after* that insn, but the offset in the
278 insn is calculated from the beginning of the insn. We also need to
279 take into account the implicit 1 coded as the "A" in PTA when counting
280 forward. If PTB reaches an odd address, we trap that as an error
281 elsewhere, so we don't have to have different relaxation entries. We
282 don't add a one to the negative range, since PTB would then have the
283 farthest backward-reaching value skipped, not generated at relaxation. */
284 #define SH64PCREL16_F (32767 * 4 - 4 + 1)
285 #define SH64PCREL16_M (-32768 * 4 - 4)
286 #define SH64PCREL16_LENGTH 0
288 /* The next step is to change that PT insn into
289 MOVI ((label - datalabel Ln) >> 16) & 65535, R25
290 SHORI (label - datalabel Ln) & 65535, R25
293 which means two extra insns, 8 extra bytes. This is the limit for the
296 The expressions look a bit bad since we have to adjust this to avoid overflow on a
298 #define SH64PCREL32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4)
299 #define SH64PCREL32_LENGTH (2 * 4)
301 /* Similarly, we just change the MOVI and add a SHORI for the 48-bit
303 #if BFD_HOST_64BIT_LONG
304 /* The "reach" type is long, so we can only do this for a 64-bit-long
306 #define SH64PCREL32_M (((long) -1 << 30) * 2 - 4)
307 #define SH64PCREL48_F ((((long) 1 << 47) - 1) - 4)
308 #define SH64PCREL48_M (((long) -1 << 47) - 4)
309 #define SH64PCREL48_LENGTH (3 * 4)
311 /* If the host does not have 64-bit longs, just make this state identical
312 in reach to the 32-bit state. Note that we have a slightly incorrect
313 reach, but the correct one above will overflow a 32-bit number. */
314 #define SH64PCREL32_M (((long) -1 << 30) * 2)
315 #define SH64PCREL48_F SH64PCREL32_F
316 #define SH64PCREL48_M SH64PCREL32_M
317 #define SH64PCREL48_LENGTH (3 * 4)
318 #endif /* BFD_HOST_64BIT_LONG */
320 /* And similarly for the 64-bit expansion; a MOVI + SHORI + SHORI + SHORI
322 #define SH64PCREL64_LENGTH (4 * 4)
324 /* For MOVI, we make the MOVI + SHORI... expansion you can see in the
325 SH64PCREL expansions. The PCREL one is similar, but the other has no
326 pc-relative reach; it must be fully expanded in
327 shmedia_md_estimate_size_before_relax. */
328 #define MOVI_16_LENGTH 0
329 #define MOVI_16_F (32767 - 4)
330 #define MOVI_16_M (-32768 - 4)
331 #define MOVI_32_LENGTH 4
332 #define MOVI_32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4)
333 #define MOVI_48_LENGTH 8
335 #if BFD_HOST_64BIT_LONG
336 /* The "reach" type is long, so we can only do this for a 64-bit-long
338 #define MOVI_32_M (((long) -1 << 30) * 2 - 4)
339 #define MOVI_48_F ((((long) 1 << 47) - 1) - 4)
340 #define MOVI_48_M (((long) -1 << 47) - 4)
342 /* If the host does not have 64-bit longs, just make this state identical
343 in reach to the 32-bit state. Note that we have a slightly incorrect
344 reach, but the correct one above will overflow a 32-bit number. */
345 #define MOVI_32_M (((long) -1 << 30) * 2)
346 #define MOVI_48_F MOVI_32_F
347 #define MOVI_48_M MOVI_32_M
348 #endif /* BFD_HOST_64BIT_LONG */
350 #define MOVI_64_LENGTH 12
351 #endif /* HAVE_SH64 */
353 #define EMPTY { 0, 0, 0, 0 }
355 const relax_typeS md_relax_table
[C (END
, 0)] = {
356 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
357 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
360 /* C (COND_JUMP, COND8) */
361 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP
, COND12
) },
362 /* C (COND_JUMP, COND12) */
363 { COND12_F
, COND12_M
, COND12_LENGTH
, C (COND_JUMP
, COND32
), },
364 /* C (COND_JUMP, COND32) */
365 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
366 /* C (COND_JUMP, UNDEF_WORD_DISP) */
367 { 0, 0, COND32_LENGTH
, 0, },
369 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
372 /* C (COND_JUMP_DELAY, COND8) */
373 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP_DELAY
, COND12
) },
374 /* C (COND_JUMP_DELAY, COND12) */
375 { COND12_F
, COND12_M
, COND12_DELAY_LENGTH
, C (COND_JUMP_DELAY
, COND32
), },
376 /* C (COND_JUMP_DELAY, COND32) */
377 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
378 /* C (COND_JUMP_DELAY, UNDEF_WORD_DISP) */
379 { 0, 0, COND32_LENGTH
, 0, },
381 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
384 /* C (UNCOND_JUMP, UNCOND12) */
385 { UNCOND12_F
, UNCOND12_M
, UNCOND12_LENGTH
, C (UNCOND_JUMP
, UNCOND32
), },
386 /* C (UNCOND_JUMP, UNCOND32) */
387 { UNCOND32_F
, UNCOND32_M
, UNCOND32_LENGTH
, 0, },
389 /* C (UNCOND_JUMP, UNDEF_WORD_DISP) */
390 { 0, 0, UNCOND32_LENGTH
, 0, },
392 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
395 /* C (SH64PCREL16_32, SH64PCREL16) */
397 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16_32
, SH64PCREL32
) },
398 /* C (SH64PCREL16_32, SH64PCREL32) */
399 { 0, 0, SH64PCREL32_LENGTH
, 0 },
401 /* C (SH64PCREL16_32, SH64PCRELPLT) */
402 { 0, 0, SH64PCREL32_LENGTH
, 0 },
404 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
406 /* C (SH64PCREL16_64, SH64PCREL16) */
408 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16_64
, SH64PCREL32
) },
409 /* C (SH64PCREL16_64, SH64PCREL32) */
410 { SH64PCREL32_F
, SH64PCREL32_M
, SH64PCREL32_LENGTH
, C (SH64PCREL16_64
, SH64PCREL48
) },
411 /* C (SH64PCREL16_64, SH64PCREL48) */
412 { SH64PCREL48_F
, SH64PCREL48_M
, SH64PCREL48_LENGTH
, C (SH64PCREL16_64
, SH64PCREL64
) },
413 /* C (SH64PCREL16_64, SH64PCREL64) */
414 { 0, 0, SH64PCREL64_LENGTH
, 0 },
415 /* C (SH64PCREL16_64, SH64PCRELPLT) */
416 { 0, 0, SH64PCREL64_LENGTH
, 0 },
418 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
420 /* C (SH64PCREL16PT_32, SH64PCREL16) */
422 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16PT_32
, SH64PCREL32
) },
423 /* C (SH64PCREL16PT_32, SH64PCREL32) */
424 { 0, 0, SH64PCREL32_LENGTH
, 0 },
426 /* C (SH64PCREL16PT_32, SH64PCRELPLT) */
427 { 0, 0, SH64PCREL32_LENGTH
, 0 },
429 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
431 /* C (SH64PCREL16PT_64, SH64PCREL16) */
433 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16PT_64
, SH64PCREL32
) },
434 /* C (SH64PCREL16PT_64, SH64PCREL32) */
438 C (SH64PCREL16PT_64
, SH64PCREL48
) },
439 /* C (SH64PCREL16PT_64, SH64PCREL48) */
440 { SH64PCREL48_F
, SH64PCREL48_M
, SH64PCREL48_LENGTH
, C (SH64PCREL16PT_64
, SH64PCREL64
) },
441 /* C (SH64PCREL16PT_64, SH64PCREL64) */
442 { 0, 0, SH64PCREL64_LENGTH
, 0 },
443 /* C (SH64PCREL16PT_64, SH64PCRELPLT) */
444 { 0, 0, SH64PCREL64_LENGTH
, 0},
446 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
448 /* C (MOVI_IMM_32, UNDEF_MOVI) */
449 { 0, 0, MOVI_32_LENGTH
, 0 },
450 /* C (MOVI_IMM_32, MOVI_16) */
451 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_32
, MOVI_32
) },
452 /* C (MOVI_IMM_32, MOVI_32) */
453 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, 0 },
455 /* C (MOVI_IMM_32, MOVI_GOTOFF) */
456 { 0, 0, MOVI_32_LENGTH
, 0 },
457 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
459 /* C (MOVI_IMM_32_PCREL, MOVI_16) */
461 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_32_PCREL
, MOVI_32
) },
462 /* C (MOVI_IMM_32_PCREL, MOVI_32) */
463 { 0, 0, MOVI_32_LENGTH
, 0 },
465 /* C (MOVI_IMM_32_PCREL, MOVI_PLT) */
466 { 0, 0, MOVI_32_LENGTH
, 0 },
468 /* C (MOVI_IMM_32_PCREL, MOVI_GOTPC) */
469 { 0, 0, MOVI_32_LENGTH
, 0 },
470 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
472 /* C (MOVI_IMM_64, UNDEF_MOVI) */
473 { 0, 0, MOVI_64_LENGTH
, 0 },
474 /* C (MOVI_IMM_64, MOVI_16) */
475 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_64
, MOVI_32
) },
476 /* C (MOVI_IMM_64, MOVI_32) */
477 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, C (MOVI_IMM_64
, MOVI_48
) },
478 /* C (MOVI_IMM_64, MOVI_48) */
479 { MOVI_48_F
, MOVI_48_M
, MOVI_48_LENGTH
, C (MOVI_IMM_64
, MOVI_64
) },
480 /* C (MOVI_IMM_64, MOVI_64) */
481 { 0, 0, MOVI_64_LENGTH
, 0 },
483 /* C (MOVI_IMM_64, MOVI_GOTOFF) */
484 { 0, 0, MOVI_64_LENGTH
, 0 },
485 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
487 /* C (MOVI_IMM_64_PCREL, MOVI_16) */
489 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_32
) },
490 /* C (MOVI_IMM_64_PCREL, MOVI_32) */
491 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_48
) },
492 /* C (MOVI_IMM_64_PCREL, MOVI_48) */
493 { MOVI_48_F
, MOVI_48_M
, MOVI_48_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_64
) },
494 /* C (MOVI_IMM_64_PCREL, MOVI_64) */
495 { 0, 0, MOVI_64_LENGTH
, 0 },
496 /* C (MOVI_IMM_64_PCREL, MOVI_PLT) */
497 { 0, 0, MOVI_64_LENGTH
, 0 },
499 /* C (MOVI_IMM_64_PCREL, MOVI_GOTPC) */
500 { 0, 0, MOVI_64_LENGTH
, 0 },
501 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
503 #endif /* HAVE_SH64 */
509 static struct hash_control
*opcode_hash_control
; /* Opcode mnemonics */
513 /* Determinet whether the symbol needs any kind of PIC relocation. */
516 sh_PIC_related_p (sym
)
524 if (sym
== GOT_symbol
)
528 if (sh_PIC_related_p (*symbol_get_tc (sym
)))
532 exp
= symbol_get_value_expression (sym
);
534 return (exp
->X_op
== O_PIC_reloc
535 || sh_PIC_related_p (exp
->X_add_symbol
)
536 || sh_PIC_related_p (exp
->X_op_symbol
));
539 /* Determine the relocation type to be used to represent the
540 expression, that may be rearranged. */
543 sh_check_fixup (main_exp
, r_type_p
)
544 expressionS
*main_exp
;
545 bfd_reloc_code_real_type
*r_type_p
;
547 expressionS
*exp
= main_exp
;
549 /* This is here for backward-compatibility only. GCC used to generated:
551 f@PLT + . - (.LPCS# + 2)
553 but we'd rather be able to handle this as a PIC-related reference
554 plus/minus a symbol. However, gas' parser gives us:
556 O_subtract (O_add (f@PLT, .), .LPCS#+2)
558 so we attempt to transform this into:
560 O_subtract (f@PLT, O_subtract (.LPCS#+2, .))
562 which we can handle simply below. */
563 if (exp
->X_op
== O_subtract
)
565 if (sh_PIC_related_p (exp
->X_op_symbol
))
568 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
570 if (exp
&& sh_PIC_related_p (exp
->X_op_symbol
))
573 if (exp
&& exp
->X_op
== O_add
574 && sh_PIC_related_p (exp
->X_add_symbol
))
576 symbolS
*sym
= exp
->X_add_symbol
;
578 exp
->X_op
= O_subtract
;
579 exp
->X_add_symbol
= main_exp
->X_op_symbol
;
581 main_exp
->X_op_symbol
= main_exp
->X_add_symbol
;
582 main_exp
->X_add_symbol
= sym
;
584 main_exp
->X_add_number
+= exp
->X_add_number
;
585 exp
->X_add_number
= 0;
590 else if (exp
->X_op
== O_add
&& sh_PIC_related_p (exp
->X_op_symbol
))
593 if (exp
->X_op
== O_symbol
|| exp
->X_op
== O_add
|| exp
->X_op
== O_subtract
)
596 if (exp
->X_add_symbol
597 && (exp
->X_add_symbol
== GOT_symbol
599 && *symbol_get_tc (exp
->X_add_symbol
) == GOT_symbol
)))
603 case BFD_RELOC_SH_IMM_LOW16
:
604 *r_type_p
= BFD_RELOC_SH_GOTPC_LOW16
;
607 case BFD_RELOC_SH_IMM_MEDLOW16
:
608 *r_type_p
= BFD_RELOC_SH_GOTPC_MEDLOW16
;
611 case BFD_RELOC_SH_IMM_MEDHI16
:
612 *r_type_p
= BFD_RELOC_SH_GOTPC_MEDHI16
;
615 case BFD_RELOC_SH_IMM_HI16
:
616 *r_type_p
= BFD_RELOC_SH_GOTPC_HI16
;
620 case BFD_RELOC_UNUSED
:
621 *r_type_p
= BFD_RELOC_SH_GOTPC
;
630 if (exp
->X_add_symbol
&& exp
->X_add_symbol
== GOT_symbol
)
632 *r_type_p
= BFD_RELOC_SH_GOTPC
;
636 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
641 if (exp
->X_op
== O_PIC_reloc
)
647 case BFD_RELOC_UNUSED
:
648 *r_type_p
= exp
->X_md
;
651 case BFD_RELOC_SH_IMM_LOW16
:
654 case BFD_RELOC_32_GOTOFF
:
655 *r_type_p
= BFD_RELOC_SH_GOTOFF_LOW16
;
658 case BFD_RELOC_SH_GOTPLT32
:
659 *r_type_p
= BFD_RELOC_SH_GOTPLT_LOW16
;
662 case BFD_RELOC_32_GOT_PCREL
:
663 *r_type_p
= BFD_RELOC_SH_GOT_LOW16
;
666 case BFD_RELOC_32_PLT_PCREL
:
667 *r_type_p
= BFD_RELOC_SH_PLT_LOW16
;
675 case BFD_RELOC_SH_IMM_MEDLOW16
:
678 case BFD_RELOC_32_GOTOFF
:
679 *r_type_p
= BFD_RELOC_SH_GOTOFF_MEDLOW16
;
682 case BFD_RELOC_SH_GOTPLT32
:
683 *r_type_p
= BFD_RELOC_SH_GOTPLT_MEDLOW16
;
686 case BFD_RELOC_32_GOT_PCREL
:
687 *r_type_p
= BFD_RELOC_SH_GOT_MEDLOW16
;
690 case BFD_RELOC_32_PLT_PCREL
:
691 *r_type_p
= BFD_RELOC_SH_PLT_MEDLOW16
;
699 case BFD_RELOC_SH_IMM_MEDHI16
:
702 case BFD_RELOC_32_GOTOFF
:
703 *r_type_p
= BFD_RELOC_SH_GOTOFF_MEDHI16
;
706 case BFD_RELOC_SH_GOTPLT32
:
707 *r_type_p
= BFD_RELOC_SH_GOTPLT_MEDHI16
;
710 case BFD_RELOC_32_GOT_PCREL
:
711 *r_type_p
= BFD_RELOC_SH_GOT_MEDHI16
;
714 case BFD_RELOC_32_PLT_PCREL
:
715 *r_type_p
= BFD_RELOC_SH_PLT_MEDHI16
;
723 case BFD_RELOC_SH_IMM_HI16
:
726 case BFD_RELOC_32_GOTOFF
:
727 *r_type_p
= BFD_RELOC_SH_GOTOFF_HI16
;
730 case BFD_RELOC_SH_GOTPLT32
:
731 *r_type_p
= BFD_RELOC_SH_GOTPLT_HI16
;
734 case BFD_RELOC_32_GOT_PCREL
:
735 *r_type_p
= BFD_RELOC_SH_GOT_HI16
;
738 case BFD_RELOC_32_PLT_PCREL
:
739 *r_type_p
= BFD_RELOC_SH_PLT_HI16
;
751 *r_type_p
= exp
->X_md
;
754 exp
->X_op
= O_symbol
;
757 main_exp
->X_add_symbol
= exp
->X_add_symbol
;
758 main_exp
->X_add_number
+= exp
->X_add_number
;
762 return (sh_PIC_related_p (exp
->X_add_symbol
)
763 || sh_PIC_related_p (exp
->X_op_symbol
));
768 /* Add expression EXP of SIZE bytes to offset OFF of fragment FRAG. */
771 sh_cons_fix_new (frag
, off
, size
, exp
)
776 bfd_reloc_code_real_type r_type
= BFD_RELOC_UNUSED
;
778 if (sh_check_fixup (exp
, &r_type
))
779 as_bad (_("Invalid PIC expression."));
781 if (r_type
== BFD_RELOC_UNUSED
)
785 r_type
= BFD_RELOC_8
;
789 r_type
= BFD_RELOC_16
;
793 r_type
= BFD_RELOC_32
;
798 r_type
= BFD_RELOC_64
;
808 as_bad (_("unsupported BFD relocation size %u"), size
);
809 r_type
= BFD_RELOC_UNUSED
;
812 fix_new_exp (frag
, off
, size
, exp
, 0, r_type
);
815 /* The regular cons() function, that reads constants, doesn't support
816 suffixes such as @GOT, @GOTOFF and @PLT, that generate
817 machine-specific relocation types. So we must define it here. */
818 /* Clobbers input_line_pointer, checks end-of-line. */
821 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
827 /* Update existing range to include a previous insn, if there was one. */
828 sh64_update_contents_mark (true);
830 /* We need to make sure the contents type is set to data. */
833 #endif /* HAVE_SH64 */
835 if (is_it_end_of_statement ())
837 demand_empty_rest_of_line ();
844 emit_expr (&exp
, (unsigned int) nbytes
);
846 while (*input_line_pointer
++ == ',');
848 input_line_pointer
--; /* Put terminator back into stream. */
849 if (*input_line_pointer
== '#' || *input_line_pointer
== '!')
851 while (! is_end_of_line
[(unsigned char) *input_line_pointer
++]);
854 demand_empty_rest_of_line ();
859 /* This function is called once, at assembler startup time. This should
860 set up all the tables, etc that the MD part of the assembler needs. */
865 sh_opcode_info
*opcode
;
866 char *prev_name
= "";
869 target_arch
= arch_sh1_up
& ~(sh_dsp
? arch_sh3e_up
: arch_sh_dsp_up
);
870 valid_arch
= target_arch
;
876 opcode_hash_control
= hash_new ();
878 /* Insert unique names into hash table. */
879 for (opcode
= sh_table
; opcode
->name
; opcode
++)
881 if (strcmp (prev_name
, opcode
->name
))
883 if (! (opcode
->arch
& target_arch
))
885 prev_name
= opcode
->name
;
886 hash_insert (opcode_hash_control
, opcode
->name
, (char *) opcode
);
890 /* Make all the opcodes with the same name point to the same
892 opcode
->name
= prev_name
;
899 static int reg_x
, reg_y
;
903 #define IDENT_CHAR(c) (ISALNUM (c) || (c) == '_')
905 /* Try to parse a reg name. Return the number of chars consumed. */
908 parse_reg (src
, mode
, reg
)
913 char l0
= TOLOWER (src
[0]);
914 char l1
= l0
? TOLOWER (src
[1]) : 0;
916 /* We use ! IDENT_CHAR for the next character after the register name, to
917 make sure that we won't accidentally recognize a symbol name such as
918 'sram' or sr_ram as being a reference to the register 'sr'. */
924 if (src
[2] >= '0' && src
[2] <= '5'
925 && ! IDENT_CHAR ((unsigned char) src
[3]))
928 *reg
= 10 + src
[2] - '0';
932 if (l1
>= '0' && l1
<= '9'
933 && ! IDENT_CHAR ((unsigned char) src
[2]))
939 if (l1
>= '0' && l1
<= '7' && strncasecmp (&src
[2], "_bank", 5) == 0
940 && ! IDENT_CHAR ((unsigned char) src
[7]))
947 if (l1
== 'e' && ! IDENT_CHAR ((unsigned char) src
[2]))
952 if (l1
== 's' && ! IDENT_CHAR ((unsigned char) src
[2]))
963 if (! IDENT_CHAR ((unsigned char) src
[2]))
969 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
978 if (! IDENT_CHAR ((unsigned char) src
[2]))
984 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
992 if (l1
== 'x' && src
[2] >= '0' && src
[2] <= '1'
993 && ! IDENT_CHAR ((unsigned char) src
[3]))
996 *reg
= 4 + (l1
- '0');
999 if (l1
== 'y' && src
[2] >= '0' && src
[2] <= '1'
1000 && ! IDENT_CHAR ((unsigned char) src
[3]))
1003 *reg
= 6 + (l1
- '0');
1006 if (l1
== 's' && src
[2] >= '0' && src
[2] <= '3'
1007 && ! IDENT_CHAR ((unsigned char) src
[3]))
1012 *reg
= n
| ((~n
& 2) << 1);
1017 if (l0
== 'i' && l1
&& ! IDENT_CHAR ((unsigned char) src
[2]))
1039 if (l0
== 'x' && l1
>= '0' && l1
<= '1'
1040 && ! IDENT_CHAR ((unsigned char) src
[2]))
1043 *reg
= A_X0_NUM
+ l1
- '0';
1047 if (l0
== 'y' && l1
>= '0' && l1
<= '1'
1048 && ! IDENT_CHAR ((unsigned char) src
[2]))
1051 *reg
= A_Y0_NUM
+ l1
- '0';
1055 if (l0
== 'm' && l1
>= '0' && l1
<= '1'
1056 && ! IDENT_CHAR ((unsigned char) src
[2]))
1059 *reg
= l1
== '0' ? A_M0_NUM
: A_M1_NUM
;
1065 && TOLOWER (src
[2]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[3]))
1071 if (l0
== 's' && l1
== 'p' && TOLOWER (src
[2]) == 'c'
1072 && ! IDENT_CHAR ((unsigned char) src
[3]))
1078 if (l0
== 's' && l1
== 'g' && TOLOWER (src
[2]) == 'r'
1079 && ! IDENT_CHAR ((unsigned char) src
[3]))
1085 if (l0
== 'd' && l1
== 's' && TOLOWER (src
[2]) == 'r'
1086 && ! IDENT_CHAR ((unsigned char) src
[3]))
1092 if (l0
== 'd' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1093 && ! IDENT_CHAR ((unsigned char) src
[3]))
1099 if (l0
== 's' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1105 if (l0
== 's' && l1
== 'p' && ! IDENT_CHAR ((unsigned char) src
[2]))
1112 if (l0
== 'p' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1117 if (l0
== 'p' && l1
== 'c' && ! IDENT_CHAR ((unsigned char) src
[2]))
1119 /* Don't use A_DISP_PC here - that would accept stuff like 'mova pc,r0'
1120 and use an uninitialized immediate. */
1124 if (l0
== 'g' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1125 && ! IDENT_CHAR ((unsigned char) src
[3]))
1130 if (l0
== 'v' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1131 && ! IDENT_CHAR ((unsigned char) src
[3]))
1137 if (l0
== 'm' && l1
== 'a' && TOLOWER (src
[2]) == 'c'
1138 && ! IDENT_CHAR ((unsigned char) src
[4]))
1140 if (TOLOWER (src
[3]) == 'l')
1145 if (TOLOWER (src
[3]) == 'h')
1151 if (l0
== 'm' && l1
== 'o' && TOLOWER (src
[2]) == 'd'
1152 && ! IDENT_CHAR ((unsigned char) src
[3]))
1157 if (l0
== 'f' && l1
== 'r')
1161 if (src
[3] >= '0' && src
[3] <= '5'
1162 && ! IDENT_CHAR ((unsigned char) src
[4]))
1165 *reg
= 10 + src
[3] - '0';
1169 if (src
[2] >= '0' && src
[2] <= '9'
1170 && ! IDENT_CHAR ((unsigned char) src
[3]))
1173 *reg
= (src
[2] - '0');
1177 if (l0
== 'd' && l1
== 'r')
1181 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1182 && ! IDENT_CHAR ((unsigned char) src
[4]))
1185 *reg
= 10 + src
[3] - '0';
1189 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1190 && ! IDENT_CHAR ((unsigned char) src
[3]))
1193 *reg
= (src
[2] - '0');
1197 if (l0
== 'x' && l1
== 'd')
1201 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1202 && ! IDENT_CHAR ((unsigned char) src
[4]))
1205 *reg
= 11 + src
[3] - '0';
1209 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1210 && ! IDENT_CHAR ((unsigned char) src
[3]))
1213 *reg
= (src
[2] - '0') + 1;
1217 if (l0
== 'f' && l1
== 'v')
1219 if (src
[2] == '1'&& src
[3] == '2' && ! IDENT_CHAR ((unsigned char) src
[4]))
1225 if ((src
[2] == '0' || src
[2] == '4' || src
[2] == '8')
1226 && ! IDENT_CHAR ((unsigned char) src
[3]))
1229 *reg
= (src
[2] - '0');
1233 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 'u'
1234 && TOLOWER (src
[3]) == 'l'
1235 && ! IDENT_CHAR ((unsigned char) src
[4]))
1241 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 's'
1242 && TOLOWER (src
[3]) == 'c'
1243 && TOLOWER (src
[4]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[5]))
1249 if (l0
== 'x' && l1
== 'm' && TOLOWER (src
[2]) == 't'
1250 && TOLOWER (src
[3]) == 'r'
1251 && TOLOWER (src
[4]) == 'x' && ! IDENT_CHAR ((unsigned char) src
[5]))
1263 sh_operand_info
*op
;
1268 save
= input_line_pointer
;
1269 input_line_pointer
= s
;
1270 expression (&op
->immediate
);
1271 if (op
->immediate
.X_op
== O_absent
)
1272 as_bad (_("missing operand"));
1274 else if (op
->immediate
.X_op
== O_PIC_reloc
1275 || sh_PIC_related_p (op
->immediate
.X_add_symbol
)
1276 || sh_PIC_related_p (op
->immediate
.X_op_symbol
))
1277 as_bad (_("misplaced PIC operand"));
1279 new = input_line_pointer
;
1280 input_line_pointer
= save
;
1284 /* The many forms of operand:
1287 @Rn Register indirect
1300 pr, gbr, vbr, macl, mach
1306 sh_operand_info
*op
;
1313 /* Must be predecrement. */
1316 len
= parse_reg (src
, &mode
, &(op
->reg
));
1317 if (mode
!= A_REG_N
)
1318 as_bad (_("illegal register after @-"));
1323 else if (src
[0] == '(')
1325 /* Could be @(disp, rn), @(disp, gbr), @(disp, pc), @(r0, gbr) or
1328 len
= parse_reg (src
, &mode
, &(op
->reg
));
1329 if (len
&& mode
== A_REG_N
)
1334 as_bad (_("must be @(r0,...)"));
1339 /* Now can be rn or gbr. */
1340 len
= parse_reg (src
, &mode
, &(op
->reg
));
1350 op
->type
= A_R0_GBR
;
1352 else if (mode
== A_REG_N
)
1354 op
->type
= A_IND_R0_REG_N
;
1358 as_bad (_("syntax error in @(r0,...)"));
1363 as_bad (_("syntax error in @(r0...)"));
1368 /* Must be an @(disp,.. thing). */
1369 src
= parse_exp (src
, op
);
1372 /* Now can be rn, gbr or pc. */
1373 len
= parse_reg (src
, &mode
, &op
->reg
);
1376 if (mode
== A_REG_N
)
1378 op
->type
= A_DISP_REG_N
;
1380 else if (mode
== A_GBR
)
1382 op
->type
= A_DISP_GBR
;
1384 else if (mode
== A_PC
)
1386 if (op
->immediate
.X_op
== O_symbol
)
1388 op
->type
= A_DISP_PC
;
1389 as_warn (_("Deprecated syntax."));
1393 op
->type
= A_DISP_PC_ABS
;
1394 /* Such operands don't get corrected for PC==.+4, so
1395 make the correction here. */
1396 op
->immediate
.X_add_number
-= 4;
1401 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1406 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1411 as_bad (_("expecting )"));
1417 src
+= parse_reg (src
, &mode
, &(op
->reg
));
1418 if (mode
!= A_REG_N
)
1419 as_bad (_("illegal register after @"));
1426 l0
= TOLOWER (src
[0]);
1427 l1
= TOLOWER (src
[1]);
1429 if ((l0
== 'r' && l1
== '8')
1430 || (l0
== 'i' && (l1
== 'x' || l1
== 's')))
1433 op
->type
= A_PMOD_N
;
1435 else if ( (l0
== 'r' && l1
== '9')
1436 || (l0
== 'i' && l1
== 'y'))
1439 op
->type
= A_PMODY_N
;
1451 get_operand (ptr
, op
)
1453 sh_operand_info
*op
;
1462 *ptr
= parse_exp (src
, op
);
1467 else if (src
[0] == '@')
1469 *ptr
= parse_at (src
, op
);
1472 len
= parse_reg (src
, &mode
, &(op
->reg
));
1481 /* Not a reg, the only thing left is a displacement. */
1482 *ptr
= parse_exp (src
, op
);
1483 op
->type
= A_DISP_PC
;
1489 get_operands (info
, args
, operand
)
1490 sh_opcode_info
*info
;
1492 sh_operand_info
*operand
;
1497 /* The pre-processor will eliminate whitespace in front of '@'
1498 after the first argument; we may be called multiple times
1499 from assemble_ppi, so don't insist on finding whitespace here. */
1503 get_operand (&ptr
, operand
+ 0);
1510 get_operand (&ptr
, operand
+ 1);
1511 /* ??? Hack: psha/pshl have a varying operand number depending on
1512 the type of the first operand. We handle this by having the
1513 three-operand version first and reducing the number of operands
1514 parsed to two if we see that the first operand is an immediate.
1515 This works because no insn with three operands has an immediate
1516 as first operand. */
1517 if (info
->arg
[2] && operand
[0].type
!= A_IMM
)
1523 get_operand (&ptr
, operand
+ 2);
1527 operand
[2].type
= 0;
1532 operand
[1].type
= 0;
1533 operand
[2].type
= 0;
1538 operand
[0].type
= 0;
1539 operand
[1].type
= 0;
1540 operand
[2].type
= 0;
1545 /* Passed a pointer to a list of opcodes which use different
1546 addressing modes, return the opcode which matches the opcodes
1549 static sh_opcode_info
*
1550 get_specific (opcode
, operands
)
1551 sh_opcode_info
*opcode
;
1552 sh_operand_info
*operands
;
1554 sh_opcode_info
*this_try
= opcode
;
1555 char *name
= opcode
->name
;
1558 while (opcode
->name
)
1560 this_try
= opcode
++;
1561 if (this_try
->name
!= name
)
1563 /* We've looked so far down the table that we've run out of
1564 opcodes with the same name. */
1568 /* Look at both operands needed by the opcodes and provided by
1569 the user - since an arg test will often fail on the same arg
1570 again and again, we'll try and test the last failing arg the
1571 first on each opcode try. */
1572 for (n
= 0; this_try
->arg
[n
]; n
++)
1574 sh_operand_info
*user
= operands
+ n
;
1575 sh_arg_type arg
= this_try
->arg
[n
];
1577 /* If this is a parallel insn check to see if both
1578 parts have the same destination register. */
1579 if ((n
== 2) && (this_try
->nibbles
[0] == PPI
))
1581 static boolean bIsPPI
= false;
1582 static int nLastDestReg
;
1587 nLastDestReg
= user
->reg
;
1589 else /* Second insn. */
1591 if (nLastDestReg
== user
->reg
)
1592 as_warn (_("destination register is same for parallel insns"));
1601 if (user
->type
== A_DISP_PC_ABS
)
1611 if (user
->type
!= arg
)
1615 /* opcode needs r0 */
1616 if (user
->type
!= A_REG_N
|| user
->reg
!= 0)
1620 if (user
->type
!= A_R0_GBR
|| user
->reg
!= 0)
1624 if (user
->type
!= F_REG_N
|| user
->reg
!= 0)
1632 case A_IND_R0_REG_N
:
1643 /* Opcode needs rn */
1644 if (user
->type
!= arg
)
1649 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1664 if (user
->type
!= arg
)
1669 if (user
->type
!= arg
)
1678 case A_IND_R0_REG_M
:
1681 /* Opcode needs rn */
1682 if (user
->type
!= arg
- A_REG_M
+ A_REG_N
)
1688 if (user
->type
!= DSP_REG_N
)
1710 if (user
->type
!= DSP_REG_N
)
1732 if (user
->type
!= DSP_REG_N
)
1754 if (user
->type
!= DSP_REG_N
)
1776 if (user
->type
!= DSP_REG_N
)
1798 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_A0_NUM
)
1802 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X0_NUM
)
1806 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X1_NUM
)
1810 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y0_NUM
)
1814 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y1_NUM
)
1824 /* Opcode needs rn */
1825 if (user
->type
!= arg
- F_REG_M
+ F_REG_N
)
1830 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1835 if (user
->type
!= XMTRX_M4
)
1841 printf (_("unhandled %d\n"), arg
);
1845 if ( !(valid_arch
& this_try
->arch
))
1847 valid_arch
&= this_try
->arch
;
1857 insert (where
, how
, pcrel
, op
)
1861 sh_operand_info
*op
;
1863 fix_new_exp (frag_now
,
1864 where
- frag_now
->fr_literal
,
1872 build_relax (opcode
, op
)
1873 sh_opcode_info
*opcode
;
1874 sh_operand_info
*op
;
1876 int high_byte
= target_big_endian
? 0 : 1;
1879 if (opcode
->arg
[0] == A_BDISP8
)
1881 int what
= (opcode
->nibbles
[1] & 4) ? COND_JUMP_DELAY
: COND_JUMP
;
1882 p
= frag_var (rs_machine_dependent
,
1883 md_relax_table
[C (what
, COND32
)].rlx_length
,
1884 md_relax_table
[C (what
, COND8
)].rlx_length
,
1886 op
->immediate
.X_add_symbol
,
1887 op
->immediate
.X_add_number
,
1889 p
[high_byte
] = (opcode
->nibbles
[0] << 4) | (opcode
->nibbles
[1]);
1891 else if (opcode
->arg
[0] == A_BDISP12
)
1893 p
= frag_var (rs_machine_dependent
,
1894 md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
,
1895 md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
,
1897 op
->immediate
.X_add_symbol
,
1898 op
->immediate
.X_add_number
,
1900 p
[high_byte
] = (opcode
->nibbles
[0] << 4);
1905 /* Insert ldrs & ldre with fancy relocations that relaxation can recognize. */
1908 insert_loop_bounds (output
, operand
)
1910 sh_operand_info
*operand
;
1915 /* Since the low byte of the opcode will be overwritten by the reloc, we
1916 can just stash the high byte into both bytes and ignore endianness. */
1919 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1920 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1924 static int count
= 0;
1926 /* If the last loop insn is a two-byte-insn, it is in danger of being
1927 swapped with the insn after it. To prevent this, create a new
1928 symbol - complete with SH_LABEL reloc - after the last loop insn.
1929 If the last loop insn is four bytes long, the symbol will be
1930 right in the middle, but four byte insns are not swapped anyways. */
1931 /* A REPEAT takes 6 bytes. The SH has a 32 bit address space.
1932 Hence a 9 digit number should be enough to count all REPEATs. */
1934 sprintf (name
, "_R%x", count
++ & 0x3fffffff);
1935 end_sym
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
1936 /* Make this a local symbol. */
1938 SF_SET_LOCAL (end_sym
);
1939 #endif /* OBJ_COFF */
1940 symbol_table_insert (end_sym
);
1941 end_sym
->sy_value
= operand
[1].immediate
;
1942 end_sym
->sy_value
.X_add_number
+= 2;
1943 fix_new (frag_now
, frag_now_fix (), 2, end_sym
, 0, 1, BFD_RELOC_SH_LABEL
);
1946 output
= frag_more (2);
1949 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1950 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1952 return frag_more (2);
1955 /* Now we know what sort of opcodes it is, let's build the bytes. */
1958 build_Mytes (opcode
, operand
)
1959 sh_opcode_info
*opcode
;
1960 sh_operand_info
*operand
;
1964 char *output
= frag_more (2);
1965 unsigned int size
= 2;
1966 int low_byte
= target_big_endian
? 1 : 0;
1972 for (index
= 0; index
< 4; index
++)
1974 sh_nibble_type i
= opcode
->nibbles
[index
];
1984 nbuf
[index
] = reg_n
;
1987 nbuf
[index
] = reg_m
;
1990 if (reg_n
< 2 || reg_n
> 5)
1991 as_bad (_("Invalid register: 'r%d'"), reg_n
);
1992 nbuf
[index
] = (reg_n
& 3) | 4;
1995 nbuf
[index
] = reg_n
| (reg_m
>> 2);
1998 nbuf
[index
] = reg_b
| 0x08;
2001 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
);
2004 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
);
2007 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
);
2010 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
+ 1);
2013 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
+ 1);
2016 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
+ 1);
2019 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
);
2022 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
);
2025 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
);
2028 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
+ 1);
2031 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
+ 1);
2034 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
+ 1);
2037 insert (output
, BFD_RELOC_SH_PCRELIMM8BY4
,
2038 operand
->type
!= A_DISP_PC_ABS
, operand
);
2041 insert (output
, BFD_RELOC_SH_PCRELIMM8BY2
,
2042 operand
->type
!= A_DISP_PC_ABS
, operand
);
2045 output
= insert_loop_bounds (output
, operand
);
2046 nbuf
[index
] = opcode
->nibbles
[3];
2050 printf (_("failed for %d\n"), i
);
2054 if (!target_big_endian
)
2056 output
[1] = (nbuf
[0] << 4) | (nbuf
[1]);
2057 output
[0] = (nbuf
[2] << 4) | (nbuf
[3]);
2061 output
[0] = (nbuf
[0] << 4) | (nbuf
[1]);
2062 output
[1] = (nbuf
[2] << 4) | (nbuf
[3]);
2067 /* Find an opcode at the start of *STR_P in the hash table, and set
2068 *STR_P to the first character after the last one read. */
2070 static sh_opcode_info
*
2071 find_cooked_opcode (str_p
)
2075 unsigned char *op_start
;
2076 unsigned char *op_end
;
2080 /* Drop leading whitespace. */
2084 /* Find the op code end.
2085 The pre-processor will eliminate whitespace in front of
2086 any '@' after the first argument; we may be called from
2087 assemble_ppi, so the opcode might be terminated by an '@'. */
2088 for (op_start
= op_end
= (unsigned char *) (str
);
2091 && !is_end_of_line
[*op_end
] && *op_end
!= ' ' && *op_end
!= '@';
2094 unsigned char c
= op_start
[nlen
];
2096 /* The machine independent code will convert CMP/EQ into cmp/EQ
2097 because it thinks the '/' is the end of the symbol. Moreover,
2098 all but the first sub-insn is a parallel processing insn won't
2099 be capitalized. Instead of hacking up the machine independent
2100 code, we just deal with it here. */
2110 as_bad (_("can't find opcode "));
2112 return (sh_opcode_info
*) hash_find (opcode_hash_control
, name
);
2115 /* Assemble a parallel processing insn. */
2116 #define DDT_BASE 0xf000 /* Base value for double data transfer insns */
2119 assemble_ppi (op_end
, opcode
)
2121 sh_opcode_info
*opcode
;
2131 /* Some insn ignore one or more register fields, e.g. psts machl,a0.
2132 Make sure we encode a defined insn pattern. */
2138 sh_operand_info operand
[3];
2140 if (opcode
->arg
[0] != A_END
)
2141 op_end
= get_operands (opcode
, op_end
, operand
);
2142 opcode
= get_specific (opcode
, operand
);
2145 /* Couldn't find an opcode which matched the operands. */
2146 char *where
= frag_more (2);
2151 as_bad (_("invalid operands for opcode"));
2155 if (opcode
->nibbles
[0] != PPI
)
2156 as_bad (_("insn can't be combined with parallel processing insn"));
2158 switch (opcode
->nibbles
[1])
2163 as_bad (_("multiple movx specifications"));
2168 as_bad (_("multiple movy specifications"));
2174 as_bad (_("multiple movx specifications"));
2175 if (reg_n
< 4 || reg_n
> 5)
2176 as_bad (_("invalid movx address register"));
2177 if (opcode
->nibbles
[2] & 8)
2179 if (reg_m
== A_A1_NUM
)
2181 else if (reg_m
!= A_A0_NUM
)
2182 as_bad (_("invalid movx dsp register"));
2187 as_bad (_("invalid movx dsp register"));
2190 movx
+= ((reg_n
- 4) << 9) + (opcode
->nibbles
[2] << 2) + DDT_BASE
;
2195 as_bad (_("multiple movy specifications"));
2196 if (opcode
->nibbles
[2] & 8)
2198 /* Bit 3 in nibbles[2] is intended for bit 4 of the opcode,
2201 if (reg_m
== A_A1_NUM
)
2203 else if (reg_m
!= A_A0_NUM
)
2204 as_bad (_("invalid movy dsp register"));
2209 as_bad (_("invalid movy dsp register"));
2212 if (reg_n
< 6 || reg_n
> 7)
2213 as_bad (_("invalid movy address register"));
2214 movy
+= ((reg_n
- 6) << 8) + opcode
->nibbles
[2] + DDT_BASE
;
2218 if (operand
[0].immediate
.X_op
!= O_constant
)
2219 as_bad (_("dsp immediate shift value not constant"));
2220 field_b
= ((opcode
->nibbles
[2] << 12)
2221 | (operand
[0].immediate
.X_add_number
& 127) << 4
2226 as_bad (_("multiple parallel processing specifications"));
2227 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2228 + (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2232 as_bad (_("multiple condition specifications"));
2233 cond
= opcode
->nibbles
[2] << 8;
2235 goto skip_cond_check
;
2239 as_bad (_("multiple parallel processing specifications"));
2240 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2241 + cond
+ (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2247 if ((field_b
& 0xef00) != 0xa100)
2248 as_bad (_("insn cannot be combined with pmuls"));
2250 switch (field_b
& 0xf)
2253 field_b
+= 0 - A_X0_NUM
;
2256 field_b
+= 1 - A_Y0_NUM
;
2259 field_b
+= 2 - A_A0_NUM
;
2262 field_b
+= 3 - A_A1_NUM
;
2265 as_bad (_("bad padd / psub pmuls output operand"));
2268 field_b
+= 0x4000 + reg_efg
;
2275 as_bad (_("condition not followed by conditionalizable insn"));
2281 opcode
= find_cooked_opcode (&op_end
);
2285 (_("unrecognized characters at end of parallel processing insn")));
2290 move_code
= movx
| movy
;
2293 /* Parallel processing insn. */
2294 unsigned long ppi_code
= (movx
| movy
| 0xf800) << 16 | field_b
;
2296 output
= frag_more (4);
2298 if (! target_big_endian
)
2300 output
[3] = ppi_code
>> 8;
2301 output
[2] = ppi_code
;
2305 output
[2] = ppi_code
>> 8;
2306 output
[3] = ppi_code
;
2308 move_code
|= 0xf800;
2312 /* Just a double data transfer. */
2313 output
= frag_more (2);
2316 if (! target_big_endian
)
2318 output
[1] = move_code
>> 8;
2319 output
[0] = move_code
;
2323 output
[0] = move_code
>> 8;
2324 output
[1] = move_code
;
2329 /* This is the guts of the machine-dependent assembler. STR points to a
2330 machine dependent instruction. This function is supposed to emit
2331 the frags/bytes it assembles to. */
2337 unsigned char *op_end
;
2338 sh_operand_info operand
[3];
2339 sh_opcode_info
*opcode
;
2340 unsigned int size
= 0;
2343 if (sh64_isa_mode
== sh64_isa_shmedia
)
2345 shmedia_md_assemble (str
);
2350 /* If we've seen pseudo-directives, make sure any emitted data or
2351 frags are marked as data. */
2352 if (seen_insn
== false)
2354 sh64_update_contents_mark (true);
2355 sh64_set_contents_type (CRT_SH5_ISA16
);
2360 #endif /* HAVE_SH64 */
2362 opcode
= find_cooked_opcode (&str
);
2367 as_bad (_("unknown opcode"));
2372 && ! seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2374 /* Output a CODE reloc to tell the linker that the following
2375 bytes are instructions, not data. */
2376 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2378 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 1;
2381 if (opcode
->nibbles
[0] == PPI
)
2383 size
= assemble_ppi (op_end
, opcode
);
2387 if (opcode
->arg
[0] == A_BDISP12
2388 || opcode
->arg
[0] == A_BDISP8
)
2390 parse_exp (op_end
+ 1, &operand
[0]);
2391 build_relax (opcode
, &operand
[0]);
2395 if (opcode
->arg
[0] == A_END
)
2397 /* Ignore trailing whitespace. If there is any, it has already
2398 been compressed to a single space. */
2404 op_end
= get_operands (opcode
, op_end
, operand
);
2406 opcode
= get_specific (opcode
, operand
);
2410 /* Couldn't find an opcode which matched the operands. */
2411 char *where
= frag_more (2);
2416 as_bad (_("invalid operands for opcode"));
2421 as_bad (_("excess operands: '%s'"), op_end
);
2423 size
= build_Mytes (opcode
, operand
);
2428 #ifdef BFD_ASSEMBLER
2429 dwarf2_emit_insn (size
);
2433 /* This routine is called each time a label definition is seen. It
2434 emits a BFD_RELOC_SH_LABEL reloc if necessary. */
2439 static fragS
*last_label_frag
;
2440 static int last_label_offset
;
2443 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2447 offset
= frag_now_fix ();
2448 if (frag_now
!= last_label_frag
2449 || offset
!= last_label_offset
)
2451 fix_new (frag_now
, offset
, 2, &abs_symbol
, 0, 0, BFD_RELOC_SH_LABEL
);
2452 last_label_frag
= frag_now
;
2453 last_label_offset
= offset
;
2458 /* This routine is called when the assembler is about to output some
2459 data. It emits a BFD_RELOC_SH_DATA reloc if necessary. */
2462 sh_flush_pending_output ()
2465 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2467 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2469 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 0;
2474 md_undefined_symbol (name
)
2475 char *name ATTRIBUTE_UNUSED
;
2481 #ifndef BFD_ASSEMBLER
2484 tc_crawl_symbol_chain (headers
)
2485 object_headers
*headers ATTRIBUTE_UNUSED
;
2487 printf (_("call to tc_crawl_symbol_chain \n"));
2491 tc_headers_hook (headers
)
2492 object_headers
*headers ATTRIBUTE_UNUSED
;
2494 printf (_("call to tc_headers_hook \n"));
2500 /* Various routines to kill one day. */
2501 /* Equal to MAX_PRECISION in atof-ieee.c. */
2502 #define MAX_LITTLENUMS 6
2504 /* Turn a string in input_line_pointer into a floating point constant
2505 of type TYPE, and store the appropriate bytes in *LITP. The number
2506 of LITTLENUMS emitted is stored in *SIZEP . An error message is
2507 returned, or NULL on OK. */
2510 md_atof (type
, litP
, sizeP
)
2516 LITTLENUM_TYPE words
[4];
2532 return _("bad call to md_atof");
2535 t
= atof_ieee (input_line_pointer
, type
, words
);
2537 input_line_pointer
= t
;
2541 if (! target_big_endian
)
2543 for (i
= prec
- 1; i
>= 0; i
--)
2545 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2551 for (i
= 0; i
< prec
; i
++)
2553 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2561 /* Handle the .uses pseudo-op. This pseudo-op is used just before a
2562 call instruction. It refers to a label of the instruction which
2563 loads the register which the call uses. We use it to generate a
2564 special reloc for the linker. */
2568 int ignore ATTRIBUTE_UNUSED
;
2573 as_warn (_(".uses pseudo-op seen when not relaxing"));
2577 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
2579 as_bad (_("bad .uses format"));
2580 ignore_rest_of_line ();
2584 fix_new_exp (frag_now
, frag_now_fix (), 2, &ex
, 1, BFD_RELOC_SH_USES
);
2586 demand_empty_rest_of_line ();
2589 CONST
char *md_shortopts
= "";
2590 struct option md_longopts
[] =
2592 #define OPTION_RELAX (OPTION_MD_BASE)
2593 #define OPTION_BIG (OPTION_MD_BASE + 1)
2594 #define OPTION_LITTLE (OPTION_BIG + 1)
2595 #define OPTION_SMALL (OPTION_LITTLE + 1)
2596 #define OPTION_DSP (OPTION_SMALL + 1)
2598 {"relax", no_argument
, NULL
, OPTION_RELAX
},
2599 {"big", no_argument
, NULL
, OPTION_BIG
},
2600 {"little", no_argument
, NULL
, OPTION_LITTLE
},
2601 {"small", no_argument
, NULL
, OPTION_SMALL
},
2602 {"dsp", no_argument
, NULL
, OPTION_DSP
},
2604 #define OPTION_ISA (OPTION_DSP + 1)
2605 #define OPTION_ABI (OPTION_ISA + 1)
2606 #define OPTION_NO_MIX (OPTION_ABI + 1)
2607 #define OPTION_SHCOMPACT_CONST_CRANGE (OPTION_NO_MIX + 1)
2608 #define OPTION_NO_EXPAND (OPTION_SHCOMPACT_CONST_CRANGE + 1)
2609 #define OPTION_PT32 (OPTION_NO_EXPAND + 1)
2610 {"isa", required_argument
, NULL
, OPTION_ISA
},
2611 {"abi", required_argument
, NULL
, OPTION_ABI
},
2612 {"no-mix", no_argument
, NULL
, OPTION_NO_MIX
},
2613 {"shcompact-const-crange", no_argument
, NULL
, OPTION_SHCOMPACT_CONST_CRANGE
},
2614 {"no-expand", no_argument
, NULL
, OPTION_NO_EXPAND
},
2615 {"expand-pt32", no_argument
, NULL
, OPTION_PT32
},
2616 #endif /* HAVE_SH64 */
2618 {NULL
, no_argument
, NULL
, 0}
2620 size_t md_longopts_size
= sizeof (md_longopts
);
2623 md_parse_option (c
, arg
)
2625 char *arg ATTRIBUTE_UNUSED
;
2634 target_big_endian
= 1;
2638 target_big_endian
= 0;
2651 if (strcasecmp (arg
, "shmedia") == 0)
2653 if (sh64_isa_mode
== sh64_isa_shcompact
)
2654 as_bad (_("Invalid combination: --isa=SHcompact with --isa=SHmedia"));
2655 sh64_isa_mode
= sh64_isa_shmedia
;
2657 else if (strcasecmp (arg
, "shcompact") == 0)
2659 if (sh64_isa_mode
== sh64_isa_shmedia
)
2660 as_bad (_("Invalid combination: --isa=SHmedia with --isa=SHcompact"));
2661 if (sh64_abi
== sh64_abi_64
)
2662 as_bad (_("Invalid combination: --abi=64 with --isa=SHcompact"));
2663 sh64_isa_mode
= sh64_isa_shcompact
;
2666 as_bad ("Invalid argument to --isa option: %s", arg
);
2670 if (strcmp (arg
, "32") == 0)
2672 if (sh64_abi
== sh64_abi_64
)
2673 as_bad (_("Invalid combination: --abi=32 with --abi=64"));
2674 sh64_abi
= sh64_abi_32
;
2676 else if (strcmp (arg
, "64") == 0)
2678 if (sh64_abi
== sh64_abi_32
)
2679 as_bad (_("Invalid combination: --abi=64 with --abi=32"));
2680 if (sh64_isa_mode
== sh64_isa_shcompact
)
2681 as_bad (_("Invalid combination: --isa=SHcompact with --abi=64"));
2682 sh64_abi
= sh64_abi_64
;
2685 as_bad ("Invalid argument to --abi option: %s", arg
);
2692 case OPTION_SHCOMPACT_CONST_CRANGE
:
2693 sh64_shcompact_const_crange
= true;
2696 case OPTION_NO_EXPAND
:
2697 sh64_expand
= false;
2703 #endif /* HAVE_SH64 */
2713 md_show_usage (stream
)
2716 fprintf (stream
, _("\
2718 -little generate little endian code\n\
2719 -big generate big endian code\n\
2720 -relax alter jump instructions for long displacements\n\
2721 -small align sections to 4 byte boundaries, not 16\n\
2722 -dsp enable sh-dsp insns, and disable sh3e / sh4 insns.\n"));
2724 fprintf (stream
, _("\
2725 -isa=[shmedia set default instruction set for SH64\n\
2729 -abi=[32|64] set size of expanded SHmedia operands and object\n\
2731 -shcompact-const-crange emit code-range descriptors for constants in\n\
2732 SHcompact code sections\n\
2733 -no-mix disallow SHmedia code in the same section as\n\
2734 constants and SHcompact code\n\
2735 -no-expand do not expand MOVI, PT, PTA or PTB instructions\n\
2736 -expand-pt32 with -abi=64, expand PT, PTA and PTB instructions\n\
2738 #endif /* HAVE_SH64 */
2741 /* This struct is used to pass arguments to sh_count_relocs through
2742 bfd_map_over_sections. */
2744 struct sh_count_relocs
2746 /* Symbol we are looking for. */
2748 /* Count of relocs found. */
2752 /* Count the number of fixups in a section which refer to a particular
2753 symbol. When using BFD_ASSEMBLER, this is called via
2754 bfd_map_over_sections. */
2757 sh_count_relocs (abfd
, sec
, data
)
2758 bfd
*abfd ATTRIBUTE_UNUSED
;
2762 struct sh_count_relocs
*info
= (struct sh_count_relocs
*) data
;
2763 segment_info_type
*seginfo
;
2767 seginfo
= seg_info (sec
);
2768 if (seginfo
== NULL
)
2772 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2774 if (fix
->fx_addsy
== sym
)
2782 /* Handle the count relocs for a particular section. When using
2783 BFD_ASSEMBLER, this is called via bfd_map_over_sections. */
2786 sh_frob_section (abfd
, sec
, ignore
)
2787 bfd
*abfd ATTRIBUTE_UNUSED
;
2789 PTR ignore ATTRIBUTE_UNUSED
;
2791 segment_info_type
*seginfo
;
2794 seginfo
= seg_info (sec
);
2795 if (seginfo
== NULL
)
2798 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2803 struct sh_count_relocs info
;
2805 if (fix
->fx_r_type
!= BFD_RELOC_SH_USES
)
2808 /* The BFD_RELOC_SH_USES reloc should refer to a defined local
2809 symbol in the same section. */
2810 sym
= fix
->fx_addsy
;
2812 || fix
->fx_subsy
!= NULL
2813 || fix
->fx_addnumber
!= 0
2814 || S_GET_SEGMENT (sym
) != sec
2815 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2816 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2818 || S_IS_EXTERNAL (sym
))
2820 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2821 _(".uses does not refer to a local symbol in the same section"));
2825 /* Look through the fixups again, this time looking for one
2826 at the same location as sym. */
2827 val
= S_GET_VALUE (sym
);
2828 for (fscan
= seginfo
->fix_root
;
2830 fscan
= fscan
->fx_next
)
2831 if (val
== fscan
->fx_frag
->fr_address
+ fscan
->fx_where
2832 && fscan
->fx_r_type
!= BFD_RELOC_SH_ALIGN
2833 && fscan
->fx_r_type
!= BFD_RELOC_SH_CODE
2834 && fscan
->fx_r_type
!= BFD_RELOC_SH_DATA
2835 && fscan
->fx_r_type
!= BFD_RELOC_SH_LABEL
)
2839 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2840 _("can't find fixup pointed to by .uses"));
2844 if (fscan
->fx_tcbit
)
2846 /* We've already done this one. */
2850 /* The variable fscan should also be a fixup to a local symbol
2851 in the same section. */
2852 sym
= fscan
->fx_addsy
;
2854 || fscan
->fx_subsy
!= NULL
2855 || fscan
->fx_addnumber
!= 0
2856 || S_GET_SEGMENT (sym
) != sec
2857 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2858 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2860 || S_IS_EXTERNAL (sym
))
2862 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2863 _(".uses target does not refer to a local symbol in the same section"));
2867 /* Now we look through all the fixups of all the sections,
2868 counting the number of times we find a reference to sym. */
2871 #ifdef BFD_ASSEMBLER
2872 bfd_map_over_sections (stdoutput
, sh_count_relocs
, (PTR
) &info
);
2877 for (iscan
= SEG_E0
; iscan
< SEG_UNKNOWN
; iscan
++)
2878 sh_count_relocs ((bfd
*) NULL
, iscan
, (PTR
) &info
);
2885 /* Generate a BFD_RELOC_SH_COUNT fixup at the location of sym.
2886 We have already adjusted the value of sym to include the
2887 fragment address, so we undo that adjustment here. */
2888 subseg_change (sec
, 0);
2889 fix_new (fscan
->fx_frag
,
2890 S_GET_VALUE (sym
) - fscan
->fx_frag
->fr_address
,
2891 4, &abs_symbol
, info
.count
, 0, BFD_RELOC_SH_COUNT
);
2895 /* This function is called after the symbol table has been completed,
2896 but before the relocs or section contents have been written out.
2897 If we have seen any .uses pseudo-ops, they point to an instruction
2898 which loads a register with the address of a function. We look
2899 through the fixups to find where the function address is being
2900 loaded from. We then generate a COUNT reloc giving the number of
2901 times that function address is referred to. The linker uses this
2902 information when doing relaxing, to decide when it can eliminate
2903 the stored function address entirely. */
2909 shmedia_frob_file_before_adjust ();
2915 #ifdef BFD_ASSEMBLER
2916 bfd_map_over_sections (stdoutput
, sh_frob_section
, (PTR
) NULL
);
2921 for (iseg
= SEG_E0
; iseg
< SEG_UNKNOWN
; iseg
++)
2922 sh_frob_section ((bfd
*) NULL
, iseg
, (PTR
) NULL
);
2927 /* Called after relaxing. Set the correct sizes of the fragments, and
2928 create relocs so that md_apply_fix3 will fill in the correct values. */
2931 md_convert_frag (headers
, seg
, fragP
)
2932 #ifdef BFD_ASSEMBLER
2933 bfd
*headers ATTRIBUTE_UNUSED
;
2935 object_headers
*headers ATTRIBUTE_UNUSED
;
2942 switch (fragP
->fr_subtype
)
2944 case C (COND_JUMP
, COND8
):
2945 case C (COND_JUMP_DELAY
, COND8
):
2946 subseg_change (seg
, 0);
2947 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2948 1, BFD_RELOC_SH_PCDISP8BY2
);
2953 case C (UNCOND_JUMP
, UNCOND12
):
2954 subseg_change (seg
, 0);
2955 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2956 1, BFD_RELOC_SH_PCDISP12BY2
);
2961 case C (UNCOND_JUMP
, UNCOND32
):
2962 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
2963 if (fragP
->fr_symbol
== NULL
)
2964 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2965 _("displacement overflows 12-bit field"));
2966 else if (S_IS_DEFINED (fragP
->fr_symbol
))
2967 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2968 _("displacement to defined symbol %s overflows 12-bit field"),
2969 S_GET_NAME (fragP
->fr_symbol
));
2971 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2972 _("displacement to undefined symbol %s overflows 12-bit field"),
2973 S_GET_NAME (fragP
->fr_symbol
));
2974 /* Stabilize this frag, so we don't trip an assert. */
2975 fragP
->fr_fix
+= fragP
->fr_var
;
2979 case C (COND_JUMP
, COND12
):
2980 case C (COND_JUMP_DELAY
, COND12
):
2981 /* A bcond won't fit, so turn it into a b!cond; bra disp; nop. */
2982 /* I found that a relax failure for gcc.c-torture/execute/930628-1.c
2983 was due to gas incorrectly relaxing an out-of-range conditional
2984 branch with delay slot. It turned:
2985 bf.s L6 (slot mov.l r12,@(44,r0))
2988 2c: 8f 01 a0 8b bf.s 32 <_main+32> (slot bra L6)
2990 32: 10 cb mov.l r12,@(44,r0)
2991 Therefore, branches with delay slots have to be handled
2992 differently from ones without delay slots. */
2994 unsigned char *buffer
=
2995 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
2996 int highbyte
= target_big_endian
? 0 : 1;
2997 int lowbyte
= target_big_endian
? 1 : 0;
2998 int delay
= fragP
->fr_subtype
== C (COND_JUMP_DELAY
, COND12
);
3000 /* Toggle the true/false bit of the bcond. */
3001 buffer
[highbyte
] ^= 0x2;
3003 /* If this is a delayed branch, we may not put the bra in the
3004 slot. So we change it to a non-delayed branch, like that:
3005 b! cond slot_label; bra disp; slot_label: slot_insn
3006 ??? We should try if swapping the conditional branch and
3007 its delay-slot insn already makes the branch reach. */
3009 /* Build a relocation to six / four bytes farther on. */
3010 subseg_change (seg
, 0);
3011 fix_new (fragP
, fragP
->fr_fix
, 2,
3012 #ifdef BFD_ASSEMBLER
3013 section_symbol (seg
),
3015 seg_info (seg
)->dot
,
3017 fragP
->fr_address
+ fragP
->fr_fix
+ (delay
? 4 : 6),
3018 1, BFD_RELOC_SH_PCDISP8BY2
);
3020 /* Set up a jump instruction. */
3021 buffer
[highbyte
+ 2] = 0xa0;
3022 buffer
[lowbyte
+ 2] = 0;
3023 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
3024 fragP
->fr_offset
, 1, BFD_RELOC_SH_PCDISP12BY2
);
3028 buffer
[highbyte
] &= ~0x4; /* Removes delay slot from branch. */
3033 /* Fill in a NOP instruction. */
3034 buffer
[highbyte
+ 4] = 0x0;
3035 buffer
[lowbyte
+ 4] = 0x9;
3044 case C (COND_JUMP
, COND32
):
3045 case C (COND_JUMP_DELAY
, COND32
):
3046 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3047 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3048 if (fragP
->fr_symbol
== NULL
)
3049 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3050 _("displacement overflows 8-bit field"));
3051 else if (S_IS_DEFINED (fragP
->fr_symbol
))
3052 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3053 _("displacement to defined symbol %s overflows 8-bit field"),
3054 S_GET_NAME (fragP
->fr_symbol
));
3056 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3057 _("displacement to undefined symbol %s overflows 8-bit field "),
3058 S_GET_NAME (fragP
->fr_symbol
));
3059 /* Stabilize this frag, so we don't trip an assert. */
3060 fragP
->fr_fix
+= fragP
->fr_var
;
3066 shmedia_md_convert_frag (headers
, seg
, fragP
, true);
3072 if (donerelax
&& !sh_relax
)
3073 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3074 _("overflow in branch to %s; converted into longer instruction sequence"),
3075 (fragP
->fr_symbol
!= NULL
3076 ? S_GET_NAME (fragP
->fr_symbol
)
3081 md_section_align (seg
, size
)
3082 segT seg ATTRIBUTE_UNUSED
;
3085 #ifdef BFD_ASSEMBLER
3088 #else /* ! OBJ_ELF */
3089 return ((size
+ (1 << bfd_get_section_alignment (stdoutput
, seg
)) - 1)
3090 & (-1 << bfd_get_section_alignment (stdoutput
, seg
)));
3091 #endif /* ! OBJ_ELF */
3092 #else /* ! BFD_ASSEMBLER */
3093 return ((size
+ (1 << section_alignment
[(int) seg
]) - 1)
3094 & (-1 << section_alignment
[(int) seg
]));
3095 #endif /* ! BFD_ASSEMBLER */
3098 /* This static variable is set by s_uacons to tell sh_cons_align that
3099 the expession does not need to be aligned. */
3101 static int sh_no_align_cons
= 0;
3103 /* This handles the unaligned space allocation pseudo-ops, such as
3104 .uaword. .uaword is just like .word, but the value does not need
3111 /* Tell sh_cons_align not to align this value. */
3112 sh_no_align_cons
= 1;
3116 /* If a .word, et. al., pseud-op is seen, warn if the value is not
3117 aligned correctly. Note that this can cause warnings to be issued
3118 when assembling initialized structured which were declared with the
3119 packed attribute. FIXME: Perhaps we should require an option to
3120 enable this warning? */
3123 sh_cons_align (nbytes
)
3129 if (sh_no_align_cons
)
3131 /* This is an unaligned pseudo-op. */
3132 sh_no_align_cons
= 0;
3137 while ((nbytes
& 1) == 0)
3146 if (now_seg
== absolute_section
)
3148 if ((abs_section_offset
& ((1 << nalign
) - 1)) != 0)
3149 as_warn (_("misaligned data"));
3153 p
= frag_var (rs_align_test
, 1, 1, (relax_substateT
) 0,
3154 (symbolS
*) NULL
, (offsetT
) nalign
, (char *) NULL
);
3156 record_alignment (now_seg
, nalign
);
3159 /* When relaxing, we need to output a reloc for any .align directive
3160 that requests alignment to a four byte boundary or larger. This is
3161 also where we check for misaligned data. */
3164 sh_handle_align (frag
)
3167 int bytes
= frag
->fr_next
->fr_address
- frag
->fr_address
- frag
->fr_fix
;
3169 if (frag
->fr_type
== rs_align_code
)
3171 static const unsigned char big_nop_pattern
[] = { 0x00, 0x09 };
3172 static const unsigned char little_nop_pattern
[] = { 0x09, 0x00 };
3174 char *p
= frag
->fr_literal
+ frag
->fr_fix
;
3183 if (target_big_endian
)
3185 memcpy (p
, big_nop_pattern
, sizeof big_nop_pattern
);
3186 frag
->fr_var
= sizeof big_nop_pattern
;
3190 memcpy (p
, little_nop_pattern
, sizeof little_nop_pattern
);
3191 frag
->fr_var
= sizeof little_nop_pattern
;
3194 else if (frag
->fr_type
== rs_align_test
)
3197 as_warn_where (frag
->fr_file
, frag
->fr_line
, _("misaligned data"));
3201 && (frag
->fr_type
== rs_align
3202 || frag
->fr_type
== rs_align_code
)
3203 && frag
->fr_address
+ frag
->fr_fix
> 0
3204 && frag
->fr_offset
> 1
3205 && now_seg
!= bss_section
)
3206 fix_new (frag
, frag
->fr_fix
, 2, &abs_symbol
, frag
->fr_offset
, 0,
3207 BFD_RELOC_SH_ALIGN
);
3210 /* This macro decides whether a particular reloc is an entry in a
3211 switch table. It is used when relaxing, because the linker needs
3212 to know about all such entries so that it can adjust them if
3215 #ifdef BFD_ASSEMBLER
3216 #define SWITCH_TABLE_CONS(fix) (0)
3218 #define SWITCH_TABLE_CONS(fix) \
3219 ((fix)->fx_r_type == 0 \
3220 && ((fix)->fx_size == 2 \
3221 || (fix)->fx_size == 1 \
3222 || (fix)->fx_size == 4))
3225 #define SWITCH_TABLE(fix) \
3226 ((fix)->fx_addsy != NULL \
3227 && (fix)->fx_subsy != NULL \
3228 && S_GET_SEGMENT ((fix)->fx_addsy) == text_section \
3229 && S_GET_SEGMENT ((fix)->fx_subsy) == text_section \
3230 && ((fix)->fx_r_type == BFD_RELOC_32 \
3231 || (fix)->fx_r_type == BFD_RELOC_16 \
3232 || (fix)->fx_r_type == BFD_RELOC_8 \
3233 || SWITCH_TABLE_CONS (fix)))
3235 /* See whether we need to force a relocation into the output file.
3236 This is used to force out switch and PC relative relocations when
3240 sh_force_relocation (fix
)
3244 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
3245 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
3246 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_START
3247 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_END
)
3253 return (fix
->fx_pcrel
3254 || SWITCH_TABLE (fix
)
3255 || fix
->fx_r_type
== BFD_RELOC_SH_COUNT
3256 || fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
3257 || fix
->fx_r_type
== BFD_RELOC_SH_CODE
3258 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3260 || fix
->fx_r_type
== BFD_RELOC_SH_SHMEDIA_CODE
3262 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
);
3267 sh_fix_adjustable (fixP
)
3271 if (fixP
->fx_addsy
== NULL
)
3274 if (fixP
->fx_r_type
== BFD_RELOC_SH_PCDISP8BY2
3275 || fixP
->fx_r_type
== BFD_RELOC_SH_PCDISP12BY2
3276 || fixP
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY2
3277 || fixP
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY4
3278 || fixP
->fx_r_type
== BFD_RELOC_8_PCREL
3279 || fixP
->fx_r_type
== BFD_RELOC_SH_SWITCH16
3280 || fixP
->fx_r_type
== BFD_RELOC_SH_SWITCH32
)
3283 if (! TC_RELOC_RTSYM_LOC_FIXUP (fixP
)
3284 || fixP
->fx_r_type
== BFD_RELOC_RVA
)
3287 /* We need the symbol name for the VTABLE entries */
3288 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
3289 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
3296 sh_elf_final_processing ()
3300 /* Set file-specific flags to indicate if this code needs
3301 a processor with the sh-dsp / sh3e ISA to execute. */
3303 /* SH5 and above don't know about the valid_arch arch_sh* bits defined
3304 in sh-opc.h, so check SH64 mode before checking valid_arch. */
3305 if (sh64_isa_mode
!= sh64_isa_unspecified
)
3308 #endif /* HAVE_SH64 */
3309 if (valid_arch
& arch_sh1
)
3311 else if (valid_arch
& arch_sh2
)
3313 else if (valid_arch
& arch_sh_dsp
)
3315 else if (valid_arch
& arch_sh3
)
3317 else if (valid_arch
& arch_sh3_dsp
)
3319 else if (valid_arch
& arch_sh3e
)
3321 else if (valid_arch
& arch_sh4
)
3326 elf_elfheader (stdoutput
)->e_flags
&= ~EF_SH_MACH_MASK
;
3327 elf_elfheader (stdoutput
)->e_flags
|= val
;
3331 /* Apply a fixup to the object file. */
3334 md_apply_fix3 (fixP
, valP
, seg
)
3337 segT seg ATTRIBUTE_UNUSED
;
3339 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
3340 int lowbyte
= target_big_endian
? 1 : 0;
3341 int highbyte
= target_big_endian
? 0 : 1;
3342 long val
= (long) *valP
;
3346 #ifdef BFD_ASSEMBLER
3347 /* A difference between two symbols, the second of which is in the
3348 current section, is transformed in a PC-relative relocation to
3349 the other symbol. We have to adjust the relocation type here. */
3352 switch (fixP
->fx_r_type
)
3358 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
3361 /* Currently, we only support 32-bit PCREL relocations.
3362 We'd need a new reloc type to handle 16_PCREL, and
3363 8_PCREL is already taken for R_SH_SWITCH8, which
3364 apparently does something completely different than what
3367 bfd_set_error (bfd_error_bad_value
);
3371 bfd_set_error (bfd_error_bad_value
);
3376 /* The function adjust_reloc_syms won't convert a reloc against a weak
3377 symbol into a reloc against a section, but bfd_install_relocation
3378 will screw up if the symbol is defined, so we have to adjust val here
3379 to avoid the screw up later.
3381 For ordinary relocs, this does not happen for ELF, since for ELF,
3382 bfd_install_relocation uses the "special function" field of the
3383 howto, and does not execute the code that needs to be undone, as long
3384 as the special function does not return bfd_reloc_continue.
3385 It can happen for GOT- and PLT-type relocs the way they are
3386 described in elf32-sh.c as they use bfd_elf_generic_reloc, but it
3387 doesn't matter here since those relocs don't use VAL; see below. */
3388 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
3389 && fixP
->fx_addsy
!= NULL
3390 && S_IS_WEAK (fixP
->fx_addsy
))
3391 val
-= S_GET_VALUE (fixP
->fx_addsy
);
3394 #ifndef BFD_ASSEMBLER
3395 if (fixP
->fx_r_type
== 0)
3397 if (fixP
->fx_size
== 2)
3398 fixP
->fx_r_type
= BFD_RELOC_16
;
3399 else if (fixP
->fx_size
== 4)
3400 fixP
->fx_r_type
= BFD_RELOC_32
;
3401 else if (fixP
->fx_size
== 1)
3402 fixP
->fx_r_type
= BFD_RELOC_8
;
3410 switch (fixP
->fx_r_type
)
3412 case BFD_RELOC_SH_IMM4
:
3414 *buf
= (*buf
& 0xf0) | (val
& 0xf);
3417 case BFD_RELOC_SH_IMM4BY2
:
3420 *buf
= (*buf
& 0xf0) | ((val
>> 1) & 0xf);
3423 case BFD_RELOC_SH_IMM4BY4
:
3426 *buf
= (*buf
& 0xf0) | ((val
>> 2) & 0xf);
3429 case BFD_RELOC_SH_IMM8BY2
:
3435 case BFD_RELOC_SH_IMM8BY4
:
3442 case BFD_RELOC_SH_IMM8
:
3443 /* Sometimes the 8 bit value is sign extended (e.g., add) and
3444 sometimes it is not (e.g., and). We permit any 8 bit value.
3445 Note that adding further restrictions may invalidate
3446 reasonable looking assembly code, such as ``and -0x1,r0''. */
3452 case BFD_RELOC_SH_PCRELIMM8BY4
:
3453 /* The lower two bits of the PC are cleared before the
3454 displacement is added in. We can assume that the destination
3455 is on a 4 byte bounday. If this instruction is also on a 4
3456 byte boundary, then we want
3458 and target - here is a multiple of 4.
3459 Otherwise, we are on a 2 byte boundary, and we want
3460 (target - (here - 2)) / 4
3461 and target - here is not a multiple of 4. Computing
3462 (target - (here - 2)) / 4 == (target - here + 2) / 4
3463 works for both cases, since in the first case the addition of
3464 2 will be removed by the division. target - here is in the
3466 val
= (val
+ 2) / 4;
3468 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3472 case BFD_RELOC_SH_PCRELIMM8BY2
:
3475 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3479 case BFD_RELOC_SH_PCDISP8BY2
:
3481 if (val
< -0x80 || val
> 0x7f)
3482 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3486 case BFD_RELOC_SH_PCDISP12BY2
:
3488 if (val
< -0x800 || val
> 0x7ff)
3489 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3490 buf
[lowbyte
] = val
& 0xff;
3491 buf
[highbyte
] |= (val
>> 8) & 0xf;
3495 case BFD_RELOC_32_PCREL
:
3496 md_number_to_chars (buf
, val
, 4);
3500 md_number_to_chars (buf
, val
, 2);
3503 case BFD_RELOC_SH_USES
:
3504 /* Pass the value into sh_coff_reloc_mangle. */
3505 fixP
->fx_addnumber
= val
;
3508 case BFD_RELOC_SH_COUNT
:
3509 case BFD_RELOC_SH_ALIGN
:
3510 case BFD_RELOC_SH_CODE
:
3511 case BFD_RELOC_SH_DATA
:
3512 case BFD_RELOC_SH_LABEL
:
3513 /* Nothing to do here. */
3516 case BFD_RELOC_SH_LOOP_START
:
3517 case BFD_RELOC_SH_LOOP_END
:
3519 case BFD_RELOC_VTABLE_INHERIT
:
3520 case BFD_RELOC_VTABLE_ENTRY
:
3525 case BFD_RELOC_32_PLT_PCREL
:
3526 /* Make the jump instruction point to the address of the operand. At
3527 runtime we merely add the offset to the actual PLT entry. */
3528 * valP
= 0xfffffffc;
3529 val
= fixP
->fx_addnumber
;
3531 val
-= S_GET_VALUE (fixP
->fx_subsy
);
3532 md_number_to_chars (buf
, val
, 4);
3535 case BFD_RELOC_SH_GOTPC
:
3536 /* This is tough to explain. We end up with this one if we have
3537 operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]".
3538 The goal here is to obtain the absolute address of the GOT,
3539 and it is strongly preferable from a performance point of
3540 view to avoid using a runtime relocation for this. There are
3541 cases where you have something like:
3543 .long _GLOBAL_OFFSET_TABLE_+[.-.L66]
3545 and here no correction would be required. Internally in the
3546 assembler we treat operands of this form as not being pcrel
3547 since the '.' is explicitly mentioned, and I wonder whether
3548 it would simplify matters to do it this way. Who knows. In
3549 earlier versions of the PIC patches, the pcrel_adjust field
3550 was used to store the correction, but since the expression is
3551 not pcrel, I felt it would be confusing to do it this way. */
3553 md_number_to_chars (buf
, val
, 4);
3556 case BFD_RELOC_32_GOT_PCREL
:
3557 case BFD_RELOC_SH_GOTPLT32
:
3558 * valP
= 0; /* Fully resolved at runtime. No addend. */
3559 md_number_to_chars (buf
, 0, 4);
3562 case BFD_RELOC_32_GOTOFF
:
3563 md_number_to_chars (buf
, val
, 4);
3569 shmedia_md_apply_fix3 (fixP
, valP
);
3578 if ((val
& ((1 << shift
) - 1)) != 0)
3579 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("misaligned offset"));
3583 val
= ((val
>> shift
)
3584 | ((long) -1 & ~ ((long) -1 >> shift
)));
3586 if (max
!= 0 && (val
< min
|| val
> max
))
3587 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("offset out of range"));
3589 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
3593 /* Called just before address relaxation. Return the length
3594 by which a fragment must grow to reach it's destination. */
3597 md_estimate_size_before_relax (fragP
, segment_type
)
3598 register fragS
*fragP
;
3599 register segT segment_type
;
3603 switch (fragP
->fr_subtype
)
3607 return shmedia_md_estimate_size_before_relax (fragP
, segment_type
);
3613 case C (UNCOND_JUMP
, UNDEF_DISP
):
3614 /* Used to be a branch to somewhere which was unknown. */
3615 if (!fragP
->fr_symbol
)
3617 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3619 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3621 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3625 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
3629 case C (COND_JUMP
, UNDEF_DISP
):
3630 case C (COND_JUMP_DELAY
, UNDEF_DISP
):
3631 what
= GET_WHAT (fragP
->fr_subtype
);
3632 /* Used to be a branch to somewhere which was unknown. */
3633 if (fragP
->fr_symbol
3634 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3636 /* Got a symbol and it's defined in this segment, become byte
3637 sized - maybe it will fix up. */
3638 fragP
->fr_subtype
= C (what
, COND8
);
3640 else if (fragP
->fr_symbol
)
3642 /* Its got a segment, but its not ours, so it will always be long. */
3643 fragP
->fr_subtype
= C (what
, UNDEF_WORD_DISP
);
3647 /* We know the abs value. */
3648 fragP
->fr_subtype
= C (what
, COND8
);
3652 case C (UNCOND_JUMP
, UNCOND12
):
3653 case C (UNCOND_JUMP
, UNCOND32
):
3654 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
3655 case C (COND_JUMP
, COND8
):
3656 case C (COND_JUMP
, COND12
):
3657 case C (COND_JUMP
, COND32
):
3658 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3659 case C (COND_JUMP_DELAY
, COND8
):
3660 case C (COND_JUMP_DELAY
, COND12
):
3661 case C (COND_JUMP_DELAY
, COND32
):
3662 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3663 /* When relaxing a section for the second time, we don't need to
3664 do anything besides return the current size. */
3668 fragP
->fr_var
= md_relax_table
[fragP
->fr_subtype
].rlx_length
;
3669 return fragP
->fr_var
;
3672 /* Put number into target byte order. */
3675 md_number_to_chars (ptr
, use
, nbytes
)
3681 /* We might need to set the contents type to data. */
3682 sh64_flag_output ();
3685 if (! target_big_endian
)
3686 number_to_chars_littleendian (ptr
, use
, nbytes
);
3688 number_to_chars_bigendian (ptr
, use
, nbytes
);
3691 /* This version is used in obj-coff.c when not using BFD_ASSEMBLER.
3692 eg for the sh-hms target. */
3695 md_pcrel_from (fixP
)
3698 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
3702 md_pcrel_from_section (fixP
, sec
)
3706 if (fixP
->fx_addsy
!= (symbolS
*) NULL
3707 && (! S_IS_DEFINED (fixP
->fx_addsy
)
3708 || S_IS_EXTERN (fixP
->fx_addsy
)
3709 || S_IS_WEAK (fixP
->fx_addsy
)
3710 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
3712 /* The symbol is undefined (or is defined but not in this section,
3713 or we're not sure about it being the final definition). Let the
3714 linker figure it out. We need to adjust the subtraction of a
3715 symbol to the position of the relocated data, though. */
3716 return fixP
->fx_subsy
? fixP
->fx_where
+ fixP
->fx_frag
->fr_address
: 0;
3719 return md_pcrel_from (fixP
);
3725 tc_coff_sizemachdep (frag
)
3728 return md_relax_table
[frag
->fr_subtype
].rlx_length
;
3731 #endif /* OBJ_COFF */
3733 #ifndef BFD_ASSEMBLER
3736 /* Map BFD relocs to SH COFF relocs. */
3740 bfd_reloc_code_real_type bfd_reloc
;
3744 static const struct reloc_map coff_reloc_map
[] =
3746 { BFD_RELOC_32
, R_SH_IMM32
},
3747 { BFD_RELOC_16
, R_SH_IMM16
},
3748 { BFD_RELOC_8
, R_SH_IMM8
},
3749 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_PCDISP8BY2
},
3750 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_PCDISP
},
3751 { BFD_RELOC_SH_IMM4
, R_SH_IMM4
},
3752 { BFD_RELOC_SH_IMM4BY2
, R_SH_IMM4BY2
},
3753 { BFD_RELOC_SH_IMM4BY4
, R_SH_IMM4BY4
},
3754 { BFD_RELOC_SH_IMM8
, R_SH_IMM8
},
3755 { BFD_RELOC_SH_IMM8BY2
, R_SH_IMM8BY2
},
3756 { BFD_RELOC_SH_IMM8BY4
, R_SH_IMM8BY4
},
3757 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_PCRELIMM8BY2
},
3758 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_PCRELIMM8BY4
},
3759 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
3760 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
3761 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
3762 { BFD_RELOC_SH_USES
, R_SH_USES
},
3763 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
3764 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
3765 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
3766 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
3767 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
3768 { BFD_RELOC_UNUSED
, 0 }
3771 /* Adjust a reloc for the SH. This is similar to the generic code,
3772 but does some minor tweaking. */
3775 sh_coff_reloc_mangle (seg
, fix
, intr
, paddr
)
3776 segment_info_type
*seg
;
3778 struct internal_reloc
*intr
;
3781 symbolS
*symbol_ptr
= fix
->fx_addsy
;
3784 intr
->r_vaddr
= paddr
+ fix
->fx_frag
->fr_address
+ fix
->fx_where
;
3786 if (! SWITCH_TABLE (fix
))
3788 const struct reloc_map
*rm
;
3790 for (rm
= coff_reloc_map
; rm
->bfd_reloc
!= BFD_RELOC_UNUSED
; rm
++)
3791 if (rm
->bfd_reloc
== (bfd_reloc_code_real_type
) fix
->fx_r_type
)
3793 if (rm
->bfd_reloc
== BFD_RELOC_UNUSED
)
3794 as_bad_where (fix
->fx_file
, fix
->fx_line
,
3795 _("Can not represent %s relocation in this object file format"),
3796 bfd_get_reloc_code_name (fix
->fx_r_type
));
3797 intr
->r_type
= rm
->sh_reloc
;
3804 if (fix
->fx_r_type
== BFD_RELOC_16
)
3805 intr
->r_type
= R_SH_SWITCH16
;
3806 else if (fix
->fx_r_type
== BFD_RELOC_8
)
3807 intr
->r_type
= R_SH_SWITCH8
;
3808 else if (fix
->fx_r_type
== BFD_RELOC_32
)
3809 intr
->r_type
= R_SH_SWITCH32
;
3813 /* For a switch reloc, we set r_offset to the difference between
3814 the reloc address and the subtrahend. When the linker is
3815 doing relaxing, it can use the determine the starting and
3816 ending points of the switch difference expression. */
3817 intr
->r_offset
= intr
->r_vaddr
- S_GET_VALUE (fix
->fx_subsy
);
3820 /* PC relative relocs are always against the current section. */
3821 if (symbol_ptr
== NULL
)
3823 switch (fix
->fx_r_type
)
3825 case BFD_RELOC_SH_PCRELIMM8BY2
:
3826 case BFD_RELOC_SH_PCRELIMM8BY4
:
3827 case BFD_RELOC_SH_PCDISP8BY2
:
3828 case BFD_RELOC_SH_PCDISP12BY2
:
3829 case BFD_RELOC_SH_USES
:
3830 symbol_ptr
= seg
->dot
;
3837 if (fix
->fx_r_type
== BFD_RELOC_SH_USES
)
3839 /* We can't store the offset in the object file, since this
3840 reloc does not take up any space, so we store it in r_offset.
3841 The fx_addnumber field was set in md_apply_fix3. */
3842 intr
->r_offset
= fix
->fx_addnumber
;
3844 else if (fix
->fx_r_type
== BFD_RELOC_SH_COUNT
)
3846 /* We can't store the count in the object file, since this reloc
3847 does not take up any space, so we store it in r_offset. The
3848 fx_offset field was set when the fixup was created in
3849 sh_coff_frob_file. */
3850 intr
->r_offset
= fix
->fx_offset
;
3851 /* This reloc is always absolute. */
3854 else if (fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
)
3856 /* Store the alignment in the r_offset field. */
3857 intr
->r_offset
= fix
->fx_offset
;
3858 /* This reloc is always absolute. */
3861 else if (fix
->fx_r_type
== BFD_RELOC_SH_CODE
3862 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3863 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
)
3865 /* These relocs are always absolute. */
3869 /* Turn the segment of the symbol into an offset. */
3870 if (symbol_ptr
!= NULL
)
3872 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
3874 intr
->r_symndx
= dot
->sy_number
;
3876 intr
->r_symndx
= symbol_ptr
->sy_number
;
3879 intr
->r_symndx
= -1;
3882 #endif /* OBJ_COFF */
3883 #endif /* ! BFD_ASSEMBLER */
3885 #ifdef BFD_ASSEMBLER
3887 /* Create a reloc. */
3890 tc_gen_reloc (section
, fixp
)
3891 asection
*section ATTRIBUTE_UNUSED
;
3895 bfd_reloc_code_real_type r_type
;
3897 rel
= (arelent
*) xmalloc (sizeof (arelent
));
3898 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3899 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
3900 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3903 && S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
3905 fixp
->fx_addnumber
-= S_GET_VALUE (fixp
->fx_subsy
);
3909 r_type
= fixp
->fx_r_type
;
3911 if (SWITCH_TABLE (fixp
))
3913 rel
->addend
= rel
->address
- S_GET_VALUE (fixp
->fx_subsy
);
3914 if (r_type
== BFD_RELOC_16
)
3915 r_type
= BFD_RELOC_SH_SWITCH16
;
3916 else if (r_type
== BFD_RELOC_8
)
3917 r_type
= BFD_RELOC_8_PCREL
;
3918 else if (r_type
== BFD_RELOC_32
)
3919 r_type
= BFD_RELOC_SH_SWITCH32
;
3923 else if (r_type
== BFD_RELOC_SH_USES
)
3924 rel
->addend
= fixp
->fx_addnumber
;
3925 else if (r_type
== BFD_RELOC_SH_COUNT
)
3926 rel
->addend
= fixp
->fx_offset
;
3927 else if (r_type
== BFD_RELOC_SH_ALIGN
)
3928 rel
->addend
= fixp
->fx_offset
;
3929 else if (r_type
== BFD_RELOC_VTABLE_INHERIT
3930 || r_type
== BFD_RELOC_VTABLE_ENTRY
)
3931 rel
->addend
= fixp
->fx_offset
;
3932 else if (r_type
== BFD_RELOC_SH_LOOP_START
3933 || r_type
== BFD_RELOC_SH_LOOP_END
)
3934 rel
->addend
= fixp
->fx_offset
;
3935 else if (r_type
== BFD_RELOC_SH_LABEL
&& fixp
->fx_pcrel
)
3938 rel
->address
= rel
->addend
= fixp
->fx_offset
;
3941 else if (shmedia_init_reloc (rel
, fixp
))
3944 else if (fixp
->fx_pcrel
)
3945 rel
->addend
= fixp
->fx_addnumber
;
3946 else if (r_type
== BFD_RELOC_32
|| r_type
== BFD_RELOC_32_GOTOFF
)
3947 rel
->addend
= fixp
->fx_addnumber
;
3951 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
3952 if (rel
->howto
== NULL
|| fixp
->fx_subsy
)
3954 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
3955 _("Cannot represent relocation type %s"),
3956 bfd_get_reloc_code_name (r_type
));
3957 /* Set howto to a garbage value so that we can keep going. */
3958 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
3959 assert (rel
->howto
!= NULL
);
3966 inline static char *
3967 sh_end_of_match (cont
, what
)
3970 int len
= strlen (what
);
3972 if (strncasecmp (cont
, what
, strlen (what
)) == 0
3973 && ! is_part_of_name (cont
[len
]))
3980 sh_parse_name (name
, exprP
, nextcharP
)
3985 char *next
= input_line_pointer
;
3990 exprP
->X_op_symbol
= NULL
;
3992 if (strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
3995 GOT_symbol
= symbol_find_or_make (name
);
3997 exprP
->X_add_symbol
= GOT_symbol
;
3999 /* If we have an absolute symbol or a reg, then we know its
4001 segment
= S_GET_SEGMENT (exprP
->X_add_symbol
);
4002 if (segment
== absolute_section
)
4004 exprP
->X_op
= O_constant
;
4005 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4006 exprP
->X_add_symbol
= NULL
;
4008 else if (segment
== reg_section
)
4010 exprP
->X_op
= O_register
;
4011 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4012 exprP
->X_add_symbol
= NULL
;
4016 exprP
->X_op
= O_symbol
;
4017 exprP
->X_add_number
= 0;
4023 exprP
->X_add_symbol
= symbol_find_or_make (name
);
4025 if (*nextcharP
!= '@')
4027 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTOFF")))
4028 reloc_type
= BFD_RELOC_32_GOTOFF
;
4029 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTPLT")))
4030 reloc_type
= BFD_RELOC_SH_GOTPLT32
;
4031 else if ((next_end
= sh_end_of_match (next
+ 1, "GOT")))
4032 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
4033 else if ((next_end
= sh_end_of_match (next
+ 1, "PLT")))
4034 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
4038 *input_line_pointer
= *nextcharP
;
4039 input_line_pointer
= next_end
;
4040 *nextcharP
= *input_line_pointer
;
4041 *input_line_pointer
= '\0';
4043 exprP
->X_op
= O_PIC_reloc
;
4044 exprP
->X_add_number
= 0;
4045 exprP
->X_md
= reloc_type
;
4050 #endif /* BFD_ASSEMBLER */